mixdog 0.9.97 → 0.9.99

package/src/runtime/agent/orchestrator/tools/builtin/read-image-resize.mjs

@@ -3,10 +3,11 @@
 // readImageWithTokenBudget) so a `read` on an image returns a viewable,
 // budget-bounded image block instead of refusing oversized originals.
 //
-// sharp is an OPTIONAL dependency. Every entry point degrades to a `null`
-// return when sharp can't be loaded (not installed, native binding missing,
-// dlopen failure); callers fall back to the legacy pass-through-with-cap
-// behaviour. No code path throws on a missing sharp.
+// sharp is a direct runtime dependency. Entry points still degrade to `null`
+// when a platform-native binding cannot load so a damaged install reports the
+// existing bounded fallback instead of crashing the whole daemon.
+
+import { createHash } from 'node:crypto';
 
 // Anthropic inline-image input is capped near 5MB base64 (API rejects on the
 // base64 LENGTH, not raw bytes). IMAGE_TARGET_RAW_SIZE is the raw-byte target
@@ -20,6 +21,70 @@ const IMAGE_MAX_HEIGHT = 2000;
 // dimension/raw-size resize governs the common case and the token gate only
 // fires on pathologically dense images.
 const DEFAULT_IMAGE_MAX_TOKENS = Math.ceil(API_IMAGE_MAX_BASE64_SIZE * 0.125);
+export const OPENAI_IMAGE_MAX_DIMENSION = 2048;
+export const OPENAI_IMAGE_PATCH_SIZE = 32;
+export const OPENAI_IMAGE_MAX_PATCHES = 1536;
+const IMAGE_RESIZE_CACHE_MAX_BYTES = 64 * 1024 * 1024;
+const imageResizeCache = new Map();
+let imageResizeCacheBytes = 0;
+let imageResizeCacheHits = 0;
+let imageResizeCacheMisses = 0;
+
+export function imageProfileForProvider(provider) {
+    const value = String(provider || '').trim().toLowerCase();
+    return /^(?:openai|xai|grok|deepseek|opencode-go|ollama|lmstudio)(?:-|$)/.test(value)
+        ? 'openai'
+        : 'anthropic';
+}
+
+export function openAIImagePatchCount(width, height) {
+    return Math.ceil(Math.max(1, Number(width) || 1) / OPENAI_IMAGE_PATCH_SIZE)
+        * Math.ceil(Math.max(1, Number(height) || 1) / OPENAI_IMAGE_PATCH_SIZE);
+}
+
+function resizeCacheKey(buffer, ext, maxTokens, profile) {
+    return createHash('sha256')
+        .update(String(ext || '')).update('\0')
+        .update(String(maxTokens || 0)).update('\0')
+        .update(String(profile || '')).update('\0')
+        .update(buffer)
+        .digest('hex');
+}
+
+function cloneResizeResult(result) {
+    return {
+        ...result,
+        ...(result?.dimensions ? { dimensions: { ...result.dimensions } } : {}),
+    };
+}
+
+function rememberResizeResult(key, result) {
+    const bytes = Buffer.byteLength(String(result?.data || ''), 'base64');
+    if (bytes <= 0 || bytes > IMAGE_RESIZE_CACHE_MAX_BYTES) return;
+    const existing = imageResizeCache.get(key);
+    if (existing) {
+        imageResizeCacheBytes -= existing.bytes;
+        imageResizeCache.delete(key);
+    }
+    imageResizeCache.set(key, { result: cloneResizeResult(result), bytes });
+    imageResizeCacheBytes += bytes;
+    while (imageResizeCacheBytes > IMAGE_RESIZE_CACHE_MAX_BYTES && imageResizeCache.size > 0) {
+        const oldest = imageResizeCache.keys().next().value;
+        const evicted = imageResizeCache.get(oldest);
+        imageResizeCache.delete(oldest);
+        imageResizeCacheBytes -= evicted?.bytes || 0;
+    }
+}
+
+export function imageResizeCacheStats() {
+    return {
+        entries: imageResizeCache.size,
+        bytes: imageResizeCacheBytes,
+        maxBytes: IMAGE_RESIZE_CACHE_MAX_BYTES,
+        hits: imageResizeCacheHits,
+        misses: imageResizeCacheMisses,
+    };
+}
 
 // Cached dynamic import. Resolves to the sharp factory or null (absent /
 // failed). Cached so repeated reads don't re-attempt a failing import.
