@a9i5k4/dsh-literature 0.2.11 → 0.3.0

package/lib/index.js

@@ -2626,6 +2626,183 @@ var init_importer = __esm({
   }
 });
 
+// src/node/courseware/pptx.js
+var pptx_exports = {};
+__export(pptx_exports, {
+  deckToText: () => deckToText,
+  parsePptx: () => parsePptx
+});
+import { readFileSync } from "node:fs";
+import { inflateRawSync } from "node:zlib";
+function readZipEntries(bytes) {
+  let eocd = -1;
+  for (let i = bytes.length - 22; i >= 0 && i > bytes.length - 66e3; i -= 1) {
+    if (bytes.readUInt32LE(i) === EOCD_SIG) {
+      eocd = i;
+      break;
+    }
+  }
+  if (eocd < 0) throw new Error("not a zip archive");
+  const count = bytes.readUInt16LE(eocd + 10);
+  let off = bytes.readUInt32LE(eocd + 16);
+  const entries = /* @__PURE__ */ new Map();
+  for (let i = 0; i < count; i += 1) {
+    if (bytes.readUInt32LE(off) !== CD_SIG) break;
+    const method = bytes.readUInt16LE(off + 10);
+    const compSize = bytes.readUInt32LE(off + 20);
+    const nameLen = bytes.readUInt16LE(off + 28);
+    const extraLen = bytes.readUInt16LE(off + 30);
+    const commentLen = bytes.readUInt16LE(off + 32);
+    const localOff = bytes.readUInt32LE(off + 42);
+    const name2 = bytes.slice(off + 46, off + 46 + nameLen).toString("utf8");
+    if (bytes.readUInt32LE(localOff) === LOCAL_SIG) {
+      const lNameLen = bytes.readUInt16LE(localOff + 26);
+      const lExtraLen = bytes.readUInt16LE(localOff + 28);
+      const dataStart = localOff + 30 + lNameLen + lExtraLen;
+      const raw = bytes.slice(dataStart, dataStart + compSize);
+      let data;
+      try {
+        data = method === 0 ? Buffer.from(raw) : inflateRawSync(raw);
+      } catch {
+        data = null;
+      }
+      entries.set(name2, data);
+    }
+    off += 46 + nameLen + extraLen + commentLen;
+  }
+  return entries;
+}
+function paragraphsFromSlideXml(xml) {
+  const out = [];
+  const re = /<a:p>([\s\S]*?)<\/a:p>/g;
+  let m;
+  while (m = re.exec(xml)) {
+    const runs = [...m[1].matchAll(/<a:t>([\s\S]*?)<\/a:t>/g)].map((r) => r[1]);
+    const text = runs.join("").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").trim();
+    if (text) out.push(text);
+  }
+  return out;
+}
+function isTitleShape(shapeXml) {
+  return /<p:ph[^>]*type="(?:title|ctrTitle)"/.test(shapeXml);
+}
+function aspectOf(cx, cy) {
+  const r = cx / cy;
+  if (r > 1.7) return "16:9";
+  if (r > 1.2) return "4:3";
+  return `${r.toFixed(2)}:1`;
+}
+function parseChartXml(xml) {
+  const cats = [...xml.matchAll(/<c:pt idx="(\d+)">\s*<c:v>([\s\S]*?)<\/c:v>/g)];
+  const catMatch = xml.match(/<c:cat>([\s\S]*?)<\/c:cat>/);
+  const categories = catMatch ? [...catMatch[1].matchAll(/<c:v>([\s\S]*?)<\/c:v>/g)].map((m) => m[1].trim()) : [];
+  const series = [];
+  for (const m of xml.matchAll(/<c:ser>([\s\S]*?)<\/c:ser>/g)) {
+    const name2 = m[1].match(/<c:tx>[\s\S]*?<c:v>([\s\S]*?)<\/c:v>/)?.[1]?.trim() ?? "";
+    const valBlock = m[1].match(/<c:val>([\s\S]*?)<\/c:val>/)?.[1] ?? "";
+    const values = [...valBlock.matchAll(/<c:v>([\s\S]*?)<\/c:v>/g)].map((v) => Number(v[1]) || 0);
+    if (values.length) series.push({ name: name2, values });
+  }
+  return { categories, series, rawPts: cats.length };
+}
+function naturalSlideIndex(name2) {
+  const m = name2.match(/slide(\d+)\.xml$/);
+  return m ? Number(m[1]) : 0;
+}
+function parsePptx(input) {
+  const bytes = Buffer.isBuffer(input) ? input : readFileSync(input);
+  const warnings = [];
+  let entries;
+  try {
+    entries = readZipEntries(bytes);
+  } catch (e) {
+    throw new Error(`\u65E0\u6CD5\u89E3\u6790\u8BE5\u6587\u4EF6\uFF1A${e.message}\uFF08\u82E5\u4E3A\u65E7\u7248 .ppt\uFF0C\u8BF7\u53E6\u5B58\u4E3A .pptx \u6216\u5BFC\u51FA PDF\uFF09`);
+  }
+  if (!entries.has("[Content_Types].xml")) throw new Error("\u4E0D\u662F\u6709\u6548\u7684 .pptx\uFF08\u7F3A\u5C11 OOXML \u5185\u5BB9\u7C7B\u578B\u6E05\u5355\uFF09");
+  const slideNames = [...entries.keys()].filter((n) => /^ppt\/slides\/slide\d+\.xml$/.test(n)).sort((a, b) => naturalSlideIndex(a) - naturalSlideIndex(b));
+  if (!slideNames.length) throw new Error("\u8BE5 .pptx \u4E2D\u6CA1\u6709\u5E7B\u706F\u7247");
+  const pres = entries.get("ppt/presentation.xml")?.toString("utf8") ?? "";
+  const size = pres.match(/<p:sldSz cx="(\d+)" cy="(\d+)"/);
+  const aspect = size ? aspectOf(Number(size[1]), Number(size[2])) : "";
+  const notesOf = /* @__PURE__ */ new Map();
+  for (const name2 of entries.keys()) {
+    const m = name2.match(/^ppt\/notesSlides\/notesSlide(\d+)\.xml$/);
+    if (m) notesOf.set(Number(m[1]), entries.get(name2)?.toString("utf8") ?? "");
+  }
+  const charts = [];
+  for (const name2 of [...entries.keys()].sort()) {
+    const m = name2.match(/^ppt\/charts\/chart(\d+)\.xml$/);
+    if (!m) continue;
+    const xml = entries.get(name2)?.toString("utf8") ?? "";
+    if (!xml) continue;
+    const parsed = parseChartXml(xml);
+    charts.push({ name: name2, ...parsed });
+  }
+  const slides = slideNames.map((name2) => {
+    const n = naturalSlideIndex(name2);
+    const xml = entries.get(name2)?.toString("utf8") ?? "";
+    const shapes = [...xml.matchAll(/<p:sp>[\s\S]*?<\/p:sp>/g)].map((s) => s[0]);
+    let title = "";
+    const body = [];
+    for (const shape of shapes) {
+      const paras = paragraphsFromSlideXml(shape);
+      if (!paras.length) continue;
+      if (!title && isTitleShape(shape)) title = paras.join(" ");
+      else body.push(...paras);
+    }
+    if (!title && body.length) {
+      title = body.shift();
+    }
+    const images = [...xml.matchAll(/<p:pic>[\s\S]*?<\/p:pic>/g)].length;
+    return {
+      index: n,
+      title: title || `\u7B2C ${n} \u9875`,
+      paragraphs: body,
+      notes: (() => {
+        const nx = notesOf.get(n) ?? "";
+        return nx ? paragraphsFromSlideXml(nx) : [];
+      })(),
+      images
+    };
+  });
+  const media = [...entries.keys()].filter((n) => n.startsWith("ppt/media/")).map((n) => ({ name: n }));
+  return {
+    kind: "pptx",
+    slideCount: slides.length,
+    aspect,
+    slides,
+    media,
+    charts,
+    warnings
+  };
+}
+function deckToText(parsed, { maxChars = 4e4 } = {}) {
+  const parts = [];
+  let total = 0;
+  for (const slide of parsed.slides) {
+    const lines = [`## \u7B2C ${slide.index} \u9875 \xB7 ${slide.title}`];
+    lines.push(...slide.paragraphs.map((p) => `- ${p}`));
+    if (slide.notes.length) lines.push(`\uFF08\u8BB2\u8005\u5907\u6CE8\uFF1A${slide.notes.join("\uFF1B")}\uFF09`);
+    if (slide.images) lines.push(`\uFF08\u672C\u9875\u63D2\u56FE ${slide.images} \u5F20\uFF09`);
+    const block = lines.join("\n");
+    if (total + block.length > maxChars) {
+      parts.push("\u2026\uFF08\u8D85\u51FA\u957F\u5EA6\u4E0A\u9650\uFF0C\u5176\u4F59\u9875\u672A\u5305\u542B\uFF09");
+      break;
+    }
+    parts.push(block);
+    total += block.length;
+  }
+  return parts.join("\n\n");
+}
+var EOCD_SIG, CD_SIG, LOCAL_SIG;
+var init_pptx = __esm({
+  "src/node/courseware/pptx.js"() {
+    EOCD_SIG = 101010256;
+    CD_SIG = 33639248;
+    LOCAL_SIG = 67324752;
+  }
+});
+
 // src/node/pipeline.js
 var pipeline_exports = {};
 __export(pipeline_exports, {
@@ -2633,6 +2810,7 @@ __export(pipeline_exports, {
   arxivBase: () => arxivBase,
   discardItem: () => discardItem,
   fetchItemPdf: () => fetchItemPdf,
+  importDroppedCourseware: () => importDroppedCourseware,
   importDroppedPdf: () => importDroppedPdf,
   importPdf: () => importPdf,
   log: () => log,
@@ -2933,8 +3111,8 @@ async function saveItem(key, { mode, tags } = {}) {
     if (wantMode === "dir") {
       let buffer = null;
       if (current.pdf?.path) {
-        const { readFile: readFile6 } = await import("node:fs/promises");
-        buffer = await readFile6(current.pdf.path).catch(() => null);
+        const { readFile: readFile7 } = await import("node:fs/promises");
+        buffer = await readFile7(current.pdf.path).catch(() => null);
       }
       result = await exportToDirectory(current.record, buffer);
       const updated2 = await patchItem(key, { state: "saved", saveMode: "dir", export: result, error: null, updatedAt: Date.now() });
@@ -2944,14 +3122,14 @@ async function saveItem(key, { mode, tags } = {}) {
     }
     let pdfBuffer = null;
     if (current.pdf?.path) {
-      const { readFile: readFile6 } = await import("node:fs/promises");
-      pdfBuffer = await readFile6(current.pdf.path).catch(() => null);
+      const { readFile: readFile7 } = await import("node:fs/promises");
+      pdfBuffer = await readFile7(current.pdf.path).catch(() => null);
     }
     if (!pdfBuffer) {
       const fetched = await fetchItemPdf(key);
       if (fetched?.pdf?.path) {
-        const { readFile: readFile6 } = await import("node:fs/promises");
-        pdfBuffer = await readFile6(fetched.pdf.path).catch(() => null);
+        const { readFile: readFile7 } = await import("node:fs/promises");
+        pdfBuffer = await readFile7(fetched.pdf.path).catch(() => null);
       } else {
         const err = fetched?.error ?? failure("fetch_failed", "\u65E0\u6CD5\u83B7\u53D6\u5168\u6587 PDF\uFF0C\u65E0\u6CD5\u4FDD\u5B58\u5230\u6587\u732E\u5E93");
         throw Object.assign(new Error(err.message), { code: err.code ?? "fetch_failed", detail: err.detail });
@@ -3088,6 +3266,48 @@ async function importDroppedPdf(buffer, { filename = "dropped.pdf" } = {}) {
   emitItem(saved);
   return saved;
 }
+async function importDroppedCourseware(buffer, { filename = "deck.pptx" } = {}) {
+  if (!buffer || buffer.length < 4 || buffer.subarray(0, 2).toString("latin1") !== "PK") {
+    throw failure("network", "\u62D6\u5165\u7684\u6587\u4EF6\u4E0D\u662F\u6709\u6548\u7684 .pptx\uFF08\u65E7\u7248 .ppt \u8BF7\u5148\u53E6\u5B58\u4E3A .pptx \u6216\u5BFC\u51FA PDF\uFF09");
+  }
+  const { parsePptx: parsePptx2, deckToText: deckToText2 } = await Promise.resolve().then(() => (init_pptx(), pptx_exports));
+  let parsed;
+  try {
+    parsed = parsePptx2(buffer);
+  } catch (e) {
+    throw failure("network", e?.message ?? "\u8BFE\u4EF6\u89E3\u6790\u5931\u8D25");
+  }
+  const base = String(filename).replace(/\.pptx$/i, "");
+  const title = parsed.slides[0]?.title && parsed.slides[0].title !== "\u7B2C 1 \u9875" ? parsed.slides[0].title : base;
+  const key = `cw_${randomUUID2().slice(0, 8)}`;
+  const path = join5(PDF_DIR, `${key.replace(/[^\w.-]+/g, "_")}.pptx`);
+  await mkdir4(dirname3(path), { recursive: true });
+  await writeFile4(path, buffer);
+  const item = await putItem({
+    key,
+    kind: "courseware",
+    display: title,
+    title,
+    sourceFile: filename,
+    state: "fetched",
+    courseware: {
+      format: "pptx",
+      path,
+      filename,
+      slideCount: parsed.slideCount,
+      aspect: parsed.aspect,
+      outline: parsed.slides.map((s) => ({ index: s.index, title: s.title })),
+      charts: parsed.charts.map((c) => ({ name: c.name, categories: c.categories, series: c.series })),
+      mediaCount: parsed.media.length,
+      text: deckToText2(parsed, { maxChars: 6e4 })
+    },
+    pdf: { path, size: buffer.length, source: "courseware-import", url: "", filename },
+    tags: ["\u8BFE\u4EF6"],
+    createdAt: Date.now()
+  });
+  emitItem(item);
+  return item;
+}
 var FAILURE_MESSAGES;
 var init_pipeline = __esm({
   "src/node/pipeline.js"() {
@@ -3136,6 +3356,118 @@ var init_session_track = __esm({
   }
 });
 
+// src/node/pyenv.js
+var pyenv_exports = {};
+__export(pyenv_exports, {
+  detectPythons: () => detectPythons,
+  figureInterpreter: () => figureInterpreter,
+  installFigureDeps: () => installFigureDeps,
+  venvDir: () => venvDir,
+  venvExists: () => venvExists
+});
+import { execFile } from "node:child_process";
+import { existsSync, readdirSync } from "node:fs";
+import { join as join6 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+function run(cmd, args, { timeout = 2e4 } = {}) {
+  return new Promise((resolve6) => {
+    execFile(cmd, args, { timeout, windowsHide: true }, (err, stdout, stderr) => {
+      resolve6({ ok: !err, out: String(stdout ?? "").trim(), err: String(stderr ?? "").trim(), code: err?.code });
+    });
+  });
+}
+async function probe(exe) {
+  const v = await run(exe, ["--version"]);
+  if (!v.ok) return null;
+  const cap = await run(exe, ["-c", 'import venv, ensurepip; print("ok")']);
+  const mpl = await run(exe, ["-c", "import matplotlib; print(matplotlib.__version__)"]);
+  return {
+    exe,
+    version: v.out.split(" ").pop() ?? "",
+    venvCapable: cap.ok,
+    hasMatplotlib: mpl.ok,
+    matplotlibVersion: mpl.ok ? mpl.out : ""
+  };
+}
+async function detectPythons({ force = false } = {}) {
+  if (!force && cache.pythons.length && Date.now() - cache.at < CACHE_MS) return cache.pythons;
+  const candidates2 = [];
+  const tryPush = async (exe) => {
+    if (!exe || candidates2.some((c) => c.exe === exe)) return;
+    const p = await probe(exe);
+    if (p) candidates2.push(p);
+  };
+  if (process.platform === "win32") {
+    const py = await run("py", ["-0p"]);
+    if (py.ok) {
+      for (const line of py.out.split("\n")) {
+        const m = line.match(/[-*]\s*(?:Version: .*)?(?:\|\s*)?(.+\.exe)\s*$/i) ?? line.match(/([A-Za-z]:\\[^\s]+python\.exe)/i);
+        if (m?.[1]) await tryPush(m[1].trim());
+      }
+    }
+  }
+  await tryPush("python");
+  await tryPush("python3");
+  if (process.env.WORKBUDDY_PY) await tryPush(process.env.WORKBUDDY_PY);
+  const managed = join6(homedir3(), ".workbuddy", "binaries", "python", "versions");
+  if (existsSync(managed)) {
+    try {
+      for (const v of readdirSync(managed).sort().reverse()) {
+        await tryPush(join6(managed, v, "python.exe"));
+        await tryPush(join6(managed, v, "bin", "python3"));
+      }
+    } catch {
+    }
+  }
+  cache = { at: Date.now(), pythons: candidates2 };
+  return candidates2;
+}
+function venvDir() {
+  return join6(homedir3(), ".dsh", "dsh-literature", "pyvenv");
+}
+function venvPython(dir = venvDir()) {
+  return process.platform === "win32" ? join6(dir, "Scripts", "python.exe") : join6(dir, "bin", "python");
+}
+function venvExists(dir = venvDir()) {
+  return existsSync(venvPython(dir));
+}
+async function figureInterpreter() {
+  if (venvExists()) {
+    const p = await probe(venvPython());
+    if (p?.hasMatplotlib) return { ...p, source: "venv" };
+    if (p) return { ...p, source: "venv", hasMatplotlib: false };
+  }
+  for (const p of await detectPythons()) {
+    if (p.hasMatplotlib) return { ...p, source: "system" };
+  }
+  return null;
+}
+async function installFigureDeps(onLog = () => {
+}) {
+  const pythons = await detectPythons({ force: true });
+  const base = pythons.find((p) => p.venvCapable);
+  if (!base) return { ok: false, error: "\u672A\u627E\u5230\u53EF\u7528\u7684 Python\uFF08\u9700\u8981\u5E26 venv \u6A21\u5757\u7684 Python 3.8+\uFF09" };
+  const dir = venvDir();
+  if (!venvExists(dir)) {
+    onLog("\u521B\u5EFA\u865A\u62DF\u73AF\u5883\u2026");
+    const r2 = await run(base.exe, ["-m", "venv", dir], { timeout: 12e4 });
+    if (!r2.ok) return { ok: false, error: "venv \u521B\u5EFA\u5931\u8D25\uFF1A" + (r2.err || r2.out) };
+  }
+  const py = venvPython(dir);
+  onLog("\u5B89\u88C5 matplotlib\u2026");
+  const r = await run(py, ["-m", "pip", "install", "--disable-pip-version-check", "matplotlib"], { timeout: 3e5 });
+  if (!r.ok) return { ok: false, error: "matplotlib \u5B89\u88C5\u5931\u8D25\uFF1A" + (r.err || r.out).slice(0, 400) };
+  cache = { at: 0, pythons: [] };
+  return { ok: true, python: py, dir };
+}
+var CACHE_MS, cache;
+var init_pyenv = __esm({
+  "src/node/pyenv.js"() {
+    CACHE_MS = 6e4;
+    cache = { at: 0, pythons: [] };
+  }
+});
+
 // node_modules/pdfjs-dist/legacy/build/pdf.mjs
 var pdf_exports = {};
 __export(pdf_exports, {
@@ -3583,7 +3915,7 @@ function getColorValues(colors) {
   }
   span.remove();
 }
-function getCurrentTransform(ctx) {
+function getCurrentTransform(ctx2) {
   const {
     a,
     b,
@@ -3591,10 +3923,10 @@ function getCurrentTransform(ctx) {
     d,
     e,
     f
-  } = ctx.getTransform();
+  } = ctx2.getTransform();
   return [a, b, c, d, e, f];
 }
-function getCurrentTransformInverse(ctx) {
+function getCurrentTransformInverse(ctx2) {
   const {
     a,
     b,
@@ -3602,7 +3934,7 @@ function getCurrentTransformInverse(ctx) {
     d,
     e,
     f
-  } = ctx.getTransform().invertSelf();
+  } = ctx2.getTransform().invertSelf();
   return [a, b, c, d, e, f];
 }
 function setLayerDimensions(div, viewport, mustFlip = false, mustRotate = true) {
@@ -4050,7 +4382,7 @@ function loadMeshShader() {
 function drawMeshWithGPU(posData, colData, vertexCount, context, backgroundColor, paddedWidth, paddedHeight, borderSize) {
   return _webGPU.draw(posData, colData, vertexCount, context, backgroundColor, paddedWidth, paddedHeight, borderSize);
 }
-function applyBoundingBox(ctx, bbox) {
+function applyBoundingBox(ctx2, bbox) {
   if (!bbox) {
     return;
   }
@@ -4058,7 +4390,7 @@ function applyBoundingBox(ctx, bbox) {
   const height = bbox[3] - bbox[1];
   const region = new Path2D();
   region.rect(bbox[0], bbox[1], width, height);
-  ctx.clip(region);
+  ctx2.clip(region);
 }
 function drawTriangle(data, context, p1, p2, p3, c1, c2, c3) {
   const coords = context.coords, colors = context.colors;
@@ -4164,31 +4496,31 @@ function getShadingPattern(IR) {
   }
   throw new Error(`Unknown IR type: ${IR[0]}`);
 }
-function mirrorContextOperations(ctx, destCtx) {
-  if (ctx._removeMirroring) {
+function mirrorContextOperations(ctx2, destCtx) {
+  if (ctx2._removeMirroring) {
     throw new Error("Context is already forwarding operations.");
   }
   const originalMethods = /* @__PURE__ */ new Map();
   for (const name2 of ["save", "restore", "rotate", "scale", "translate", "transform", "setTransform", "resetTransform", "clip", "moveTo", "lineTo", "bezierCurveTo", "quadraticCurveTo", "arc", "arcTo", "ellipse", "rect", "roundRect", "closePath", "beginPath"]) {
-    const original = ctx[name2];
+    const original = ctx2[name2];
     if (typeof original !== "function" || typeof destCtx[name2] !== "function") {
       continue;
     }
     originalMethods.set(name2, original);
-    ctx[name2] = function(...args) {
+    ctx2[name2] = function(...args) {
       destCtx[name2](...args);
       return original.apply(this, args);
     };
   }
-  ctx._removeMirroring = () => {
+  ctx2._removeMirroring = () => {
     for (const [name2, original] of originalMethods) {
-      ctx[name2] = original;
+      ctx2[name2] = original;
     }
-    delete ctx._removeMirroring;
+    delete ctx2._removeMirroring;
   };
 }
-function drawImageAtIntegerCoords(ctx, srcImg, srcX, srcY, srcW, srcH, destX, destY, destW, destH) {
-  const [a, b, c, d, tx, ty] = getCurrentTransform(ctx);
+function drawImageAtIntegerCoords(ctx2, srcImg, srcX, srcY, srcW, srcH, destX, destY, destW, destH) {
+  const [a, b, c, d, tx, ty] = getCurrentTransform(ctx2);
   if (b === 0 && c === 0) {
     const tlX = destX * a + tx;
     const rTlX = Math.round(tlX);
@@ -4198,9 +4530,9 @@ function drawImageAtIntegerCoords(ctx, srcImg, srcX, srcY, srcW, srcH, destX, de
     const rWidth = Math.abs(Math.round(brX) - rTlX) || 1;
     const brY = (destY + destH) * d + ty;
     const rHeight = Math.abs(Math.round(brY) - rTlY) || 1;
-    ctx.setTransform(Math.sign(a), 0, 0, Math.sign(d), rTlX, rTlY);
-    ctx.drawImage(srcImg, srcX, srcY, srcW, srcH, 0, 0, rWidth, rHeight);
-    ctx.setTransform(a, b, c, d, tx, ty);
+    ctx2.setTransform(Math.sign(a), 0, 0, Math.sign(d), rTlX, rTlY);
+    ctx2.drawImage(srcImg, srcX, srcY, srcW, srcH, 0, 0, rWidth, rHeight);
+    ctx2.setTransform(a, b, c, d, tx, ty);
     return [rWidth, rHeight];
   }
   if (a === 0 && d === 0) {
@@ -4212,17 +4544,17 @@ function drawImageAtIntegerCoords(ctx, srcImg, srcX, srcY, srcW, srcH, destX, de
     const rWidth = Math.abs(Math.round(brX) - rTlX) || 1;
     const brY = (destX + destW) * b + ty;
     const rHeight = Math.abs(Math.round(brY) - rTlY) || 1;
-    ctx.setTransform(0, Math.sign(b), Math.sign(c), 0, rTlX, rTlY);
-    ctx.drawImage(srcImg, srcX, srcY, srcW, srcH, 0, 0, rHeight, rWidth);
-    ctx.setTransform(a, b, c, d, tx, ty);
+    ctx2.setTransform(0, Math.sign(b), Math.sign(c), 0, rTlX, rTlY);
+    ctx2.drawImage(srcImg, srcX, srcY, srcW, srcH, 0, 0, rHeight, rWidth);
+    ctx2.setTransform(a, b, c, d, tx, ty);
     return [rHeight, rWidth];
   }
-  ctx.drawImage(srcImg, srcX, srcY, srcW, srcH, destX, destY, destW, destH);
+  ctx2.drawImage(srcImg, srcX, srcY, srcW, srcH, destX, destY, destW, destH);
   const scaleX = Math.hypot(a, b);
   const scaleY = Math.hypot(c, d);
   return [scaleX * destW, scaleY * destH];
 }
-function putBinaryImageData(ctx, imgData) {
+function putBinaryImageData(ctx2, imgData) {
   const {
     width,
     height,
@@ -4231,7 +4563,7 @@ function putBinaryImageData(ctx, imgData) {
   const partialChunkHeight = height % FULL_CHUNK_HEIGHT;
   const fullChunks = (height - partialChunkHeight) / FULL_CHUNK_HEIGHT;
   const totalChunks = partialChunkHeight === 0 ? fullChunks : fullChunks + 1;
-  const chunkImgData = ctx.createImageData(width, FULL_CHUNK_HEIGHT);
+  const chunkImgData = ctx2.createImageData(width, FULL_CHUNK_HEIGHT);
   let srcPos = 0;
   const src = imgData.data;
   const dest = chunkImgData.data;
@@ -4247,7 +4579,7 @@ function putBinaryImageData(ctx, imgData) {
         width,
         height: i < fullChunks ? FULL_CHUNK_HEIGHT : partialChunkHeight
       }));
-      ctx.putImageData(chunkImgData, 0, i * FULL_CHUNK_HEIGHT);
+      ctx2.putImageData(chunkImgData, 0, i * FULL_CHUNK_HEIGHT);
     }
   } else if (kind === ImageKind.RGBA_32BPP) {
     let j = 0;
@@ -4255,13 +4587,13 @@ function putBinaryImageData(ctx, imgData) {
     for (i = 0; i < fullChunks; i++) {
       dest.set(src.subarray(srcPos, srcPos + elemsInThisChunk));
       srcPos += elemsInThisChunk;
-      ctx.putImageData(chunkImgData, 0, j);
+      ctx2.putImageData(chunkImgData, 0, j);
       j += FULL_CHUNK_HEIGHT;
     }
     if (i < totalChunks) {
       elemsInThisChunk = width * partialChunkHeight * 4;
       dest.set(src.subarray(srcPos, srcPos + elemsInThisChunk));
-      ctx.putImageData(chunkImgData, 0, j);
+      ctx2.putImageData(chunkImgData, 0, j);
     }
   } else if (kind === ImageKind.RGB_24BPP) {
     for (i = 0; i < totalChunks; i++) {
@@ -4274,15 +4606,15 @@ function putBinaryImageData(ctx, imgData) {
         width,
         height: i < fullChunks ? FULL_CHUNK_HEIGHT : partialChunkHeight
       }));
-      ctx.putImageData(chunkImgData, 0, i * FULL_CHUNK_HEIGHT);
+      ctx2.putImageData(chunkImgData, 0, i * FULL_CHUNK_HEIGHT);
     }
   } else {
     throw new Error(`bad image kind: ${kind}`);
   }
 }
-function putBinaryImageMask(ctx, imgData) {
+function putBinaryImageMask(ctx2, imgData) {
   if (imgData.bitmap) {
-    ctx.drawImage(imgData.bitmap, 0, 0);
+    ctx2.drawImage(imgData.bitmap, 0, 0);
     return;
   }
   const {
@@ -4292,7 +4624,7 @@ function putBinaryImageMask(ctx, imgData) {
   const partialChunkHeight = height % FULL_CHUNK_HEIGHT;
   const fullChunks = (height - partialChunkHeight) / FULL_CHUNK_HEIGHT;
   const totalChunks = partialChunkHeight === 0 ? fullChunks : fullChunks + 1;
-  const chunkImgData = ctx.createImageData(width, FULL_CHUNK_HEIGHT);
+  const chunkImgData = ctx2.createImageData(width, FULL_CHUNK_HEIGHT);
   let srcPos = 0;
   const src = imgData.data;
   const dest = chunkImgData.data;
@@ -4307,7 +4639,7 @@ function putBinaryImageMask(ctx, imgData) {
       height: i < fullChunks ? FULL_CHUNK_HEIGHT : partialChunkHeight,
       nonBlackColor: 0
     }));
-    ctx.putImageData(chunkImgData, 0, i * FULL_CHUNK_HEIGHT);
+    ctx2.putImageData(chunkImgData, 0, i * FULL_CHUNK_HEIGHT);
   }
 }
 function copyCtxState(sourceCtx, destCtx) {
@@ -4322,25 +4654,25 @@ function copyCtxState(sourceCtx, destCtx) {
     destCtx.lineDashOffset = sourceCtx.lineDashOffset;
   }
 }
-function resetCtxToDefault(ctx) {
-  ctx.strokeStyle = ctx.fillStyle = "#000000";
-  ctx.fillRule = "nonzero";
-  ctx.globalAlpha = 1;
-  ctx.lineWidth = 1;
-  ctx.lineCap = "butt";
-  ctx.lineJoin = "miter";
-  ctx.miterLimit = 10;
-  ctx.globalCompositeOperation = "source-over";
-  ctx.font = "10px sans-serif";
-  if (ctx.setLineDash !== void 0) {
-    ctx.setLineDash([]);
-    ctx.lineDashOffset = 0;
+function resetCtxToDefault(ctx2) {
+  ctx2.strokeStyle = ctx2.fillStyle = "#000000";
+  ctx2.fillRule = "nonzero";
+  ctx2.globalAlpha = 1;
+  ctx2.lineWidth = 1;
+  ctx2.lineCap = "butt";
+  ctx2.lineJoin = "miter";
+  ctx2.miterLimit = 10;
+  ctx2.globalCompositeOperation = "source-over";
+  ctx2.font = "10px sans-serif";
+  if (ctx2.setLineDash !== void 0) {
+    ctx2.setLineDash([]);
+    ctx2.lineDashOffset = 0;
   }
   const {
     filter
-  } = ctx;
+  } = ctx2;
   if (filter !== "none" && filter !== "") {
-    ctx.filter = "none";
+    ctx2.filter = "none";
   }
 }
 function getImageSmoothingEnabled(transform, interpolate) {
@@ -5990,10 +6322,10 @@ var init_pdf2 = __esm({
         var isCallable = __webpack_require__2(4901);
         var replacement = /#|\.prototype\./;
         var isForced = function(feature, detection) {
-          var value = data[normalize(feature)];
+          var value = data[normalize2(feature)];
           return value === POLYFILL ? true : value === NATIVE ? false : isCallable(detection) ? fails(detection) : !!detection;
         };
-        var normalize = isForced.normalize = function(string) {
+        var normalize2 = isForced.normalize = function(string) {
           return String(string).replace(replacement, ".").toLowerCase();
         };
         var data = isForced.data = {};
@@ -6363,7 +6695,7 @@ var init_pdf2 = __esm({
         var defineProperty = Object.defineProperty;
         var stringSlice = uncurryThis("".slice);
         var replace = uncurryThis("".replace);
-        var join7 = uncurryThis([].join);
+        var join9 = uncurryThis([].join);
         var CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function() {
           return defineProperty(function() {
           }, "length", { value: 8 }).length !== 8;
@@ -6390,7 +6722,7 @@ var init_pdf2 = __esm({
           }
           var state2 = enforceInternalState(value);
           if (!hasOwn(state2, "source")) {
-            state2.source = join7(TEMPLATE, typeof name2 == "string" ? name2 : "");
+            state2.source = join9(TEMPLATE, typeof name2 == "string" ? name2 : "");
           }
           return value;
         };
@@ -8913,7 +9245,7 @@ var init_pdf2 = __esm({
         var charAt = uncurryThis("".charAt);
         var Uint8Array2 = globalThis2.Uint8Array;
         var $Array = globalThis2.Array;
-        var join7 = uncurryThis([].join);
+        var join9 = uncurryThis([].join);
         var INCORRECT_BEHAVIOR_OR_DOESNT_EXISTS = !Uint8Array2 || !Uint8Array2.prototype.toBase64 || !(function() {
           try {
             var target = new Uint8Array2();
@@ -8959,7 +9291,7 @@ var init_pdf2 = __esm({
                 result[written++] = "=";
               }
             }
-            return join7(result, "");
+            return join9(result, "");
           }
         });
       },
@@ -8971,7 +9303,7 @@ var init_pdf2 = __esm({
         var anUint8Array = __webpack_require__2(4154);
         var notDetached = __webpack_require__2(5169);
         var numberToString = uncurryThis(1.1.toString);
-        var join7 = uncurryThis([].join);
+        var join9 = uncurryThis([].join);
         var $Array = Array;
         var Uint8Array2 = globalThis2.Uint8Array;
         var INCORRECT_BEHAVIOR_OR_DOESNT_EXISTS = !Uint8Array2 || !Uint8Array2.prototype.toHex || !(function() {
@@ -8991,7 +9323,7 @@ var init_pdf2 = __esm({
               var hex = numberToString(this[i], 16);
               result[i] = hex.length === 1 ? "0" + hex : hex;
             }
-            return join7(result, "");
+            return join9(result, "");
           }
         });
       },
@@ -9470,13 +9802,13 @@ var init_pdf2 = __esm({
         });
       }
       static get isCanvasFilterSupported() {
-        let ctx;
+        let ctx2;
         if (this.isOffscreenCanvasSupported) {
-          ctx = new OffscreenCanvas(1, 1).getContext("2d");
+          ctx2 = new OffscreenCanvas(1, 1).getContext("2d");
         } else if (typeof document !== "undefined") {
-          ctx = document.createElement("canvas").getContext("2d");
+          ctx2 = document.createElement("canvas").getContext("2d");
         }
-        return shadow(this, "isCanvasFilterSupported", ctx?.filter !== void 0);
+        return shadow(this, "isCanvasFilterSupported", ctx2?.filter !== void 0);
       }
       static get isAlphaColorInputSupported() {
         if (typeof document === "undefined") {
@@ -10623,14 +10955,14 @@ var init_pdf2 = __esm({
       static get _isSVGFittingCanvas() {
         const svg = `data:image/svg+xml;charset=UTF-8,<svg viewBox="0 0 1 1" width="1" height="1" xmlns="${SVG_NS}"><rect width="1" height="1" style="fill:red;"/></svg>`;
         const canvas = new OffscreenCanvas(1, 3);
-        const ctx = canvas.getContext("2d", {
+        const ctx2 = canvas.getContext("2d", {
           willReadFrequently: true
         });
         const image = new Image();
         image.src = svg;
         const promise = image.decode().then(() => {
-          ctx.drawImage(image, 0, 0, 1, 1, 0, 0, 1, 3);
-          return new Uint32Array(ctx.getImageData(0, 0, 1, 1).data.buffer)[0] === 0;
+          ctx2.drawImage(image, 0, 0, 1, 1, 0, 0, 1, 3);
+          return new Uint32Array(ctx2.getImageData(0, 0, 1, 1).data.buffer)[0] === 0;
         });
         return shadow(this, "_isSVGFittingCanvas", promise);
       }
@@ -10738,8 +11070,8 @@ var init_pdf2 = __esm({
           return data;
         }
         const offscreen = new OffscreenCanvas(canvas.width, canvas.height);
-        const ctx = offscreen.getContext("2d");
-        ctx.drawImage(canvas, 0, 0);
+        const ctx2 = offscreen.getContext("2d");
+        ctx2.drawImage(canvas, 0, 0);
         data = {
           bitmap: offscreen.transferToImageBitmap(),
           id: `image_${this.#baseId}_${this.#id++}`,
@@ -10772,8 +11104,8 @@ var init_pdf2 = __esm({
         } = data;
         if (!data.url && !data.file) {
           const canvas = new OffscreenCanvas(bitmap.width, bitmap.height);
-          const ctx = canvas.getContext("bitmaprenderer");
-          ctx.transferFromImageBitmap(bitmap);
+          const ctx2 = canvas.getContext("bitmaprenderer");
+          ctx2.transferFromImageBitmap(bitmap);
           data.blobPromise = canvas.convertToBlob();
         }
         bitmap.close?.();
@@ -15670,8 +16002,8 @@ var init_pdf2 = __esm({
         }
         return this;
       }
-      pushBaseTransform(ctx) {
-        this.#baseTransformStack.push(Util.multiplyByDOMMatrix(this.#baseTransformStack.at(-1), ctx.getTransform()));
+      pushBaseTransform(ctx2) {
+        this.#baseTransformStack.push(Util.multiplyByDOMMatrix(this.#baseTransformStack.at(-1), ctx2.getTransform()));
         return this;
       }
       popBaseTransform() {
@@ -15687,8 +16019,8 @@ var init_pdf2 = __esm({
         }
         return this;
       }
-      recordClipBox(idx, ctx, minX, maxX, minY, maxY) {
-        const transform = Util.multiplyByDOMMatrix(this.#baseTransformStack.at(-1), ctx.getTransform());
+      recordClipBox(idx, ctx2, minX, maxX, minY, maxY) {
+        const transform = Util.multiplyByDOMMatrix(this.#baseTransformStack.at(-1), ctx2.getTransform());
         const clipBox = BBOX_INIT.slice();
         Util.axialAlignedBoundingBox([minX, minY, maxX, maxY], transform, clipBox);
         const intersection = Util.intersect(this.#clipBox, clipBox);
@@ -15703,12 +16035,12 @@ var init_pdf2 = __esm({
         }
         return this;
       }
-      recordBBox(idx, ctx, minX, maxX, minY, maxY) {
+      recordBBox(idx, ctx2, minX, maxX, minY, maxY) {
         const clipBox = this.#clipBox;
         if (clipBox[0] === Infinity) {
           return this;
         }
-        const transform = Util.multiplyByDOMMatrix(this.#baseTransformStack.at(-1), ctx.getTransform());
+        const transform = Util.multiplyByDOMMatrix(this.#baseTransformStack.at(-1), ctx2.getTransform());
         if (clipBox[0] === -Infinity) {
           Util.axialAlignedBoundingBox([minX, minY, maxX, maxY], transform, this.#pendingBBox);
           return this;
@@ -15791,7 +16123,7 @@ var init_pdf2 = __esm({
       inheritPendingDependenciesAsFutureForcedDependencies() {
         return this;
       }
-      recordCharacterBBox(idx, ctx, font, scale = 1, x = 0, y = 0, getMeasure) {
+      recordCharacterBBox(idx, ctx2, font, scale = 1, x = 0, y = 0, getMeasure) {
         return this;
       }
       getSimpleIndex(dependencyName) {
@@ -15890,8 +16222,8 @@ var init_pdf2 = __esm({
         this.#bboxTracker.endMarkedContent(opIdx, this.#recordDebugMetadataDepenencyAfterRestore);
         return this;
       }
-      pushBaseTransform(ctx) {
-        this.#bboxTracker.pushBaseTransform(ctx);
+      pushBaseTransform(ctx2) {
+        this.#bboxTracker.pushBaseTransform(ctx2);
         return this;
       }
       popBaseTransform() {
@@ -15939,15 +16271,15 @@ var init_pdf2 = __esm({
         this.#bboxTracker.resetBBox(idx);
         return this;
       }
-      recordClipBox(idx, ctx, minX, maxX, minY, maxY) {
-        this.#bboxTracker.recordClipBox(idx, ctx, minX, maxX, minY, maxY);
+      recordClipBox(idx, ctx2, minX, maxX, minY, maxY) {
+        this.#bboxTracker.recordClipBox(idx, ctx2, minX, maxX, minY, maxY);
         return this;
       }
-      recordBBox(idx, ctx, minX, maxX, minY, maxY) {
-        this.#bboxTracker.recordBBox(idx, ctx, minX, maxX, minY, maxY);
+      recordBBox(idx, ctx2, minX, maxX, minY, maxY) {
+        this.#bboxTracker.recordBBox(idx, ctx2, minX, maxX, minY, maxY);
         return this;
       }
-      recordCharacterBBox(idx, ctx, font, scale = 1, x = 0, y = 0, getMeasure) {
+      recordCharacterBBox(idx, ctx2, font, scale = 1, x = 0, y = 0, getMeasure) {
         const fontBBox = font.bbox;
         let isBBoxTrustworthy;
         let computedBBox;
@@ -15960,7 +16292,7 @@ var init_pdf2 = __esm({
               scaleCharBBox(scale, -scale, x, y, computedBBox);
             }
             if (isBBoxTrustworthy) {
-              return this.recordBBox(idx, ctx, computedBBox[0], computedBBox[2], computedBBox[1], computedBBox[3]);
+              return this.recordBBox(idx, ctx2, computedBBox[0], computedBBox[2], computedBBox[1], computedBBox[3]);
             }
           }
         }
@@ -15972,10 +16304,10 @@ var init_pdf2 = __esm({
           isBBoxTrustworthy = computedBBox[0] <= x - measure.actualBoundingBoxLeft && computedBBox[2] >= x + measure.actualBoundingBoxRight && computedBBox[1] <= y - measure.actualBoundingBoxAscent && computedBBox[3] >= y + measure.actualBoundingBoxDescent;
           this.#fontBBoxTrustworthy.set(font, isBBoxTrustworthy);
           if (isBBoxTrustworthy) {
-            return this.recordBBox(idx, ctx, computedBBox[0], computedBBox[2], computedBBox[1], computedBBox[3]);
+            return this.recordBBox(idx, ctx2, computedBBox[0], computedBBox[2], computedBBox[1], computedBBox[3]);
           }
         }
-        return this.recordBBox(idx, ctx, x - measure.actualBoundingBoxLeft, x + measure.actualBoundingBoxRight, y - measure.actualBoundingBoxAscent, y + measure.actualBoundingBoxDescent);
+        return this.recordBBox(idx, ctx2, x - measure.actualBoundingBoxLeft, x + measure.actualBoundingBoxRight, y - measure.actualBoundingBoxAscent, y + measure.actualBoundingBoxDescent);
       }
       recordFullPageBBox(idx) {
         this.#bboxTracker.recordFullPageBBox(idx);
@@ -16097,8 +16429,8 @@ var init_pdf2 = __esm({
       endMarkedContent(opIdx) {
         return this;
       }
-      pushBaseTransform(ctx) {
-        this.#dependencyTracker.pushBaseTransform(ctx);
+      pushBaseTransform(ctx2) {
+        this.#dependencyTracker.pushBaseTransform(ctx2);
         return this;
       }
       popBaseTransform() {
@@ -16142,21 +16474,21 @@ var init_pdf2 = __esm({
         }
         return this;
       }
-      recordClipBox(idx, ctx, minX, maxX, minY, maxY) {
+      recordClipBox(idx, ctx2, minX, maxX, minY, maxY) {
         if (!this.#ignoreBBoxes) {
-          this.#dependencyTracker.recordClipBox(this.#opIdx, ctx, minX, maxX, minY, maxY);
+          this.#dependencyTracker.recordClipBox(this.#opIdx, ctx2, minX, maxX, minY, maxY);
         }
         return this;
       }
-      recordBBox(idx, ctx, minX, maxX, minY, maxY) {
+      recordBBox(idx, ctx2, minX, maxX, minY, maxY) {
         if (!this.#ignoreBBoxes) {
-          this.#dependencyTracker.recordBBox(this.#opIdx, ctx, minX, maxX, minY, maxY);
+          this.#dependencyTracker.recordBBox(this.#opIdx, ctx2, minX, maxX, minY, maxY);
         }
         return this;
       }
-      recordCharacterBBox(idx, ctx, font, scale, x, y, getMeasure) {
+      recordCharacterBBox(idx, ctx2, font, scale, x, y, getMeasure) {
         if (!this.#ignoreBBoxes) {
-          this.#dependencyTracker.recordCharacterBBox(this.#opIdx, ctx, font, scale, x, y, getMeasure);
+          this.#dependencyTracker.recordCharacterBBox(this.#opIdx, ctx2, font, scale, x, y, getMeasure);
         }
         return this;
       }
@@ -16218,14 +16550,14 @@ var init_pdf2 = __esm({
         this.#canvasWidth = canvas.width;
         this.#canvasHeight = canvas.height;
       }
-      record(ctx, width, height, clipBox) {
+      record(ctx2, width, height, clipBox) {
         if (this.#count === this.#capacity) {
           this.#capacity *= 2;
           const newCoords = new _CanvasImagesTracker.#CoordsArray(this.#capacity * 6);
           newCoords.set(this.#coords);
           this.#coords = newCoords;
         }
-        const transform = getCurrentTransform(ctx);
+        const transform = getCurrentTransform(ctx2);
         let coords;
         if (clipBox[0] !== Infinity) {
           const bbox = BBOX_INIT.slice();
@@ -16451,7 +16783,7 @@ var init_pdf2 = __esm({
         const canvas = this._document.createElement("canvas");
         canvas.width = 1;
         canvas.height = 1;
-        const ctx = canvas.getContext("2d");
+        const ctx2 = canvas.getContext("2d");
         let called = 0;
         function isFontReady(name2, callback) {
           if (++called > 30) {
@@ -16459,9 +16791,9 @@ var init_pdf2 = __esm({
             callback();
             return;
           }
-          ctx.font = "30px " + name2;
-          ctx.fillText(".", 0, 20);
-          const imageData = ctx.getImageData(0, 0, 1, 1);
+          ctx2.font = "30px " + name2;
+          ctx2.fillText(".", 0, 20);
+          const imageData = ctx2.getImageData(0, 0, 1, 1);
           if (imageData.data[3] > 0) {
             callback();
             return;
@@ -18200,7 +18532,7 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         const dist = Math.hypot(this._p0[0] - this._p1[0], this._p0[1] - this._p1[1]);
         return dist + this._r1 > this._r0 && dist + this._r0 > this._r1;
       }
-      _createGradient(ctx, transform = null) {
+      _createGradient(ctx2, transform = null) {
         let grad;
         let firstPoint = this._p0;
         let secondPoint = this._p1;
@@ -18211,7 +18543,7 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
           Util.applyTransform(secondPoint, transform);
         }
         if (this._type === "axial") {
-          grad = ctx.createLinearGradient(firstPoint[0], firstPoint[1], secondPoint[0], secondPoint[1]);
+          grad = ctx2.createLinearGradient(firstPoint[0], firstPoint[1], secondPoint[0], secondPoint[1]);
         } else if (this._type === "radial") {
           let r0 = this._r0;
           let r1 = this._r1;
@@ -18221,14 +18553,14 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
             r0 *= scale[0];
             r1 *= scale[0];
           }
-          grad = ctx.createRadialGradient(firstPoint[0], firstPoint[1], r0, secondPoint[0], secondPoint[1], r1);
+          grad = ctx2.createRadialGradient(firstPoint[0], firstPoint[1], r0, secondPoint[0], secondPoint[1], r1);
         }
         for (const colorStop of this._colorStops) {
           grad.addColorStop(colorStop[0], colorStop[1]);
         }
         return grad;
       }
-      _createReversedGradient(ctx, transform = null) {
+      _createReversedGradient(ctx2, transform = null) {
         let firstPoint = this._p1;
         let secondPoint = this._p0;
         if (transform) {
@@ -18245,14 +18577,14 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
           r0 *= scale[0];
           r1 *= scale[0];
         }
-        const grad = ctx.createRadialGradient(firstPoint[0], firstPoint[1], r0, secondPoint[0], secondPoint[1], r1);
+        const grad = ctx2.createRadialGradient(firstPoint[0], firstPoint[1], r0, secondPoint[0], secondPoint[1], r1);
         const reversedStops = this._colorStops.map(([t, c]) => [1 - t, c]).reverse();
         for (const [t, c] of reversedStops) {
           grad.addColorStop(t, c);
         }
         return grad;
       }
-      getPattern(ctx, owner, inverse, pathType) {
+      getPattern(ctx2, owner, inverse, pathType) {
         let pattern;
         if (pathType === PathType.STROKE || pathType === PathType.FILL) {
           if (this.isOriginBased()) {
@@ -18267,14 +18599,14 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
             if (Math.abs(ps) < precision) {
               if (this.isRadial()) {
                 if (Math.abs(n1 - n2) < precision) {
-                  return this._createGradient(ctx, transf);
+                  return this._createGradient(ctx2, transf);
                 }
               } else {
-                return this._createGradient(ctx, transf);
+                return this._createGradient(ctx2, transf);
               }
             }
           }
-          const ownerBBox = owner.current.getClippedPathBoundingBox(pathType, getCurrentTransform(ctx)) || [0, 0, 0, 0];
+          const ownerBBox = owner.current.getClippedPathBoundingBox(pathType, getCurrentTransform(ctx2)) || [0, 0, 0, 0];
           const width = Math.ceil(ownerBBox[2] - ownerBBox[0]) || 1;
           const height = Math.ceil(ownerBBox[3] - ownerBBox[1]) || 1;
           const tmpCanvas = owner.canvasFactory.create(width, height);
@@ -18295,20 +18627,20 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
           }
           tmpCtx.fillStyle = this._createGradient(tmpCtx);
           tmpCtx.fill();
-          pattern = ctx.createPattern(tmpCanvas.canvas, "no-repeat");
+          pattern = ctx2.createPattern(tmpCanvas.canvas, "no-repeat");
           owner.canvasFactory.destroy(tmpCanvas);
           const domMatrix = new DOMMatrix(inverse);
           pattern.setTransform(domMatrix);
         } else {
           if (this.areConic()) {
-            ctx.save();
-            applyBoundingBox(ctx, this._bbox);
-            ctx.fillStyle = this._createReversedGradient(ctx);
-            ctx.fillRect(-1e10, -1e10, 2e10, 2e10);
-            ctx.restore();
+            ctx2.save();
+            applyBoundingBox(ctx2, this._bbox);
+            ctx2.fillStyle = this._createReversedGradient(ctx2);
+            ctx2.fillRect(-1e10, -1e10, 2e10, 2e10);
+            ctx2.restore();
           }
-          applyBoundingBox(ctx, this._bbox);
-          pattern = this._createGradient(ctx);
+          applyBoundingBox(ctx2, this._bbox);
+          pattern = this._createGradient(ctx2);
         }
         return pattern;
       }
@@ -18376,11 +18708,11 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
       isModifyingCurrentTransform() {
         return true;
       }
-      getPattern(ctx, owner, inverse, pathType) {
-        applyBoundingBox(ctx, this._bbox);
+      getPattern(ctx2, owner, inverse, pathType) {
+        applyBoundingBox(ctx2, this._bbox);
         const scale = new Float32Array(2);
         if (pathType === PathType.SHADING) {
-          Util.singularValueDecompose2dScale(getCurrentTransform(ctx), scale);
+          Util.singularValueDecompose2dScale(getCurrentTransform(ctx2), scale);
         } else if (this.matrix) {
           Util.singularValueDecompose2dScale(this.matrix, scale);
           const [matrixScaleX, matrixScaleY] = scale;
@@ -18392,14 +18724,14 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         }
         const temporaryPatternCanvas = this._createMeshCanvas(scale, pathType === PathType.SHADING ? null : this._background, owner.canvasFactory);
         if (pathType !== PathType.SHADING) {
-          ctx.setTransform(...owner.baseTransform);
+          ctx2.setTransform(...owner.baseTransform);
           if (this.matrix) {
-            ctx.transform(...this.matrix);
+            ctx2.transform(...this.matrix);
           }
         }
-        ctx.translate(temporaryPatternCanvas.offsetX, temporaryPatternCanvas.offsetY);
-        ctx.scale(temporaryPatternCanvas.scaleX, temporaryPatternCanvas.scaleY);
-        const pattern = ctx.createPattern(temporaryPatternCanvas.canvas, "no-repeat");
+        ctx2.translate(temporaryPatternCanvas.offsetX, temporaryPatternCanvas.offsetY);
+        ctx2.scale(temporaryPatternCanvas.scaleX, temporaryPatternCanvas.scaleY);
+        const pattern = ctx2.createPattern(temporaryPatternCanvas.canvas, "no-repeat");
         owner.canvasFactory.destroy(temporaryPatternCanvas);
         return pattern;
       }
@@ -18415,7 +18747,7 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
     };
     TilingPattern = class _TilingPattern {
       static MAX_PATTERN_SIZE = 3e3;
-      constructor(IR, ctx, canvasGraphicsFactory, baseTransform) {
+      constructor(IR, ctx2, canvasGraphicsFactory, baseTransform) {
         this.color = IR[1];
         this.operatorList = IR[2];
         this.matrix = IR[3];
@@ -18425,7 +18757,7 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         this.paintType = IR[7];
         this.tilingType = IR[8];
         this.needsIsolation = IR[9] ?? true;
-        this.ctx = ctx;
+        this.ctx = ctx2;
         this.canvasGraphicsFactory = canvasGraphicsFactory;
         this.baseTransform = baseTransform;
         this.patternBaseMatrix = this.matrix ? Util.transform(baseTransform, this.matrix) : baseTransform;
@@ -18627,13 +18959,13 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
       isModifyingCurrentTransform() {
         return false;
       }
-      getPattern(ctx, owner, inverse, pathType, opIdx) {
+      getPattern(ctx2, owner, inverse, pathType, opIdx) {
         const matrix = pathType !== PathType.SHADING ? Util.transform(inverse, this.patternBaseMatrix) : inverse;
         const temporaryPatternCanvas = this.createPatternCanvas(owner, opIdx);
         let domMatrix = new DOMMatrix(matrix);
         domMatrix = domMatrix.translate(temporaryPatternCanvas.offsetX, temporaryPatternCanvas.offsetY);
         domMatrix = domMatrix.scale(1 / temporaryPatternCanvas.scaleX, 1 / temporaryPatternCanvas.scaleY);
-        const pattern = ctx.createPattern(temporaryPatternCanvas.canvas, "repeat");
+        const pattern = ctx2.createPattern(temporaryPatternCanvas.canvas, "repeat");
         owner.canvasFactory.destroy(temporaryPatternCanvas.canvasEntry);
         pattern.setTransform(domMatrix);
         return pattern;
@@ -18910,13 +19242,13 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         this.#knockoutElementDepth = 0;
         this.#knockoutGroupLevel = 0;
         this.cachedPatterns.clear();
-        for (const cache2 of this._cachedBitmapsMap.values()) {
-          for (const canvas of cache2.values()) {
+        for (const cache3 of this._cachedBitmapsMap.values()) {
+          for (const canvas of cache3.values()) {
             if (typeof HTMLCanvasElement !== "undefined" && canvas instanceof HTMLCanvasElement) {
               canvas.width = canvas.height = 0;
             }
           }
-          cache2.clear();
+          cache3.clear();
         }
         this._cachedBitmapsMap.clear();
         this.#drawFilter();
@@ -19002,20 +19334,20 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         };
       }
       _createMaskCanvas(opIdx, img) {
-        const ctx = this.ctx;
+        const ctx2 = this.ctx;
         const {
           width,
           height
         } = img;
         const fillColor = this.current.fillColor;
         const isPatternFill = this.current.patternFill;
-        const currentTransform = getCurrentTransform(ctx);
-        let cache2, cacheKey, scaled, maskCanvas;
+        const currentTransform = getCurrentTransform(ctx2);
+        let cache3, cacheKey, scaled, maskCanvas;
         if ((img.bitmap || img.data) && img.count > 1) {
           const mainKey = img.bitmap || img.data.buffer;
           cacheKey = JSON.stringify(isPatternFill ? currentTransform : [currentTransform.slice(0, 4), fillColor]);
-          cache2 = this._cachedBitmapsMap.getOrInsertComputed(mainKey, makeMap);
-          const cachedImage = cache2.get(cacheKey);
+          cache3 = this._cachedBitmapsMap.getOrInsertComputed(mainKey, makeMap);
+          const cachedImage = cache3.get(cacheKey);
           if (cachedImage && !isPatternFill) {
             const offsetX2 = Math.round(Math.min(currentTransform[0], currentTransform[2]) + currentTransform[4]);
             const offsetY2 = Math.round(Math.min(currentTransform[1], currentTransform[3]) + currentTransform[5]);
@@ -19054,8 +19386,8 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
             this.canvasFactory.destroy(maskCanvas);
             maskCanvas = null;
           }
-          if (cache2 && isPatternFill) {
-            cache2.set(cacheKey, scaled);
+          if (cache3 && isPatternFill) {
+            cache3.set(cacheKey, scaled);
             scaledEntry = null;
             maskCanvas = null;
           }
@@ -19070,15 +19402,15 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         }
         fillCtx.globalCompositeOperation = "source-in";
         const inverse = Util.transform(getCurrentTransformInverse(fillCtx), [1, 0, 0, 1, -offsetX, -offsetY]);
-        fillCtx.fillStyle = isPatternFill ? fillColor.getPattern(ctx, this, inverse, PathType.FILL, opIdx) : fillColor;
+        fillCtx.fillStyle = isPatternFill ? fillColor.getPattern(ctx2, this, inverse, PathType.FILL, opIdx) : fillColor;
         fillCtx.fillRect(0, 0, width, height);
-        if (cache2 && !isPatternFill) {
-          cache2.set(cacheKey, fillCanvas.canvas);
+        if (cache3 && !isPatternFill) {
+          cache3.set(cacheKey, fillCanvas.canvas);
         }
         this.dependencyTracker?.recordDependencies(opIdx, Dependencies.transformAndFill);
         return {
           canvas: fillCanvas.canvas,
-          canvasEntry: cache2 && !isPatternFill ? null : fillCanvas,
+          canvasEntry: cache3 && !isPatternFill ? null : fillCanvas,
           offsetX: Math.round(offsetX),
           offsetY: Math.round(offsetY)
         };
@@ -19105,10 +19437,10 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
       }
       setDash(opIdx, dashArray, dashPhase) {
         this.dependencyTracker?.recordSimpleData("dash", opIdx);
-        const ctx = this.ctx;
-        if (ctx.setLineDash !== void 0) {
-          ctx.setLineDash(dashArray);
-          ctx.lineDashOffset = dashPhase;
+        const ctx2 = this.ctx;
+        if (ctx2.setLineDash !== void 0) {
+          ctx2.setLineDash(dashArray);
+          ctx2.lineDashOffset = dashPhase;
         }
       }
       setRenderingIntent(opIdx, intent) {
@@ -19307,10 +19639,10 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         const scratchCanvas = this.canvasFactory.create(drawnWidth, drawnHeight);
         this.smaskScratchCanvas = scratchCanvas;
         this.suspendedCtx = this.ctx;
-        const ctx = this.ctx = scratchCanvas.context;
-        ctx.setTransform(this.suspendedCtx.getTransform());
-        copyCtxState(this.suspendedCtx, ctx);
-        mirrorContextOperations(ctx, this.suspendedCtx);
+        const ctx2 = this.ctx = scratchCanvas.context;
+        ctx2.setTransform(this.suspendedCtx.getTransform());
+        copyCtxState(this.suspendedCtx, ctx2);
+        mirrorContextOperations(ctx2, this.suspendedCtx);
         this._ensurePreparedSMask(this.current.activeSMask);
         this.setGState(opIdx, [["BM", "source-over"]]);
       }
@@ -19379,11 +19711,11 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
           }
           return entry;
         }
-        const ctx = entry.context;
-        ctx.save();
-        ctx.setTransform(1, 0, 0, 1, 0, 0);
-        ctx.clearRect(0, 0, width, height);
-        ctx.restore();
+        const ctx2 = entry.context;
+        ctx2.save();
+        ctx2.setTransform(1, 0, 0, 1, 0, 0);
+        ctx2.clearRect(0, 0, width, height);
+        ctx2.restore();
         return entry;
       }
       #compositeKnockoutSurface(destCtx, surfaceCanvas, options = {}) {
@@ -19523,7 +19855,7 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         this.ctx.clearRect(0, 0, this.ctx.canvas.width, this.ctx.canvas.height);
         this.ctx.restore();
       }
-      composeSMask(ctx, smask, layerCtx, layerBox) {
+      composeSMask(ctx2, smask, layerCtx, layerBox) {
         const layerOffsetX = layerBox[0];
         const layerOffsetY = layerBox[1];
         const layerWidth = layerBox[2] - layerOffsetX;
@@ -19566,15 +19898,15 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         } else {
           this.genericComposeSMask(smask, layerCtx, layerWidth, layerHeight, layerOffsetX, layerOffsetY);
         }
-        if (!ctx) {
+        if (!ctx2) {
           return;
         }
-        ctx.save();
-        ctx.globalAlpha = 1;
-        ctx.globalCompositeOperation = smask.blendMode || "source-over";
-        ctx.setTransform(1, 0, 0, 1, 0, 0);
-        ctx.drawImage(layerCtx.canvas, layerOffsetX, layerOffsetY, layerWidth, layerHeight, layerOffsetX, layerOffsetY, layerWidth, layerHeight);
-        ctx.restore();
+        ctx2.save();
+        ctx2.globalAlpha = 1;
+        ctx2.globalCompositeOperation = smask.blendMode || "source-over";
+        ctx2.setTransform(1, 0, 0, 1, 0, 0);
+        ctx2.drawImage(layerCtx.canvas, layerOffsetX, layerOffsetY, layerWidth, layerHeight, layerOffsetX, layerOffsetY, layerWidth, layerHeight);
+        ctx2.restore();
       }
       _applySMaskOOBAlpha(layerCtx, layerOffsetX, layerOffsetY, layerWidth, layerHeight, maskX0, maskY0, maskX1, maskY1, alpha) {
         const hasInnerCutout = maskX0 < maskX1 && maskY0 < maskY1;
@@ -19681,21 +20013,21 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
       }
       stroke(opIdx, path, consumePath = true) {
         const started = consumePath && this.#beginKnockoutElement(this.current.strokeAlpha);
-        const ctx = this.ctx;
+        const ctx2 = this.ctx;
         const strokeColor = this.current.strokeColor;
-        ctx.globalAlpha = this.current.strokeAlpha;
+        ctx2.globalAlpha = this.current.strokeAlpha;
         if (this.contentVisible) {
           if (typeof strokeColor === "object" && strokeColor?.getPattern) {
-            const baseTransform = strokeColor.isModifyingCurrentTransform() ? ctx.getTransform() : null;
-            ctx.save();
-            ctx.strokeStyle = strokeColor.getPattern(ctx, this, getCurrentTransformInverse(ctx), PathType.STROKE, opIdx);
+            const baseTransform = strokeColor.isModifyingCurrentTransform() ? ctx2.getTransform() : null;
+            ctx2.save();
+            ctx2.strokeStyle = strokeColor.getPattern(ctx2, this, getCurrentTransformInverse(ctx2), PathType.STROKE, opIdx);
             if (baseTransform) {
               const newPath = new Path2D();
-              newPath.addPath(path, ctx.getTransform().invertSelf().multiplySelf(baseTransform));
+              newPath.addPath(path, ctx2.getTransform().invertSelf().multiplySelf(baseTransform));
               path = newPath;
             }
             this.rescaleAndStroke(path, false);
-            ctx.restore();
+            ctx2.restore();
           } else {
             this.rescaleAndStroke(path, true);
           }
@@ -19704,7 +20036,7 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         if (consumePath) {
           this.consumePath(opIdx, path, this.current.getClippedPathBoundingBox(PathType.STROKE, getCurrentTransform(this.ctx)));
         }
-        ctx.globalAlpha = this.current.fillAlpha;
+        ctx2.globalAlpha = this.current.fillAlpha;
         this.#endKnockoutElement(started);
       }
       closeStroke(opIdx, path) {
@@ -19712,7 +20044,7 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
       }
       fill(opIdx, path, consumePath = true) {
         const started = consumePath && this.#beginKnockoutElement(this.current.fillAlpha);
-        const ctx = this.ctx;
+        const ctx2 = this.ctx;
         const fillColor = this.current.fillColor;
         const isPatternFill = this.current.patternFill;
         let needRestore = false;
@@ -19731,27 +20063,27 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
             this.#endKnockoutElement(started);
             return;
           }
-          const baseTransform = fillColor.isModifyingCurrentTransform() ? ctx.getTransform() : null;
+          const baseTransform = fillColor.isModifyingCurrentTransform() ? ctx2.getTransform() : null;
           this.dependencyTracker?.save(opIdx);
-          ctx.save();
-          ctx.fillStyle = fillColor.getPattern(ctx, this, getCurrentTransformInverse(ctx), PathType.FILL, opIdx);
+          ctx2.save();
+          ctx2.fillStyle = fillColor.getPattern(ctx2, this, getCurrentTransformInverse(ctx2), PathType.FILL, opIdx);
           if (baseTransform) {
             const newPath = new Path2D();
-            newPath.addPath(path, ctx.getTransform().invertSelf().multiplySelf(baseTransform));
+            newPath.addPath(path, ctx2.getTransform().invertSelf().multiplySelf(baseTransform));
             path = newPath;
           }
           needRestore = true;
         }
         if (this.contentVisible && intersect !== null) {
           if (this.pendingEOFill) {
-            ctx.fill(path, "evenodd");
+            ctx2.fill(path, "evenodd");
             this.pendingEOFill = false;
           } else {
-            ctx.fill(path);
+            ctx2.fill(path);
           }
         }
         if (needRestore) {
-          ctx.restore();
+          ctx2.restore();
           this.dependencyTracker?.restore(opIdx);
         }
         if (consumePath) {
@@ -19807,7 +20139,7 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
       }
       endText(opIdx) {
         const paths = this.pendingTextPaths;
-        const ctx = this.ctx;
+        const ctx2 = this.ctx;
         if (this.dependencyTracker) {
           const {
             dependencyTracker
@@ -19819,7 +20151,7 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         }
         if (paths !== void 0) {
           const newPath = new Path2D();
-          const invTransf = ctx.getTransform().invertSelf();
+          const invTransf = ctx2.getTransform().invertSelf();
           for (const {
             transform,
             x,
@@ -19832,7 +20164,7 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
             }
             newPath.addPath(path, new DOMMatrix(transform).preMultiplySelf(invTransf).translate(x, y).scale(fontSize, -fontSize));
           }
-          ctx.clip(newPath);
+          ctx2.clip(newPath);
         }
         delete this.pendingTextPaths;
       }
@@ -19924,7 +20256,7 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         return newPath;
       }
       paintChar(opIdx, character, x, y, patternFillTransform, patternStrokeTransform) {
-        const ctx = this.ctx;
+        const ctx2 = this.ctx;
         const current = this.current;
         const font = current.font;
         const textRenderingMode = current.textRenderingMode;
@@ -19938,25 +20270,25 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
           path = font.getPathGenerator(this.commonObjs, character);
         }
         if (path && (font.disableFontFace || patternFill || patternStroke)) {
-          ctx.save();
-          ctx.translate(x, y);
-          ctx.scale(fontSize, -fontSize);
-          this.dependencyTracker?.recordCharacterBBox(opIdx, ctx, font);
+          ctx2.save();
+          ctx2.translate(x, y);
+          ctx2.scale(fontSize, -fontSize);
+          this.dependencyTracker?.recordCharacterBBox(opIdx, ctx2, font);
           let currentTransform;
           if (fillStrokeMode === TextRenderingMode.FILL || fillStrokeMode === TextRenderingMode.FILL_STROKE) {
             if (patternFillTransform) {
-              currentTransform = ctx.getTransform();
-              ctx.setTransform(...patternFillTransform);
+              currentTransform = ctx2.getTransform();
+              ctx2.setTransform(...patternFillTransform);
               const scaledPath = this.#getScaledPath(path, currentTransform, patternFillTransform);
-              ctx.fill(scaledPath);
+              ctx2.fill(scaledPath);
             } else {
-              ctx.fill(path);
+              ctx2.fill(path);
             }
           }
           if (fillStrokeMode === TextRenderingMode.STROKE || fillStrokeMode === TextRenderingMode.FILL_STROKE) {
             if (patternStrokeTransform) {
-              currentTransform ||= ctx.getTransform();
-              ctx.setTransform(...patternStrokeTransform);
+              currentTransform ||= ctx2.getTransform();
+              ctx2.setTransform(...patternStrokeTransform);
               const {
                 a,
                 b,
@@ -19966,44 +20298,44 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
               const invPatternTransform = Util.inverseTransform(patternStrokeTransform);
               const transf = Util.transform([a, b, c, d, 0, 0], invPatternTransform);
               Util.singularValueDecompose2dScale(transf, XY);
-              ctx.lineWidth *= Math.max(XY[0], XY[1]) / fontSize;
-              ctx.stroke(this.#getScaledPath(path, currentTransform, patternStrokeTransform));
+              ctx2.lineWidth *= Math.max(XY[0], XY[1]) / fontSize;
+              ctx2.stroke(this.#getScaledPath(path, currentTransform, patternStrokeTransform));
             } else {
-              ctx.lineWidth /= fontSize;
-              ctx.stroke(path);
+              ctx2.lineWidth /= fontSize;
+              ctx2.stroke(path);
             }
           }
-          ctx.restore();
+          ctx2.restore();
         } else {
           if (fillStrokeMode === TextRenderingMode.FILL || fillStrokeMode === TextRenderingMode.FILL_STROKE) {
-            ctx.fillText(character, x, y);
-            this.dependencyTracker?.recordCharacterBBox(opIdx, ctx, font, fontSize, x, y, () => ctx.measureText(character));
+            ctx2.fillText(character, x, y);
+            this.dependencyTracker?.recordCharacterBBox(opIdx, ctx2, font, fontSize, x, y, () => ctx2.measureText(character));
           }
           if (fillStrokeMode === TextRenderingMode.STROKE || fillStrokeMode === TextRenderingMode.FILL_STROKE) {
             if (this.dependencyTracker) {
-              this.dependencyTracker?.recordCharacterBBox(opIdx, ctx, font, fontSize, x, y, () => ctx.measureText(character)).recordDependencies(opIdx, Dependencies.stroke);
+              this.dependencyTracker?.recordCharacterBBox(opIdx, ctx2, font, fontSize, x, y, () => ctx2.measureText(character)).recordDependencies(opIdx, Dependencies.stroke);
             }
-            ctx.strokeText(character, x, y);
+            ctx2.strokeText(character, x, y);
           }
         }
         if (isAddToPathSet) {
           const paths = this.pendingTextPaths ||= [];
           paths.push({
-            transform: getCurrentTransform(ctx),
+            transform: getCurrentTransform(ctx2),
             x,
             y,
             fontSize,
             path
           });
-          this.dependencyTracker?.recordCharacterBBox(opIdx, ctx, font, fontSize, x, y);
+          this.dependencyTracker?.recordCharacterBBox(opIdx, ctx2, font, fontSize, x, y);
         }
       }
       get isFontSubpixelAAEnabled() {
         const tmpCanvas = this.canvasFactory.create(10, 10);
-        const ctx = tmpCanvas.context;
-        ctx.scale(1.5, 1);
-        ctx.fillText("I", 0, 10);
-        const data = ctx.getImageData(0, 0, 10, 10).data;
+        const ctx2 = tmpCanvas.context;
+        ctx2.scale(1.5, 1);
+        ctx2.fillText("I", 0, 10);
+        const data = ctx2.getImageData(0, 0, 10, 10).data;
         this.canvasFactory.destroy(tmpCanvas);
         let enabled = false;
         for (let i = 3; i < data.length; i += 4) {
@@ -20036,7 +20368,7 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
           return;
         }
         const started = this.#beginKnockoutElement(current.fillAlpha);
-        const ctx = this.ctx;
+        const ctx2 = this.ctx;
         const fontSizeScale = current.fontSizeScale;
         const charSpacing = current.charSpacing;
         const wordSpacing = current.wordSpacing;
@@ -20048,15 +20380,15 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         const defaultVMetrics = font.defaultVMetrics;
         const widthAdvanceScale = fontSize * current.fontMatrix[0];
         const simpleFillText = current.textRenderingMode === TextRenderingMode.FILL && !font.disableFontFace && !current.patternFill;
-        ctx.save();
+        ctx2.save();
         if (current.textMatrix) {
-          ctx.transform(...current.textMatrix);
+          ctx2.transform(...current.textMatrix);
         }
-        ctx.translate(current.x, current.y + current.textRise);
+        ctx2.translate(current.x, current.y + current.textRise);
         if (fontDirection > 0) {
-          ctx.scale(textHScale, -1);
+          ctx2.scale(textHScale, -1);
         } else {
-          ctx.scale(textHScale, 1);
+          ctx2.scale(textHScale, 1);
         }
         let patternFillTransform, patternStrokeTransform;
         const fillStrokeMode = current.textRenderingMode & TextRenderingMode.FILL_STROKE_MASK;
@@ -20072,23 +20404,23 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
           lineWidth /= scale;
         }
         if (fontSizeScale !== 1) {
-          ctx.scale(fontSizeScale, fontSizeScale);
+          ctx2.scale(fontSizeScale, fontSizeScale);
           lineWidth /= fontSizeScale;
         }
-        ctx.lineWidth = lineWidth;
+        ctx2.lineWidth = lineWidth;
         if (needsFill && current.patternFill) {
-          ctx.save();
-          const pattern = current.fillColor.getPattern(ctx, this, getCurrentTransformInverse(ctx), PathType.FILL, opIdx);
-          patternFillTransform = getCurrentTransform(ctx);
-          ctx.restore();
-          ctx.fillStyle = pattern;
+          ctx2.save();
+          const pattern = current.fillColor.getPattern(ctx2, this, getCurrentTransformInverse(ctx2), PathType.FILL, opIdx);
+          patternFillTransform = getCurrentTransform(ctx2);
+          ctx2.restore();
+          ctx2.fillStyle = pattern;
         }
         if (needsStroke && current.patternStroke) {
-          ctx.save();
-          const pattern = current.strokeColor.getPattern(ctx, this, getCurrentTransformInverse(ctx), PathType.STROKE, opIdx);
-          patternStrokeTransform = getCurrentTransform(ctx);
-          ctx.restore();
-          ctx.strokeStyle = pattern;
+          ctx2.save();
+          const pattern = current.strokeColor.getPattern(ctx2, this, getCurrentTransformInverse(ctx2), PathType.STROKE, opIdx);
+          patternStrokeTransform = getCurrentTransform(ctx2);
+          ctx2.restore();
+          ctx2.strokeStyle = pattern;
         }
         if (font.isInvalidPDFjsFont) {
           const chars = [];
@@ -20098,13 +20430,13 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
             width += glyph.width;
           }
           const joinedChars = chars.join("");
-          ctx.fillText(joinedChars, 0, 0);
+          ctx2.fillText(joinedChars, 0, 0);
           if (this.dependencyTracker !== null) {
-            const measure = ctx.measureText(joinedChars);
+            const measure = ctx2.measureText(joinedChars);
             this.dependencyTracker.recordBBox(opIdx, this.ctx, -measure.actualBoundingBoxLeft, measure.actualBoundingBoxRight, -measure.actualBoundingBoxAscent, measure.actualBoundingBoxDescent).recordShowTextOperation(opIdx);
           }
           current.x += width * widthAdvanceScale * textHScale;
-          ctx.restore();
+          ctx2.restore();
           this.compose();
           this.#endKnockoutElement(started);
           return;
@@ -20135,13 +20467,13 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
           }
           let measure;
           if (font.remeasure && width > 0) {
-            measure = ctx.measureText(character);
+            measure = ctx2.measureText(character);
             const measuredWidth = measure.width * 1e3 / fontSize * fontSizeScale;
             if (width < measuredWidth && this.isFontSubpixelAAEnabled) {
               const characterScaleX = width / measuredWidth;
               restoreNeeded = true;
-              ctx.save();
-              ctx.scale(characterScaleX, 1);
+              ctx2.save();
+              ctx2.scale(characterScaleX, 1);
               scaledX /= characterScaleX;
             } else if (width !== measuredWidth) {
               scaledX += (width - measuredWidth) / 2e3 * fontSize / fontSizeScale;
@@ -20149,10 +20481,10 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
           }
           if (this.contentVisible && (glyph.isInFont || font.missingFile)) {
             if (simpleFillText && !accent) {
-              ctx.fillText(character, scaledX, scaledY);
-              this.dependencyTracker?.recordCharacterBBox(opIdx, ctx, measure ? {
+              ctx2.fillText(character, scaledX, scaledY);
+              this.dependencyTracker?.recordCharacterBBox(opIdx, ctx2, measure ? {
                 bbox: null
-              } : font, fontSize / fontSizeScale, scaledX, scaledY, () => measure ?? ctx.measureText(character));
+              } : font, fontSize / fontSizeScale, scaledX, scaledY, () => measure ?? ctx2.measureText(character));
             } else {
               this.paintChar(opIdx, character, scaledX, scaledY, patternFillTransform, patternStrokeTransform);
               if (accent) {
@@ -20165,7 +20497,7 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
           const charWidth = vertical ? width * widthAdvanceScale - spacing * fontDirection : width * widthAdvanceScale + spacing * fontDirection;
           x += charWidth;
           if (restoreNeeded) {
-            ctx.restore();
+            ctx2.restore();
           }
         }
         if (vertical) {
@@ -20173,13 +20505,13 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         } else {
           current.x += x * textHScale;
         }
-        ctx.restore();
+        ctx2.restore();
         this.compose();
         this.dependencyTracker?.recordShowTextOperation(opIdx);
         this.#endKnockoutElement(started);
       }
       showType3Text(opIdx, glyphs) {
-        const ctx = this.ctx;
+        const ctx2 = this.ctx;
         const current = this.current;
         const font = current.font;
         const fontSize = current.fontSize;
@@ -20197,12 +20529,12 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         }
         this._cachedScaleForStroking[0] = -1;
         this._cachedGetSinglePixelWidth = null;
-        ctx.save();
+        ctx2.save();
         if (current.textMatrix) {
-          ctx.transform(...current.textMatrix);
+          ctx2.transform(...current.textMatrix);
         }
-        ctx.translate(current.x, current.y + current.textRise);
-        ctx.scale(textHScale, fontDirection);
+        ctx2.translate(current.x, current.y + current.textRise);
+        ctx2.scale(textHScale, fontDirection);
         const dependencyTracker = this.dependencyTracker;
         this.dependencyTracker = dependencyTracker ? new CanvasNestedDependencyTracker(dependencyTracker, opIdx) : null;
         for (i = 0; i < glyphsLength; ++i) {
@@ -20221,20 +20553,20 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
             this.save();
             if (operatorList.fnArray[0] === OPS.setCharWidth) {
               current.fillAlpha = current.strokeAlpha = 1;
-              ctx.globalAlpha = 1;
+              ctx2.globalAlpha = 1;
             }
-            ctx.scale(fontSize, fontSize);
-            ctx.transform(...fontMatrix);
+            ctx2.scale(fontSize, fontSize);
+            ctx2.transform(...fontMatrix);
             this.executeOperatorList(operatorList);
             this.restore();
           }
           const p = [glyph.width, 0];
           Util.applyTransform(p, fontMatrix);
           width = p[0] * fontSize + spacing;
-          ctx.translate(width, 0);
+          ctx2.translate(width, 0);
           current.x += width * textHScale;
         }
-        ctx.restore();
+        ctx2.restore();
         if (dependencyTracker) {
           this.dependencyTracker = dependencyTracker;
         }
@@ -20253,7 +20585,7 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         if (IR[0] === "TilingPattern") {
           const baseTransform = this.baseTransform || getCurrentTransform(this.ctx);
           const canvasGraphicsFactory = {
-            createCanvasGraphics: (ctx, renderingOpIdx) => new _CanvasGraphics(ctx, this.commonObjs, this.objs, this.canvasFactory, this.filterFactory, {
+            createCanvasGraphics: (ctx2, renderingOpIdx) => new _CanvasGraphics(ctx2, this.commonObjs, this.objs, this.canvasFactory, this.filterFactory, {
               optionalContentConfig: this.optionalContentConfig,
               markedContentStack: this.markedContentStack
             }, void 0, void 0, this.dependencyTracker ? new CanvasNestedDependencyTracker(this.dependencyTracker, renderingOpIdx, true) : null)
@@ -20309,16 +20641,16 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
           return;
         }
         const started = this.#beginKnockoutElement(this.current.fillAlpha);
-        const ctx = this.ctx;
+        const ctx2 = this.ctx;
         this.save(opIdx);
         const pattern = this._getPattern(opIdx, objId);
-        ctx.fillStyle = pattern.getPattern(ctx, this, getCurrentTransformInverse(ctx), PathType.SHADING, opIdx);
-        const inv = getCurrentTransformInverse(ctx);
+        ctx2.fillStyle = pattern.getPattern(ctx2, this, getCurrentTransformInverse(ctx2), PathType.SHADING, opIdx);
+        const inv = getCurrentTransformInverse(ctx2);
         if (inv) {
           const {
             width,
             height
-          } = ctx.canvas;
+          } = ctx2.canvas;
           const minMax = F32_BBOX_INIT.slice();
           Util.axialAlignedBoundingBox([0, 0, width, height], inv, minMax);
           const [x0, y0, x1, y1] = minMax;
@@ -20490,19 +20822,19 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         }
         this.groupLevel--;
         const groupCtx = this.ctx;
-        const ctx = this.groupStack.pop();
+        const ctx2 = this.groupStack.pop();
         const groupMeta = this.#groupStackMeta.pop();
         if (groupMeta) {
           this.#knockoutGroupLevel = groupMeta.savedKnockoutLevel;
         }
-        if (ctx === null) {
+        if (ctx2 === null) {
           this.restore(opIdx);
           return;
         }
         if (group.isGray) {
           this.#convertGroupToGray(groupCtx);
         }
-        this.ctx = ctx;
+        this.ctx = ctx2;
         this.ctx.imageSmoothingEnabled = false;
         this.dependencyTracker?.popBaseTransform();
         if (group.smask) {
@@ -20532,7 +20864,7 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
               } = groupCtx.canvas;
               const colorEntry = this.canvasFactory.create(width, height);
               const colorCtx = colorEntry.context;
-              colorCtx.drawImage(ctx.canvas, groupMeta.offsetX, groupMeta.offsetY, width, height, 0, 0, width, height);
+              colorCtx.drawImage(ctx2.canvas, groupMeta.offsetX, groupMeta.offsetY, width, height, 0, 0, width, height);
               colorCtx.globalCompositeOperation = "source-over";
               colorCtx.drawImage(groupCtx.canvas, 0, 0);
               const shapeMaskEntry = this.#createKnockoutMaskCanvas(groupCtx.canvas);
@@ -20706,14 +21038,14 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         img = this.getObject(opIdx, img.data, img);
         img.count = count;
         const started = this.#beginKnockoutElement(this.current.fillAlpha);
-        const ctx = this.ctx;
+        const ctx2 = this.ctx;
         const mask = this._createMaskCanvas(opIdx, img);
         const maskCanvas = mask.canvas;
-        ctx.save();
-        ctx.setTransform(1, 0, 0, 1, 0, 0);
-        ctx.drawImage(maskCanvas, mask.offsetX, mask.offsetY);
+        ctx2.save();
+        ctx2.setTransform(1, 0, 0, 1, 0, 0);
+        ctx2.drawImage(maskCanvas, mask.offsetX, mask.offsetY);
         this.dependencyTracker?.resetBBox(opIdx).recordBBox(opIdx, this.ctx, mask.offsetX, mask.offsetX + maskCanvas.width, mask.offsetY, mask.offsetY + maskCanvas.height).recordOperation(opIdx);
-        ctx.restore();
+        ctx2.restore();
         if (mask.canvasEntry) {
           this.canvasFactory.destroy(mask.canvasEntry);
         }
@@ -20726,19 +21058,19 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         }
         img = this.getObject(opIdx, img.data, img);
         const started = this.#beginKnockoutElement(this.current.fillAlpha);
-        const ctx = this.ctx;
-        ctx.save();
-        const currentTransform = getCurrentTransform(ctx);
-        ctx.transform(scaleX, skewX, skewY, scaleY, 0, 0);
+        const ctx2 = this.ctx;
+        ctx2.save();
+        const currentTransform = getCurrentTransform(ctx2);
+        ctx2.transform(scaleX, skewX, skewY, scaleY, 0, 0);
         const mask = this._createMaskCanvas(opIdx, img);
-        ctx.setTransform(1, 0, 0, 1, mask.offsetX - currentTransform[4], mask.offsetY - currentTransform[5]);
+        ctx2.setTransform(1, 0, 0, 1, mask.offsetX - currentTransform[4], mask.offsetY - currentTransform[5]);
         this.dependencyTracker?.resetBBox(opIdx);
         for (let i = 0, ii = positions.length; i < ii; i += 2) {
           const trans = Util.transform(currentTransform, [scaleX, skewX, skewY, scaleY, positions[i], positions[i + 1]]);
-          ctx.drawImage(mask.canvas, trans[4], trans[5]);
+          ctx2.drawImage(mask.canvas, trans[4], trans[5]);
           this.dependencyTracker?.recordBBox(opIdx, this.ctx, trans[4], trans[4] + mask.canvas.width, trans[5], trans[5] + mask.canvas.height);
         }
-        ctx.restore();
+        ctx2.restore();
         if (mask.canvasEntry) {
           this.canvasFactory.destroy(mask.canvasEntry);
         }
@@ -20751,7 +21083,7 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
           return;
         }
         const started = this.#beginKnockoutElement(this.current.fillAlpha);
-        const ctx = this.ctx;
+        const ctx2 = this.ctx;
         const fillColor = this.current.fillColor;
         const isPatternFill = this.current.patternFill;
         this.dependencyTracker?.resetBBox(opIdx).recordDependencies(opIdx, Dependencies.transformAndFill);
@@ -20768,16 +21100,16 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
           const img = this.getObject(opIdx, data, image);
           putBinaryImageMask(maskCtx, img);
           maskCtx.globalCompositeOperation = "source-in";
-          maskCtx.fillStyle = isPatternFill ? fillColor.getPattern(maskCtx, this, getCurrentTransformInverse(ctx), PathType.FILL, opIdx) : fillColor;
+          maskCtx.fillStyle = isPatternFill ? fillColor.getPattern(maskCtx, this, getCurrentTransformInverse(ctx2), PathType.FILL, opIdx) : fillColor;
           maskCtx.fillRect(0, 0, width, height);
           maskCtx.restore();
-          ctx.save();
-          ctx.transform(...transform);
-          ctx.scale(1, -1);
-          drawImageAtIntegerCoords(ctx, maskCanvas.canvas, 0, 0, width, height, 0, -1, 1, 1);
+          ctx2.save();
+          ctx2.transform(...transform);
+          ctx2.scale(1, -1);
+          drawImageAtIntegerCoords(ctx2, maskCanvas.canvas, 0, 0, width, height, 0, -1, 1, 1);
           this.canvasFactory.destroy(maskCanvas);
-          this.dependencyTracker?.recordBBox(opIdx, ctx, 0, width, 0, height);
-          ctx.restore();
+          this.dependencyTracker?.recordBBox(opIdx, ctx2, 0, width, 0, height);
+          ctx2.restore();
         }
         this.compose();
         this.dependencyTracker?.recordOperation(opIdx);
@@ -20817,13 +21149,13 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         }
         this.paintInlineImageXObjectGroup(opIdx, imgData, map);
       }
-      applyTransferMapsToCanvas(ctx) {
+      applyTransferMapsToCanvas(ctx2) {
         if (this.current.transferMaps !== "none") {
-          ctx.filter = this.current.transferMaps;
-          ctx.drawImage(ctx.canvas, 0, 0);
-          ctx.filter = "none";
+          ctx2.filter = this.current.transferMaps;
+          ctx2.drawImage(ctx2.canvas, 0, 0);
+          ctx2.filter = "none";
         }
-        return ctx.canvas;
+        return ctx2.canvas;
       }
       applyTransferMapsToBitmap(imgData) {
         if (this.current.transferMaps === "none") {
@@ -20854,15 +21186,15 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         const width = imgData.width;
         const height = imgData.height;
         const started = this.#beginKnockoutElement(this.current.fillAlpha);
-        const ctx = this.ctx;
+        const ctx2 = this.ctx;
         this.save(opIdx);
         const {
           filter
-        } = ctx;
+        } = ctx2;
         if (filter !== "none" && filter !== "") {
-          ctx.filter = "none";
+          ctx2.filter = "none";
         }
-        ctx.scale(1 / width, -1 / height);
+        ctx2.scale(1 / width, -1 / height);
         let imgToPaint;
         let inlineImgCanvas = null;
         if (imgData.bitmap) {
@@ -20875,13 +21207,13 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
           imgToPaint = this.applyTransferMapsToCanvas(tmpCanvas.context);
           inlineImgCanvas = tmpCanvas;
         }
-        const scaled = this._scaleImage(imgToPaint, getCurrentTransformInverse(ctx));
-        ctx.imageSmoothingEnabled = getImageSmoothingEnabled(getCurrentTransform(ctx), imgData.interpolate);
+        const scaled = this._scaleImage(imgToPaint, getCurrentTransformInverse(ctx2));
+        ctx2.imageSmoothingEnabled = getImageSmoothingEnabled(getCurrentTransform(ctx2), imgData.interpolate);
         if (this.dependencyTracker) {
-          this.dependencyTracker.resetBBox(opIdx).recordBBox(opIdx, ctx, 0, width, -height, 0).recordDependencies(opIdx, Dependencies.imageXObject).recordOperation(opIdx);
-          this.imagesTracker?.record(ctx, width, height, this.dependencyTracker.clipBox);
+          this.dependencyTracker.resetBBox(opIdx).recordBBox(opIdx, ctx2, 0, width, -height, 0).recordDependencies(opIdx, Dependencies.imageXObject).recordOperation(opIdx);
+          this.imagesTracker?.record(ctx2, width, height, this.dependencyTracker.clipBox);
         }
-        drawImageAtIntegerCoords(ctx, scaled.img, 0, 0, scaled.paintWidth, scaled.paintHeight, 0, -height, width, height);
+        drawImageAtIntegerCoords(ctx2, scaled.img, 0, 0, scaled.paintWidth, scaled.paintHeight, 0, -height, width, height);
         if (scaled.tmpCanvas) {
           this.canvasFactory.destroy(scaled.tmpCanvas);
         }
@@ -20897,7 +21229,7 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
           return;
         }
         const started = this.#beginKnockoutElement(this.current.fillAlpha);
-        const ctx = this.ctx;
+        const ctx2 = this.ctx;
         let imgToPaint;
         let inlineImgCanvas = null;
         if (imgData.bitmap) {
@@ -20912,12 +21244,12 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         }
         this.dependencyTracker?.resetBBox(opIdx);
         for (const entry of map) {
-          ctx.save();
-          ctx.transform(...entry.transform);
-          ctx.scale(1, -1);
-          drawImageAtIntegerCoords(ctx, imgToPaint, entry.x, entry.y, entry.w, entry.h, 0, -1, 1, 1);
-          this.dependencyTracker?.recordBBox(opIdx, ctx, 0, 1, -1, 0);
-          ctx.restore();
+          ctx2.save();
+          ctx2.transform(...entry.transform);
+          ctx2.scale(1, -1);
+          drawImageAtIntegerCoords(ctx2, imgToPaint, entry.x, entry.y, entry.w, entry.h, 0, -1, 1, 1);
+          this.dependencyTracker?.recordBBox(opIdx, ctx2, 0, 1, -1, 0);
+          ctx2.restore();
         }
         if (inlineImgCanvas) {
           this.canvasFactory.destroy(inlineImgCanvas);
@@ -20976,13 +21308,13 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         if (!this.pendingClip) {
           this.compose(clipBox);
         }
-        const ctx = this.ctx;
+        const ctx2 = this.ctx;
         if (this.pendingClip) {
           if (!isEmpty) {
             if (this.pendingClip === EO_CLIP) {
-              ctx.clip(path, "evenodd");
+              ctx2.clip(path, "evenodd");
             } else {
-              ctx.clip(path);
+              ctx2.clip(path);
             }
           }
           this.pendingClip = null;
@@ -21057,36 +21389,36 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
       }
       rescaleAndStroke(path, saveRestore) {
         const {
-          ctx,
+          ctx: ctx2,
           current: {
             lineWidth
           }
         } = this;
         const [scaleX, scaleY] = this.getScaleForStroking();
         if (scaleX === scaleY) {
-          ctx.lineWidth = (lineWidth || 1) * scaleX;
-          ctx.stroke(path);
+          ctx2.lineWidth = (lineWidth || 1) * scaleX;
+          ctx2.stroke(path);
           return;
         }
         const SCALE_MATRIX = _CanvasGraphics.#SCALE_MATRIX ??= new DOMMatrix();
-        const dashes = ctx.getLineDash();
+        const dashes = ctx2.getLineDash();
         if (saveRestore) {
-          ctx.save();
+          ctx2.save();
         }
-        ctx.scale(scaleX, scaleY);
+        ctx2.scale(scaleX, scaleY);
         SCALE_MATRIX.a = 1 / scaleX;
         SCALE_MATRIX.d = 1 / scaleY;
         const newPath = new Path2D();
         newPath.addPath(path, SCALE_MATRIX);
         if (dashes.length > 0) {
           const scale = Math.max(scaleX, scaleY);
-          ctx.setLineDash(dashes.map((x) => x / scale));
-          ctx.lineDashOffset /= scale;
+          ctx2.setLineDash(dashes.map((x) => x / scale));
+          ctx2.lineDashOffset /= scale;
         }
-        ctx.lineWidth = lineWidth || 1;
-        ctx.stroke(newPath);
+        ctx2.lineWidth = lineWidth || 1;
+        ctx2.stroke(newPath);
         if (saveRestore) {
-          ctx.restore();
+          ctx2.restore();
         }
       }
       isContentVisible() {
@@ -22785,7 +23117,7 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         const {
           div,
           properties,
-          ctx
+          ctx: ctx2
         } = params;
         const {
           style
@@ -22798,10 +23130,10 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
             canvasWidth,
             fontSize
           } = properties;
-          _TextLayer.#ensureCtxFont(ctx, fontSize * this.#scale, fontFamily);
+          _TextLayer.#ensureCtxFont(ctx2, fontSize * this.#scale, fontFamily);
           const {
             width
-          } = ctx.measureText(div.textContent);
+          } = ctx2.measureText(div.textContent);
           if (width > 0) {
             style.setProperty("--scale-x", canvasWidth * this.#scale / width);
           }
@@ -22823,30 +23155,30 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         this.#canvasContexts.clear();
       }
       static #getCtx(lang = null) {
-        let ctx = this.#canvasContexts.get(lang ||= "");
-        if (!ctx) {
+        let ctx2 = this.#canvasContexts.get(lang ||= "");
+        if (!ctx2) {
           const canvas = document.createElement("canvas");
           canvas.style.cssText = "position:absolute;top:0;left:0;width:0;height:0;display:none;letter-spacing:normal;word-spacing:normal";
           canvas.lang = lang;
           document.body.append(canvas);
-          ctx = canvas.getContext("2d", {
+          ctx2 = canvas.getContext("2d", {
             alpha: false,
             willReadFrequently: true
           });
-          this.#canvasContexts.set(lang, ctx);
-          this.#canvasCtxFonts.set(ctx, {
+          this.#canvasContexts.set(lang, ctx2);
+          this.#canvasCtxFonts.set(ctx2, {
             size: 0,
             family: ""
           });
         }
-        return ctx;
+        return ctx2;
       }
-      static #ensureCtxFont(ctx, size, family) {
-        const cached3 = this.#canvasCtxFonts.get(ctx);
+      static #ensureCtxFont(ctx2, size, family) {
+        const cached3 = this.#canvasCtxFonts.get(ctx2);
         if (size === cached3.size && family === cached3.family) {
           return;
         }
-        ctx.font = `${size}px ${family}`;
+        ctx2.font = `${size}px ${family}`;
         cached3.size = size;
         cached3.family = family;
       }
@@ -22869,13 +23201,13 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         if (cachedAscent) {
           return cachedAscent;
         }
-        const ctx = this.#getCtx(lang);
-        ctx.canvas.width = ctx.canvas.height = DEFAULT_FONT_SIZE;
-        this.#ensureCtxFont(ctx, DEFAULT_FONT_SIZE, fontFamily);
-        const metrics = ctx.measureText("");
+        const ctx2 = this.#getCtx(lang);
+        ctx2.canvas.width = ctx2.canvas.height = DEFAULT_FONT_SIZE;
+        this.#ensureCtxFont(ctx2, DEFAULT_FONT_SIZE, fontFamily);
+        const metrics = ctx2.measureText("");
         const ascent = metrics.fontBoundingBoxAscent;
         const descent = Math.abs(metrics.fontBoundingBoxDescent);
-        ctx.canvas.width = ctx.canvas.height = 0;
+        ctx2.canvas.width = ctx2.canvas.height = 0;
         let ratio = 0.8;
         if (ascent) {
           ratio = ascent / (ascent + descent);
@@ -32615,8 +32947,8 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
             newWidth = Math.ceil(prevWidth / 2);
             newHeight = Math.ceil(prevHeight / 2);
             const offscreen2 = new OffscreenCanvas(newWidth, newHeight);
-            const ctx2 = offscreen2.getContext("2d");
-            ctx2.drawImage(bitmap, 0, 0, prevWidth, prevHeight, 0, 0, newWidth, newHeight);
+            const ctx3 = offscreen2.getContext("2d");
+            ctx3.drawImage(bitmap, 0, 0, prevWidth, prevHeight, 0, 0, newWidth, newHeight);
             prevWidth = newWidth;
             prevHeight = newHeight;
             if (bitmap !== originalBitmap) {
@@ -32629,14 +32961,14 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
           newHeight = Math.round(newHeight * ratio);
         }
         const offscreen = new OffscreenCanvas(newWidth, newHeight);
-        const ctx = offscreen.getContext("2d", {
+        const ctx2 = offscreen.getContext("2d", {
           willReadFrequently: true
         });
-        ctx.fillStyle = "white";
-        ctx.fillRect(0, 0, newWidth, newHeight);
-        ctx.filter = "grayscale(1)";
-        ctx.drawImage(bitmap, 0, 0, bitmap.width, bitmap.height, 0, 0, newWidth, newHeight);
-        const grayImage = ctx.getImageData(0, 0, newWidth, newHeight).data;
+        ctx2.fillStyle = "white";
+        ctx2.fillRect(0, 0, newWidth, newHeight);
+        ctx2.filter = "grayscale(1)";
+        ctx2.drawImage(bitmap, 0, 0, bitmap.width, bitmap.height, 0, 0, newWidth, newHeight);
+        const grayImage = ctx2.getImageData(0, 0, newWidth, newHeight).data;
         const uint8Buf = this.#toUint8(grayImage);
         return [uint8Buf, newWidth, newHeight];
       }
@@ -32646,11 +32978,11 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         fontWeight
       }, pageWidth, pageHeight, rotation, innerMargin) {
         let canvas = new OffscreenCanvas(1, 1);
-        let ctx = canvas.getContext("2d", {
+        let ctx2 = canvas.getContext("2d", {
           alpha: false
         });
         const fontSize = 200;
-        const font = ctx.font = `${fontStyle} ${fontWeight} ${fontSize}px ${fontFamily}`;
+        const font = ctx2.font = `${fontStyle} ${fontWeight} ${fontSize}px ${fontFamily}`;
         const {
           actualBoundingBoxLeft,
           actualBoundingBoxRight,
@@ -32659,22 +32991,22 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
           fontBoundingBoxAscent,
           fontBoundingBoxDescent,
           width
-        } = ctx.measureText(text);
+        } = ctx2.measureText(text);
         const SCALE = 1.5;
         const canvasWidth = Math.ceil(Math.max(Math.abs(actualBoundingBoxLeft) + Math.abs(actualBoundingBoxRight) || 0, width) * SCALE);
         const canvasHeight = Math.ceil(Math.max(Math.abs(actualBoundingBoxAscent) + Math.abs(actualBoundingBoxDescent) || fontSize, Math.abs(fontBoundingBoxAscent) + Math.abs(fontBoundingBoxDescent) || fontSize) * SCALE);
         canvas = new OffscreenCanvas(canvasWidth, canvasHeight);
-        ctx = canvas.getContext("2d", {
+        ctx2 = canvas.getContext("2d", {
           alpha: true,
           willReadFrequently: true
         });
-        ctx.font = font;
-        ctx.filter = "grayscale(1)";
-        ctx.fillStyle = "white";
-        ctx.fillRect(0, 0, canvasWidth, canvasHeight);
-        ctx.fillStyle = "black";
-        ctx.fillText(text, canvasWidth * (SCALE - 1) / 2, canvasHeight * (3 - SCALE) / 2);
-        const uint8Buf = this.#toUint8(ctx.getImageData(0, 0, canvasWidth, canvasHeight).data);
+        ctx2.font = font;
+        ctx2.filter = "grayscale(1)";
+        ctx2.fillStyle = "white";
+        ctx2.fillRect(0, 0, canvasWidth, canvasHeight);
+        ctx2.fillStyle = "black";
+        ctx2.fillText(text, canvasWidth * (SCALE - 1) / 2, canvasHeight * (3 - SCALE) / 2);
+        const uint8Buf = this.#toUint8(ctx2.getImageData(0, 0, canvasWidth, canvasHeight).data);
         const histogram = this.#getHistogram(uint8Buf);
         const threshold = this.#guessThreshold(histogram);
         const contourList = this.#findContours(uint8Buf, canvasWidth, canvasHeight, threshold);
@@ -33640,8 +33972,8 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
           if (!this.#isSvg) {
             bitmap = this.#scaleBitmap(scaledWidth, scaledHeight);
           }
-          const ctx = canvas.getContext("2d");
-          ctx.filter = this._uiManager.hcmFilter;
+          const ctx2 = canvas.getContext("2d");
+          ctx2.filter = this._uiManager.hcmFilter;
           let white = "white", black = "#cfcfd8";
           if (this._uiManager.hcmFilter !== "none") {
             black = "black";
@@ -33659,9 +33991,9 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
           patternCtx.fillStyle = black;
           patternCtx.fillRect(0, 0, boxDimWidth, boxDimHeight);
           patternCtx.fillRect(boxDimWidth, boxDimHeight, boxDimWidth, boxDimHeight);
-          ctx.fillStyle = ctx.createPattern(pattern, "repeat");
-          ctx.fillRect(0, 0, scaledWidth, scaledHeight);
-          ctx.drawImage(bitmap, 0, 0, bitmap.width, bitmap.height, 0, 0, scaledWidth, scaledHeight);
+          ctx2.fillStyle = ctx2.createPattern(pattern, "repeat");
+          ctx2.fillRect(0, 0, scaledWidth, scaledHeight);
+          ctx2.drawImage(bitmap, 0, 0, bitmap.width, bitmap.height, 0, 0, scaledWidth, scaledHeight);
         }
         let imageData = null;
         if (createImageData) {
@@ -33716,8 +34048,8 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
             newHeight = Math.ceil(newHeight / 2);
           }
           const offscreen = new OffscreenCanvas(newWidth, newHeight);
-          const ctx = offscreen.getContext("2d");
-          ctx.drawImage(bitmap, 0, 0, prevWidth, prevHeight, 0, 0, newWidth, newHeight);
+          const ctx2 = offscreen.getContext("2d");
+          ctx2.drawImage(bitmap, 0, 0, prevWidth, prevHeight, 0, 0, newWidth, newHeight);
           bitmap = offscreen.transferToImageBitmap();
         }
         return bitmap;
@@ -33738,9 +34070,9 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
         canvas.width = scaledWidth;
         canvas.height = scaledHeight;
         const bitmap = this.#isSvg ? this.#bitmap : this.#scaleBitmap(scaledWidth, scaledHeight);
-        const ctx = canvas.getContext("2d");
-        ctx.filter = this._uiManager.hcmFilter;
-        ctx.drawImage(bitmap, 0, 0, bitmap.width, bitmap.height, 0, 0, scaledWidth, scaledHeight);
+        const ctx2 = canvas.getContext("2d");
+        ctx2.filter = this._uiManager.hcmFilter;
+        ctx2.drawImage(bitmap, 0, 0, bitmap.width, bitmap.height, 0, 0, scaledWidth, scaledHeight);
       }
       #serializeBitmap(toUrl) {
         if (toUrl) {
@@ -33755,8 +34087,8 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
             width: canvas.width,
             height: canvas.height
           } = this.#bitmap);
-          const ctx = canvas.getContext("2d");
-          ctx.drawImage(this.#bitmap, 0, 0);
+          const ctx2 = canvas.getContext("2d");
+          ctx2.drawImage(this.#bitmap, 0, 0);
           return canvas.toDataURL();
         }
         if (this.#isSvg) {
@@ -33764,8 +34096,8 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
           const width = Math.round(this.width * pageWidth * PixelsPerInch.PDF_TO_CSS_UNITS);
           const height = Math.round(this.height * pageHeight * PixelsPerInch.PDF_TO_CSS_UNITS);
           const offscreen = new OffscreenCanvas(width, height);
-          const ctx = offscreen.getContext("2d");
-          ctx.drawImage(this.#bitmap, 0, 0, this.#bitmap.width, this.#bitmap.height, 0, 0, width, height);
+          const ctx2 = offscreen.getContext("2d");
+          ctx2.drawImage(this.#bitmap, 0, 0, this.#bitmap.width, this.#bitmap.height, 0, 0, width, height);
           return offscreen.transferToImageBitmap();
         }
         return structuredClone(this.#bitmap);
@@ -35264,10 +35596,10 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
           const imageY2 = Math.floor((y1 + height / this.#pageHeight) * pageCanvas.height);
           imgElement.width = imageX2 - imageX1;
           imgElement.height = imageY2 - imageY1;
-          const ctx = imgElement.getContext("2d");
-          ctx.setTransform(...inverseTransform);
-          ctx.translate(-imageX1, -imageY1);
-          ctx.drawImage(pageCanvas, 0, 0);
+          const ctx2 = imgElement.getContext("2d");
+          ctx2.setTransform(...inverseTransform);
+          ctx2.translate(-imageX1, -imageY1);
+          ctx2.drawImage(pageCanvas, 0, 0);
         });
         return container;
       }
@@ -35385,7 +35717,7 @@ async function pdfjs() {
   return pdfjsPromise;
 }
 async function extractPdfText(pdfPath, { maxChars = DEFAULT_MAX_CHARS, force = false } = {}) {
-  const hit = cache.get(pdfPath);
+  const hit = cache2.get(pdfPath);
   if (!force && hit && Date.now() - hit.at < CACHE_TTL_MS) return hit.text;
   const data = new Uint8Array(await readFile4(pdfPath));
   const getDocument2 = (await pdfjs()).getDocument;
@@ -35407,16 +35739,16 @@ async function extractPdfText(pdfPath, { maxChars = DEFAULT_MAX_CHARS, force = f
     doc.cleanup?.();
   }
   const text = chunks.join("\n").trim();
-  cache.set(pdfPath, { text, at: Date.now() });
+  cache2.set(pdfPath, { text, at: Date.now() });
   return text;
 }
-var DEFAULT_MAX_CHARS, CACHE_TTL_MS, cache, pdfjsPromise;
+var DEFAULT_MAX_CHARS, CACHE_TTL_MS, cache2, pdfjsPromise;
 var init_pdf_text = __esm({
   "src/node/pdf-text.js"() {
     init_log();
     DEFAULT_MAX_CHARS = 12e4;
     CACHE_TTL_MS = 10 * 60 * 1e3;
-    cache = /* @__PURE__ */ new Map();
+    cache2 = /* @__PURE__ */ new Map();
     pdfjsPromise = null;
   }
 });
@@ -35425,7 +35757,8 @@ var init_pdf_text = __esm({
 var ai_exports = {};
 __export(ai_exports, {
   askAi: () => askAi,
-  buildPrompt: () => buildPrompt
+  buildPrompt: () => buildPrompt,
+  sendFigure: () => sendFigure
 });
 function buildPrompt({ title, action, question = "", selection = "", text = "" }) {
   const head = `\u3010\u6587\u732E\u52A9\u624B \xB7 ${title}\u3011`;
@@ -35472,7 +35805,7 @@ ${text}
 """`;
   }
 }
-async function askAi(ctx, { key, action = "ask", question = "", selection = "", sessionId = null } = {}) {
+async function askAi(ctx2, { key, action = "ask", question = "", selection = "", sessionId = null } = {}) {
   const entry = await getItem(String(key ?? ""));
   if (!entry) throw Object.assign(new Error("\u6761\u76EE\u4E0D\u5B58\u5728"), { code: "not_found" });
   if (!["translate", "explain", "summarize", "tldr", "ask"].includes(action)) action = "ask";
@@ -35480,7 +35813,7 @@ async function askAi(ctx, { key, action = "ask", question = "", selection = "",
   if (!sid) {
     throw Object.assign(new Error("\u5F53\u524D\u6CA1\u6709\u6D3B\u8DC3\u5BF9\u8BDD\uFF0C\u8BF7\u5148\u5F00\u59CB\u4E00\u4E2A\u5BF9\u8BDD\u518D\u8BD5"), { code: "no_session" });
   }
-  const agent = ctx?.agents?.get?.(sid);
+  const agent = ctx2?.agents?.get?.(sid);
   if (!agent || typeof agent.steer !== "function") {
     throw Object.assign(new Error("\u5F53\u524D\u5BF9\u8BDD\u4E0D\u53EF\u7528\uFF0C\u8BF7\u5237\u65B0\u540E\u91CD\u8BD5"), { code: "no_session" });
   }
@@ -35517,6 +35850,38 @@ async function askAi(ctx, { key, action = "ask", question = "", selection = "",
   log(`ai ask steered (${action}) into session ${sid}`);
   return { ok: true, sessionId: sid, action };
 }
+async function sendFigure(ctx2, { png, caption = "", title = "\u793A\u610F\u56FE", sessionId = null } = {}) {
+  if (!png || !png.length) throw Object.assign(new Error("\u6CA1\u6709\u56FE\u7247\u6570\u636E"), { code: "no_image" });
+  const sid = sessionId && String(sessionId) || recentSession();
+  if (!sid) throw Object.assign(new Error("\u5F53\u524D\u6CA1\u6709\u6D3B\u8DC3\u5BF9\u8BDD\uFF0C\u8BF7\u5148\u5F00\u59CB\u4E00\u4E2A\u5BF9\u8BDD\u518D\u8BD5"), { code: "no_session" });
+  const agent = ctx2?.agents?.get?.(sid);
+  if (!agent || typeof agent.steer !== "function") {
+    throw Object.assign(new Error("\u5F53\u524D\u5BF9\u8BDD\u4E0D\u53EF\u7528\uFF0C\u8BF7\u5237\u65B0\u540E\u91CD\u8BD5"), { code: "no_session" });
+  }
+  if (!ctx2?.attachments?.saveImages) {
+    throw Object.assign(new Error("\u5BBF\u4E3B\u4E0D\u652F\u6301\u56FE\u7247\u9644\u4EF6"), { code: "no_attachments" });
+  }
+  let bytes = png;
+  const limits = ctx2.attachments.imageLimits ?? {};
+  const maxBytes = limits.maxImageBytes ?? 5 * 1024 * 1024;
+  if (bytes.length > maxBytes) {
+    throw Object.assign(new Error(`\u56FE\u7247\u8D85\u8FC7\u5BBF\u4E3B\u5927\u5C0F\u9650\u5236\uFF08${bytes.length} > ${maxBytes} \u5B57\u8282\uFF09`), { code: "too_large" });
+  }
+  const mediaType = limits.mediaTypes?.length ? limits.mediaTypes.includes("image/png") ? "image/png" : limits.mediaTypes[0] : "image/png";
+  const [ref] = await ctx2.attachments.saveImages([{ data: new Uint8Array(bytes), mediaType, name: title.slice(0, 60) }]);
+  if (!ref) throw Object.assign(new Error("\u56FE\u7247\u9644\u4EF6\u521B\u5EFA\u5931\u8D25"), { code: "no_attachments" });
+  const text = `\u3010\u6587\u732E\u52A9\u624B \xB7 ${title}\u3011
+${caption || "\u6839\u636E\u6570\u636E\u751F\u6210\u7684\u793A\u610F\u56FE\u3002"}
+\uFF08\u56FE\u7531\u63D2\u4EF6\u6839\u636E\u539F\u59CB\u6570\u636E\u7ED8\u5236\uFF0C\u975E\u539F\u6587\u63D2\u56FE\uFF09`;
+  try {
+    const { createUserMessage } = await import("@deepseek-ai/dsh-llm");
+    agent.steer(createUserMessage({ content: [{ type: "text", text }, { type: "image", attachment: ref }], source: { kind: "user" } }));
+  } catch {
+    agent.steer({ content: [{ type: "text", text }, { type: "image", attachment: ref }], source: { kind: "user" }, role: "user", id: `lit_fig_${Date.now()}` });
+  }
+  log(`figure steered into session ${sid}`);
+  return { ok: true, sessionId: sid };
+}
 var FULLTEXT_ACTIONS, MAX_CONTEXT_CHARS;
 var init_ai = __esm({
   "src/node/ai.js"() {
@@ -35538,13 +35903,13 @@ __export(doctor_selfheal_exports, {
   pipeAvailable: () => pipeAvailable
 });
 import { createHash } from "node:crypto";
-import { existsSync, readdirSync } from "node:fs";
-import { join as join6 } from "node:path";
-import { homedir as homedir3 } from "node:os";
+import { existsSync as existsSync2, readdirSync as readdirSync2 } from "node:fs";
+import { join as join8 } from "node:path";
+import { homedir as homedir4 } from "node:os";
 import { spawn } from "node:child_process";
 import net from "node:net";
 function doctorRoot() {
-  return process.env.DSH_DOCTOR_HOME?.trim() || join6(homedir3(), ".dsh-doctor");
+  return process.env.DSH_DOCTOR_HOME?.trim() || join8(homedir4(), ".dsh-doctor");
 }
 function doctorPipeName(root = doctorRoot()) {
   const hash = createHash("sha256").update(root).digest("hex").slice(0, 16);
@@ -35569,16 +35934,16 @@ function pipeAvailable(pipe, timeoutMs = 1500) {
   });
 }
 function findDoctorCli() {
-  const profilesDir = join6(homedir3(), ".dsh", "profiles");
+  const profilesDir = join8(homedir4(), ".dsh", "profiles");
   let entries = [];
   try {
-    entries = readdirSync(profilesDir);
+    entries = readdirSync2(profilesDir);
   } catch {
     return "";
   }
   for (const name2 of entries) {
-    const candidate = join6(profilesDir, name2, "node_modules", "@linxin666", "dsh-doctor", "lib", "cli.mjs");
-    if (existsSync(candidate)) return candidate;
+    const candidate = join8(profilesDir, name2, "node_modules", "@linxin666", "dsh-doctor", "lib", "cli.mjs");
+    if (existsSync2(candidate)) return candidate;
   }
   return "";
 }
@@ -35769,7 +36134,7 @@ async function readJsonBody2(req) {
   const { readJsonBody: read } = await Promise.resolve().then(() => (init_http(), http_exports));
   return read(req);
 }
-async function handler(req, res, ctx) {
+async function handler(req, res, ctx2) {
   if (!isLoopbackRequest(req)) {
     writeJson(res, 403, { error: "forbidden: loopback-only", code: "forbidden" });
     return;
@@ -35787,6 +36152,29 @@ async function handler(req, res, ctx) {
       await handleEvents(req, res);
       return;
     }
+    if (head === "activate" && activation) {
+      activation.activate("panel-open");
+      writeJson(res, 200, { ok: true, active: true });
+      return;
+    }
+    if (head === "pyenv" && methodOk(req, "GET")) {
+      const { detectPythons: detectPythons2, figureInterpreter: figureInterpreter2, venvExists: venvExists2, venvDir: venvDir2 } = await Promise.resolve().then(() => (init_pyenv(), pyenv_exports));
+      const pythons = await detectPythons2();
+      const fig = await figureInterpreter2();
+      writeJson(res, 200, {
+        pythons,
+        venv: { exists: venvExists2(), dir: venvDir2() },
+        figure: fig ? { exe: fig.exe, version: fig.version, source: fig.source, hasMatplotlib: fig.hasMatplotlib } : null
+      });
+      return;
+    }
+    if (head === "install-deps" && methodOk(req, "POST")) {
+      const { installFigureDeps: installFigureDeps2 } = await Promise.resolve().then(() => (init_pyenv(), pyenv_exports));
+      const logs = [];
+      const result = await installFigureDeps2((m) => logs.push(m));
+      writeJson(res, result.ok ? 200 : 500, { ...result, logs });
+      return;
+    }
     if (head === "state" && methodOk(req, "GET")) {
       await handleState(res);
       return;
@@ -35936,6 +36324,11 @@ async function handler(req, res, ctx) {
       const url = new URL(req.url ?? "/", "http://127.0.0.1");
       const filename = url.searchParams.get("filename") || "dropped.pdf";
       const buffer = await readRawBody(req, 128 * 1024 * 1024);
+      if (buffer.length > 4 && buffer.subarray(0, 2).toString("latin1") === "PK" && /\.pptx$/i.test(filename)) {
+        const item2 = await importDroppedCourseware(buffer, { filename });
+        writeJson(res, 200, { item: item2 });
+        return;
+      }
       const item = await importDroppedPdf(buffer, { filename });
       writeJson(res, 200, { item });
       return;
@@ -35999,7 +36392,7 @@ async function handler(req, res, ctx) {
       if (sub === "ask" && methodOk(req, "POST")) {
         const body = await readJsonBody2(req);
         const { askAi: askAi2 } = await Promise.resolve().then(() => (init_ai(), ai_exports));
-        const result = await askAi2(ctx, {
+        const result = await askAi2(ctx2, {
           key: String(body?.key ?? ""),
           action: String(body?.action ?? "ask"),
           question: String(body?.question ?? ""),
@@ -36022,11 +36415,11 @@ async function handler(req, res, ctx) {
     else res.end();
   }
 }
-function registerRoutes(ctx) {
-  const disposers = [ctx.webServer.register({ kind: "prefix", path: PREFIX2, handler: (req, res) => handler(req, res, ctx) })];
-  if (typeof ctx.on === "function") {
+function registerRoutes(ctx2, { activation: activation2 } = {}) {
+  const disposers = [ctx2.webServer.register({ kind: "prefix", path: PREFIX2, handler: (req, res) => handler(req, res, ctx2) })];
+  if (typeof ctx2.on === "function") {
     disposers.push(
-      ctx.on("session/event", (session) => {
+      ctx2.on("session/event", (session) => {
         noteSession(session);
       })
     );
@@ -36038,76 +36431,472 @@ function registerRoutes(ctx) {
 // src/node/tools.js
 init_pipeline();
 init_db();
+
+// src/node/store/search.js
+function tokenize(text) {
+  const s = String(text ?? "").toLowerCase();
+  const out = /* @__PURE__ */ new Set();
+  for (const m of s.matchAll(/[a-z0-9][a-z0-9._-]*/g)) {
+    if (m[0].length >= 2) out.add(m[0]);
+  }
+  const cjkRuns = s.match(/[\u3400-\u4dbf\u4e00-\u9fff\u3040-\u30ff]+/g) ?? [];
+  for (const run2 of cjkRuns) {
+    for (let i = 0; i < run2.length; i += 1) {
+      out.add(run2[i]);
+      if (i + 1 < run2.length) out.add(run2.slice(i, i + 2));
+    }
+  }
+  return [...out];
+}
+var WEIGHTS = {
+  title: 3,
+  authors: 2,
+  container: 2,
+  abstract: 1,
+  tags: 1
+};
+function fieldText(item, field) {
+  const rec = item.record ?? {};
+  switch (field) {
+    case "title":
+      return rec.title ?? item.title ?? item.display ?? "";
+    case "authors":
+      return (rec.authors ?? []).map((a) => `${a.lastName ?? ""} ${a.firstName ?? ""}`.trim()).join(" ");
+    case "container":
+      return rec.container ?? "";
+    case "abstract":
+      return rec.abstract ?? "";
+    case "tags":
+      return (item.tags ?? []).join(" ");
+    default:
+      return "";
+  }
+}
+function searchItems2(items, query, { limit = 20 } = {}) {
+  const terms = tokenize(query);
+  if (!terms.length) return [];
+  const scored = [];
+  for (const item of items) {
+    let score = 0;
+    let matched = false;
+    for (const [field, weight] of Object.entries(WEIGHTS)) {
+      const text = String(fieldText(item, field)).toLowerCase();
+      if (!text) continue;
+      for (const t of terms) {
+        if (text.includes(t)) {
+          matched = true;
+          score += weight * (t.length >= 2 ? 2 : 1);
+        }
+      }
+    }
+    if (!matched) continue;
+    const rec = item.record ?? {};
+    scored.push({
+      key: item.key,
+      title: rec.title ?? item.title ?? item.display ?? "(\u65E0\u6807\u9898)",
+      authors: (rec.authors ?? []).slice(0, 3).map((a) => a.lastName ?? "").filter(Boolean).join(", "),
+      year: rec.year ?? item.year ?? null,
+      container: rec.container ?? "",
+      snippet: snippetFor(item, terms),
+      state: item.state ?? "",
+      score
+    });
+  }
+  scored.sort((a, b) => b.score !== a.score ? b.score - a.score : a.key < b.key ? -1 : 1);
+  return scored.slice(0, Math.max(1, Math.min(limit, 50)));
+}
+function snippetFor(item, terms) {
+  const rec = item.record ?? {};
+  const source = rec.abstract || rec.title || "";
+  if (!source) return "";
+  const lower = source.toLowerCase();
+  let at = -1;
+  for (const t of terms) {
+    const i = lower.indexOf(t);
+    if (i >= 0 && (at < 0 || i < at)) at = i;
+  }
+  if (at < 0) return String(source).slice(0, 160);
+  const start = Math.max(0, at - 60);
+  const head = start > 0 ? "\u2026" : "";
+  return head + String(source).slice(start, start + 220).trim();
+}
+
+// src/node/tools.js
 init_normalize();
 init_log();
+import { writeFile as writeFile5, mkdtemp, readFile as readFile6, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join as join7 } from "node:path";
 function textResult(value) {
   return {
     schema: { type: "string" },
     render: (_args, v) => [{ type: "text", text: String(v) }]
   };
 }
-function registerTools(ctx) {
-  const disposers = [];
-  disposers.push(
-    ctx.tools.register({
-      name: "zotero_lookup",
-      description: "\u4ECE\u6587\u672C\u6216\u6807\u8BC6\u7B26\u4E2D\u8BC6\u522B\u5B66\u672F\u6587\u732E\uFF08DOI\u3001arXiv ID\u3001PMID\u3001ISBN\u3001\u6807\u9898\uFF09\uFF0C\u89E3\u6790\u5143\u6570\u636E\u5E76\u751F\u6210\u4FA7\u7A97\u6761\u76EE\u3002\u5F53\u4F60\u68C0\u7D22\u6216\u5F15\u7528\u6587\u732E\u5E76\u5E0C\u671B\u7528\u6237\u80FD\u5728\u4FA7\u8FB9\u680F\u9884\u89C8/\u4FDD\u5B58\u5168\u6587\u65F6\u8C03\u7528\u3002",
-      parameters: {
-        type: "object",
-        properties: {
-          text: { type: "string", description: "\u5305\u542B\u6587\u732E\u6807\u8BC6\u7B26\u6216\u5F15\u7528\u6587\u672C\u7684\u7247\u6BB5" },
-          resolve: { type: "string", description: "\u662F\u5426\u7ACB\u5373\u8054\u7F51\u89E3\u6790\u5143\u6570\u636E\uFF0C\u9ED8\u8BA4 yes" }
-        },
-        required: []
-      },
-      output: textResult(),
-      timeoutMs: 12e4,
-      async execute(args) {
-        const text = String(args?.text ?? "");
-        if (!text.trim()) return "\u6CA1\u6709\u63D0\u4F9B\u6587\u672C\u3002";
-        const created = await scanText(text);
-        if (!created.length) return "\u672A\u8BC6\u522B\u5230\u65B0\u7684\u6587\u732E\u6761\u76EE\uFF08\u53EF\u80FD\u5DF2\u5B58\u5728\u4E8E\u4FA7\u7A97\uFF09\u3002";
-        const wantResolve = String(args?.resolve ?? "yes").toLowerCase() !== "no";
-        if (wantResolve) {
-          await Promise.all(created.map((i) => resolveItem(i.key).catch((e) => warn("resolve failed", e.message))));
-        }
-        const items = await Promise.all(created.map((i) => getItem(i.key)));
-        const lines = items.filter(Boolean).map((i) => `- ${i.record?.title || i.display} [${i.key}]`);
-        return `\u5DF2\u52A0\u5165\u4FA7\u7A97 ${items.length} \u6761\uFF1A
-${lines.join("\n")}`;
+function toolDefs() {
+  return [lookupTool(), searchTool(), getTool(), citeTool(), noteTool(), statusTool(), saveTool(), figureTool()];
+}
+function registerTools(ctx2) {
+  let mounted = [];
+  return {
+    mount() {
+      if (mounted.length) return;
+      mounted = toolDefs().map((def) => {
+        try {
+          return ctx2.tools.register(def);
+        } catch (e) {
+          warn("tool registration failed:", def.name, e?.message);
+          return null;
+        }
+      });
+      log(`tools mounted: ${toolDefs().map((d) => d.name).join(", ")}`);
+    },
+    unmount() {
+      if (!mounted.length) return;
+      for (const dispose of mounted) {
+        try {
+          dispose?.();
+        } catch (e) {
+          warn("tool dispose failed:", e?.message);
+        }
       }
-    })
-  );
-  disposers.push(
-    ctx.tools.register({
-      name: "zotero_save",
-      description: "\u628A\u4FA7\u7A97\u4E2D\u5DF2\u8BC6\u522B\u7684\u6587\u732E\u4FDD\u5B58\u5230\u672C\u5730 Zotero \u5E93\u6216\u5BFC\u51FA\u76EE\u5F55\uFF08\u4F1A\u81EA\u52A8\u4E0B\u8F7D\u5168\u6587 PDF\uFF09\u3002",
-      parameters: {
-        type: "object",
-        properties: {
-          key: { type: "string", description: "\u6761\u76EE key\uFF08\u6765\u81EA zotero_lookup \u7684\u8FD4\u56DE\uFF09" },
-          mode: { type: "string", description: "\u4FDD\u5B58\u65B9\u5F0F\uFF1Azotero \u6216 dir\uFF0C\u7F3A\u7701\u7528\u914D\u7F6E\u503C" },
-          tags: { type: "string", description: "\u9017\u53F7\u5206\u9694\u7684\u6807\u7B7E" }
+      mounted = [];
+      log("tools unmounted");
+    },
+    isMounted: () => mounted.length > 0,
+    dispose() {
+      this.unmount();
+    }
+  };
+}
+function formatHit(h) {
+  const bits = [h.title];
+  if (h.authors) bits.push(h.authors);
+  if (h.year) bits.push(String(h.year));
+  if (h.container) bits.push(h.container);
+  const line = bits.join(" | ") + `  [key=${h.key}]`;
+  return h.snippet ? `${line}
+    ${h.snippet.slice(0, 160)}` : line;
+}
+var NEXT_STEP = "\n[\u4E0B\u4E00\u6B65] literature_get(key=\u2026) \u770B\u8BE6\u60C5 \xB7 literature_cite \u751F\u6210\u5F15\u7528 \xB7 literature_search \u7EE7\u7EED\u68C0\u7D22";
+function lookupTool() {
+  return {
+    name: "literature_lookup",
+    description: "\u4ECE\u6587\u672C\u6216\u6807\u8BC6\u7B26\u4E2D\u8BC6\u522B\u5B66\u672F\u6587\u732E\uFF08DOI\u3001arXiv ID\u3001PMID\u3001ISBN\u3001\u6807\u9898\uFF09\uFF0C\u89E3\u6790\u5143\u6570\u636E\u5E76\u751F\u6210\u4FA7\u7A97\u6761\u76EE\u3002\u5F53\u4F60\u68C0\u7D22\u6216\u5F15\u7528\u6587\u732E\u5E76\u5E0C\u671B\u7528\u6237\u80FD\u5728\u4FA7\u8FB9\u680F\u9884\u89C8/\u4FDD\u5B58\u5168\u6587\u65F6\u8C03\u7528\u3002",
+    parameters: {
+      type: "object",
+      properties: {
+        text: { type: "string", description: "\u5305\u542B\u6587\u732E\u6807\u8BC6\u7B26\u6216\u5F15\u7528\u6587\u672C\u7684\u7247\u6BB5" },
+        resolve: { type: "string", description: "\u662F\u5426\u7ACB\u5373\u8054\u7F51\u89E3\u6790\u5143\u6570\u636E\uFF0C\u9ED8\u8BA4 yes" }
+      },
+      required: []
+    },
+    output: textResult(),
+    timeoutMs: 12e4,
+    async execute(args) {
+      const text = String(args?.text ?? "");
+      if (!text.trim()) return "\u6CA1\u6709\u63D0\u4F9B\u6587\u672C\u3002";
+      const created = await scanText(text);
+      if (!created.length) return "\u672A\u8BC6\u522B\u5230\u65B0\u7684\u6587\u732E\u6761\u76EE\uFF08\u53EF\u80FD\u5DF2\u5B58\u5728\u4E8E\u4FA7\u7A97\uFF09\u3002";
+      const wantResolve = String(args?.resolve ?? "yes").toLowerCase() !== "no";
+      if (wantResolve) {
+        await Promise.all(created.map((i) => resolveItem(i.key).catch((e) => warn("resolve failed", e.message))));
+      }
+      const items = await Promise.all(created.map((i) => getItem(i.key)));
+      const lines = items.filter(Boolean).map((i) => `- ${i.record?.title || i.display} [key=${i.key}]`);
+      return `\u5DF2\u52A0\u5165\u4FA7\u7A97 ${items.length} \u6761\uFF1A
+${lines.join("\n")}${NEXT_STEP}`;
+    }
+  };
+}
+function searchTool() {
+  return {
+    name: "literature_search",
+    description: "\u5728\u7528\u6237\u7684\u6587\u732E\u5E93\u4E2D\u68C0\u7D22\u5DF2\u4FDD\u5B58\u7684\u6587\u732E\uFF08\u6807\u9898/\u4F5C\u8005/\u671F\u520A/\u6458\u8981/\u6807\u7B7E\u7684\u5173\u952E\u8BCD\u5339\u914D\uFF09\u3002\u5F53\u7528\u6237\u95EE\u300C\u6211\u4E4B\u524D\u5B58\u7684\u90A3\u7BC7\u300D\u300C\u6211\u5E93\u91CC\u6709\u6CA1\u6709\u8BB2 X \u7684\u300D\u300C\u6709\u4EC0\u4E48\u6587\u732E\u53EF\u4EE5\u7528\u300D\u65F6\u8C03\u7528\u3002\u8FD4\u56DE\u7CBE\u7B80\u6761\u76EE\uFF0C\u9700\u8981\u5B8C\u6574\u4FE1\u606F\u518D\u7528 literature_get\u3002",
+    parameters: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "\u68C0\u7D22\u8BCD\uFF1A\u4E3B\u9898\u3001\u6807\u9898\u7247\u6BB5\u3001\u4F5C\u8005\u59D3\u6C0F\u6216\u671F\u520A\u540D" },
+        limit: { type: "number", description: "\u8FD4\u56DE\u6761\u6570\uFF0C\u9ED8\u8BA4 8\uFF0C\u6700\u5927 20" }
+      },
+      required: ["query"]
+    },
+    output: textResult(),
+    timeoutMs: 15e3,
+    async execute(args) {
+      const query = String(args?.query ?? "").trim();
+      if (!query) return "\u7F3A\u5C11\u68C0\u7D22\u8BCD\u3002";
+      const limit = Math.max(1, Math.min(Number(args?.limit) || 8, 20));
+      const items = await listItems();
+      const hits = searchItems2(items, query, { limit });
+      if (!hits.length) return `\u672A\u5728\u5E93\u4E2D\u627E\u5230\u4E0E\u300C${query}\u300D\u5339\u914D\u7684\u6761\u76EE\u3002\u53EF\u5148\u7528 literature_lookup \u6DFB\u52A0\uFF0C\u6216\u6362\u66F4\u5BBD\u6CDB\u7684\u68C0\u7D22\u8BCD\u3002`;
+      return `\u547D\u4E2D ${hits.length} \u6761\uFF1A
+${hits.map((h) => `- ${formatHit(h)}`).join("\n")}${NEXT_STEP}`;
+    }
+  };
+}
+function getTool() {
+  return {
+    name: "literature_get",
+    description: "\u6309 key \u83B7\u53D6\u6761\u76EE\u7684\u5B8C\u6574\u4FE1\u606F\uFF1A\u5143\u6570\u636E\u3001\u6458\u8981\u3001\u6279\u6CE8\u4E0E\u7B14\u8BB0\u3002\u4EC5\u5728 literature_search \u8FD4\u56DE\u8FC7\u8BE5 key \u65F6\u4F7F\u7528\u2014\u2014\u4E0D\u8981\u51ED\u731C\u6D4B\u7F16\u9020 key\u3002",
+    parameters: {
+      type: "object",
+      properties: {
+        key: { type: "string", description: "\u6761\u76EE key" },
+        includeAnnotations: { type: "boolean", description: "\u662F\u5426\u5305\u542B\u6279\u6CE8\uFF0C\u9ED8\u8BA4 true" }
+      },
+      required: ["key"]
+    },
+    output: textResult(),
+    timeoutMs: 15e3,
+    async execute(args) {
+      const key = String(args?.key ?? "");
+      if (!key) return "\u7F3A\u5C11\u6761\u76EE key\u3002";
+      const item = await getItem(key);
+      if (!item) return `\u672A\u627E\u5230\u6761\u76EE ${key}\u3002\u8BF7\u5148\u7528 literature_search \u83B7\u53D6\u6B63\u786E\u7684 key\u3002`;
+      const rec = item.record ?? {};
+      const lines = [
+        `\u6807\u9898\uFF1A${rec.title ?? item.title ?? item.display ?? "(\u65E0\u6807\u9898)"}`,
+        `\u4F5C\u8005\uFF1A${(rec.authors ?? []).map((a) => `${a.lastName ?? ""} ${a.firstName ?? ""}`.trim()).filter(Boolean).join("; ") || "\u2014"}`,
+        `\u5E74\u4EFD\uFF1A${rec.year ?? "\u2014"}`,
+        `\u671F\u520A/\u4F1A\u8BAE\uFF1A${rec.container ?? "\u2014"}`,
+        `DOI\uFF1A${rec.doi ?? "\u2014"}`,
+        `\u72B6\u6001\uFF1A${item.state ?? "\u2014"}${item.pdf ? "\uFF08\u5DF2\u6709\u5168\u6587\uFF09" : "\uFF08\u65E0\u5168\u6587\uFF09"}`
+      ];
+      if (rec.abstract) lines.push(`\u6458\u8981\uFF1A${String(rec.abstract).slice(0, 600)}`);
+      if (String(args?.includeAnnotations ?? true) !== "false") {
+        const anns = await getAnnotations(key);
+        if (anns.length) {
+          const shown = anns.slice(0, 50);
+          lines.push(`\u6279\u6CE8\uFF08${anns.length} \u6761${anns.length > shown.length ? `\uFF0C\u5C55\u793A\u524D ${shown.length} \u6761` : ""}\uFF09\uFF1A`);
+          for (const a of shown) lines.push(`  - p.${a.pageIndex ?? "?"} ${String(a.text ?? "").slice(0, 120)}${a.note ? ` \uFF5C \u7B14\u8BB0\uFF1A${String(a.note).slice(0, 120)}` : ""}`);
+        }
+      }
+      return lines.join("\n") + "\n[\u4E0B\u4E00\u6B65] literature_cite \u751F\u6210\u5F15\u7528 \xB7 literature_note \u8BB0\u5F55\u5173\u7CFB";
+    }
+  };
+}
+function citeTool() {
+  return {
+    name: "literature_cite",
+    description: "\u751F\u6210\u89C4\u8303\u5316\u7684\u5F15\u7528\u6587\u672C\uFF08APA 7 / GB/T 7714 / MLA 9 / Chicago 17 / BibTeX\uFF09\uFF0C\u652F\u6301\u53C2\u8003\u6587\u732E\u6761\u76EE\u3001\u6587\u5185\u5F15\u7528\u4E0E\u5E26\u9875\u7801\u7684\u76F4\u63A5\u5F15\u7528\u3002\u5199\u4F5C\u4E2D\u9700\u8981\u5F15\u7528\u6587\u732E\u65F6\u76F4\u63A5\u8C03\u7528\uFF0C\u4E0D\u8981\u624B\u5DE5\u62FC\u88C5\u4F5C\u8005\u4E0E\u5E74\u4EFD\u3002",
+    parameters: {
+      type: "object",
+      properties: {
+        key: { type: "string", description: "\u6761\u76EE key" },
+        style: { type: "string", description: "apa | gb | mla | chicago | bibtex\uFF0C\u9ED8\u8BA4 apa" },
+        mode: { type: "string", description: "reference\uFF08\u9ED8\u8BA4\uFF09| intext | direct" },
+        pages: { type: "string", description: "\u76F4\u63A5\u5F15\u7528\u7684\u9875\u7801\uFF0C\u5982 12 \u6216 12-15" }
+      },
+      required: ["key"]
+    },
+    output: textResult(),
+    timeoutMs: 15e3,
+    async execute(args) {
+      const key = String(args?.key ?? "");
+      if (!key) return "\u7F3A\u5C11\u6761\u76EE key\u3002";
+      const item = await getItem(key);
+      if (!item?.record) return `\u6761\u76EE ${key} \u7F3A\u5C11\u5143\u6570\u636E\uFF0C\u65E0\u6CD5\u751F\u6210\u5F15\u7528\u3002\u8BF7\u5148\u7528 literature_lookup \u89E3\u6790\u5143\u6570\u636E\u3002`;
+      const { citeDetailed: citeDetailed2 } = await Promise.resolve().then(() => (init_cite(), cite_exports));
+      const d = citeDetailed2(item.record, {
+        style: args?.style ?? "apa",
+        mode: args?.mode ?? "reference",
+        pages: args?.pages
+      });
+      return `${d.text}
+\uFF08${d.style} \xB7 ${d.mode}\uFF09
+[\u4E0B\u4E00\u6B65] literature_verify \u6838\u9A8C\u5F15\u7528\u771F\u5B9E\u6027 \xB7 literature_note \u8BB0\u5F55\u5B83\u548C\u5F53\u524D\u5199\u4F5C\u7684\u5173\u7CFB`;
+    }
+  };
+}
+function noteTool() {
+  return {
+    name: "literature_note",
+    description: "\u628A\u4E00\u6761\u7B14\u8BB0\u5199\u56DE\u6587\u732E\u6761\u76EE\uFF1A\u8FD9\u7BC7\u6587\u732E\u4E0E\u7528\u6237\u5F53\u524D\u5199\u4F5C/\u7814\u7A76\u7684\u5173\u7CFB\u3001\u53EF\u7528\u8BBA\u70B9\u3001\u5F85\u9A8C\u8BC1\u4E4B\u5904\u3002\u4F1A\u8FFD\u52A0\u4FDD\u5B58\uFF0C\u4E0B\u6B21\u68C0\u7D22\u8BE5\u6761\u76EE\u65F6\u80FD\u88AB\u627E\u56DE\u3002",
+    parameters: {
+      type: "object",
+      properties: {
+        key: { type: "string", description: "\u6761\u76EE key" },
+        note: { type: "string", description: "\u8981\u8BB0\u5F55\u7684\u7B14\u8BB0\u5185\u5BB9" }
+      },
+      required: ["key", "note"]
+    },
+    output: textResult(),
+    timeoutMs: 15e3,
+    async execute(args) {
+      const key = String(args?.key ?? "");
+      const note = String(args?.note ?? "").trim();
+      if (!key) return "\u7F3A\u5C11\u6761\u76EE key\u3002";
+      if (!note) return "\u7B14\u8BB0\u5185\u5BB9\u4E3A\u7A7A\uFF0C\u672A\u5199\u5165\u3002";
+      const item = await getItem(key);
+      if (!item) return `\u672A\u627E\u5230\u6761\u76EE ${key}\u3002`;
+      const notes = Array.isArray(item.notes) ? item.notes : [];
+      if (notes.some((n) => (typeof n === "string" ? n : n.text) === note)) return "\u8BE5\u7B14\u8BB0\u5DF2\u5B58\u5728\uFF0C\u672A\u91CD\u590D\u5199\u5165\u3002";
+      const entry = { text: note, at: (/* @__PURE__ */ new Date()).toISOString() };
+      await patchItem(key, { notes: [...notes, entry] });
+      return `\u5DF2\u8BB0\u5F55\u5230\u6761\u76EE ${key}\uFF08\u5171 ${notes.length + 1} \u6761\u7B14\u8BB0\uFF09\u3002`;
+    }
+  };
+}
+function statusTool() {
+  return {
+    name: "literature_status",
+    description: "\u67E5\u770B\u6587\u732E\u5E93\u7684\u5F53\u524D\u72B6\u6001\uFF1A\u6761\u76EE\u603B\u6570\u3001\u5404\u72B6\u6001\u5206\u5E03\u3001\u6700\u8FD1\u6DFB\u52A0\u7684\u6761\u76EE\u3001\u8FDB\u884C\u4E2D\u7684\u4EFB\u52A1\u3002\u5728\u5F00\u59CB\u6587\u732E\u5DE5\u4F5C\u524D\u4E86\u89E3\u5E93\u91CC\u6709\u4EC0\u4E48\u65F6\u8C03\u7528\u3002",
+    parameters: { type: "object", properties: {}, required: [] },
+    output: textResult(),
+    timeoutMs: 15e3,
+    async execute() {
+      const items = await listItems();
+      const byState = {};
+      for (const i of items) {
+        const s = i.state ?? "unknown";
+        byState[s] = (byState[s] ?? 0) + 1;
+      }
+      const recent = [...items].sort((a, b) => Number(b.createdAt ?? 0) - Number(a.createdAt ?? 0)).slice(0, 5).map((i) => `- ${i.record?.title ?? i.title ?? i.display ?? "(\u65E0\u6807\u9898)"} [key=${i.key}]`);
+      const running = (await listTasks()).filter((t) => t.status === "running");
+      return [
+        `\u6761\u76EE\u603B\u6570\uFF1A${items.length}`,
+        `\u72B6\u6001\u5206\u5E03\uFF1A${Object.entries(byState).map(([k, v]) => `${k}=${v}`).join(", ") || "\u2014"}`,
+        running.length ? `\u8FDB\u884C\u4E2D\u4EFB\u52A1\uFF1A${running.map((t) => `${t.key}(${t.progress ?? 0}%)`).join(", ")}` : "\u8FDB\u884C\u4E2D\u4EFB\u52A1\uFF1A\u65E0",
+        recent.length ? `\u6700\u8FD1\u6DFB\u52A0\uFF1A
+${recent.join("\n")}` : "\u5E93\u662F\u7A7A\u7684\u3002"
+      ].join("\n") + NEXT_STEP;
+    }
+  };
+}
+function figureTool() {
+  const CHART_TYPES = /* @__PURE__ */ new Set(["bar", "line", "pie"]);
+  return {
+    name: "literature_figure",
+    description: "\u6839\u636E\u8868\u683C\u6570\u636E\u7ED8\u5236\u793A\u610F\u56FE\u5E76\u63D2\u5165\u5F53\u524D\u5BF9\u8BDD\uFF08\u67F1\u72B6\u56FE/\u6298\u7EBF\u56FE/\u997C\u56FE\uFF09\u3002\u4EC5\u5728\u7528\u6237\u660E\u786E\u8981\u6C42\u300C\u753B\u4E2A\u56FE/\u53EF\u89C6\u5316/\u505A\u793A\u610F\u56FE\u300D\u65F6\u8C03\u7528\uFF1B\u4E0D\u8981\u5728\u6CA1\u6709\u6570\u636E\u4F9D\u636E\u65F6\u51ED\u7A7A\u7F16\u9020\u6570\u503C\u3002",
+    parameters: {
+      type: "object",
+      properties: {
+        title: { type: "string", description: "\u56FE\u8868\u6807\u9898\uFF08\u4E5F\u4F1A\u4F5C\u4E3A\u6D88\u606F\u6807\u9898\uFF09" },
+        categories: { type: "array", items: { type: "string" }, description: '\u6A2A\u8F74\u7C7B\u522B\uFF0C\u5982 ["2023","2024","2025"]' },
+        series: {
+          type: "array",
+          description: "\u6570\u636E\u7CFB\u5217\uFF0C\u6BCF\u9879 { name, values }\uFF0Cvalues \u4E0E categories \u7B49\u957F",
+          items: {
+            type: "object",
+            properties: {
+              name: { type: "string" },
+              values: { type: "array", items: { type: "number" } }
+            },
+            required: ["name", "values"]
+          }
         },
-        required: ["key"]
+        chartType: { type: "string", description: "bar\uFF08\u9ED8\u8BA4\uFF09| line | pie" },
+        caption: { type: "string", description: "\u56FE\u4E0B\u8BF4\u660E\u6587\u5B57" },
+        key: { type: "string", description: "\u53EF\u9009\uFF1A\u6570\u636E\u6765\u6E90\u6761\u76EE key\uFF08\u4FBF\u4E8E\u6807\u6CE8\u51FA\u5904\uFF09" }
       },
-      output: textResult(),
-      timeoutMs: 3e5,
-      async execute(args) {
-        const key = String(args?.key ?? "");
-        if (!key) return "\u7F3A\u5C11\u6761\u76EE key\u3002";
-        const tags = String(args?.tags ?? "").split(",").map((t) => t.trim()).filter(Boolean);
-        const item = await saveItem(key, { mode: args?.mode, tags });
-        if (!item) return `\u627E\u4E0D\u5230\u6761\u76EE ${key}\u3002`;
-        if (item.state === "saved") {
-          return `\u5DF2\u4FDD\u5B58\uFF1A${shortLabel(item.record ?? {})}\uFF08${item.saveMode === "dir" ? item.export?.pdfPath : "Zotero \u5E93"}\uFF09`;
-        }
-        return `\u4FDD\u5B58\u5931\u8D25\uFF1A${item.error?.message ?? "\u672A\u77E5\u9519\u8BEF"}\uFF08${item.error?.code ?? "unknown"}\uFF09`;
+      required: ["title", "categories", "series"]
+    },
+    output: textResult(),
+    timeoutMs: 12e4,
+    async execute(args, exec) {
+      const title = String(args?.title ?? "").trim() || "\u793A\u610F\u56FE";
+      const categories = Array.isArray(args?.categories) ? args.categories.map(String) : [];
+      const series = Array.isArray(args?.series) ? args.series.map((s) => ({ name: String(s?.name ?? "series"), values: (Array.isArray(s?.values) ? s.values : []).map((v) => Number(v)) })).filter((s) => s.values.length) : [];
+      const chartType = CHART_TYPES.has(args?.chartType) ? args.chartType : "bar";
+      if (!categories.length || !series.length) return "\u7F3A\u5C11\u6570\u636E\uFF08categories \u6216 series \u4E3A\u7A7A\uFF09\u3002\u793A\u610F\u56FE\u9700\u8981\u771F\u5B9E\u6570\u636E\uFF0C\u4E0D\u80FD\u51ED\u7A7A\u7ED8\u5236\u3002";
+      const { figureInterpreter: figureInterpreter2 } = await Promise.resolve().then(() => (init_pyenv(), pyenv_exports));
+      const fig = await figureInterpreter2();
+      if (!fig || !fig.hasMatplotlib) {
+        return "\u793A\u610F\u56FE\u5F15\u64CE\u5C1A\u672A\u5C31\u7EEA\uFF1A\u672C\u673A\u7F3A\u5C11 Python + matplotlib\u3002\u8BF7\u5728\u4FA7\u7A97\u8BBE\u7F6E\u9875\u300C\u793A\u610F\u56FE\u5F15\u64CE\u300D\u4E2D\u70B9\u51FB\u300C\u5B89\u88C5\u4F9D\u8D56\u300D\u540E\u91CD\u8BD5\uFF1B\u671F\u95F4\u53EF\u4EE5\u8BA9\u6211\u8F93\u51FA\u6570\u636E\u8868\u683C\u4EE3\u66FF\u56FE\u8868\u3002";
+      }
+      const { mkdtemp: _mk, writeFile: _w, readFile: _r, rm: _rm } = { mkdtemp, writeFile: writeFile5, readFile: readFile6, rm };
+      const dir = await mkdtemp(join7(tmpdir(), "lit-fig-"));
+      const pyFile = join7(dir, "fig.py");
+      const pngFile = join7(dir, "fig.png");
+      const script = [
+        "import matplotlib",
+        "matplotlib.use('Agg')",
+        "import matplotlib.pyplot as plt",
+        // CJK glyphs are missing from matplotlib's default font (DejaVu Sans),
+        // which turns Chinese labels into tofu boxes. Pick the first installed
+        // CJK-capable font; degrade silently on non-CJK systems.
+        "from matplotlib import font_manager",
+        "_available = {f.name for f in font_manager.fontManager.ttflist}",
+        "for _name in ['Microsoft YaHei', 'SimHei', 'PingFang SC', 'Noto Sans CJK SC', 'Source Han Sans SC', 'WenQuanYi Zen Hei']:",
+        "    if _name in _available:",
+        "        plt.rcParams['font.sans-serif'] = [_name]",
+        "        break",
+        "plt.rcParams['axes.unicode_minus'] = False",
+        `categories = ${JSON.stringify(categories)}`,
+        `series = ${JSON.stringify(series)}`,
+        `chart_type = ${JSON.stringify(chartType)}`,
+        `title = ${JSON.stringify(title)}`,
+        "fig, ax = plt.subplots(figsize=(7, 4.2), dpi=150)",
+        "if chart_type == 'pie':",
+        "    vals = series[0]['values']",
+        "    ax.pie(vals, labels=categories, autopct='%1.1f%%', startangle=90)",
+        "    ax.axis('equal')",
+        "elif chart_type == 'line':",
+        "    for s in series: ax.plot(categories, s['values'], marker='o', label=s['name'])",
+        "    ax.legend()",
+        "else:",
+        "    import numpy as np",
+        "    x = np.arange(len(categories)); w = 0.8 / max(len(series), 1)",
+        "    for i, s in enumerate(series): ax.bar(x + i * w, s['values'], w, label=s['name'])",
+        "    ax.set_xticks(x + w * (len(series) - 1) / 2); ax.set_xticklabels(categories)",
+        "    ax.legend()",
+        "ax.set_title(title)",
+        "plt.tight_layout()",
+        `plt.savefig(${JSON.stringify(pngFile)})`
+      ].join("\n");
+      await writeFile5(pyFile, script, "utf8");
+      const { execFile: execFile2 } = await import("node:child_process");
+      const run2 = () => new Promise((resolve6) => execFile2(fig.exe, [pyFile], { timeout: 6e4, windowsHide: true }, (err, stdout, stderr) => resolve6({ err, stdout, stderr })));
+      const r = await run2();
+      let png = null;
+      try {
+        png = await readFile6(pngFile);
+      } catch {
       }
-    })
-  );
-  log("tools registered: zotero_lookup, zotero_save");
-  return disposers;
+      await rm(dir, { recursive: true, force: true }).catch(() => {
+      });
+      if (!png) return "\u7ED8\u56FE\u5931\u8D25\uFF1A" + (r.stderr || r.stdout || "\u672A\u77E5\u9519\u8BEF").slice(0, 300);
+      const { sendFigure: sendFigure2 } = await Promise.resolve().then(() => (init_ai(), ai_exports));
+      const sourceNote = args?.key ? `\uFF08\u6570\u636E\u6765\u6E90\uFF1A\u6761\u76EE ${args.key}\uFF09` : "";
+      try {
+        await sendFigure2(ctx, { png, title, caption: `${args?.caption ?? ""}${sourceNote}`.trim(), sessionId: exec?.agent?.sessionId ?? null });
+        return `\u793A\u610F\u56FE\u300C${title}\u300D\u5DF2\u751F\u6210\u5E76\u63D2\u5165\u5F53\u524D\u5BF9\u8BDD\u3002`;
+      } catch (e) {
+        if (e?.code === "no_session") return "\u793A\u610F\u56FE\u5DF2\u751F\u6210\uFF0C\u4F46\u5F53\u524D\u6CA1\u6709\u6D3B\u8DC3\u5BF9\u8BDD\u53EF\u63D2\u5165\u3002\u8BF7\u5148\u6253\u5F00\u4E00\u4E2A\u5BF9\u8BDD\u518D\u8BA9\u6211\u753B\u56FE\u3002";
+        return "\u56FE\u7247\u63D2\u5165\u5BF9\u8BDD\u5931\u8D25\uFF1A" + (e?.message ?? "\u672A\u77E5\u9519\u8BEF");
+      }
+    }
+  };
+}
+function saveTool() {
+  return {
+    name: "literature_save",
+    description: "\u628A\u4FA7\u7A97\u4E2D\u5DF2\u8BC6\u522B\u7684\u6587\u732E\u4FDD\u5B58\u5230\u672C\u5730\u6587\u732E\u5E93\u6216\u5BFC\u51FA\u76EE\u5F55\uFF08\u4F1A\u81EA\u52A8\u4E0B\u8F7D\u5168\u6587 PDF\uFF09\u3002",
+    parameters: {
+      type: "object",
+      properties: {
+        key: { type: "string", description: "\u6761\u76EE key\uFF08\u6765\u81EA literature_lookup \u6216 literature_search \u7684\u8FD4\u56DE\uFF09" },
+        mode: { type: "string", description: "\u4FDD\u5B58\u65B9\u5F0F\uFF1Azotero \u6216 dir\uFF0C\u7F3A\u7701\u7528\u914D\u7F6E\u503C" },
+        tags: { type: "string", description: "\u9017\u53F7\u5206\u9694\u7684\u6807\u7B7E" }
+      },
+      required: ["key"]
+    },
+    output: textResult(),
+    timeoutMs: 3e5,
+    async execute(args) {
+      const key = String(args?.key ?? "");
+      if (!key) return "\u7F3A\u5C11\u6761\u76EE key\u3002";
+      const tags = String(args?.tags ?? "").split(",").map((t) => t.trim()).filter(Boolean);
+      const item = await saveItem(key, { mode: args?.mode, tags });
+      if (!item) return `\u627E\u4E0D\u5230\u6761\u76EE ${key}\u3002`;
+      if (item.state === "saved") {
+        return `\u5DF2\u4FDD\u5B58\uFF1A${shortLabel(item.record ?? {})}\uFF08${item.saveMode === "dir" ? item.export?.pdfPath : "\u672C\u5730\u6587\u732E\u5E93"}\uFF09
+[\u4E0B\u4E00\u6B65] literature_get \u67E5\u770B\u8BE6\u60C5 \xB7 literature_cite \u751F\u6210\u5F15\u7528`;
+      }
+      return `\u4FDD\u5B58\u5931\u8D25\uFF1A${item.error?.message ?? "\u672A\u77E5\u9519\u8BEF"}\uFF08${item.error?.code ?? "unknown"}\uFF09`;
+    }
+  };
 }
 
 // src/node/session-hook.js
@@ -36144,11 +36933,15 @@ function textFromSessionEvent(event) {
   }
   return "";
 }
-function registerSessionHook(ctx) {
+function registerSessionHook(ctx2, { activation: activation2, detectIntent: detectIntent2 } = {}) {
   const disposers = [];
   disposers.push(
-    ctx.on("session/event", (session, event) => {
+    ctx2.on("session/event", (session, event) => {
       const text = textFromSessionEvent(event);
+      if (activation2 && detectIntent2 && event?.type === "user/message") {
+        const verdict = detectIntent2(textFromSessionEvent(event));
+        if (verdict.active) activation2.activate(verdict.reason);
+      }
       if (!text || text.length < 20) return;
       if (!extractIdentifiers(text).length) return;
       checkConfig().then((config) => {
@@ -36170,26 +36963,184 @@ async function checkConfig() {
   return cachedConfig;
 }
 
+// src/node/activation.js
+var IDLE_TIMEOUT_MS = 30 * 60 * 1e3;
+var STRONG = [
+  "\u6587\u732E",
+  "\u8BBA\u6587",
+  "\u53C2\u8003\u6587\u732E",
+  "\u5F15\u7528\u683C\u5F0F",
+  "\u5F15\u6587",
+  "\u7EFC\u8FF0",
+  "\u5F00\u9898",
+  "\u7EC4\u4F1A",
+  "doi",
+  "arxiv",
+  "pmid",
+  "isbn",
+  "bibtex",
+  "apa",
+  "mla",
+  "chicago",
+  "gb/t 7714",
+  "gbt7714",
+  "abstract",
+  "citation",
+  "reference list",
+  "related work",
+  "literature review",
+  "paper",
+  "preprint",
+  "thesis",
+  " dissertation"
+];
+var WEAK = ["\u641C\u96C6", "\u6536\u96C6", "\u68C0\u7D22", "\u67E5\u9605", "\u6574\u7406", "\u51C6\u5907", "\u8C03\u7814", "\u67E5\u4E00\u4E0B", "\u627E\u51E0\u7BC7", "search", "collect", "gather", "find some"];
+var ACADEMIC_COMPANION = [
+  "\u6587\u732E",
+  "\u8BBA\u6587",
+  "\u8D44\u6599",
+  "\u7814\u7A76",
+  "\u5B66\u672F",
+  "\u671F\u520A",
+  "\u4F1A\u8BAE",
+  "\u5B9E\u9A8C",
+  "\u65B9\u6CD5",
+  "\u7ED3\u8BBA",
+  "research",
+  "study",
+  "studies",
+  "academic",
+  "journal",
+  "conference",
+  "survey"
+];
+var NEGATIVE = [
+  "\u62A5\u9519",
+  "\u5D29\u6E83",
+  "\u7F16\u8BD1",
+  "\u6784\u5EFA",
+  "\u90E8\u7F72",
+  "\u5355\u5143\u6D4B\u8BD5",
+  "commit",
+  "merge",
+  "\u91CD\u6784",
+  "debug",
+  "stack trace",
+  "segfault",
+  "npm ",
+  "pnpm ",
+  "yarn ",
+  "git ",
+  "build failed",
+  "regression"
+];
+function normalize(text) {
+  return String(text ?? "").toLowerCase();
+}
+function hitCount(text, list) {
+  let n = 0;
+  for (const w of list) if (text.includes(w)) n += 1;
+  return n;
+}
+function detectIntent(text) {
+  const t = normalize(text);
+  if (!t || t.length < 6) return { active: false, score: 0, reason: "empty" };
+  const strong = hitCount(t, STRONG);
+  if (strong > 0) {
+    const neg = hitCount(t, NEGATIVE);
+    if (neg > 0 && neg >= strong) return { active: false, score: 0, reason: "coding-context" };
+    return { active: true, score: 1, reason: "strong-signal" };
+  }
+  const weak = hitCount(t, WEAK);
+  if (weak > 0 && hitCount(t, ACADEMIC_COMPANION) > 0) {
+    return { active: true, score: 0.6, reason: "weak+academic" };
+  }
+  return { active: false, score: 0, reason: "no-signal" };
+}
+function createActivation({ idleTimeoutMs = IDLE_TIMEOUT_MS } = {}) {
+  const listeners = /* @__PURE__ */ new Set();
+  let active = false;
+  let reason = "";
+  let timer = null;
+  let lastActivityAt = 0;
+  function emit2(next) {
+    active = next;
+    for (const fn of listeners) {
+      try {
+        fn({ active, reason });
+      } catch {
+      }
+    }
+  }
+  function clearTimer() {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  }
+  function armIdle() {
+    clearTimer();
+    timer = setTimeout(() => {
+      if (!active) return;
+      reason = "idle-timeout";
+      emit2(false);
+    }, idleTimeoutMs);
+    timer.unref?.();
+  }
+  return {
+    /** Mount the tools. Safe to call repeatedly — it just refreshes the idle timer. */
+    activate(why = "manual") {
+      lastActivityAt = Date.now();
+      if (!active) {
+        reason = why;
+        emit2(true);
+      }
+      armIdle();
+    },
+    deactivate(why = "manual") {
+      clearTimer();
+      if (active) {
+        reason = why;
+        emit2(false);
+      }
+    },
+    onTransition(fn) {
+      listeners.add(fn);
+      return () => listeners.delete(fn);
+    },
+    isActive: () => active,
+    reason: () => reason,
+    lastActivityAt: () => lastActivityAt,
+    dispose() {
+      clearTimer();
+      listeners.clear();
+    }
+  };
+}
+
 // src/node/index.js
 init_log();
 var name = "dsh-literature-pre";
 var inject = ["webServer", "tools"];
-function apply(ctx, config) {
+function apply(ctx2, config) {
   const onUncaught = (e) => error("uncaught exception:", e?.stack ?? e);
   const onUnhandled = (e) => error("unhandled rejection:", e?.stack ?? e);
   process.on("uncaughtException", onUncaught);
   process.on("unhandledRejection", onUnhandled);
   const disposers = [];
-  ctx.effect(() => {
+  ctx2.effect(() => {
     ensureDirs().then(() => init()).catch((e) => error("storage init failed:", e.message));
   }, "dsh-literature: storage");
   const ready = (async () => {
     await ensureDirs();
     await init();
-    disposers.push(...registerRoutes(ctx));
-    disposers.push(...registerTools(ctx));
+    const activation2 = createActivation();
+    const toolsCtl = registerTools(ctx2);
+    disposers.push(activation2.onTransition(({ active }) => active ? toolsCtl.mount() : toolsCtl.unmount()));
+    disposers.push(() => activation2.dispose());
+    disposers.push(...registerRoutes(ctx2, { activation: activation2 }));
     try {
-      disposers.push(...registerSessionHook(ctx));
+      disposers.push(...registerSessionHook(ctx2, { activation: activation2, detectIntent }));
     } catch (e) {
       error("session hook unavailable:", e.message);
     }