compress-pdf-lib 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,202 @@
+# compress-pdf-lib
+
+Client-side PDF compression. Renders each page with `pdf.js`, encodes it to
+JPEG with mozjpeg (WASM, via `@jsquash/jpeg`) across a parallel `Worker`
+pool, and rebuilds the PDF with `pdf-lib`. Nothing leaves the browser, and
+there's no bundled UI — you call one function and get a compressed file back.
+
+## Requirements
+
+This package ships as **raw ESM source**, not a pre-bundled dist. It relies on
+Vite-specific import syntax (`?url` asset imports, `new URL(..., import.meta.url)`
+worker resolution), so it only works inside a **Vite-powered build**:
+
+- ✅ React + Vite (`npm create vite@latest`)
+- ✅ Astro (Astro's dev server and build are Vite under the hood)
+- ✅ Any other Vite app (SvelteKit, Vue + Vite, plain Vite, etc.)
+- ❌ Webpack / CRA / Next.js's default Webpack build (untested, likely needs
+  worker-loader / asset-url tweaks)
+
+It also only runs in the browser — it uses `Worker`, `OffscreenCanvas`,
+`createImageBitmap`, and `navigator.*`, so call it from client-side code
+(a React event handler, a browser `<script>` in Astro, etc.), never during
+SSR.
+
+## Install
+
+```bash
+npm install compress-pdf-lib
+```
+
+Or, straight from GitHub without publishing to npm:
+
+```bash
+npm install github:dgbkn/compress-pdf-lib
+```
+
+## Usage
+
+```js
+import { compressPDF } from "compress-pdf-lib";
+
+const { file, stats } = await compressPDF(pdfFile, {
+  quality: 70,       // JPEG quality, 0-100
+  resolution: 1600,  // max px on a page's longest side
+});
+
+console.log(stats);
+// {
+//   pages, originalBytes, compressedBytes, savedBytes,
+//   reduction,   // percent
+//   elapsed,     // ms
+//   workersUsed,
+//   perPage: [{ pageNumber, renderedWidth, renderedHeight, jpegBytes }, ...]
+// }
+```
+
+`compressPDF(input, options)` accepts a `File`, `Blob`, `ArrayBuffer`, or
+typed array, and returns `{ file, stats }` where `file` is a `File` (or
+`Blob` if `File` isn't available) you can upload, download, or inspect.
+
+### React + Vite
+
+```jsx
+import { compressPDF } from "compress-pdf-lib";
+
+function Uploader() {
+  async function handleChange(event) {
+    const original = event.target.files[0];
+    const { file, stats } = await compressPDF(original, { quality: 65 });
+
+    console.log(`${stats.reduction.toFixed(1)}% smaller`);
+    // upload `file`, or trigger a download, etc.
+  }
+
+  return <input type="file" accept="application/pdf" onChange={handleChange} />;
+}
+```
+
+### Astro
+
+Astro components render on the server by default, so run this inside a
+client-side script or an interactive island (`client:load` etc.):
+
+```astro
+---
+// src/pages/index.astro
+---
+<input type="file" id="pdf-input" accept="application/pdf" />
+<pre id="stats"></pre>
+
+<script>
+  import { compressPDF } from "compress-pdf-lib";
+
+  const input = document.getElementById("pdf-input");
+  const statsEl = document.getElementById("stats");
+
+  input.addEventListener("change", async (event) => {
+    const file = event.target.files?.[0];
+    if (!file) return;
+
+    const { file: compressed, stats } = await compressPDF(file, { quality: 70 });
+    statsEl.textContent = JSON.stringify(stats, null, 2);
+  });
+</script>
+```
+
+(A React/Vue/Svelte island with `client:load` works the same way — just call
+`compressPDF` inside a browser event handler.)
+
+### Intercepting a fetch upload
+
+```js
+import { compressPDF } from "compress-pdf-lib";
+
+const originalFetch = window.fetch;
+
+window.fetch = async function (...args) {
+  const [resource, config] = args;
+
+  if (config?.body instanceof FormData) {
+    const entries = [...config.body.entries()];
+    const hasPdf = entries.some(
+      ([, v]) => v instanceof File && v.type === "application/pdf"
+    );
+
+    if (hasPdf) {
+      const newFormData = new FormData();
+
+      for (const [key, value] of entries) {
+        if (value instanceof File && value.type === "application/pdf") {
+          const { file, stats } = await compressPDF(value, { quality: 70 });
+          console.log(`Compressed ${value.name}:`, stats);
+          newFormData.append(key, file, value.name);
+        } else {
+          newFormData.append(key, value);
+        }
+      }
+
+      config.body = newFormData;
+    }
+  }
+
+  return originalFetch.call(this, resource, config);
+};
+```
+
+## API
+
+### `compressPDF(input, options?)`
+
+| Option       | Type     | Default | Description                                  |
+|--------------|----------|---------|-----------------------------------------------|
+| `quality`    | number   | `65`    | JPEG quality, 0–100                            |
+| `resolution` | number   | `1600`  | Max px on a page's longest rendered side       |
+| `workers`    | number   | auto    | Override the auto-detected worker count        |
+| `onProgress` | function | —       | `(update) => void`, called with `{ stage, progress, ... }` |
+
+Returns `Promise<{ file, stats }>`.
+
+### `getClientPower()`
+
+Returns `{ cores, memory, workers }` — the auto-detected hardware profile and
+the worker count `compressPDF` would use by default.
+
+### `CompressionPool`
+
+The underlying worker-pool class, exported in case you want to manage the
+pool's lifecycle yourself across multiple compressions instead of letting
+`compressPDF` create/destroy one per call.
+
+## Publishing this package
+
+### Option A — npm registry
+
+```bash
+cd compress-pdf-lib
+npm login
+npm publish
+```
+
+(`publishConfig.access: public` is already set in `package.json`, needed if
+you ever scope the package name like `@you/compress-pdf-lib`.)
+
+Bump `version` in `package.json` before each subsequent `npm publish`
+(`npm version patch|minor|major` does this for you and tags git).
+
+### Option B — GitHub only (no npm publish)
+
+1. Push this folder as a repo, e.g. `github.com/YOUR_USERNAME/compress-pdf-lib`.
+2. Consumers install with:
+   ```bash
+   npm install github:YOUR_USERNAME/compress-pdf-lib
+   # or a specific tag/branch:
+   npm install github:YOUR_USERNAME/compress-pdf-lib#v1.0.0
+   ```
+
+Either way, update the `repository`/`homepage`/`bugs` URLs in `package.json`
+to your actual GitHub username first.
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "compress-pdf-lib",
+  "version": "1.0.0",
+  "description": "Client-side PDF compression: pdf.js render + mozjpeg (WASM) encoding via a parallel worker pool + pdf-lib rebuild. No server, no UI. Ships as raw ESM source for Vite-based apps (React + Vite, Astro).",
+  "type": "module",
+  "main": "src/index.js",
+  "module": "src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./worker": "./src/pdf-compressor.worker.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "sideEffects": [
+    "src/pdf-compressor.worker.js"
+  ],
+  "keywords": [
+    "pdf",
+    "compression",
+    "compress-pdf",
+    "jpeg",
+    "mozjpeg",
+    "pdfjs",
+    "pdf-lib",
+    "vite",
+    "astro",
+    "react"
+  ],
+  "author": "Dev Goyal",
+  "license": "MIT",
+  "dependencies": {
+    "pdfjs-dist": "^6.3.289",
+    "pdf-lib": "^1.17.1",
+    "@jsquash/jpeg": "^1.4.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dgbkn/compress-pdf-lib.git"
+  },
+  "homepage": "https://github.com/dgbkn/compress-pdf-lib#readme",
+  "bugs": {
+    "url": "https://github.com/dgbkn/compress-pdf-lib/issues"
+  }
+}