@@ -38,6 +103,10 @@ async function loadSharp() {
     return _sharpPromise;
 }
 
+export function prewarmImageResizer() {
+    return loadSharp();
+}
+
 // True when sharp resolved; used for the per-file change summary / fallback note.
 async function sharpAvailable() {
     return (await loadSharp()) !== null;
@@ -88,8 +157,21 @@ export function imageMetadataText(dims, sourcePath) {
 // Returns { data (base64), mimeType ("image/..."), dimensions } on success,
 // or null when sharp is unavailable OR any sharp op threw (caller falls back
 // to legacy pass-through-with-cap).
-export async function resizeImageBuffer(buffer, ext, { maxTokens = DEFAULT_IMAGE_MAX_TOKENS } = {}) {
+export async function resizeImageBuffer(buffer, ext, {
+    maxTokens = DEFAULT_IMAGE_MAX_TOKENS,
+    profile = 'anthropic',
+} = {}) {
     if (!Buffer.isBuffer(buffer) || buffer.length === 0) return null;
+    const normalizedProfile = profile === 'openai' ? 'openai' : 'anthropic';
+    const cacheKey = resizeCacheKey(buffer, ext, maxTokens, normalizedProfile);
+    const cached = imageResizeCache.get(cacheKey);
+    if (cached) {
+        imageResizeCacheHits += 1;
+        imageResizeCache.delete(cacheKey);
+        imageResizeCache.set(cacheKey, cached);
+        return cloneResizeResult(cached.result);
+    }
+    imageResizeCacheMisses += 1;
     const sharp = await loadSharp();
     if (!sharp) return null;
     try {
@@ -108,13 +190,20 @@ export async function resizeImageBuffer(buffer, ext, { maxTokens = DEFAULT_IMAGE
             // Constrain dimensions while preserving aspect ratio.
             let width = originalWidth;
             let height = originalHeight;
-            if (width > IMAGE_MAX_WIDTH) {
-                height = Math.round((height * IMAGE_MAX_WIDTH) / width);
-                width = IMAGE_MAX_WIDTH;
+            const maxWidth = normalizedProfile === 'openai' ? OPENAI_IMAGE_MAX_DIMENSION : IMAGE_MAX_WIDTH;
+            const maxHeight = normalizedProfile === 'openai' ? OPENAI_IMAGE_MAX_DIMENSION : IMAGE_MAX_HEIGHT;
+            let scale = Math.min(1, maxWidth / width, maxHeight / height);
+            if (normalizedProfile === 'openai') {
+                scale = Math.min(
+                    scale,
+                    Math.sqrt((OPENAI_IMAGE_MAX_PATCHES * OPENAI_IMAGE_PATCH_SIZE ** 2) / (width * height)),
+                );
             }
-            if (height > IMAGE_MAX_HEIGHT) {
-                width = Math.round((width * IMAGE_MAX_HEIGHT) / height);
-                height = IMAGE_MAX_HEIGHT;
+            width = Math.max(1, Math.floor(width * scale));
+            height = Math.max(1, Math.floor(height * scale));
+            while (normalizedProfile === 'openai' && openAIImagePatchCount(width, height) > OPENAI_IMAGE_MAX_PATCHES) {
+                if (width >= height) width -= 1;
+                else height -= 1;
             }
             const needsResize = width !== originalWidth || height !== originalHeight;
             if (needsResize || originalSize > IMAGE_TARGET_RAW_SIZE) {
@@ -162,11 +251,13 @@ export async function resizeImageBuffer(buffer, ext, { maxTokens = DEFAULT_IMAGE
             }
         }
 
-        return {
+        const result = {
             data: base64,
             mimeType: `image/${mediaType}`,
             dimensions: { originalWidth, originalHeight, displayWidth, displayHeight },
         };
+        rememberResizeResult(cacheKey, result);
+        return result;
     } catch {
         // sharp present but processing failed (corrupt header, unsupported
         // format, OOM). Signal fallback rather than throwing.

package/src/runtime/agent/orchestrator/tools/builtin/read-special-files.mjs

@@ -1,16 +1,15 @@
 import { readFile, stat } from 'fs/promises';
 import { open } from 'fs/promises';
-import { createRequire } from 'module';
 import { READ_MAX_SIZE_BYTES } from './read-constants.mjs';
 import { imageBlocksFromBuffer } from './read-image-resize.mjs';
+import { inspectPdfBuffer } from '../../../../attachments/pdf-extract.mjs';
 
-const requireCjs = createRequire(import.meta.url);
 const DEFAULT_READ_MAX_OUTPUT_BYTES = 100 * 1024;
 
 // PDFs at or under this size are emitted as an Anthropic base64 document
 // block (the model reads the rendered PDF directly): 20MB raw → ~27MB
 // base64, which stays under the 32MB request cap.
-// Larger PDFs fall back to pdf-parse TEXT extraction.
+// Larger PDFs fall back to bounded PDF.js text extraction.
 const PDF_DOCUMENT_MAX_BYTES = 20 * 1024 * 1024;
 
 // %PDF- magic bytes (0x25 0x50 0x44 0x46 0x2D). A document block must only be
@@ -66,37 +65,18 @@ function parsePagesArg(pagesArg) {
     return { filter: { from, to } };
 }
 
-// pdf-parse TEXT extraction. Fallback path for PDFs over the document-block
+// PDF.js text extraction. Fallback path for PDFs over the document-block
 // size cap, and the always-path when a page range is requested (a base64
 // document block can't be page-filtered, so a narrowed read keeps using text).
 async function extractPdfTextBody(fullPath, pageFilter, maxOutputBytes) {
-    const pdfParse = requireCjs('pdf-parse');
     const buf = await readFile(fullPath);
-    const pageTexts = [];
-    const data = await pdfParse(buf, {
-        pagerender: (pageData) => {
-            // pdf-parse exposes either `pageNumber` (1-based, pdf.js) or
-            // `_pageIndex` (0-based, internal); preferring pageIndex+1 over
-            // pageNumber dropped/duplicated pages when pdf.js renumbered with
-            // annotations or oddball page trees. Use pageNumber first.
-            const pageNum = (typeof pageData.pageNumber === 'number')
-                ? pageData.pageNumber
-                : ((pageData._pageIndex ?? pageData.pageIndex ?? 0) + 1);
-            if (pageFilter && (pageNum < pageFilter.from || pageNum > pageFilter.to)) return Promise.resolve('');
-            return pageData.getTextContent().then((tc) => {
-                const text = tc.items.map((i) => i.str).join(' ');
-                pageTexts.push({ page: pageNum, text });
-                return text;
-            });
-        },
+    const result = await inspectPdfBuffer(buf, {
+        extractText: true,
+        maxPages: Infinity,
+        maxOutputBytes,
+        pageRange: pageFilter,
     });
-    let out = pageFilter
-        ? pageTexts.map((p) => `--- Page ${p.page} ---\n${p.text}`).join('\n\n')
-        : (data.text || '');
-    if (out.length > maxOutputBytes) {
-        out = out.slice(0, maxOutputBytes) + `\n\n... [PDF output truncated at ${Math.round(maxOutputBytes / 1024)} KB; use pages param to narrow]`;
-    }
-    return out || '(no text content extracted from PDF)';
+    return result.text || '(no text content extracted from PDF)';
 }
 
 export async function extractPdfText(fullPath, pagesArg, { maxOutputBytes = DEFAULT_READ_MAX_OUTPUT_BYTES, textOnly = false } = {}) {
@@ -136,7 +116,7 @@ export async function extractPdfText(fullPath, pagesArg, { maxOutputBytes = DEFA
         // TEXT fallback: >20MB PDFs, page-filtered reads, or non-magic files.
         return await extractPdfTextBody(fullPath, pages.filter, maxOutputBytes);
     } catch (err) {
-        return `Error: pdf-parse failed — ${err instanceof Error ? err.message : String(err)}`;
+        return `Error: PDF extraction failed — ${err instanceof Error ? err.message : String(err)}`;
     }
 }
 

package/src/runtime/agent/orchestrator/tools/patch/orchestrator.mjs

@@ -200,7 +200,7 @@ async function applyParsedWave({ parsed: wparsed, entries: wentries, headerRewri
 async function applyPatchSequence(patchStr, requestedFormat, basePath, ctx) {
   const {
     v4aConvertOpts, dryRun, fuzz, fuzzy, rejectPartial,
-    readStateScope, abortSignal, mutationPlan, rollbackOnFailure,
+    readStateScope, abortSignal, mutationPlan,
     toolCallId, sessionId,
   } = ctx;
 
@@ -328,52 +328,8 @@ async function applyPatchSequence(patchStr, requestedFormat, basePath, ctx) {
 
   return withBuiltinPathLocks(lockPaths, () =>
     withAdvisoryLocks(lockPaths, async () => {
-      // Most multi-file failures are stale context in a later, independent
-      // file. For unique targets, validate every section against current bytes
-      // before the first write. Same-target sequences retain the existing
-      // ordered conversion/rollback path because later sections may
-      // intentionally depend on earlier edits.
-      const preparedUnits = new Map();
-      const uniqueTargets = new Set(lockPaths.map(patchPathKey)).size === units.length;
-      if (!dryRun && rollbackOnFailure && uniqueTargets) {
-        for (let i = 0; i < units.length; i++) {
-          const unit = units[i];
-          if (abortSignal?.aborted) return 'Error: apply_patch aborted during preflight; no files were written';
-          let parsed;
-          try {
-            parsed = await unit.buildParsed();
-          } catch (err) {
-            return `Error: apply_patch preflight rejected section ${i + 1}/${units.length} (${unit.displayPath}); no files were written.\n${err?.message || String(err)}`;
-          }
-          if (!Array.isArray(parsed) || parsed.length === 0) {
-            preparedUnits.set(i, { parsed, wave: null });
-            continue;
-          }
-          let wave;
-          try {
-            const { entries, headerRewrites } = await preValidateNativeBatch(parsed, basePath);
-            wave = { parsed, entries, headerRewrites };
-          } catch (err) {
-            return `Error: apply_patch preflight rejected section ${i + 1}/${units.length} (${unit.displayPath}); no files were written.\n${err?.message || String(err)}`;
-          }
-          const checked = await applyParsedWave(wave, basePath, { ...waveOpts, dryRun: true });
-          if (checked.error) {
-            const detail = checked.error.replace(/^Error:\s*/, '');
-            return `Error: apply_patch preflight rejected section ${i + 1}/${units.length} (${unit.displayPath}); no files were written.\n${detail}`;
-          }
-          preparedUnits.set(i, { parsed, wave });
-        }
-      }
-      let rollbackSnapshots = [];
       let uiBeforeSnapshots = [];
-      if (!dryRun && rollbackOnFailure) {
-        try {
-          rollbackSnapshots = capturePatchRollbackState(lockPaths);
-          uiBeforeSnapshots = rollbackSnapshots;
-        } catch (err) {
-          return `Error: ${err?.message || String(err)}`;
-        }
-      } else if (!dryRun && toolCallId && sessionId) {
+      if (!dryRun && toolCallId && sessionId) {
         try {
           uiBeforeSnapshots = capturePatchRollbackState(lockPaths);
         } catch {
@@ -393,15 +349,13 @@ async function applyPatchSequence(patchStr, requestedFormat, basePath, ctx) {
           failedIndex = i;
           continue;
         }
-        let parsed = preparedUnits.get(i)?.parsed;
-        if (!preparedUnits.has(i)) {
-          try {
-            parsed = await unit.buildParsed();
-          } catch (err) {
-            failed = { displayPath: unit.displayPath, error: `Error: ${err?.message || String(err)}` };
-            failedIndex = i;
-            continue;
-          }
+        let parsed;
+        try {
+          parsed = await unit.buildParsed();
+        } catch (err) {
+          failed = { displayPath: unit.displayPath, error: `Error: ${err?.message || String(err)}` };
+          failedIndex = i;
+          continue;
         }
         if (!Array.isArray(parsed) || parsed.length === 0) {
           // Section produced no applicable hunks (all skipped / no-op). Nothing
@@ -409,16 +363,14 @@ async function applyPatchSequence(patchStr, requestedFormat, basePath, ctx) {
           applied.push({ displayPath: unit.displayPath, text: `(no changes) ${unit.displayPath}` });
           continue;
         }
-        let wave = preparedUnits.get(i)?.wave;
-        if (!wave) {
-          try {
-            const { entries, headerRewrites } = await preValidateNativeBatch(parsed, basePath);
-            wave = { parsed, entries, headerRewrites };
-          } catch (err) {
-            failed = { displayPath: unit.displayPath, error: `Error: ${err?.message || String(err)}` };
-            failedIndex = i;
-            continue;
-          }
+        let wave;
+        try {
+          const { entries, headerRewrites } = await preValidateNativeBatch(parsed, basePath);
+          wave = { parsed, entries, headerRewrites };
+        } catch (err) {
+          failed = { displayPath: unit.displayPath, error: `Error: ${err?.message || String(err)}` };
+          failedIndex = i;
+          continue;
         }
         const res = await applyParsedWave(wave, basePath, waveOpts);
         executor = res.executor;
@@ -462,13 +414,10 @@ async function applyPatchSequence(patchStr, requestedFormat, basePath, ctx) {
         return wrapPatchMutationOutput(body, mutationPlan, { executor });
       }
       const failMsg = failed.error.replace(/^Error:\s*/, '');
-      const rollbackErrors = (!dryRun && rollbackOnFailure)
-        ? restorePatchRollbackState(rollbackSnapshots, readStateScope)
-        : [];
       if (
         !dryRun
         && uiBeforeSnapshots.length > 0
-        && ((!rollbackOnFailure && applied.length > 0) || rollbackErrors.length > 0)
+        && applied.length > 0
       ) {
         registerCommittedPatchUiDiff({
           callId: toolCallId,
@@ -480,22 +429,18 @@ async function applyPatchSequence(patchStr, requestedFormat, basePath, ctx) {
       }
       const committedPhrase = dryRun
         ? `${applied.length} earlier section(s) were validated`
-        : (rollbackOnFailure
-          ? (rollbackErrors.length === 0
-            ? `${applied.length} earlier section(s) were applied, then all touched paths were rolled back to their pre-patch state`
-            : `${applied.length} earlier section(s) were applied, but rollback was incomplete`)
-          : `${applied.length} earlier section(s) were applied to disk (committed) and left in place`);
+        : `${applied.length} earlier section(s) were applied to disk (committed) and left in place`;
       const lines = [
         `Error: apply_patch sequence stopped at section ${failedIndex + 1}/${units.length} (${failed.displayPath}); `
           + `${committedPhrase}; ${skipped.length} later section(s) were skipped (not attempted).`,
       ];
+      if (!dryRun) {
+        lines.push('Retry only the failed and skipped sections; do not resend committed sections.');
+      }
       if (appliedTexts) {
-        lines.push(`--- ${dryRun ? 'validated' : (rollbackOnFailure ? 'applied before rollback' : 'applied (committed to disk)')} ---`, appliedTexts);
+        lines.push(`--- ${dryRun ? 'validated' : 'applied (committed to disk)'} ---`, appliedTexts);
       }
       lines.push(`--- failed section: ${failed.displayPath} ---`, failMsg);
-      if (rollbackErrors.length > 0) {
-        lines.push('--- rollback incomplete ---', ...rollbackErrors);
-      }
       if (skipped.length > 0) {
         lines.push(`--- skipped (not attempted): ${skipped.join(', ')} ---`);
       }
@@ -830,11 +775,10 @@ async function apply_patch(args, cwd, options = {}) {
   let inputPatchStr = patchStr;
   const rejectedV4AHunks = [];
   const v4aConvertOpts = { rejectPartial, rejectedHunks: rejectedV4AHunks, fuzzy, dryRun, readStateScope };
-  // Default internal ordered mode: apply sections in listed order, stop at the
-  // first failure, and roll every touched path back to its pre-patch state.
-  // mode:"partial" retains the old committed-prefix behavior for internal
-  // callers that explicitly need it.
-  // The legacy bulk/atomic path remains available as an explicit escape hatch.
+  // Default ordered mode mirrors Codex's lower executor: apply sections in
+  // listed order, stop at the first failure, and keep the committed prefix.
+  // The model-visible schema stays unchanged; legacy bulk/atomic rollback
+  // remains an internal escape hatch.
   const patchMode = String(args?.mode || '').toLowerCase();
   const legacyBulkMode = args?.sequence === false
     || ['atomic', 'bulk'].includes(patchMode);
@@ -842,7 +786,6 @@ async function apply_patch(args, cwd, options = {}) {
     const seqOut = await applyPatchSequence(patchStr, requestedFormat, basePath, {
       v4aConvertOpts, dryRun, fuzz, fuzzy, rejectPartial,
       readStateScope, abortSignal, mutationPlan,
-      rollbackOnFailure: patchMode !== 'partial',
       toolCallId: options?.toolCallId || null,
       sessionId: options?.sessionId || null,
     });

package/src/runtime/attachments/pdf-extract.mjs

@@ -0,0 +1,83 @@
+/**
+ * Bounded PDF inspection/text extraction shared by prompt intake and `read`.
+ *
+ * Native PDF-capable providers receive the original content-addressed file.
+ * OpenAI-compatible providers without a document contract receive page-ordered
+ * text extracted here, so they never see an unsupported inline Base64 block.
+ */
+const DEFAULT_MAX_PAGES = 100;
+const DEFAULT_MAX_OUTPUT_BYTES = 1024 * 1024;
+
+function boundedUtf8(value, maxBytes) {
+  const buffer = Buffer.from(String(value || ''), 'utf8');
+  if (buffer.length <= maxBytes) return { text: buffer.toString('utf8'), bytes: buffer.length, truncated: false };
+  if (maxBytes <= 0) return { text: '', bytes: 0, truncated: true };
+  const text = buffer.subarray(0, maxBytes).toString('utf8').replace(/\uFFFD+$/g, '');
+  return { text, bytes: Buffer.byteLength(text, 'utf8'), truncated: true };
+}
+
+export async function inspectPdfBuffer(buffer, {
+  extractText = false,
+  maxPages = DEFAULT_MAX_PAGES,
+  maxOutputBytes = DEFAULT_MAX_OUTPUT_BYTES,
+  pageRange = null,
+} = {}) {
+  if (!Buffer.isBuffer(buffer) || buffer.length === 0) throw new TypeError('PDF payload is empty');
+  const { getDocumentProxy } = await import('unpdf');
+  const pdf = await getDocumentProxy(new Uint8Array(buffer));
+  try {
+    const pageCount = Math.max(0, Number(pdf?.numPages) || 0);
+    const pageLimit = Number.isFinite(Number(maxPages)) ? Math.max(1, Math.floor(Number(maxPages))) : Infinity;
+    if (pageCount > pageLimit) {
+      throw new RangeError(`PDF has ${pageCount} pages; maximum supported attachment is ${pageLimit} pages`);
+    }
+    if (!extractText) return { pageCount, text: '', truncated: false };
+
+    const from = Math.max(1, Number(pageRange?.from) || 1);
+    const to = Math.min(pageCount, Math.max(from, Number(pageRange?.to) || pageCount));
+    const byteLimit = Math.max(1, Number(maxOutputBytes) || DEFAULT_MAX_OUTPUT_BYTES);
+    const chunks = [];
+    let bytes = 0;
+    let truncated = false;
+    for (let pageNumber = from; pageNumber <= to; pageNumber += 1) {
+      const page = await pdf.getPage(pageNumber);
+      try {
+        const content = await page.getTextContent();
+        const body = (content?.items || [])
+          .map((item) => typeof item?.str === 'string' ? item.str : '')
+          .filter(Boolean)
+          .join(' ')
+          .trim();
+        const block = `--- Page ${pageNumber} ---\n${body || '(no extractable text on this page)'}`;
+        const separatorBytes = chunks.length ? 2 : 0;
+        const remaining = byteLimit - bytes - separatorBytes;
+        if (remaining <= 0) {
+          truncated = true;
+          break;
+        }
+        const bounded = boundedUtf8(block, remaining);
+        if (chunks.length) {
+          chunks.push('\n\n');
+          bytes += 2;
+        }
+        chunks.push(bounded.text);
+        bytes += bounded.bytes;
+        if (bounded.truncated) {
+          truncated = true;
+          break;
+        }
+      } finally {
+        try { page.cleanup?.(); } catch {}
+      }
+    }
+    if (truncated) {
+      const suffix = '\n\n... [PDF text truncated to the prompt input budget]';
+      const room = Math.max(0, byteLimit - Buffer.byteLength(suffix, 'utf8'));
+      const bounded = boundedUtf8(chunks.join(''), room);
+      return { pageCount, text: `${bounded.text}${suffix}`, truncated: true };
+    }
+    return { pageCount, text: chunks.join(''), truncated: false };
+  } finally {
+    try { await pdf.destroy?.(); } catch {}
+  }
+}