package/src/compress.js

@@ -0,0 +1,537 @@
+/**
+ * compress.js
+ *
+ * Full, UI-less PDF compression library: worker-pool + parallel page
+ * rendering + mozjpeg (WASM) encoding + pdf-lib rebuild.
+ *
+ * Pairs with pdf-compressor.worker.js (same folder).
+ *
+ * Usage:
+ *   import { compressPDF } from 'compress-pdf-lib';
+ *
+ *   const { file, stats } = await compressPDF(pdfFile, {
+ *     quality: 70,
+ *     resolution: 1600,
+ *   });
+ *
+ *   console.log(stats);
+ *   // {
+ *   //   pages, originalBytes, compressedBytes, savedBytes,
+ *   //   reduction, elapsed, workersUsed, perPage: [...]
+ *   // }
+ */
+
+import * as pdfjsLib from "pdfjs-dist";
+import { PDFDocument } from "pdf-lib";
+import pdfWorkerUrl from "pdfjs-dist/build/pdf.worker.min.mjs?url";
+
+pdfjsLib.GlobalWorkerOptions.workerSrc = pdfWorkerUrl;
+
+/* ============================================================
+   CLIENT POWER DETECTION
+============================================================ */
+
+export function getClientPower() {
+  const cores = navigator.hardwareConcurrency || 4;
+  const memory = navigator.deviceMemory || 4;
+
+  /*
+   * Conservative worker count.
+   * We don't want one worker per core because
+   * WASM JPEG encoding is CPU intensive.
+   */
+
+  let workers;
+
+  if (cores <= 2) {
+    workers = 1;
+  } else if (cores <= 4) {
+    workers = 2;
+  } else if (cores <= 8) {
+    workers = 3;
+  } else if (cores <= 12) {
+    workers = 4;
+  } else {
+    workers = 6;
+  }
+
+  /* Memory protection */
+
+  if (memory <= 2) {
+    workers = Math.min(workers, 1);
+  } else if (memory <= 4) {
+    workers = Math.min(workers, 2);
+  } else if (memory <= 8) {
+    workers = Math.min(workers, 4);
+  }
+
+  /* Never create ridiculous amounts of workers */
+
+  workers = Math.max(1, Math.min(workers, Math.max(1, cores - 1), 6));
+
+  return { cores, memory, workers };
+}
+
+/* ============================================================
+   WORKER POOL
+============================================================ */
+
+export class CompressionPool {
+  constructor() {
+    this.workers = [];
+    this.idle = [];
+    this.jobs = new Map();
+    this.queue = [];
+    this.nextId = 1;
+  }
+
+  init(count) {
+    this.destroy();
+
+    for (let i = 0; i < count; i++) {
+      const worker = new Worker(
+        new URL("./pdf-compressor.worker.js", import.meta.url),
+        { type: "module" }
+      );
+
+      const slot = { worker, busy: false };
+
+      worker.onmessage = (event) => {
+        const data = event.data;
+
+        if (data.type === "image-complete") {
+          const jobId = data.jobId;
+          const job = this.jobs.get(jobId);
+
+          if (!job) return;
+
+          this.jobs.delete(jobId);
+          slot.busy = false;
+          this.idle.push(slot);
+
+          job.resolve(data);
+          this.pump();
+        } else if (data.type === "error") {
+          const jobId = data.jobId;
+          const job = this.jobs.get(jobId);
+
+          if (!job) return;
+
+          this.jobs.delete(jobId);
+          slot.busy = false;
+          this.idle.push(slot);
+
+          job.reject(new Error(data.message || "Worker compression failed"));
+          this.pump();
+        }
+      };
+
+      worker.onerror = (error) => {
+        console.error("Worker error:", error);
+        slot.busy = false;
+
+        for (const [id, job] of this.jobs) {
+          if (job.slot === slot) {
+            this.jobs.delete(id);
+            job.reject(new Error("Compression worker crashed"));
+          }
+        }
+
+        this.pump();
+      };
+
+      this.workers.push(slot);
+      this.idle.push(slot);
+    }
+  }
+
+  run(payload, transferables = []) {
+    return new Promise((resolve, reject) => {
+      const id = this.nextId++;
+
+      this.queue.push({ id, payload, transferables, resolve, reject });
+
+      this.pump();
+    });
+  }
+
+  pump() {
+    while (this.queue.length > 0 && this.idle.length > 0) {
+      const slot = this.idle.shift();
+      if (!slot) return;
+
+      const job = this.queue.shift();
+      slot.busy = true;
+      job.slot = slot;
+
+      this.jobs.set(job.id, job);
+
+      slot.worker.postMessage({ ...job.payload, jobId: job.id }, job.transferables);
+    }
+  }
+
+  async drain() {
+    while (this.queue.length > 0 || this.jobs.size > 0) {
+      await new Promise((resolve) => setTimeout(resolve, 5));
+    }
+  }
+
+  destroy() {
+    for (const slot of this.workers) {
+      try {
+        slot.worker.terminate();
+      } catch {}
+    }
+
+    this.workers = [];
+    this.idle = [];
+    this.jobs.clear();
+    this.queue = [];
+  }
+}
+
+/* ============================================================
+   SAFE PDF PAGE CLEANUP
+============================================================ */
+
+function safePageCleanup(page) {
+  try {
+    if (page && typeof page.cleanup === "function") {
+      page.cleanup();
+    }
+  } catch (error) {
+    console.warn("Page cleanup skipped:", error);
+  }
+}
+
+/* ============================================================
+   INPUT NORMALIZATION
+============================================================ */
+
+async function normalizeInput(input) {
+  let arrayBuffer;
+  let fileName = "document.pdf";
+  let fileType = "application/pdf";
+
+  if (typeof File !== "undefined" && input instanceof File) {
+    fileName = input.name || fileName;
+    fileType = input.type || fileType;
+    arrayBuffer = await input.arrayBuffer();
+  } else if (input instanceof Blob) {
+    fileType = input.type || fileType;
+    arrayBuffer = await input.arrayBuffer();
+  } else if (input instanceof ArrayBuffer) {
+    arrayBuffer = input;
+  } else if (ArrayBuffer.isView(input)) {
+    arrayBuffer = input.buffer.slice(
+      input.byteOffset,
+      input.byteOffset + input.byteLength
+    );
+  } else {
+    throw new Error("compressPDF: unsupported input type");
+  }
+
+  return { arrayBuffer, fileName, fileType, originalBytes: arrayBuffer.byteLength };
+}
+
+/* ============================================================
+   RENDER + COMPRESS ONE PAGE
+============================================================ */
+
+async function processPage(pdf, pool, pageNumber, totalPages, { quality, resolution }) {
+  let page = null;
+  let canvas = null;
+  let bitmap = null;
+
+  try {
+    page = await pdf.getPage(pageNumber);
+
+    const baseViewport = page.getViewport({ scale: 1 });
+    const pdfWidth = baseViewport.width;
+    const pdfHeight = baseViewport.height;
+
+    const largestDimension = Math.max(pdfWidth, pdfHeight);
+
+    let scale = resolution / largestDimension;
+    scale = Math.max(scale, 0.25);
+    scale = Math.min(scale, 3);
+
+    const viewport = page.getViewport({ scale });
+    const width = Math.ceil(viewport.width);
+    const height = Math.ceil(viewport.height);
+
+    canvas = document.createElement("canvas");
+    canvas.width = width;
+    canvas.height = height;
+
+    const ctx = canvas.getContext("2d", {
+      alpha: false,
+      desynchronized: true,
+      willReadFrequently: false,
+    });
+
+    if (!ctx) {
+      throw new Error(`Canvas unavailable for page ${pageNumber}`);
+    }
+
+    ctx.fillStyle = "#ffffff";
+    ctx.fillRect(0, 0, width, height);
+
+    await page.render({
+      canvasContext: ctx,
+      viewport,
+      background: "white",
+    }).promise;
+
+    bitmap = await createImageBitmap(canvas);
+
+    canvas.width = 1;
+    canvas.height = 1;
+
+    const compressed = await pool.run(
+      {
+        type: "compress-image",
+        bitmap,
+        pageNumber,
+        totalPages,
+        quality,
+        pdfWidth,
+        pdfHeight,
+      },
+      [bitmap]
+    );
+
+    bitmap = null;
+
+    return compressed;
+  } finally {
+    if (canvas) {
+      try {
+        canvas.width = 1;
+        canvas.height = 1;
+      } catch {}
+    }
+
+    if (bitmap) {
+      try {
+        bitmap.close();
+      } catch {}
+    }
+
+    safePageCleanup(page);
+  }
+}
+
+/* ============================================================
+   PARALLEL PAGE PIPELINE
+============================================================ */
+
+async function processPages(pdf, pool, totalPages, { quality, resolution, workers, onProgress }) {
+  const results = new Array(totalPages);
+
+  const renderConcurrency = Math.max(1, Math.min(workers, 4));
+
+  let nextPage = 1;
+  let completed = 0;
+
+  async function runner() {
+    while (true) {
+      const pageNumber = nextPage++;
+
+      if (pageNumber > totalPages) {
+        return;
+      }
+
+      const result = await processPage(pdf, pool, pageNumber, totalPages, {
+        quality,
+        resolution,
+      });
+
+      results[pageNumber - 1] = result;
+      completed++;
+
+      if (typeof onProgress === "function") {
+        onProgress({
+          stage: "compressing",
+          pageNumber,
+          totalPages,
+          completed,
+          progress: Math.round((completed / totalPages) * 90),
+        });
+      }
+    }
+  }
+
+  const runners = Math.min(renderConcurrency, totalPages);
+
+  await Promise.all(Array.from({ length: runners }, () => runner()));
+
+  return results;
+}
+
+/* ============================================================
+   BUILD FINAL PDF
+============================================================ */
+
+async function buildPdf(compressedPages, { originalBytes, startedAt, workersUsed, onProgress }) {
+  if (typeof onProgress === "function") {
+    onProgress({ stage: "building", progress: 92 });
+  }
+
+  const outputPdf = await PDFDocument.create();
+
+  const perPage = [];
+
+  for (let i = 0; i < compressedPages.length; i++) {
+    const item = compressedPages[i];
+
+    if (!item) {
+      throw new Error(`Missing compressed page ${i + 1}`);
+    }
+
+    let jpegBytes;
+
+    if (item.jpeg instanceof ArrayBuffer) {
+      jpegBytes = new Uint8Array(item.jpeg);
+    } else if (item.jpeg instanceof Uint8Array) {
+      jpegBytes = item.jpeg;
+    } else if (ArrayBuffer.isView(item.jpeg)) {
+      jpegBytes = new Uint8Array(item.jpeg.buffer, item.jpeg.byteOffset, item.jpeg.byteLength);
+    } else {
+      throw new Error(`Invalid JPEG for page ${i + 1}`);
+    }
+
+    const image = await outputPdf.embedJpg(jpegBytes);
+
+    const page = outputPdf.addPage([item.pdfWidth, item.pdfHeight]);
+
+    page.drawImage(image, {
+      x: 0,
+      y: 0,
+      width: item.pdfWidth,
+      height: item.pdfHeight,
+    });
+
+    perPage.push({
+      pageNumber: i + 1,
+      renderedWidth: item.width,
+      renderedHeight: item.height,
+      jpegBytes: item.jpegBytes,
+    });
+
+    item.jpeg = null;
+
+    if (typeof onProgress === "function") {
+      onProgress({
+        stage: "building",
+        progress: 92 + Math.round(((i + 1) / compressedPages.length) * 7),
+      });
+    }
+  }
+
+  if (typeof onProgress === "function") {
+    onProgress({ stage: "finalizing", progress: 99 });
+  }
+
+  const pdfBytes = await outputPdf.save({
+    useObjectStreams: true,
+    addDefaultPage: false,
+    objectsPerTick: 50,
+  });
+
+  const blob = new Blob([pdfBytes], { type: "application/pdf" });
+
+  const compressedBytes = blob.size;
+  const savedBytes = Math.max(0, originalBytes - compressedBytes);
+  const reduction = originalBytes > 0 ? (savedBytes / originalBytes) * 100 : 0;
+  const elapsed = performance.now() - startedAt;
+
+  const stats = {
+    pages: compressedPages.length,
+    originalBytes,
+    compressedBytes,
+    savedBytes,
+    reduction,
+    elapsed,
+    workersUsed,
+    perPage,
+  };
+
+  if (typeof onProgress === "function") {
+    onProgress({ stage: "complete", progress: 100 });
+  }
+
+  return { blob, stats };
+}
+
+/* ============================================================
+   PUBLIC API
+============================================================ */
+
+/**
+ * Compress a PDF using the same render -> mozjpeg WASM -> pdf-lib rebuild
+ * pipeline as the original app, run across a parallel worker pool.
+ *
+ * @param {File|Blob|ArrayBuffer|ArrayBufferView} input
+ * @param {Object} [options]
+ * @param {number} [options.quality=65] - JPEG quality, 0-100
+ * @param {number} [options.resolution=1600] - max px on the longest page side
+ * @param {number} [options.workers] - override auto-detected worker count
+ * @param {(update: object) => void} [options.onProgress] - optional progress callback
+ * @returns {Promise<{file: File|Blob, stats: object}>}
+ */
+export async function compressPDF(input, options = {}) {
+  const { quality = 65, resolution = 1600, workers: workerOverride, onProgress } = options;
+
+  const startedAt = performance.now();
+
+  const { arrayBuffer, fileName, fileType, originalBytes } = await normalizeInput(input);
+
+  const power = getClientPower();
+  const workerCount = workerOverride || power.workers;
+
+  const pool = new CompressionPool();
+  pool.init(workerCount);
+
+  const loadingTask = pdfjsLib.getDocument({
+    data: new Uint8Array(arrayBuffer.slice(0)),
+    useSystemFonts: true,
+    isEvalSupported: true,
+  });
+
+  try {
+    const pdf = await loadingTask.promise;
+    const totalPages = pdf.numPages;
+
+    const compressedPages = await processPages(pdf, pool, totalPages, {
+      quality,
+      resolution,
+      workers: workerCount,
+      onProgress,
+    });
+
+    const { blob, stats } = await buildPdf(compressedPages, {
+      originalBytes,
+      startedAt,
+      workersUsed: workerCount,
+      onProgress,
+    });
+
+    const file =
+      typeof File !== "undefined"
+        ? new File([blob], fileName, { type: fileType })
+        : blob;
+
+    return { file, stats };
+  } finally {
+    try {
+      if (loadingTask && typeof loadingTask.destroy === "function") {
+        await loadingTask.destroy();
+      }
+    } catch (cleanupError) {
+      console.warn("compressPDF: loading task cleanup skipped:", cleanupError);
+    }
+
+    pool.destroy();
+  }
+}

package/src/index.js

@@ -0,0 +1 @@
+export { compressPDF, getClientPower, CompressionPool } from "./compress.js";

package/src/pdf-compressor.worker.js

@@ -0,0 +1,132 @@
+/**
+ * pdf-compressor.worker.js
+ *
+ * Same worker used by CompressionPool in compressPDFLIB.js.
+ * Takes a transferred ImageBitmap, draws it to an OffscreenCanvas,
+ * encodes it with mozjpeg (WASM) via @jsquash/jpeg, and transfers
+ * the resulting JPEG bytes back to the main thread.
+ */
+
+import { encode as encodeJpeg } from "@jsquash/jpeg";
+
+self.onmessage = async (event) => {
+  const data = event.data;
+
+  if (data?.type !== "compress-image") {
+    return;
+  }
+
+  const {
+    jobId,
+    bitmap,
+    pageNumber,
+    totalPages,
+    quality,
+    pdfWidth,
+    pdfHeight,
+  } = data;
+
+  try {
+    if (!bitmap) {
+      throw new Error("ImageBitmap missing");
+    }
+
+    const width = bitmap.width;
+    const height = bitmap.height;
+
+    /* ================================================
+       OFFSCREEN CANVAS
+    ================================================ */
+
+    const canvas = new OffscreenCanvas(width, height);
+
+    const ctx = canvas.getContext("2d", {
+      alpha: false,
+      desynchronized: true,
+    });
+
+    if (!ctx) {
+      bitmap.close();
+      throw new Error("OffscreenCanvas unavailable");
+    }
+
+    ctx.fillStyle = "#ffffff";
+    ctx.fillRect(0, 0, width, height);
+
+    ctx.drawImage(bitmap, 0, 0, width, height);
+
+    bitmap.close();
+
+    /* ================================================
+       GET PIXELS
+    ================================================ */
+
+    const imageData = ctx.getImageData(0, 0, width, height);
+
+    /* ================================================
+       MOZJPEG WASM
+    ================================================ */
+
+    const encoded = await encodeJpeg(imageData, {
+      quality: Number(quality),
+      progressive: true,
+      optimize_coding: true,
+    });
+
+    /* ================================================
+       NORMALIZE ARRAYBUFFER
+    ================================================ */
+
+    let jpegBuffer;
+
+    if (encoded instanceof ArrayBuffer) {
+      jpegBuffer = encoded;
+    } else if (ArrayBuffer.isView(encoded)) {
+      jpegBuffer = encoded.buffer.slice(
+        encoded.byteOffset,
+        encoded.byteOffset + encoded.byteLength
+      );
+    } else {
+      throw new Error("Invalid JPEG encoder output");
+    }
+
+    if (jpegBuffer.byteLength === 0) {
+      throw new Error("Empty JPEG");
+    }
+
+    /* ================================================
+       TRANSFER
+    ================================================ */
+
+    self.postMessage(
+      {
+        type: "image-complete",
+        jobId,
+        pageNumber,
+        totalPages,
+        jpeg: jpegBuffer,
+        jpegBytes: jpegBuffer.byteLength,
+        width,
+        height,
+        pdfWidth,
+        pdfHeight,
+      },
+      [jpegBuffer]
+    );
+
+    canvas.width = 1;
+    canvas.height = 1;
+  } catch (error) {
+    try {
+      bitmap?.close();
+    } catch {}
+
+    self.postMessage({
+      type: "error",
+      jobId,
+      pageNumber,
+      totalPages,
+      message: error?.message || String(error),
+    });
+  }
+};