diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
index f11c435f..5aba4924 100644
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@@ -1,2 +1,2 @@
 github: alam00000
-ko_fi: alio01
\ No newline at end of file
+ko_fi: alio01
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index 8bf2edc7..b7f273d2 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -1,15 +1,15 @@
 version: 2
 updates:
-  - package-ecosystem: "npm"
-    directory: "/"
+  - package-ecosystem: 'npm'
+    directory: '/'
     schedule:
-      interval: "daily"
+      interval: 'daily'
     groups:
       npm-dependencies:
         patterns:
-          - "*"
+          - '*'
 
-  - package-ecosystem: "github-actions"
-    directory: "/"
+  - package-ecosystem: 'github-actions'
+    directory: '/'
     schedule:
-      interval: "daily"
+      interval: 'daily'
diff --git a/README.md b/README.md
index 4bd04a99..52fe5c60 100644
--- a/README.md
+++ b/README.md
@@ -26,16 +26,18 @@ BentoPDF offers a comprehensive suite of tools to handle all your PDF needs.
 
 ### Organize & Manage PDFs
 
-| Tool Name          | Description                                                                |
-| :----------------- | :------------------------------------------------------------------------- |
-| **Merge PDFs**     | Combine multiple PDF files into one.                                       |
-| **Split PDFs**     | Extract specific pages or divide a document into smaller files.            |
-| **Organize Pages** | Reorder, duplicate, or delete pages with a simple drag-and-drop interface. |
-| **Extract Pages**  | Save a specific range of pages as a new PDF.                               |
-| **Delete Pages**   | Remove unwanted pages from your document.                                  |
-| **Rotate PDF**     | Rotate individual or all pages in a document.                              |
-| **N-Up PDF**       | Combine multiple pages onto a single page.                                 |
-| **View PDF**       | A powerful, integrated PDF viewer.                                         |
+| Tool Name                 | Description                                                                |
+| :------------------------ | :------------------------------------------------------------------------- |
+| **Merge PDFs**            | Combine multiple PDF files into one.                                       |
+| **Split PDFs**            | Extract specific pages or divide a document into smaller files.            |
+| **Organize Pages**        | Reorder, duplicate, or delete pages with a simple drag-and-drop interface. |
+| **Extract Pages**         | Save a specific range of pages as a new PDF.                               |
+| **Delete Pages**          | Remove unwanted pages from your document.                                  |
+| **Rotate PDF**            | Rotate individual or all pages in a document.                              |
+| **N-Up PDF**              | Combine multiple pages onto a single page.                                 |
+| **View PDF**              | A powerful, integrated PDF viewer.                                         |
+| **Alternate & Mix pages** | Merge pages by alternating pages from each PDF.                            |
+| **Posterize PDF**         | Split a PDF into multiple smaller pages for print.                         |
 
 ### Edit & Modify PDFs
 
@@ -52,6 +54,7 @@ BentoPDF offers a comprehensive suite of tools to handle all your PDF needs.
 | **Fill Forms**         | Fill out PDF forms directly in your browser.                |
 | **Flatten PDF**        | Flatten form fields and annotations into static content.    |
 | **Remove Annotations** | Remove comments, highlights, and other annotations.         |
+| **Remove Blank Pages** | Auto detect and remove blank pages in a PDF.                |
 
 ### Convert to PDF
 
@@ -82,6 +85,8 @@ BentoPDF offers a comprehensive suite of tools to handle all your PDF needs.
 | **Redact Content**     | Permanently remove sensitive content from your PDFs.               |
 | **Edit Metadata**      | View and modify PDF metadata (author, title, keywords, etc.).      |
 | **Remove Metadata**    | Strip all metadata from your PDF for privacy.                      |
+| **Linearize PDF**      | Optimize PDF for fast web view.                                    |
+| **Sanitize PDF**       | Remove potentially unwanted or malicous files from PDF.            |
 
 ---
 
@@ -165,8 +170,8 @@ npm run release:minor
 npm run release:major
 ```
 
-````
 For detailed release instructions, see [RELEASE.md](RELEASE.md).
+
 ### 🚀 Development Setup
 
 #### Option 1: Run with npm
@@ -176,7 +181,7 @@ For detailed release instructions, see [RELEASE.md](RELEASE.md).
    ```bash
    git clone https://github.com/alam00000/bentopdf.git
    cd bentopdf
-````
+   ```
 
 2. **Install Dependencies**:
 
@@ -235,10 +240,8 @@ BentoPDF was originally built using **HTML**, **CSS**, and **vanilla JavaScript*
 
 - **HTML to PDF**: Convert HTML files or web pages into PDF documents.
 - **Markdown to PDF**: Enhanced support for converting `.md` files to PDF.
-- **Sanitize PDF**: Remove potentially malicious content like scripts from PDFs.
 - **Convert to PDF/A**: Convert PDFs to the PDF/A archival format.
 - **Edit PDF Content**: Directly edit text and other content within your PDF.
-- **Linearize PDF**: Optimize PDFs for fast web viewing.
 - **PDF to Office**: Converts PDF files into editable Word, Excel, and PowerPoint formats.
 - **Office to PDF**: Converts Word, Excel, and PowerPoint documents into optimized PDFs.
 
@@ -266,10 +269,11 @@ BentoPDF wouldn't be possible without the amazing open-source tools and librarie
 - **[PDFLib.js](https://pdf-lib.js.org/)** – For enabling powerful client-side PDF manipulation.
 - **[PDF.js](https://mozilla.github.io/pdf.js/)** – For the robust PDF rendering engine in the browser.
 - **[PDFKit](https://pdfkit.org/)** – For creating and editing PDFs with ease.
-- **[EmbedPDF](https://github.com/embedpdf/embed-pdf-viewer)** – For seamless PDF embedding in web pages.
+- **[EmbedPDF](https://github.com/embedpdf/embed-pdf-viewer)** – For seamless PDF editing in pure JS.
 - **[Cropper.js](https://fengyuanchen.github.io/cropperjs/)** – For intuitive image cropping functionality.
 - **[Vite](https://vitejs.dev/)** – For lightning-fast development and build tooling.
 - **[Tailwind CSS](https://tailwindcss.com/)** – For rapid, flexible, and beautiful UI styling.
+- **[qpdf](https://github.com/qpdf/qpdf)** and **[qpdf-wasm](https://github.com/neslinesli93/qpdf-wasm)**– A powerful command-line tool and library for inspecting, repairing, and transforming PDF file ported to wasm
 
 Your work inspires and empowers developers everywhere. Thank you for making open-source amazing!
 
diff --git a/index.html b/index.html
index 6ade8a4e..767cd74f 100644
--- a/index.html
+++ b/index.html
@@ -31,6 +31,7 @@
   </head>
 
   <body class="antialiased">
+    <canvas id="qtcanvas" style="display: none;"></canvas>
     <nav class="bg-gray-800 border-b border-gray-700 sticky top-0 z-30">
       <div class="container mx-auto px-4">
         <div class="flex justify-between items-center h-16">
@@ -937,7 +938,28 @@
       </div>
     </footer>
 
+    <script>
+        window.sofficeLoaded = false;
+
+        var Module = {
+            canvas: document.getElementById('qtcanvas'),
+            uno_scripts: ["zeta.js", "office_thread.js"],
+            locateFile(path, prefix) {
+                if (path.endsWith('.wasm') || path.endsWith('.data') || path.endsWith('.js') || path.endsWith('.metadata')) {
+                    return `/public/static/${path}`;
+                }
+                return path;
+            },
+            onRuntimeInitialized() {
+                window.sofficeLoaded = true;
+                console.log("✅ LibreOffice WASM cargado y listo.");
+            },
+            arguments: ['--headless']
+        };
+    </script>
+    <script src="/public/static/soffice.js"></script>
     <script type="module" src="src/js/main.ts"></script>
     <script type="module" src="src/js/mobileMenu.ts"></script>
   </body>
 </html>
+</html>
diff --git a/package.json b/package.json
index 9e254856..582df8c1 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "bento-pdf",
   "private": true,
-  "version": "1.0.2",
+  "version": "1.1.0",
   "license": "Apache-2.0",
   "type": "module",
   "scripts": {
diff --git a/src/js/config/pdf-tools.ts b/src/js/config/pdf-tools.ts
index 574b64f8..56d0cd32 100644
--- a/src/js/config/pdf-tools.ts
+++ b/src/js/config/pdf-tools.ts
@@ -38,6 +38,7 @@ export const singlePdfLoadTools = [
   'posterize',
   'remove-blank-pages',
   'add-attachments',
+  'sanitize-pdf',
 ];
 
 export const simpleTools = [
diff --git a/src/js/config/tools.ts b/src/js/config/tools.ts
index b5bb6285..afb709b6 100644
--- a/src/js/config/tools.ts
+++ b/src/js/config/tools.ts
@@ -204,7 +204,12 @@ export const categories = [
       },
       // { id: 'md-to-pdf', name: 'Markdown to PDF', icon: 'file-text', subtitle: 'Convert a Markdown file into a PDF.' },
       // { id: 'scan-to-pdf', name: 'Scan to PDF', icon: 'camera', subtitle: 'Use your camera to create a scanned PDF.' },
-      // { id: 'word-to-pdf', name: 'Word to PDF', icon: 'file-text', subtitle: 'Convert .docx documents to PDF.' },
+      {
+        id: 'word-to-pdf',
+        name: 'Word to PDF',
+        icon: 'file-text',
+        subtitle: 'Convert .docx documents to PDF.',
+      },
     ],
   },
   {
@@ -369,7 +374,7 @@ export const categories = [
       {
         id: 'posterize',
         name: 'Posterize PDF',
-        icon: 'layout-grid',
+        icon: 'notepad-text-dashed',
         subtitle: 'Split a large page into multiple smaller pages.',
       },
     ],
@@ -392,7 +397,7 @@ export const categories = [
       {
         id: 'linearize',
         name: 'Linearize PDF',
-        icon: 'zap',
+        icon: 'gauge',
         subtitle: 'Optimize PDF for fast web viewing.',
       },
       {
@@ -412,6 +417,12 @@ export const categories = [
         icon: 'lock',
         subtitle: 'Add a password to protect your PDF.',
       },
+      {
+        id: 'sanitize-pdf',
+        name: 'Sanitize PDF',
+        icon: 'brush-cleaning',
+        subtitle: 'Remove metadata, annotations, scripts, and more.',
+      },
       {
         id: 'decrypt',
         name: 'Decrypt PDF',
diff --git a/src/js/handlers/fileHandler.ts b/src/js/handlers/fileHandler.ts
index 9d6f2508..3c044137 100644
--- a/src/js/handlers/fileHandler.ts
+++ b/src/js/handlers/fileHandler.ts
@@ -269,9 +269,9 @@ async function handleSinglePdfUpload(toolId, file) {
             if ((child as Element).nodeType !== 1) continue;
 
             let key = (child as Element).tagName;
-            const elementChildren = Array.from((child as Element).children).filter(
-              (c) => c.nodeType === 1
-            );
+            const elementChildren = Array.from(
+              (child as Element).children
+            ).filter((c) => c.nodeType === 1);
 
             if (key === 'rdf:li') {
               appendXmpNodes(child, ulElement, indentLevel);
diff --git a/src/js/logic/flatten.ts b/src/js/logic/flatten.ts
index 16e4c804..17f58edc 100644
--- a/src/js/logic/flatten.ts
+++ b/src/js/logic/flatten.ts
@@ -2,6 +2,11 @@ import { showLoader, hideLoader, showAlert } from '../ui.js';
 import { downloadFile } from '../utils/helpers.js';
 import { state } from '../state.js';
 
+export function flattenFormsInDoc(pdfDoc) {
+  const form = pdfDoc.getForm();
+  form.flatten();
+}
+
 export async function flatten() {
   if (!state.pdfDoc) {
     showAlert('Error', 'PDF not loaded.');
@@ -9,8 +14,7 @@ export async function flatten() {
   }
   showLoader('Flattening PDF...');
   try {
-    const form = state.pdfDoc.getForm();
-    form.flatten();
+    flattenFormsInDoc(state.pdfDoc);
 
     const flattenedBytes = await state.pdfDoc.save();
     downloadFile(
diff --git a/src/js/logic/index.ts b/src/js/logic/index.ts
index 4ba504b9..bf3c3bcb 100644
--- a/src/js/logic/index.ts
+++ b/src/js/logic/index.ts
@@ -47,7 +47,7 @@ import { changeBackgroundColor } from './change-background-color.js';
 import { changeTextColor, setupTextColorTool } from './change-text-color.js';
 import { setupCompareTool } from './compare-pdfs.js';
 import { setupOcrTool } from './ocr-pdf.js';
-import { wordToPdf } from './word-to-pdf.js';
+import { setupWordToPdfTool } from './word-to-pdf.js';
 import { applyAndSaveSignatures, setupSignTool } from './sign-pdf.js';
 import {
   removeAnnotations,
@@ -63,6 +63,7 @@ import {
 import { alternateMerge, setupAlternateMergeTool } from './alternate-merge.js';
 import { linearizePdf } from './linearize.js';
 import { addAttachments, setupAddAttachmentsTool } from './add-attachments.js';
+import { sanitizePdf } from './sanitize-pdf.js';
 
 export const toolLogic = {
   merge: { process: merge, setup: setupMergeTool },
@@ -113,7 +114,7 @@ export const toolLogic = {
   'change-text-color': { process: changeTextColor, setup: setupTextColorTool },
   'compare-pdfs': { setup: setupCompareTool },
   'ocr-pdf': { setup: setupOcrTool },
-  'word-to-pdf': wordToPdf,
+  'word-to-pdf': { process: setupWordToPdfTool, setup: setupWordToPdfTool },
   'sign-pdf': { process: applyAndSaveSignatures, setup: setupSignTool },
   'remove-annotations': {
     process: removeAnnotations,
@@ -135,4 +136,5 @@ export const toolLogic = {
     process: addAttachments,
     setup: setupAddAttachmentsTool,
   },
+  'sanitize-pdf': sanitizePdf,
 };
diff --git a/src/js/logic/remove-annotations.ts b/src/js/logic/remove-annotations.ts
index 5aa425e8..e079f8f6 100644
--- a/src/js/logic/remove-annotations.ts
+++ b/src/js/logic/remove-annotations.ts
@@ -28,6 +28,48 @@ export function setupRemoveAnnotationsTool() {
   });
 }
 
+export function removeAnnotationsFromDoc(
+  pdfDoc,
+  pageIndices = null,
+  annotationTypes = null
+) {
+  const pages = pdfDoc.getPages();
+  const targetPages =
+    pageIndices || Array.from({ length: pages.length }, (_, i) => i);
+
+  for (const pageIndex of targetPages) {
+    const page = pages[pageIndex];
+    const annotRefs = page.node.Annots()?.asArray() || [];
+
+    if (!annotationTypes) {
+      if (annotRefs.length > 0) {
+        page.node.delete(PDFName.of('Annots'));
+      }
+    } else {
+      const annotsToKeep = [];
+
+      for (const ref of annotRefs) {
+        const annot = pdfDoc.context.lookup(ref);
+        const subtype = annot
+          .get(PDFName.of('Subtype'))
+          ?.toString()
+          .substring(1);
+
+        if (!subtype || !annotationTypes.has(subtype)) {
+          annotsToKeep.push(ref);
+        }
+      }
+
+      if (annotsToKeep.length > 0) {
+        const newAnnotsArray = pdfDoc.context.obj(annotsToKeep);
+        page.node.set(PDFName.of('Annots'), newAnnotsArray);
+      } else {
+        page.node.delete(PDFName.of('Annots'));
+      }
+    }
+  }
+}
+
 export async function removeAnnotations() {
   showLoader('Removing annotations...');
   try {
@@ -80,34 +122,7 @@ export async function removeAnnotations() {
     if (typesToRemove.size === 0)
       throw new Error('Please select at least one annotation type to remove.');
 
-    const pages = state.pdfDoc.getPages();
-
-    for (const pageIndex of targetPageIndices) {
-      const page = pages[pageIndex];
-      const annotRefs = page.node.Annots()?.asArray() || [];
-
-      const annotsToKeep = [];
-
-      for (const ref of annotRefs) {
-        const annot = state.pdfDoc.context.lookup(ref);
-        const subtype = annot
-          .get(PDFName.of('Subtype'))
-          ?.toString()
-          .substring(1);
-
-        // If the subtype is NOT in the list to remove, add it to our new array
-        if (!subtype || !typesToRemove.has(subtype)) {
-          annotsToKeep.push(ref);
-        }
-      }
-
-      if (annotsToKeep.length > 0) {
-        const newAnnotsArray = state.pdfDoc.context.obj(annotsToKeep);
-        page.node.set(PDFName.of('Annots'), newAnnotsArray);
-      } else {
-        page.node.delete(PDFName.of('Annots'));
-      }
-    }
+    removeAnnotationsFromDoc(state.pdfDoc, targetPageIndices, typesToRemove);
 
     const newPdfBytes = await state.pdfDoc.save();
     downloadFile(
diff --git a/src/js/logic/remove-metadata.ts b/src/js/logic/remove-metadata.ts
index a4f140fb..3fbbc4ec 100644
--- a/src/js/logic/remove-metadata.ts
+++ b/src/js/logic/remove-metadata.ts
@@ -1,23 +1,54 @@
 import { showLoader, hideLoader, showAlert } from '../ui.js';
 import { downloadFile } from '../utils/helpers.js';
 import { state } from '../state.js';
+import { PDFName } from 'pdf-lib';
+
+export function removeMetadataFromDoc(pdfDoc) {
+  const infoDict = pdfDoc.getInfoDict();
+  const allKeys = infoDict.keys();
+  allKeys.forEach((key: any) => {
+    infoDict.delete(key);
+  });
+
+  pdfDoc.setTitle('');
+  pdfDoc.setAuthor('');
+  pdfDoc.setSubject('');
+  pdfDoc.setKeywords([]);
+  pdfDoc.setCreator('');
+  pdfDoc.setProducer('');
+
+  try {
+    const catalogDict = pdfDoc.catalog.dict;
+    if (catalogDict.has(PDFName.of('Metadata'))) {
+      catalogDict.delete(PDFName.of('Metadata'));
+    }
+  } catch (e) {
+    console.warn('Could not remove XMP metadata:', e.message);
+  }
+
+  try {
+    const context = pdfDoc.context;
+    if (context.trailerInfo) {
+      delete context.trailerInfo.ID;
+    }
+  } catch (e) {
+    console.warn('Could not remove document IDs:', e.message);
+  }
+
+  try {
+    const catalogDict = pdfDoc.catalog.dict;
+    if (catalogDict.has(PDFName.of('PieceInfo'))) {
+      catalogDict.delete(PDFName.of('PieceInfo'));
+    }
+  } catch (e) {
+    console.warn('Could not remove PieceInfo:', e.message);
+  }
+}
 
 export async function removeMetadata() {
   showLoader('Removing all metadata...');
   try {
-    const infoDict = state.pdfDoc.getInfoDict();
-
-    const allKeys = infoDict.keys();
-    allKeys.forEach((key: any) => {
-      infoDict.delete(key);
-    });
-
-    state.pdfDoc.setTitle('');
-    state.pdfDoc.setAuthor('');
-    state.pdfDoc.setSubject('');
-    state.pdfDoc.setKeywords([]);
-    state.pdfDoc.setCreator('');
-    state.pdfDoc.setProducer('');
+    removeMetadataFromDoc(state.pdfDoc);
 
     const newPdfBytes = await state.pdfDoc.save();
     downloadFile(
diff --git a/src/js/logic/sanitize-pdf.ts b/src/js/logic/sanitize-pdf.ts
new file mode 100644
index 00000000..b1a0eca5
--- /dev/null
+++ b/src/js/logic/sanitize-pdf.ts
@@ -0,0 +1,587 @@
+import { showLoader, hideLoader, showAlert } from '../ui.js';
+import { downloadFile } from '../utils/helpers.js';
+import { state } from '../state.js';
+import { removeMetadataFromDoc } from './remove-metadata.js';
+import { removeAnnotationsFromDoc } from './remove-annotations.js';
+import { flattenFormsInDoc } from './flatten.js';
+import { PDFName } from 'pdf-lib';
+
+export async function sanitizePdf() {
+  if (!state.pdfDoc) {
+    showAlert('Error', 'No PDF document loaded.');
+    return;
+  }
+
+  showLoader('Sanitizing PDF...');
+  try {
+    const pdfDoc = state.pdfDoc;
+
+    const shouldFlattenForms = (
+      document.getElementById('flatten-forms') as HTMLInputElement
+    ).checked;
+    const shouldRemoveMetadata = (
+      document.getElementById('remove-metadata') as HTMLInputElement
+    ).checked;
+    const shouldRemoveAnnotations = (
+      document.getElementById('remove-annotations') as HTMLInputElement
+    ).checked;
+    const shouldRemoveJavascript = (
+      document.getElementById('remove-javascript') as HTMLInputElement
+    ).checked;
+    const shouldRemoveEmbeddedFiles = (
+      document.getElementById('remove-embedded-files') as HTMLInputElement
+    ).checked;
+    const shouldRemoveLayers = (
+      document.getElementById('remove-layers') as HTMLInputElement
+    ).checked;
+    const shouldRemoveLinks = (
+      document.getElementById('remove-links') as HTMLInputElement
+    ).checked;
+    const shouldRemoveStructureTree = (
+      document.getElementById('remove-structure-tree') as HTMLInputElement
+    ).checked;
+    const shouldRemoveMarkInfo = (
+      document.getElementById('remove-markinfo') as HTMLInputElement
+    ).checked;
+    const shouldRemoveFonts = (
+      document.getElementById('remove-fonts') as HTMLInputElement
+    ).checked;
+
+    let changesMade = false;
+
+    if (shouldFlattenForms) {
+      try {
+        flattenFormsInDoc(pdfDoc);
+        changesMade = true;
+      } catch (e) {
+        console.warn(`Could not flatten forms: ${e.message}`);
+        try {
+          const catalogDict = pdfDoc.catalog.dict;
+          if (catalogDict.has(PDFName.of('AcroForm'))) {
+            catalogDict.delete(PDFName.of('AcroForm'));
+            changesMade = true;
+          }
+        } catch (removeError) {
+          console.warn('Could not remove AcroForm:', removeError.message);
+        }
+      }
+    }
+
+    if (shouldRemoveMetadata) {
+      removeMetadataFromDoc(pdfDoc);
+      changesMade = true;
+    }
+
+    if (shouldRemoveAnnotations) {
+      removeAnnotationsFromDoc(pdfDoc);
+      changesMade = true;
+    }
+
+    if (shouldRemoveJavascript) {
+      try {
+        if (pdfDoc.javaScripts && pdfDoc.javaScripts.length > 0) {
+          pdfDoc.javaScripts = [];
+          changesMade = true;
+        }
+
+        const catalogDict = pdfDoc.catalog.dict;
+
+        const namesRef = catalogDict.get(PDFName.of('Names'));
+        if (namesRef) {
+          try {
+            const namesDict = pdfDoc.context.lookup(namesRef);
+            if (namesDict.has(PDFName.of('JavaScript'))) {
+              namesDict.delete(PDFName.of('JavaScript'));
+              changesMade = true;
+            }
+          } catch (e) {
+            console.warn('Could not access Names/JavaScript:', e.message);
+          }
+        }
+
+        if (catalogDict.has(PDFName.of('OpenAction'))) {
+          catalogDict.delete(PDFName.of('OpenAction'));
+          changesMade = true;
+        }
+
+        if (catalogDict.has(PDFName.of('AA'))) {
+          catalogDict.delete(PDFName.of('AA'));
+          changesMade = true;
+        }
+
+        const pages = pdfDoc.getPages();
+        for (const page of pages) {
+          try {
+            const pageDict = page.node;
+
+            if (pageDict.has(PDFName.of('AA'))) {
+              pageDict.delete(PDFName.of('AA'));
+              changesMade = true;
+            }
+
+            const annotRefs = pageDict.Annots()?.asArray() || [];
+            for (const annotRef of annotRefs) {
+              try {
+                const annot = pdfDoc.context.lookup(annotRef);
+
+                if (annot.has(PDFName.of('A'))) {
+                  const actionRef = annot.get(PDFName.of('A'));
+                  try {
+                    const actionDict = pdfDoc.context.lookup(actionRef);
+                    const actionType = actionDict
+                      .get(PDFName.of('S'))
+                      ?.toString()
+                      .substring(1);
+
+                    if (actionType === 'JavaScript') {
+                      annot.delete(PDFName.of('A'));
+                      changesMade = true;
+                    }
+                  } catch (e) {
+                    console.warn('Could not read action:', e.message);
+                  }
+                }
+
+                if (annot.has(PDFName.of('AA'))) {
+                  annot.delete(PDFName.of('AA'));
+                  changesMade = true;
+                }
+              } catch (e) {
+                console.warn('Could not process annotation for JS:', e.message);
+              }
+            }
+          } catch (e) {
+            console.warn('Could not remove page actions:', e.message);
+          }
+        }
+
+        try {
+          const acroFormRef = catalogDict.get(PDFName.of('AcroForm'));
+          if (acroFormRef) {
+            const acroFormDict = pdfDoc.context.lookup(acroFormRef);
+            const fieldsRef = acroFormDict.get(PDFName.of('Fields'));
+
+            if (fieldsRef) {
+              const fieldsArray = pdfDoc.context.lookup(fieldsRef);
+              const fields = fieldsArray.asArray();
+
+              for (const fieldRef of fields) {
+                try {
+                  const field = pdfDoc.context.lookup(fieldRef);
+
+                  if (field.has(PDFName.of('A'))) {
+                    field.delete(PDFName.of('A'));
+                    changesMade = true;
+                  }
+
+                  if (field.has(PDFName.of('AA'))) {
+                    field.delete(PDFName.of('AA'));
+                    changesMade = true;
+                  }
+                } catch (e) {
+                  console.warn('Could not process field for JS:', e.message);
+                }
+              }
+            }
+          }
+        } catch (e) {
+          console.warn('Could not process form fields for JS:', e.message);
+        }
+      } catch (e) {
+        console.warn(`Could not remove JavaScript: ${e.message}`);
+      }
+    }
+
+    if (shouldRemoveEmbeddedFiles) {
+      try {
+        const catalogDict = pdfDoc.catalog.dict;
+
+        const namesRef = catalogDict.get(PDFName.of('Names'));
+        if (namesRef) {
+          try {
+            const namesDict = pdfDoc.context.lookup(namesRef);
+            if (namesDict.has(PDFName.of('EmbeddedFiles'))) {
+              namesDict.delete(PDFName.of('EmbeddedFiles'));
+              changesMade = true;
+            }
+          } catch (e) {
+            console.warn('Could not access Names/EmbeddedFiles:', e.message);
+          }
+        }
+
+        if (catalogDict.has(PDFName.of('EmbeddedFiles'))) {
+          catalogDict.delete(PDFName.of('EmbeddedFiles'));
+          changesMade = true;
+        }
+
+        const pages = pdfDoc.getPages();
+        for (const page of pages) {
+          try {
+            const annotRefs = page.node.Annots()?.asArray() || [];
+            const annotsToKeep = [];
+
+            for (const ref of annotRefs) {
+              try {
+                const annot = pdfDoc.context.lookup(ref);
+                const subtype = annot
+                  .get(PDFName.of('Subtype'))
+                  ?.toString()
+                  .substring(1);
+
+                if (subtype !== 'FileAttachment') {
+                  annotsToKeep.push(ref);
+                } else {
+                  changesMade = true;
+                }
+              } catch (e) {
+                annotsToKeep.push(ref);
+              }
+            }
+
+            if (annotsToKeep.length !== annotRefs.length) {
+              if (annotsToKeep.length > 0) {
+                const newAnnotsArray = pdfDoc.context.obj(annotsToKeep);
+                page.node.set(PDFName.of('Annots'), newAnnotsArray);
+              } else {
+                page.node.delete(PDFName.of('Annots'));
+              }
+            }
+          } catch (pageError) {
+            console.warn(
+              `Could not process page for attachments: ${pageError.message}`
+            );
+          }
+        }
+
+        if (pdfDoc.embeddedFiles && pdfDoc.embeddedFiles.length > 0) {
+          pdfDoc.embeddedFiles = [];
+          changesMade = true;
+        }
+
+        if (catalogDict.has(PDFName.of('Collection'))) {
+          catalogDict.delete(PDFName.of('Collection'));
+          changesMade = true;
+        }
+      } catch (e) {
+        console.warn(`Could not remove embedded files: ${e.message}`);
+      }
+    }
+
+    if (shouldRemoveLayers) {
+      try {
+        const catalogDict = pdfDoc.catalog.dict;
+
+        if (catalogDict.has(PDFName.of('OCProperties'))) {
+          catalogDict.delete(PDFName.of('OCProperties'));
+          changesMade = true;
+        }
+
+        const pages = pdfDoc.getPages();
+        for (const page of pages) {
+          try {
+            const pageDict = page.node;
+
+            if (pageDict.has(PDFName.of('OCProperties'))) {
+              pageDict.delete(PDFName.of('OCProperties'));
+              changesMade = true;
+            }
+
+            const resourcesRef = pageDict.get(PDFName.of('Resources'));
+            if (resourcesRef) {
+              try {
+                const resourcesDict = pdfDoc.context.lookup(resourcesRef);
+                if (resourcesDict.has(PDFName.of('Properties'))) {
+                  resourcesDict.delete(PDFName.of('Properties'));
+                  changesMade = true;
+                }
+              } catch (e) {
+                console.warn('Could not access Resources:', e.message);
+              }
+            }
+          } catch (e) {
+            console.warn('Could not remove page layers:', e.message);
+          }
+        }
+      } catch (e) {
+        console.warn(`Could not remove layers: ${e.message}`);
+      }
+    }
+
+    // TODO:@ALAM
+    // Currently if the links are embedded in a stream they can't be removed
+    // Find a way to remove them from the stream
+    if (shouldRemoveLinks) {
+      try {
+        const pages = pdfDoc.getPages();
+
+        for (let pageIndex = 0; pageIndex < pages.length; pageIndex++) {
+          try {
+            const page = pages[pageIndex];
+            const pageDict = page.node;
+
+            const annotsRef = pageDict.get(PDFName.of('Annots'));
+            if (!annotsRef) continue;
+
+            const annotsArray = pdfDoc.context.lookup(annotsRef);
+            const annotRefs = annotsArray.asArray();
+
+            if (annotRefs.length === 0) continue;
+
+            const annotsToKeep = [];
+            let linksRemoved = 0;
+
+            for (const ref of annotRefs) {
+              try {
+                const annot = pdfDoc.context.lookup(ref);
+                const subtype = annot
+                  .get(PDFName.of('Subtype'))
+                  ?.toString()
+                  .substring(1);
+
+                let isLink = false;
+
+                if (subtype === 'Link') {
+                  isLink = true;
+                  linksRemoved++;
+                } else {
+                  const actionRef = annot.get(PDFName.of('A'));
+                  if (actionRef) {
+                    try {
+                      const actionDict = pdfDoc.context.lookup(actionRef);
+                      const actionType = actionDict
+                        .get(PDFName.of('S'))
+                        ?.toString()
+                        .substring(1);
+
+                      if (
+                        actionType === 'URI' ||
+                        actionType === 'Launch' ||
+                        actionType === 'GoTo' ||
+                        actionType === 'GoToR'
+                      ) {
+                        isLink = true;
+                        linksRemoved++;
+                      }
+                    } catch (e) {
+                      console.warn('Could not read action:', e.message);
+                    }
+                  }
+
+                  const dest = annot.get(PDFName.of('Dest'));
+                  if (dest && !isLink) {
+                    isLink = true;
+                    linksRemoved++;
+                  }
+                }
+
+                if (!isLink) {
+                  annotsToKeep.push(ref);
+                }
+              } catch (e) {
+                console.warn('Could not process annotation:', e.message);
+                annotsToKeep.push(ref);
+              }
+            }
+
+            if (linksRemoved > 0) {
+              if (annotsToKeep.length > 0) {
+                const newAnnotsArray = pdfDoc.context.obj(annotsToKeep);
+                pageDict.set(PDFName.of('Annots'), newAnnotsArray);
+              } else {
+                pageDict.delete(PDFName.of('Annots'));
+              }
+              changesMade = true;
+            }
+          } catch (pageError) {
+            console.warn(
+              `Could not process page ${pageIndex + 1} for links: ${pageError.message}`
+            );
+          }
+        }
+
+        try {
+          const catalogDict = pdfDoc.catalog.dict;
+          const namesRef = catalogDict.get(PDFName.of('Names'));
+          if (namesRef) {
+            try {
+              const namesDict = pdfDoc.context.lookup(namesRef);
+              if (namesDict.has(PDFName.of('Dests'))) {
+                namesDict.delete(PDFName.of('Dests'));
+                changesMade = true;
+              }
+            } catch (e) {
+              console.warn('Could not access Names/Dests:', e.message);
+            }
+          }
+
+          if (catalogDict.has(PDFName.of('Dests'))) {
+            catalogDict.delete(PDFName.of('Dests'));
+            changesMade = true;
+          }
+        } catch (e) {
+          console.warn('Could not remove named destinations:', e.message);
+        }
+      } catch (e) {
+        console.warn(`Could not remove links: ${e.message}`);
+      }
+    }
+
+    if (shouldRemoveStructureTree) {
+      try {
+        const catalogDict = pdfDoc.catalog.dict;
+
+        if (catalogDict.has(PDFName.of('StructTreeRoot'))) {
+          catalogDict.delete(PDFName.of('StructTreeRoot'));
+          changesMade = true;
+        }
+
+        const pages = pdfDoc.getPages();
+        for (const page of pages) {
+          try {
+            const pageDict = page.node;
+            if (pageDict.has(PDFName.of('StructParents'))) {
+              pageDict.delete(PDFName.of('StructParents'));
+              changesMade = true;
+            }
+          } catch (e) {
+            console.warn('Could not remove page StructParents:', e.message);
+          }
+        }
+
+        if (catalogDict.has(PDFName.of('ParentTree'))) {
+          catalogDict.delete(PDFName.of('ParentTree'));
+          changesMade = true;
+        }
+      } catch (e) {
+        console.warn(`Could not remove structure tree: ${e.message}`);
+      }
+    }
+
+    if (shouldRemoveMarkInfo) {
+      try {
+        const catalogDict = pdfDoc.catalog.dict;
+
+        if (catalogDict.has(PDFName.of('MarkInfo'))) {
+          catalogDict.delete(PDFName.of('MarkInfo'));
+          changesMade = true;
+        }
+
+        if (catalogDict.has(PDFName.of('Marked'))) {
+          catalogDict.delete(PDFName.of('Marked'));
+          changesMade = true;
+        }
+      } catch (e) {
+        console.warn(`Could not remove MarkInfo: ${e.message}`);
+      }
+    }
+
+    if (shouldRemoveFonts) {
+      try {
+        const pages = pdfDoc.getPages();
+
+        for (let pageIndex = 0; pageIndex < pages.length; pageIndex++) {
+          try {
+            const page = pages[pageIndex];
+            const pageDict = page.node;
+            const resourcesRef = pageDict.get(PDFName.of('Resources'));
+
+            if (resourcesRef) {
+              try {
+                const resourcesDict = pdfDoc.context.lookup(resourcesRef);
+
+                if (resourcesDict.has(PDFName.of('Font'))) {
+                  const fontRef = resourcesDict.get(PDFName.of('Font'));
+
+                  try {
+                    const fontDict = pdfDoc.context.lookup(fontRef);
+                    const fontKeys = fontDict.keys();
+
+                    for (const fontKey of fontKeys) {
+                      try {
+                        const specificFontRef = fontDict.get(fontKey);
+                        const specificFont =
+                          pdfDoc.context.lookup(specificFontRef);
+
+                        if (specificFont.has(PDFName.of('FontDescriptor'))) {
+                          const descriptorRef = specificFont.get(
+                            PDFName.of('FontDescriptor')
+                          );
+                          const descriptor =
+                            pdfDoc.context.lookup(descriptorRef);
+
+                          const fontFileKeys = [
+                            'FontFile',
+                            'FontFile2',
+                            'FontFile3',
+                          ];
+                          for (const key of fontFileKeys) {
+                            if (descriptor.has(PDFName.of(key))) {
+                              descriptor.delete(PDFName.of(key));
+                              changesMade = true;
+                            }
+                          }
+                        }
+
+                        // Users/Developers: Uncomment this if you can delete the entire font entry -- might break the rendering though
+                        // fontDict.delete(fontKey);
+                        // changesMade = true;
+                      } catch (e) {
+                        console.warn(
+                          `Could not process font ${fontKey}:`,
+                          e.message
+                        );
+                      }
+                    }
+                  } catch (e) {
+                    console.warn(
+                      'Could not access font dictionary:',
+                      e.message
+                    );
+                  }
+                }
+              } catch (e) {
+                console.warn(
+                  'Could not access Resources for fonts:',
+                  e.message
+                );
+              }
+            }
+          } catch (e) {
+            console.warn(
+              `Could not remove fonts from page ${pageIndex + 1}:`,
+              e.message
+            );
+          }
+        }
+
+        if (pdfDoc.fonts && pdfDoc.fonts.length > 0) {
+          pdfDoc.fonts = [];
+          changesMade = true;
+        }
+      } catch (e) {
+        console.warn(`Could not remove fonts: ${e.message}`);
+      }
+    }
+
+    if (!changesMade) {
+      showAlert(
+        'No Changes',
+        'No items were selected for removal or none were found in the PDF.'
+      );
+      hideLoader();
+      return;
+    }
+
+    const sanitizedPdfBytes = await pdfDoc.save();
+    downloadFile(
+      new Blob([sanitizedPdfBytes], { type: 'application/pdf' }),
+      'sanitized.pdf'
+    );
+    showAlert('Success', 'PDF has been sanitized and downloaded.');
+  } catch (e) {
+    console.error('Sanitization Error:', e);
+    showAlert('Error', `An error occurred during sanitization: ${e.message}`);
+  } finally {
+    hideLoader();
+  }
+}
diff --git a/src/js/logic/word-to-pdf.ts b/src/js/logic/word-to-pdf.ts
index 6439ab29..2a67ebc2 100644
--- a/src/js/logic/word-to-pdf.ts
+++ b/src/js/logic/word-to-pdf.ts
@@ -1,140 +1,137 @@
-// NOTE: This is a work in progress and does not work correctly as of yet
-import { showLoader, hideLoader, showAlert } from '../ui.js';
-import { readFileAsArrayBuffer } from '../utils/helpers.js';
-import { state } from '../state.js';
+import { ZetaHelperMain } from '../../lib/zetajs/zetaHelper';
 
-export async function wordToPdf() {
-  const file = state.files[0];
-  if (!file) {
-    showAlert('No File', 'Please upload a .docx file first.');
+async function waitForSofficeLoaded(timeout = 10000): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const start = Date.now();
+    function check() {
+      if ((window as any).sofficeLoaded) {
+        resolve();
+      } else if (Date.now() - start > timeout) {
+        reject('Timeout waiting for soffice.wasm to load.');
+      } else {
+        requestAnimationFrame(check);
+      }
+    }
+    check();
+  });
+}
+
+async function waitForElements(ids: string[], timeout = 5000): Promise<Record<string, HTMLElement>> {
+  return new Promise((resolve, reject) => {
+    const start = Date.now();
+
+    function check() {
+      const elements: Record<string, HTMLElement> = {};
+      let allFound = true;
+
+      for (const id of ids) {
+        const el = document.getElementById(id);
+        if (!el) allFound = false;
+        else elements[id] = el;
+      }
+
+      if (allFound) resolve(elements);
+      else if (Date.now() - start > timeout) reject('Timeout waiting for DOM elements: ' + ids.join(', '));
+      else requestAnimationFrame(check);
+    }
+
+    check();
+  });
+}
+
+export async function setupWordToPdfTool() {
+  let elements: Record<string, HTMLElement>;
+  try {
+    await waitForSofficeLoaded();
+    elements = await waitForElements([
+      'qtcanvas',
+      'file-input',
+      'download',
+      'frame',
+      'word-to-pdf-output'
+    ]);
+  } catch (err) {
+    console.error(err);
     return;
   }
 
-  showLoader('Preparing preview...');
+  const {
+    qtcanvas: canvas,
+    'file-input': input,
+    download: downloadCheckbox,
+    frame: iframe,
+    'word-to-pdf-output': wordToPdfOutput
+  } = elements;
 
-  try {
-    const mammothOptions = {
-      // @ts-expect-error TS(2304) FIXME: Cannot find name 'mammoth'.
-      convertImage: mammoth.images.inline((element: any) => {
-        return element.read('base64').then((imageBuffer: any) => {
-          return {
-            src: `data:${element.contentType};base64,${imageBuffer}`,
-          };
-        });
-      }),
-    };
-    const arrayBuffer = await readFileAsArrayBuffer(file);
-    // @ts-expect-error TS(2304) FIXME: Cannot find name 'mammoth'.
-    const { value: html } = await mammoth.convertToHtml(
-      { arrayBuffer },
-      mammothOptions
-    );
+  const zHM = new ZetaHelperMain('/static/office_thread.js', {
+    threadJsType: 'module',
+    wasmPkg: 'url:/static/'
+  });
 
-    // Get references to our modal elements from index.html
-    const previewModal = document.getElementById('preview-modal');
-    const previewContent = document.getElementById('preview-content');
-    const downloadBtn = document.getElementById('preview-download-btn');
-    const closeBtn = document.getElementById('preview-close-btn');
+  // Assign thrPort.onmessage immediately
+  zHM.thrPort.onmessage = (e: MessageEvent) => {
+    const data = e.data;
+    switch (data.cmd) {
+      case 'converted':
+        try { (window as any).FS.unlink(data.from); } catch {}
+        const fileData = (window as any).FS.readFile(data.to);
+        const blob = new Blob([fileData], { type: 'application/pdf' });
+        const url = URL.createObjectURL(blob);
 
-    const styledHtml = `
-            <style>
-                #preview-content { font-family: 'Times New Roman', Times, serif; font-size: 12pt; line-height: 1.5; color: black; }
-                #preview-content table { border-collapse: collapse; width: 100%; }
-                #preview-content td, #preview-content th { border: 1px solid #dddddd; text-align: left; padding: 8px; }
-                #preview-content img { max-width: 100%; height: auto; }
-                #preview-content a { color: #0000ee; text-decoration: underline; }
-            </style>
-            ${html}
-        `;
-    previewContent.innerHTML = styledHtml;
+        // Show PDF in iframe
+        (iframe as HTMLIFrameElement).src = url;
+        wordToPdfOutput.classList.remove('hidden');
 
-    const marginDiv = document.createElement('div');
-    marginDiv.style.height = '100px';
-    previewContent.appendChild(marginDiv);
+        // Download if checkbox is checked
+        if ((downloadCheckbox as HTMLInputElement).checked) {
+          const a = document.createElement('a');
+          a.href = url;
+          a.download = `${data.name || 'output'}.pdf`;
+          a.click();
+        }
 
-    const images = previewContent.querySelectorAll('img');
-    const imagePromises = Array.from(images).map((img) => {
-      return new Promise((resolve) => {
-        // @ts-expect-error TS(2794) FIXME: Expected 1 arguments, but got 0. Did you forget to... Remove this comment to see the full error message
-        if (img.complete) resolve();
-        else img.onload = resolve;
-      });
-    });
-    await Promise.all(imagePromises);
+        try { (window as any).FS.unlink(data.to); } catch {}
+        (input as HTMLInputElement).disabled = false;
+        break;
 
-    previewModal.classList.remove('hidden');
-    hideLoader();
+      case 'start':
+        // Internal message, can ignore
+        break;
 
-    const downloadHandler = async () => {
-      showLoader('Generating High-Quality PDF...');
+      default:
+        console.warn('Unknown command from WASM:', data.cmd);
+    }
+  };
 
-      // @ts-expect-error TS(2339) FIXME: Property 'jspdf' does not exist on type 'Window & ... Remove this comment to see the full error message
-      const { jsPDF } = window.jspdf;
-      const doc = new jsPDF({
-        orientation: 'p',
-        unit: 'pt',
-        format: 'letter',
-      });
+  // Wait for ZetaHelper to initialize
+  await new Promise<void>(resolve => zHM.start(resolve));
 
-      await doc.html(previewContent, {
-        callback: function (doc: any) {
-          const links = previewContent.querySelectorAll('a');
-          const pageHeight = doc.internal.pageSize.getHeight();
-          const containerRect = previewContent.getBoundingClientRect(); // Get container's position
+  // Handle file selection
+  (input as HTMLInputElement).onchange = async () => {
+    const inputEl = input as HTMLInputElement;
+    if (!inputEl.files || inputEl.files.length === 0) {
+      console.error('No file selected.');
+      return;
+    }
 
-          links.forEach((link) => {
-            if (!link.href) return;
+    inputEl.disabled = true;
+    const file = inputEl.files[0];
+    let name = file.name;
+    let from = '/tmp/input';
+    const n = name.lastIndexOf('.');
+    if (n > 0) {
+      from += name.substring(n);
+      name = name.substring(0, n);
+    }
 
-            const linkRect = link.getBoundingClientRect();
+    const arrayBuffer = await file.arrayBuffer();
+    if (!(window as any).FS) {
+      console.error('FS not initialized yet.');
+      inputEl.disabled = false;
+      return;
+    }
 
-            // Calculate position relative to the preview container's top-left
-            const relativeX = linkRect.left - containerRect.left;
-            const relativeY = linkRect.top - containerRect.top;
-
-            const pageNum = Math.floor(relativeY / pageHeight) + 1;
-            const yOnPage = relativeY % pageHeight;
-
-            doc.setPage(pageNum);
-            try {
-              doc.link(
-                relativeX + 45,
-                yOnPage + 45,
-                linkRect.width,
-                linkRect.height,
-                { url: link.href }
-              );
-            } catch (e) {
-              console.warn('Could not add link:', link.href, e);
-            }
-          });
-
-          const outputFileName = `${file.name.replace(/\.[^/.]+$/, '')}.pdf`;
-          doc.save(outputFileName);
-          hideLoader();
-        },
-        autoPaging: 'slice',
-        x: 45,
-        y: 45,
-        width: 522,
-        windowWidth: previewContent.scrollWidth,
-      });
-    };
-
-    const closeHandler = () => {
-      previewModal.classList.add('hidden');
-      previewContent.innerHTML = '';
-      downloadBtn.removeEventListener('click', downloadHandler);
-      closeBtn.removeEventListener('click', closeHandler);
-    };
-
-    downloadBtn.addEventListener('click', downloadHandler);
-    closeBtn.addEventListener('click', closeHandler);
-  } catch (e) {
-    console.error(e);
-    hideLoader();
-    showAlert(
-      'Preview Error',
-      `Could not generate a preview. The file may be corrupt or contain unsupported features. Error: ${e.message}`
-    );
-  }
+    (window as any).FS.writeFile(from, new Uint8Array(arrayBuffer));
+    zHM.thrPort.postMessage({ cmd: 'convert', name, from, to: '/tmp/output' });
+  };
 }
diff --git a/src/js/ui.ts b/src/js/ui.ts
index d85ff7a2..c53d62da 100644
--- a/src/js/ui.ts
+++ b/src/js/ui.ts
@@ -1477,23 +1477,27 @@ export const toolTemplates = {
 `,
 
   'word-to-pdf': () => `
-        <h2 class="text-2xl font-bold text-white mb-4">Word to PDF Converter</h2>
-        <p class="mb-6 text-gray-400">Upload a .docx file to convert it into a high-quality PDF with selectable text. Complex layouts may not be perfectly preserved.</p>
-        
-        <div id="file-input-wrapper">
-             <div class="relative flex flex-col items-center justify-center w-full h-48 border-2 border-dashed border-gray-600 rounded-xl cursor-pointer bg-gray-900 hover:bg-gray-700">
-                <div class="flex flex-col items-center justify-center pt-5 pb-6">
-                    <i data-lucide="file-text" class="w-10 h-10 mb-3 text-gray-400"></i>
-                    <p class="mb-2 text-sm text-gray-400"><span class="font-semibold">Click to select a file</span> or drag and drop</p>
-                    <p class="text-xs text-gray-500">A single .docx file</p>
-                </div>
-                <input id="file-input" type="file" class="absolute top-0 left-0 w-full h-full opacity-0 cursor-pointer" accept=".docx,application/vnd.openxmlformats-officedocument.wordprocessingml.document">
+<div id="word-to-pdf-output" >
+    <canvas id="qtcanvas" class="hidden"></canvas>
+    <iframe id="frame" class="w-full h-[600px] mt-4 border border-gray-600 rounded-lg"></iframe>
+    <input type="checkbox" id="download" class="hidden" checked /> <!-- optional -->
+    
+    <div id="file-input-wrapper">
+         <div class="relative flex flex-col items-center justify-center w-full h-48 border-2 border-dashed border-gray-600 rounded-xl cursor-pointer bg-gray-900 hover:bg-gray-700">
+            <div class="flex flex-col items-center justify-center pt-5 pb-6">
+                <i data-lucide="file-text" class="w-10 h-10 mb-3 text-gray-400"></i>
+                <p class="mb-2 text-sm text-gray-400"><span class="font-semibold">Click to select a file</span> or drag and drop</p>
+                <p class="text-xs text-gray-500">A single .docx file</p>
             </div>
+            <input id="file-input" type="file" class="absolute top-0 left-0 w-full h-full opacity-0 cursor-pointer" accept=".docx,application/vnd.openxmlformats-officedocument.wordprocessingml.document">
         </div>
-        
-        <div id="file-display-area" class="mt-4 space-y-2"></div>
-        <button id="process-btn" class="btn-gradient w-full mt-6" disabled>Preview & Convert</button>
-    `,
+    </div>
+    
+    <div id="file-display-area" class="mt-4 space-y-2"></div>
+    <button id="process-btn" class="btn-gradient w-full mt-6" disabled>Preview & Convert</button>
+</div>
+`
+,
 
   'sign-pdf': () => `
     <h2 class="text-2xl font-bold text-white mb-4">Sign PDF</h2>
@@ -1910,4 +1914,72 @@ export const toolTemplates = {
       <button id="process-btn" class="hidden btn-gradient w-full mt-6" disabled>Embed Files & Download</button>
     </div>
   `,
+
+  'sanitize-pdf': () => `
+    <h2 class="text-2xl font-bold text-white mb-4">Sanitize PDF</h2>
+    <p class="mb-6 text-gray-400">Remove potentially sensitive or unnecessary information from your PDF before sharing. Select the items you want to remove.</p>
+    ${createFileInputHTML()}
+    <div id="file-display-area" class="mt-4 space-y-2"></div>
+
+    <div id="sanitize-pdf-options" class="hidden mt-6 space-y-4 p-4 bg-gray-900 border border-gray-700 rounded-lg">
+        <h3 class="text-lg font-semibold text-white mb-3">Sanitization Options</h3>
+    <div>
+            <strong class="font-semibold text-yellow-200">Note:</strong>
+            Removing <code class="bg-gray-700 px-1 rounded text-white">Embedded Fonts</code> may break text rendering! Text may not display correctly or at all. Only use if you're sure the PDF viewer has substitute fonts.
+    </div>
+        <div class="mb-4">
+            <h4 class="text-sm font-semibold text-gray-400 mb-2">Essential Security</h4>
+            <div class="grid grid-cols-1 sm:grid-cols-2 gap-3">
+                <label class="flex items-center space-x-2 p-3 rounded-md bg-gray-800 hover:bg-gray-700 cursor-pointer">
+                    <input type="checkbox" id="flatten-forms" name="sanitizeOption" value="flatten-forms" checked class="w-5 h-5 text-indigo-600 bg-gray-700 border-gray-600 rounded focus:ring-indigo-500">
+                    <span class="text-white">Flatten Form Fields</span>
+                </label>
+                <label class="flex items-center space-x-2 p-3 rounded-md bg-gray-800 hover:bg-gray-700 cursor-pointer">
+                    <input type="checkbox" id="remove-metadata" name="sanitizeOption" value="metadata" checked class="w-5 h-5 text-indigo-600 bg-gray-700 border-gray-600 rounded focus:ring-indigo-500">
+                    <span class="text-white">Remove All Metadata</span>
+                </label>
+                <label class="flex items-center space-x-2 p-3 rounded-md bg-gray-800 hover:bg-gray-700 cursor-pointer">
+                    <input type="checkbox" id="remove-annotations" name="sanitizeOption" value="annotations" checked class="w-5 h-5 text-indigo-600 bg-gray-700 border-gray-600 rounded focus:ring-indigo-500">
+                    <span class="text-white">Remove Annotations</span>
+                </label>
+                <label class="flex items-center space-x-2 p-3 rounded-md bg-gray-800 hover:bg-gray-700 cursor-pointer">
+                    <input type="checkbox" id="remove-javascript" name="sanitizeOption" value="javascript" checked class="w-5 h-5 text-indigo-600 bg-gray-700 border-gray-600 rounded focus:ring-indigo-500">
+                    <span class="text-white">Remove JavaScript</span>
+                </label>
+                <label class="flex items-center space-x-2 p-3 rounded-md bg-gray-800 hover:bg-gray-700 cursor-pointer">
+                    <input type="checkbox" id="remove-embedded-files" name="sanitizeOption" value="embeddedFiles" checked class="w-5 h-5 text-indigo-600 bg-gray-700 border-gray-600 rounded focus:ring-indigo-500">
+                    <span class="text-white">Remove Embedded Files</span>
+                </label>
+                <label class="flex items-center space-x-2 p-3 rounded-md bg-gray-800 hover:bg-gray-700 cursor-pointer">
+                    <input type="checkbox" id="remove-layers" name="sanitizeOption" value="layers" checked class="w-5 h-5 text-indigo-600 bg-gray-700 border-gray-600 rounded focus:ring-indigo-500">
+                    <span class="text-white">Remove Layers (OCG)</span>
+                </label>
+                <label class="flex items-center space-x-2 p-3 rounded-md bg-gray-800 hover:bg-gray-700 cursor-pointer">
+                    <input type="checkbox" id="remove-links" name="sanitizeOption" value="links" checked class="w-5 h-5 text-indigo-600 bg-gray-700 border-gray-600 rounded focus:ring-indigo-500">
+                    <span class="text-white">Remove External Links</span>
+                </label>
+            </div>
+        </div>
+
+        <div>
+            <h4 class="text-sm font-semibold text-gray-400 mb-2">Additional Options</h4>
+            <div class="grid grid-cols-1 sm:grid-cols-2 gap-3">
+                <label class="flex items-center space-x-2 p-3 rounded-md bg-gray-800 hover:bg-gray-700 cursor-pointer">
+                    <input type="checkbox" id="remove-structure-tree" name="sanitizeOption" value="structure" class="w-5 h-5 text-indigo-600 bg-gray-700 border-gray-600 rounded focus:ring-indigo-500">
+                    <span class="text-white">Remove Structure Tree</span>
+                </label>
+                <label class="flex items-center space-x-2 p-3 rounded-md bg-gray-800 hover:bg-gray-700 cursor-pointer">
+                    <input type="checkbox" id="remove-markinfo" name="sanitizeOption" value="markinfo" class="w-5 h-5 text-indigo-600 bg-gray-700 border-gray-600 rounded focus:ring-indigo-500">
+                    <span class="text-white">Remove Tagging Info</span>
+                </label>
+                <label class="flex items-center space-x-2 p-3 rounded-md bg-gray-800 hover:bg-gray-700 cursor-pointer">
+                    <input type="checkbox" id="remove-fonts" name="sanitizeOption" value="fonts" class="w-5 h-5 text-indigo-600 bg-gray-700 border-gray-600 rounded focus:ring-indigo-500">
+                    <span class="text-white text-sm">Remove Embedded Fonts</span>
+                </label>
+            </div>
+        </div>
+
+        <button id="process-btn" class="btn-gradient w-full mt-6">Sanitize PDF & Download</button>
+    </div>
+`,
 };
diff --git a/src/lib/zetajs/office_thread.js b/src/lib/zetajs/office_thread.js
new file mode 100644
index 00000000..c04109c5
--- /dev/null
+++ b/src/lib/zetajs/office_thread.js
@@ -0,0 +1,83 @@
+import { ZetaHelperMain } from '@zetajs/zetaHelper.js';
+
+// Elements
+const canvas = document.getElementById('qtcanvas');
+const input = document.getElementById('input');
+const fileButton = document.getElementById('file-button');
+const downloadCheckbox = document.getElementById('download');
+const iframe = document.getElementById('frame');
+
+const wasmPkg = 'url:./static/'; // adjust if needed
+
+const zHM = new ZetaHelperMain('./src/office_thread.js', {
+  threadJsType: 'module',
+  wasmPkg
+});
+
+zHM.start(() => {
+  // ✅ Assign onmessage handler immediately after start
+  zHM.thrPort.onmessage = (e) => {
+    switch (e.data.cmd) {
+      case 'converted':
+        try { window.FS.unlink(e.data.from); } catch {}
+        const data = window.FS.readFile(e.data.to);
+        const blob = new Blob([data], { type: 'application/pdf' });
+        const url = URL.createObjectURL(blob);
+
+        iframe.src = url;
+
+        if (downloadCheckbox.checked) {
+          const a = document.createElement('a');
+          a.href = url;
+          a.download = `${e.data.name || 'output'}.pdf`;
+          document.body.appendChild(a);
+          a.click();
+          a.remove();
+        }
+
+        try { window.FS.unlink(e.data.to); } catch {}
+        URL.revokeObjectURL(url);
+        break;
+
+      case 'start':
+        input.disabled = false;
+        fileButton.disabled = false;
+        break;
+
+      default:
+        console.warn('Unknown message command:', e.data.cmd);
+    }
+  };
+
+  // ✅ Assign fileButton click
+  fileButton.onclick = () => input.click();
+
+  // ✅ Assign input onchange
+  input.onchange = async () => {
+    input.disabled = true;
+    fileButton.disabled = true;
+
+    const file = input.files?.[0];
+    if (!file) return;
+
+    if (!window.FS) {
+      console.error('FS not initialized yet.');
+      input.disabled = false;
+      fileButton.disabled = false;
+      return;
+    }
+
+    let name = file.name;
+    let from = '/tmp/input';
+    const n = name.lastIndexOf('.');
+    if (n > 0) {
+      from += name.substring(n);
+      name = name.substring(0, n);
+    }
+
+    const arrayBuffer = await file.arrayBuffer();
+    window.FS.writeFile(from, new Uint8Array(arrayBuffer));
+
+    zHM.thrPort.postMessage({ cmd: 'convert', name, from, to: '/tmp/output' });
+  };
+});
diff --git a/src/lib/zetajs/zeta.js b/src/lib/zetajs/zeta.js
new file mode 100644
index 00000000..aeab34f1
--- /dev/null
+++ b/src/lib/zetajs/zeta.js
@@ -0,0 +1,1104 @@
+/* -*- Mode: JS; tab-width: 2; indent-tabs-mode: nil; js-indent-level: 2; fill-column: 100 -*- */
+// SPDX-License-Identifier: MIT
+
+'use strict';
+
+Module.zetajs = new Promise(function (resolve, reject) {
+  Module.zetajs$resolve = function() {
+    // A FinalizationRegistry for zetajs objects that own Embind objects that, in turn, should
+    // be .delete()'d (so that Embind doesn't print any "Embind found a leaked C++ instance"
+    // warnings for them); it is tied to Module so it doesn't itself get GC'ed early:
+    Module.uno$zetajs_deleteRegistry = new FinalizationRegistry(function(value) {
+      value.forEach((val) => val.delete());
+    });
+    const getProxyTarget = Symbol('getProxyTarget');
+    const keepAlive = Symbol('keepAlive');
+    function gcWrap(obj) {
+      // Embind has already registered obj at some FinalizationRegistry that prints the
+      // "Embind found a leaked C++ instance" warning, which we want to suppress; and if we
+      // registered obj itself also at our deleting FinalizationRegistry, the Embind one might
+      // fire first and still print the warning; so instead wrap obj in a Proxy and register
+      // that:
+      const proxy = new Proxy(obj, {});
+      Module.uno$zetajs_deleteRegistry.register(proxy, [obj]);
+      return proxy
+    }
+    function getEmbindSequenceCtor(componentType) {
+      let typename = componentType.toString();
+      let name = 'uno_Sequence';
+      let n = 1;
+      while (typename.startsWith('[]')) {
+        typename = typename.substr(2);
+        ++n;
+      }
+      if (n !== 1) {
+        name += n;
+      }
+      name += '_' + typename.replace(/ /g, '_').replace(/\./g, '$');
+      return Module[name];
+    };
+    function getTypeDescriptionManager() {
+      const ctx = Module.getUnoComponentContext();
+      const tdmAny = ctx.getValueByName(
+        '/singletons/com.sun.star.reflection.theTypeDescriptionManager');
+      ctx.delete();
+      const val = tdmAny.get();
+      tdmAny.delete();
+      const tdm = Module.uno.com.sun.star.container.XHierarchicalNameAccess.query(val);
+      val.delete();
+      return tdm;
+    };
+    function translateTypeDescription(td) {
+      switch (td.getTypeClass()) {
+      case Module.uno.com.sun.star.uno.TypeClass.VOID:
+        return Module.uno_Type.Void();
+      case Module.uno.com.sun.star.uno.TypeClass.BOOLEAN:
+        return Module.uno_Type.Boolean();
+      case Module.uno.com.sun.star.uno.TypeClass.BYTE:
+        return Module.uno_Type.Byte();
+      case Module.uno.com.sun.star.uno.TypeClass.SHORT:
+        return Module.uno_Type.Short();
+      case Module.uno.com.sun.star.uno.TypeClass.UNSIGNED_SHORT:
+        return Module.uno_Type.UnsignedShort();
+      case Module.uno.com.sun.star.uno.TypeClass.LONG:
+        return Module.uno_Type.Long();
+      case Module.uno.com.sun.star.uno.TypeClass.UNSIGNED_LONG:
+        return Module.uno_Type.UnsignedLong();
+      case Module.uno.com.sun.star.uno.TypeClass.HYPER:
+        return Module.uno_Type.Hyper();
+      case Module.uno.com.sun.star.uno.TypeClass.UNSIGNED_HYPER:
+        return Module.uno_Type.UnsignedHyper();
+      case Module.uno.com.sun.star.uno.TypeClass.FLOAT:
+        return Module.uno_Type.Float();
+      case Module.uno.com.sun.star.uno.TypeClass.DOUBLE:
+        return Module.uno_Type.Double();
+      case Module.uno.com.sun.star.uno.TypeClass.CHAR:
+        return Module.uno_Type.Char();
+      case Module.uno.com.sun.star.uno.TypeClass.STRING:
+        return Module.uno_Type.String();
+      case Module.uno.com.sun.star.uno.TypeClass.TYPE:
+        return Module.uno_Type.Type();
+      case Module.uno.com.sun.star.uno.TypeClass.ANY:
+        return Module.uno_Type.Any();
+      case Module.uno.com.sun.star.uno.TypeClass.SEQUENCE:
+        {
+          const itd = Module.uno.com.sun.star.reflection.XIndirectTypeDescription.query(td);
+          const rtd = itd.getReferencedType();
+          itd.delete();
+          const type = translateTypeDescriptionAndDelete(rtd);
+          try {
+            return Module.uno_Type.Sequence(type);
+          } finally {
+            type.delete();
+          }
+        }
+      case Module.uno.com.sun.star.uno.TypeClass.ENUM:
+        return Module.uno_Type.Enum(td.getName());
+      case Module.uno.com.sun.star.uno.TypeClass.STRUCT:
+        return Module.uno_Type.Struct(td.getName());
+      case Module.uno.com.sun.star.uno.TypeClass.EXCEPTION:
+        return Module.uno_Type.Exception(td.getName());
+      case Module.uno.com.sun.star.uno.TypeClass.INTERFACE:
+        return Module.uno_Type.Interface(td.getName());
+      default:
+        throw new Error(
+          'bad type description ' + td.getName() + ' type class ' + td.getTypeClass());
+      }
+    };
+    function translateTypeDescriptionAndDelete(td) {
+      try {
+        return translateTypeDescription(td);
+      } finally {
+        td.delete();
+      }
+    }
+    function translateToEmbind(obj, type, toDelete) {
+      switch (type.getTypeClass()) {
+      case Module.uno.com.sun.star.uno.TypeClass.ANY:
+          {
+              const {any, owning} = translateToAny(obj, Module.uno_Type.Any());
+              if (owning) {
+                  toDelete.push(any);
+              }
+              return any;
+          }
+      case Module.uno.com.sun.star.uno.TypeClass.SEQUENCE:
+          if (Array.isArray(obj)) {
+              const ctype = type.getSequenceComponentType();
+              const seq = new (getEmbindSequenceCtor(ctype))(
+                  obj.length, Module.uno_Sequence.FromSize);
+              for (let i = 0; i !== obj.length; ++i) {
+                  seq.set(i, translateToEmbind(obj[i], ctype, toDelete));
+              }
+              ctype.delete();
+              toDelete.push(seq);
+              return seq;
+          }
+          break;
+      case Module.uno.com.sun.star.uno.TypeClass.STRUCT:
+      case Module.uno.com.sun.star.uno.TypeClass.EXCEPTION:
+          {
+              const val = {};
+              function walk(td) {
+                  const base = td.getBaseType();
+                  if (base !== null) {
+                      const td = Module.uno.com.sun.star.reflection.XCompoundTypeDescription
+                          .query(base);
+                      base.delete();
+                      walk(td);
+                      td.delete();
+                  }
+                  const types = td.getMemberTypes();
+                  const names = td.getMemberNames();
+                  for (let i = 0; i !== types.size(); ++i) {
+                      const name = names.get(i);
+                      const type = translateTypeDescriptionAndDelete(types.get(i));
+                      val[name] = translateToEmbind(obj[name], type, toDelete);
+                      type.delete();
+                  }
+                  types.delete();
+                  names.delete();
+              };
+              const tdm = getTypeDescriptionManager();
+              const tdAny = tdm.getByHierarchicalName(type.toString());
+              tdm.delete();
+              const ifc = tdAny.get();
+              tdAny.delete();
+              const td = Module.uno.com.sun.star.reflection.XCompoundTypeDescription.query(
+                  ifc);
+              ifc.delete();
+              walk(td);
+              td.delete();
+              return val;
+          }
+      case Module.uno.com.sun.star.uno.TypeClass.INTERFACE:
+          if (obj !== null) {
+              const target = obj[getProxyTarget];
+              const handle = target === undefined ? obj : target;
+              if (handle instanceof Module.ClassHandle) {
+                  if (type.toString() === 'com.sun.star.uno.XInterface') {
+                      return handle;
+                  }
+                  const embindType = 'uno_Type_' + type.toString().replace(/\./g, '$');
+                  if (embindType === handle.$$.ptrType.registeredClass.name) {
+                      return handle;
+                  } else {
+                      const ifc = Module[embindType].query(handle);
+                      toDelete.push(ifc);
+                      return ifc;
+                  }
+              }
+          }
+          break;
+      }
+      return obj;
+    };
+    function translateToAny(obj, type) {
+      try {
+        let any;
+        let owning;
+        if (obj instanceof Module.uno_Any) {
+          any = obj;
+          owning = false;
+        } else {
+          let fromType;
+          let val;
+          if (type.getTypeClass() === Module.uno.com.sun.star.uno.TypeClass.ANY) {
+            fromType = getAnyType(obj);
+            if (fromType === undefined) {
+              throw new Error('bad UNO method call argument ' + obj);
+            }
+            val = fromAny(obj);
+          } else {
+            fromType = type;
+            val = obj;
+          }
+          const toDelete = [];
+          any = new Module.uno_Any(fromType, translateToEmbind(val, fromType, toDelete));
+          owning = true;
+          toDelete.forEach((val) => val.delete());
+        }
+        return {any, owning};
+      } finally {
+        type.delete();
+      }
+    };
+    function translateFromEmbind(val, type, precise, cleanUpVal) {
+      switch (type.getTypeClass()) {
+      case Module.uno.com.sun.star.uno.TypeClass.BOOLEAN:
+        return Boolean(val);
+      case Module.uno.com.sun.star.uno.TypeClass.TYPE:
+        return gcWrap(val);
+      case Module.uno.com.sun.star.uno.TypeClass.ANY:
+        {
+          const ty = gcWrap(val.getType());
+          let v;
+          try {
+            v = translateFromEmbind(val.get(), ty, precise, cleanUpVal);
+          } finally {
+            if (cleanUpVal) {
+              val.delete();
+            }
+          }
+          return precise ? new Any(ty, v) : v;
+        }
+      case Module.uno.com.sun.star.uno.TypeClass.SEQUENCE:
+        {
+          const td = type.getSequenceComponentType();
+          const arr = [];
+          for (let i = 0; i !== val.size(); ++i) {
+            arr.push(translateFromEmbind(val.get(i), td, precise, cleanUpVal));
+          }
+          if (cleanUpVal) {
+            val.delete();
+          }
+          td.delete();
+          return arr;
+        }
+      case Module.uno.com.sun.star.uno.TypeClass.STRUCT:
+      case Module.uno.com.sun.star.uno.TypeClass.EXCEPTION:
+        {
+          const obj = {
+            [Module.unoTagSymbol]: {
+              kind: type.getTypeClass()
+                == Module.uno.com.sun.star.uno.TypeClass.STRUCT
+                ? 'struct-instance' : 'exception-instance',
+              type: type.toString()
+            }
+          };
+          function walk(td) {
+            const base = td.getBaseType();
+            if (base !== null) {
+              const td = Module.uno.com.sun.star.reflection.XCompoundTypeDescription
+                .query(base);
+              base.delete();
+              walk(td);
+              td.delete();
+            }
+            const types = td.getMemberTypes();
+            const names = td.getMemberNames();
+            for (let i = 0; i !== types.size(); ++i) {
+              const name = names.get(i);
+              const td = translateTypeDescriptionAndDelete(types.get(i));
+              obj[name] = translateFromEmbind(val[name], td, precise, cleanUpVal);
+              td.delete();
+            }
+            types.delete();
+            names.delete();
+          };
+          const tdm = getTypeDescriptionManager();
+          const tdAny = tdm.getByHierarchicalName(type.toString());
+          tdm.delete();
+          const ifc = tdAny.get();
+          tdAny.delete();
+          const td = Module.uno.com.sun.star.reflection.XCompoundTypeDescription.query(
+            ifc);
+          ifc.delete();
+          walk(td);
+          td.delete();
+          return obj;
+        }
+      case Module.uno.com.sun.star.uno.TypeClass.INTERFACE:
+        return proxy(val);
+      default:
+        return val;
+      }
+    };
+    function translateFromAny(any, type, precise) {
+      if (type.getTypeClass() === Module.uno.com.sun.star.uno.TypeClass.ANY) {
+        return translateFromEmbind(any, type, precise, false);
+      } else {
+        const td = any.getType();
+        const val = translateFromEmbind(any.get(), td, precise, true);
+        td.delete();
+        return val;
+      }
+    };
+    function translateFromAnyAndDelete(any, type, precise) {
+      const val = translateFromAny(any, type, precise);
+      any.delete();
+      return val;
+    };
+    function proxy(unoObject) {
+      if (unoObject === null) {
+        return null;
+      }
+      const prox = {};
+      const toDelete = [unoObject];
+      Module.uno$zetajs_deleteRegistry.register(prox, toDelete);
+      prox[getProxyTarget] = unoObject;
+      prox.$precise = {[getProxyTarget]: unoObject, [keepAlive]: prox};
+      // css.script.XInvocation2::getInfo invents additional members (e.g., an attribute "Foo"
+      // if there is a method "getFoo"), so better determine the actual set of members via
+      // css.lang.XTypeProvider::getTypes:
+      const typeprov = Module.uno.com.sun.star.lang.XTypeProvider.query(unoObject);
+      if (typeprov !== null) {
+        const ty = Module.uno_Type.Interface('com.sun.star.uno.XInterface');
+        const arg = new Module.uno_Any(ty, unoObject);
+        ty.delete();
+        const args = new Module.uno_Sequence_any([arg]);
+        arg.delete();
+        const ctx = Module.getUnoComponentContext();
+        const serv = Module.uno.com.sun.star.script.Invocation.create(ctx);
+        ctx.delete();
+        const inst = serv.createInstanceWithArguments(args);
+        args.delete();
+        serv.delete();
+        const invoke = Module.uno.com.sun.star.script.XInvocation2.query(inst);
+        inst.delete();
+        toDelete.push(invoke);
+        function invokeMethod(name, args, precise) {
+          const info = invoke.getInfoForName(name, true);
+          try {
+            if (args.length != info.aParamTypes.size()) {
+              throw new Error(
+                'bad number of arguments in call to ' + name + ', expected ' +
+                  info.aParamTypes.size() + ' vs. actual ' + args.length);
+            }
+            const unoArgs = new Module.uno_Sequence_any(
+              info.aParamTypes.size(), Module.uno_Sequence.FromSize);
+            const deleteArgs = [];
+            for (let i = 0; i !== info.aParamTypes.size(); ++i) {
+              switch (info.aParamModes.get(i)) {
+              case Module.uno.com.sun.star.reflection.ParamMode.IN:
+                {
+                  const {any, owning} = translateToAny(
+                    args[i], info.aParamTypes.get(i));
+                  unoArgs.set(i, any);
+                  if (owning) {
+                    deleteArgs.push(any);
+                  }
+                  break;
+                }
+              case Module.uno.com.sun.star.reflection.ParamMode.INOUT:
+                {
+                  const {any, owning} = translateToAny(
+                    args[i].val, info.aParamTypes.get(i));
+                  unoArgs.set(i, any);
+                  if (owning) {
+                    deleteArgs.push(any);
+                  }
+                  break;
+                }
+              }
+            }
+            const outparamindex_out = new Module.uno_InOutParam_sequence_short;
+            const outparam_out = new Module.uno_InOutParam_sequence_any;
+            let ret;
+            try {
+              ret = invoke.invoke(name, unoArgs, outparamindex_out, outparam_out);
+            } catch (e) {
+              outparamindex_out.delete();
+              outparam_out.delete();
+              const exc = catchUnoException(e);
+              if (getAnyType(exc) ==
+                'com.sun.star.reflection.InvocationTargetException')
+              {
+                throwUnoException(exc.TargetException);
+              } else {
+                throwUnoException(exc);
+              }
+            } finally {
+              deleteArgs.forEach((arg) => arg.delete());
+              unoArgs.delete();
+            }
+            const outparamindex = outparamindex_out.val;
+            outparamindex_out.delete();
+            const outparam = outparam_out.val;
+            outparam_out.delete();
+            for (let i = 0; i !== outparamindex.size(); ++i) {
+              const j = outparamindex.get(i);
+              const ty = info.aParamTypes.get(j);
+              args[j].val = translateFromAnyAndDelete(outparam.get(i), ty, precise);
+              ty.delete();
+            }
+            outparamindex.delete();
+            outparam.delete();
+            return translateFromAnyAndDelete(ret, info.aType, precise);
+          } finally {
+            info.aType.delete();
+            info.aParamTypes.delete();
+            info.aParamModes.delete();
+          }
+        };
+        function invokeGetter(name, precise) {
+          const info = invoke.getInfoForName(name, true);
+          try {
+            const ret = invoke.getValue(name);
+            return translateFromAnyAndDelete(ret, info.aType, precise);
+          } finally {
+            info.aType.delete();
+            info.aParamTypes.delete();
+            info.aParamModes.delete();
+          }
+        };
+        function invokeSetter(name, value) {
+          const info = invoke.getInfoForName(name, true);
+          const deleteArgs = [];
+          const {any, owning} = translateToAny(value, info.aType);
+          if (owning) {
+            deleteArgs.push(any);
+          }
+          try {
+            invoke.setValue(name, any);
+          } finally {
+            // info.aType already deleted in translateToAny above
+            info.aParamTypes.delete();
+            info.aParamModes.delete();
+          }
+        };
+        prox.queryInterface = function() {
+            return invokeMethod('queryInterface', arguments, false); };
+        prox.$precise.queryInterface = function() {
+            return invokeMethod('queryInterface', arguments, true); };
+        const seen = {'com.sun.star.uno.XInterface': true};
+        function walk(td) {
+          const iname = td.getName();
+          if (!Object.hasOwn(seen, iname)) {
+            seen[iname] = true;
+            if (td.getTypeClass() !== Module.uno.com.sun.star.uno.TypeClass.INTERFACE) {
+              throw new Error('not a UNO interface type: ' + iname);
+            }
+            const itd = Module.uno.com.sun.star.reflection.XInterfaceTypeDescription2
+                .query(td);
+            const bases = itd.getBaseTypes();
+            for (let i = 0; i !== bases.size(); ++i) {
+              const base = bases.get(i);
+              walk(base);
+              base.delete();
+            }
+            bases.delete();
+            const mems = itd.getMembers();
+            for (let i = 0; i !== mems.size(); ++i) {
+              const mem = mems.get(i);
+              const name = mem.getMemberName();
+              const atd = Module.uno.com.sun.star.reflection
+                  .XInterfaceAttributeTypeDescription.query(mem);
+              mem.delete();
+              if (atd !== null) {
+                Object.defineProperty(prox, name, {
+                  enumerable: true,
+                  get() { return invokeGetter(name, false); },
+                  set: atd.isReadOnly()
+                    ? undefined
+                    : function(value) { return invokeSetter(name, value); }});
+                Object.defineProperty(prox.$precise, name, {
+                  enumerable: true,
+                  get() { return invokeGetter(name, true); },
+                  set: atd.isReadOnly()
+                    ? undefined
+                    : function(value) { return invokeSetter(name, value); }});
+                atd.delete();
+              } else {
+                prox[name] = function() { return invokeMethod(name, arguments, false); };
+                prox.$precise[name] = function() { return invokeMethod(name, arguments, true); };
+              }
+            }
+            itd.delete();
+            mems.delete();
+            if (iname === 'com.sun.star.container.XEnumeration') {
+              prox[Symbol.iterator] = function*() {
+                while (prox.hasMoreElements()) {
+                  yield prox.nextElement();
+                }
+              }
+              prox.$precise[Symbol.iterator] = function*() {
+                while (prox.$precise.hasMoreElements()) {
+                  yield prox.$precise.nextElement();
+                }
+              }
+            }
+          }
+        };
+        const tdm = getTypeDescriptionManager();
+        const types = typeprov.getTypes();
+        typeprov.delete();
+        for (let i = 0; i != types.size(); ++i) {
+          const ty = types.get(i);
+          const td = tdm.getByHierarchicalName(ty.toString());
+          ty.delete();
+          const ifc1 = td.get();
+          td.delete();
+          const ifc2 = Module.uno.com.sun.star.reflection.XTypeDescription.query(ifc1);
+          ifc1.delete();
+          walk(ifc2);
+          ifc2.delete();
+        }
+        tdm.delete();
+        types.delete();
+      }
+      return prox;
+    };
+    function singleton(name) {
+      return function(context) {
+        const any = context.getValueByName('/singletons/' + name);
+        if (getAnyType(any).getTypeClass() !==
+            Module.uno.com.sun.star.uno.TypeClass.INTERFACE
+          || any === null)
+        {
+          throwUnoException(
+            new uno.com.sun.star.uno.DeploymentException(
+              {Message: 'cannot get singeleton ' + name}));
+        }
+        return any.val;
+      };
+    };
+    function service(name, td) {
+      const obj = {};
+      const ctors = td.getConstructors();
+      for (let i = 0; i !== ctors.size(); ++i) {
+        const ctor = ctors.get(i);
+        if (ctor.isDefaultConstructor()) {
+          obj.create = function(context) {
+            const ifc = context.getServiceManager().createInstanceWithContext(
+              name, context);
+            if (ifc === null) {
+              throwUnoException(
+                new uno.com.sun.star.uno.DeploymentException(
+                  {Message:
+                   'cannot instantiate single-interface service ' + name}));
+            }
+            return ifc;
+          };
+        } else {
+          obj[ctor.getName()] = function() {
+            const context = arguments[0];
+            const args = [];
+            const params = ctor.getParameters();
+            for (let j = 0; j !== params.size(); ++j) {
+              const param = params.get(j);
+              if (param.isRestParameter()) {
+                for (; j + 1 < arguments.length; ++j) {
+                  args.push(arguments[j + 1]);
+                }
+                break;
+              } else {
+                let arg = arguments[j + 1];
+                const ty = param.getType();
+                if (ty.getTypeClass() !== Module.uno.com.sun.star.uno.TypeClass.ANY)
+                {
+                  arg = new Any(
+                    gcWrap(translateTypeDescriptionAndDelete(param.getType())),
+                    arg);
+                }
+                ty.delete();
+                args.push(arg);
+              }
+              param.delete();
+            }
+            params.delete();
+            const ifc = context.getServiceManager()
+                  .createInstanceWithArgumentsAndContext(name, args, context);
+            if (ifc === null) {
+              throwUnoException(
+                new uno.com.sun.star.uno.DeploymentException(
+                  {Message:
+                   'cannot instantiate single-interface service ' + name}));
+            }
+            return ifc;
+          };
+        }
+      }
+      ctors.delete();
+      return obj;
+    };
+    function defaultValue(type) {
+      switch (type.getTypeClass()) {
+      case Module.uno.com.sun.star.uno.TypeClass.BOOLEAN:
+        return false;
+      case Module.uno.com.sun.star.uno.TypeClass.BYTE:
+      case Module.uno.com.sun.star.uno.TypeClass.SHORT:
+      case Module.uno.com.sun.star.uno.TypeClass.UNSIGNED_SHORT:
+      case Module.uno.com.sun.star.uno.TypeClass.LONG:
+      case Module.uno.com.sun.star.uno.TypeClass.UNSIGNED_LONG:
+      case Module.uno.com.sun.star.uno.TypeClass.FLOAT:
+      case Module.uno.com.sun.star.uno.TypeClass.DOUBLE:
+        return 0;
+      case Module.uno.com.sun.star.uno.TypeClass.HYPER:
+      case Module.uno.com.sun.star.uno.TypeClass.UNSIGNED_HYPER:
+        return 0n;
+      case Module.uno.com.sun.star.uno.TypeClass.CHAR:
+        return '\0';
+      case Module.uno.com.sun.star.uno.TypeClass.STRING:
+        return '';
+      case Module.uno.com.sun.star.uno.TypeClass.TYPE:
+        return Module.uno_Type.Void();
+      case Module.uno.com.sun.star.uno.TypeClass.ANY:
+        return undefined;
+      case Module.uno.com.sun.star.uno.TypeClass.SEQUENCE:
+        return [];
+      case Module.uno.com.sun.star.uno.TypeClass.ENUM:
+        {
+          const tdm = getTypeDescriptionManager();
+          const tdAny = tdm.getByHierarchicalName(type.toString());
+          tdm.delete();
+          const ifc = tdAny.get();
+          tdAny.delete();
+          const td = Module.uno.com.sun.star.reflection.XEnumTypeDescription.query(ifc);
+          ifc.delete();
+          const names = td.getEnumNames();
+          td.delete();
+          const first = names.get(0);
+          names.delete();
+          return Module['uno_Type_' + type.toString().replace(/\./g, '$')][first];
+        }
+      case Module.uno.com.sun.star.uno.TypeClass.STRUCT:
+        {
+          //TODO: Make val an instanceof the corresponding struct constructor function:
+          const tdm = getTypeDescriptionManager();
+          const tdAny = tdm.getByHierarchicalName(type.toString());
+          tdm.delete();
+          const ifc = tdAny.get();
+          tdAny.delete();
+          const td = Module.uno.com.sun.star.reflection.XTypeDescription.query(ifc);
+          ifc.delete();
+          const members = {};
+          computeMembers(td, members);
+          td.delete();
+          const val = {};
+          populate(val, [], members);
+          return val;
+        }
+      case Module.uno.com.sun.star.uno.TypeClass.INTERFACE:
+        return null;
+      default:
+        throw new Error('bad member type ' + type);
+      }
+    }
+    function TypeArgumentIndex(index) { this.index = index; };
+    function computeMembers(type, obj) {
+      const td = Module.uno.com.sun.star.reflection.XCompoundTypeDescription.query(type);
+      const base = td.getBaseType();
+      if (base !== null) {
+        computeMembers(base, obj);
+        base.delete();
+      }
+      const types = td.getMemberTypes();
+      const names = td.getMemberNames();
+      td.delete();
+      for (let i = 0; i !== types.size(); ++i) {
+        const memtype = types.get(i);
+        let val;
+        if (memtype.getTypeClass() === Module.uno.com.sun.star.uno.TypeClass.UNKNOWN) {
+          const paramName = memtype.getName();
+          const std = Module.uno.com.sun.star.reflection.XStructTypeDescription.query(
+            type);
+          const params = std.getTypeParameters();
+          std.delete();
+          let index = 0;
+          for (; index !== params.size(); ++index) {
+            if (params.get(index) === paramName) {
+              break;
+            }
+          }
+          params.delete();
+          val = new TypeArgumentIndex(index);
+        } else {
+          const type = translateTypeDescription(memtype);
+          val = defaultValue(type);
+          type.delete();
+        }
+        memtype.delete();
+        obj[names.get(i)] = val;
+      }
+      types.delete();
+      names.delete();
+    };
+    function populate(obj, types, members, values) {
+      for (let i in members) {
+        let val;
+        if (values !== undefined && i in values) {
+          val = values[i];
+        } else {
+          val = members[i];
+          if (val instanceof TypeArgumentIndex) {
+            val = defaultValue(types[val.index]);
+          }
+        }
+        obj[i] = val;
+      }
+    };
+    function instantiationName(templateName, types) {
+      let name = templateName + '<';
+      for (let i = 0; i !== types.length; ++i) {
+        if (i !== 0) {
+          name += ',';
+        }
+        name += types[i];
+      }
+      return name + '>';
+    }
+    function unoidlProxy(path, embindObject) {
+      return new Proxy({}, {
+        get(target, prop) {
+          if (!Object.hasOwn(target, prop)) {
+            const name = path + '.' + prop;
+            const tdm = getTypeDescriptionManager();
+            const tdAny = tdm.getByHierarchicalName(name);
+            tdm.delete();
+            const ifc = tdAny.get();
+            tdAny.delete();
+            const td = Module.uno.com.sun.star.reflection.XTypeDescription.query(ifc);
+            ifc.delete();
+            switch (td.getTypeClass()) {
+            case Module.uno.com.sun.star.uno.TypeClass.ENUM:
+              target[prop] = embindObject[prop];
+              target[prop][Module.unoTagSymbol] = {kind: 'enum', type: name};
+              break;
+            case Module.uno.com.sun.star.uno.TypeClass.STRUCT:
+              {
+                const members = {};
+                computeMembers(td, members);
+                const std = Module.uno.com.sun.star.reflection
+                  .XStructTypeDescription.query(td);
+                const params = std.getTypeParameters();
+                std.delete();
+                const paramCount = params.size();
+                params.delete();
+                if (paramCount === 0) {
+                  target[prop] = function(values) {
+                    populate(this, [], members, values);
+                    this[Module.unoTagSymbol] = {
+                      kind: 'struct-instance', type: name};
+                  };
+                } else {
+                  target[prop] = function(types, values) {
+                    if (types.length !== paramCount) {
+                      throw new Error(
+                        'bad number of type arguments in call to ' + name +
+                          ', expected ' + paramCount + ' vs. actual ' +
+                          types.length);
+                    }
+                    populate(this, types, members, values);
+                    this[Module.unoTagSymbol] = {
+                      kind: 'struct-instance',
+                      type: instantiationName(name, types)};
+                  };
+                }
+                target[prop][Module.unoTagSymbol] = {kind: 'struct', type: name};
+                break;
+              }
+            case Module.uno.com.sun.star.uno.TypeClass.EXCEPTION:
+              {
+                const members = {};
+                computeMembers(td, members);
+                target[prop] = function(values) {
+                  populate(this, [], members, values);
+                  this[Module.unoTagSymbol] = {
+                    kind: 'exception-instance', type: name};
+                };
+                target[prop][Module.unoTagSymbol] = {kind: 'exception', type: name};
+                break;
+              }
+            case Module.uno.com.sun.star.uno.TypeClass.INTERFACE:
+              target[prop] = {[Module.unoTagSymbol]: {kind: 'interface', type: name}};
+              break;
+            case Module.uno.com.sun.star.uno.TypeClass.MODULE:
+              target[prop] = unoidlProxy(name, embindObject[prop]);
+              break;
+            case Module.uno.com.sun.star.uno.TypeClass.SINGLETON:
+              target[prop] = singleton(name);
+              break;
+            case Module.uno.com.sun.star.uno.TypeClass.SERVICE:
+              {
+                const std = Module.uno.com.sun.star.reflection
+                  .XServiceTypeDescription2.query(td);
+                if (std.isSingleInterfaceBased()) {
+                  target[prop] = service(name, std);
+                }
+                std.delete();
+                break;
+              }
+            case Module.uno.com.sun.star.uno.TypeClass.CONSTANTS:
+              target[prop] = embindObject[prop];
+              break;
+            }
+            td.delete();
+          }
+          return target[prop];
+        }
+      });
+    };
+    function Any(type, val) {
+      this.type = type;
+      this.val = val;
+    };
+    function getAnyType(val) {
+      switch (typeof val) {
+      case 'undefined':
+        return gcWrap(Module.uno_Type.Void());
+      case 'boolean':
+        return gcWrap(Module.uno_Type.Boolean());
+      case 'number':
+        return gcWrap(
+          Number.isInteger(val) && val >= -0x80000000 && val < 0x80000000
+            ? Module.uno_Type.Long()
+            : Number.isInteger(val) && val >= 0 && val < 0x100000000
+            ? Module.uno_Type.UnsignedLong()
+            : Module.uno_Type.Double());
+      case 'bigint':
+        return gcWrap(
+          val < 0x8000000000000000n
+            ? Module.uno_Type.Hyper() : Module.uno_Type.UnsignedHyper());
+      case 'string':
+        return gcWrap(Module.uno_Type.String());
+      case 'object':
+        if (val === null || Object.hasOwn(val, getProxyTarget)) {
+          return gcWrap(Module.uno_Type.Interface('com.sun.star.uno.XInterface'));
+        } else if (val instanceof Module.uno_Type) {
+          return gcWrap(Module.uno_Type.Type());
+        } else if (val instanceof Any) {
+          return val.type;
+        } else if (val instanceof Array) {
+          const t = Module.uno_Type.Any();
+          try {
+            return gcWrap(Module.uno_Type.Sequence(t));
+          } finally {
+            t.delete();
+          }
+        } else {
+          const tag = val[Module.unoTagSymbol];
+          if (tag !== undefined) {
+            if (tag.kind === 'enumerator') {
+              return gcWrap(Module.uno_Type.Enum(tag.type));
+            } else if (tag.kind === 'struct-instance') {
+              return gcWrap(Module.uno_Type.Struct(tag.type));
+            } else if (tag.kind === 'exception-instance') {
+              return gcWrap(Module.uno_Type.Exception(tag.type));
+            }
+          }
+        }
+        // fallthrough
+      default:
+        return undefined;
+      }
+    };
+    function fromAny(val) { return val instanceof Any ? val.val : val; };
+    function throwUnoException(exception) {
+      const type = gcWrap(Module.uno_Type.Exception(exception[Module.unoTagSymbol].type));
+      const toDelete = [];
+      const val = translateToEmbind(exception, type, toDelete);
+      Module.throwUnoException(type, val, toDelete);
+    };
+    function catchUnoException(exception) {
+        const td = Module.uno_Type.Any();
+        try {
+          return translateFromAnyAndDelete(Module.catchUnoException(exception), td);
+        } finally {
+          td.delete();
+        }
+    };
+    const uno = new Proxy({}, {
+      get(target, prop) {
+        if (!Object.hasOwn(target, prop)) {
+          const tdm = getTypeDescriptionManager();
+          const td = tdm.getByHierarchicalName(prop);
+          tdm.delete();
+          td.delete();
+          target[prop] = unoidlProxy(prop, Module.uno[prop]);
+        }
+        return target[prop];
+      }
+    });
+    const zetajs = {
+      type: {
+        void: gcWrap(Module.uno_Type.Void()),
+        boolean: gcWrap(Module.uno_Type.Boolean()),
+        byte: gcWrap(Module.uno_Type.Byte()),
+        short: gcWrap(Module.uno_Type.Short()),
+        unsigned_short: gcWrap(Module.uno_Type.UnsignedShort()),
+        long: gcWrap(Module.uno_Type.Long()),
+        unsigned_long: gcWrap(Module.uno_Type.UnsignedLong()),
+        hyper: gcWrap(Module.uno_Type.Hyper()),
+        unsigned_hyper: gcWrap(Module.uno_Type.UnsignedHyper()),
+        float: gcWrap(Module.uno_Type.Float()),
+        double: gcWrap(Module.uno_Type.Double()),
+        char: gcWrap(Module.uno_Type.Char()),
+        string: gcWrap(Module.uno_Type.String()),
+        type: gcWrap(Module.uno_Type.Type()),
+        any: gcWrap(Module.uno_Type.Any()),
+        sequence(type) { return gcWrap(Module.uno_Type.Sequence(type)); },
+        enum(name) {
+          if (typeof name === 'function' && Object.hasOwn(name, Module.unoTagSymbol)
+            && name[Module.unoTagSymbol].kind === 'enum')
+          {
+            name = name[Module.unoTagSymbol].type;
+          }
+          return gcWrap(Module.uno_Type.Enum(name));
+        },
+        struct(name) {
+          if (typeof name === 'function' && Object.hasOwn(name, Module.unoTagSymbol)
+            && name[Module.unoTagSymbol].kind === 'struct')
+          {
+            name = name[Module.unoTagSymbol].type;
+          }
+          return gcWrap(Module.uno_Type.Struct(name));
+        },
+        exception(name) {
+          if (typeof name === 'function' && Object.hasOwn(name, Module.unoTagSymbol)
+            && name[Module.unoTagSymbol].kind === 'exception')
+          {
+            name = name[Module.unoTagSymbol].type;
+          }
+          return gcWrap(Module.uno_Type.Exception(name));
+        },
+        interface(name) {
+          if (typeof name === 'object' && Object.hasOwn(name, Module.unoTagSymbol)
+            && name[Module.unoTagSymbol].kind === 'interface')
+          {
+            name = name[Module.unoTagSymbol].type;
+          }
+          return gcWrap(Module.uno_Type.Interface(name));
+        }
+      },
+      Any,
+      getAnyType,
+      fromAny,
+      sameUnoObject: function(obj1, obj2) {
+        const type = Module.uno_Type.Interface('com.sun.star.uno.XInterface');
+        const toDelete = [];
+        try {
+          return Module.sameUnoObject(
+            translateToEmbind(obj1, type, toDelete),
+            translateToEmbind(obj2, type, toDelete));
+        } finally {
+          type.delete();
+          toDelete.forEach((val) => val.delete());
+        }
+      },
+      getUnoComponentContext: function() {
+        return proxy(Module.getUnoComponentContext());
+      },
+      throwUnoException,
+      catchUnoException,
+      uno,
+      unoObject: function(interfaces, obj) {
+        const wrapper = {};
+        const toDelete = [];
+        Module.uno$zetajs_deleteRegistry.register(wrapper, toDelete);
+        const seen = {
+          'com.sun.star.lang.XTypeProvider': true, 'com.sun.star.uno.XInterface': true};
+        function walk(td) {
+          const iname = td.getName();
+          if (!Object.hasOwn(seen, iname)) {
+            seen[iname] = true;
+            if (td.getTypeClass() !== Module.uno.com.sun.star.uno.TypeClass.INTERFACE) {
+              throw new Error('not a UNO interface type: ' + iname);
+            }
+            const itd = Module.uno.com.sun.star.reflection.XInterfaceTypeDescription2
+                  .query(td);
+            const bases = itd.getBaseTypes();
+            for (let i = 0; i !== bases.size(); ++i) {
+              const base = bases.get(i);
+              walk(base);
+              base.delete();
+            }
+            bases.delete();
+            const mems = itd.getMembers();
+            itd.delete();
+            for (let i = 0; i !== mems.size(); ++i) {
+              const ifc = mems.get(i);
+              const atd = Module.uno.com.sun.star.reflection
+                .XInterfaceAttributeTypeDescription.query(ifc);
+              ifc.delete();
+              if (atd !== null) {
+                const aname = atd.getMemberName();
+                const type = translateTypeDescriptionAndDelete(atd.getType());
+                toDelete.push(type);
+                wrapper['get' + aname] = function() {
+                  return translateToEmbind(
+                    obj['get' + aname].apply(obj), type, []);
+                };
+                if (!atd.isReadOnly()) {
+                  wrapper['set' + aname] = function() {
+                    obj['set' + aname].apply(
+                      obj, [translateFromEmbind(arguments[0], type, true, false)]);
+                  };
+                }
+                atd.delete();
+              } else {
+                const ifc = mems.get(i);
+                const mtd = Module.uno.com.sun.star.reflection
+                  .XInterfaceMethodTypeDescription.query(ifc);
+                ifc.delete();
+                const mname = mtd.getMemberName();
+                const retType = translateTypeDescriptionAndDelete(
+                  mtd.getReturnType());
+                toDelete.push(retType);
+                const params = [];
+                const descrs = mtd.getParameters();
+                mtd.delete();
+                for (let j = 0; j !== descrs.size(); ++j) {
+                  const descr = descrs.get(j);
+                  const type = translateTypeDescriptionAndDelete(descr.getType());
+                  toDelete.push(type);
+                  params.push({type, dirIn: descr.isIn(), dirOut: descr.isOut()});
+                  descr.delete();
+                }
+                descrs.delete();
+                wrapper[mname] = function() {
+                  const args = [];
+                  for (let i = 0; i !== params.length; ++i) {
+                    let arg;
+                    if (params[i].dirOut) {
+                      arg = {};
+                      if (params[i].dirIn) {
+                        arg.val = translateFromEmbind(
+                          arguments[i].val, params[i].type, true, false);
+                      }
+                    } else {
+                      arg = translateFromEmbind(
+                        arguments[i], params[i].type, true, false);
+                    }
+                    args.push(arg);
+                  }
+                  const ret = translateToEmbind(
+                    obj[mname].apply(obj, args), retType, []);
+                  for (let i = 0; i !== params.length; ++i) {
+                    if (params[i].dirOut) {
+                      arguments[i].val = translateToEmbind(
+                        args[i].val, params[i].type, []);
+                    }
+                  }
+                  return ret;
+                };
+              }
+            }
+            mems.delete();
+          }
+        };
+        const tdm = getTypeDescriptionManager();
+        const interfaceNames = [];
+        interfaces.forEach((i) => {
+          let name = i;
+          if (typeof name === 'object' && Object.hasOwn(name, Module.unoTagSymbol)
+              && name[Module.unoTagSymbol].kind === 'interface')
+          {
+              name = name[Module.unoTagSymbol].type;
+          } else if (name instanceof Module.uno_Type
+                     && (name.getTypeClass()
+                         === Module.uno.com.sun.star.uno.TypeClass.INTERFACE))
+          {
+            name = name.toString();
+          }
+          interfaceNames.push(name);
+          const tdAny = tdm.getByHierarchicalName(name);
+          const ifc = tdAny.get();
+          const td = Module.uno.com.sun.star.reflection.XTypeDescription.query(ifc);
+          ifc.delete();
+          walk(td);
+          td.delete();
+        })
+        tdm.delete();
+        return proxy(Module.unoObject(interfaceNames, wrapper));
+      },
+      mainPort: Module.uno_mainPort
+    };
+    resolve(zetajs);
+  };
+  Module.zetajs$reject = reject;
+});
+
+Module.uno_init.then(function() { Module.zetajs$resolve(); });
+
+/* vim:set shiftwidth=2 softtabstop=2 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */
\ No newline at end of file
diff --git a/src/lib/zetajs/zetaHelper.js b/src/lib/zetajs/zetaHelper.js
new file mode 100644
index 00000000..3743ae89
--- /dev/null
+++ b/src/lib/zetajs/zetaHelper.js
@@ -0,0 +1,209 @@
+// ATTENTION: Experimental code! Expect heavy API changes.
+/**
+ * Helper for code in the browsers main thread.
+ * @beta
+ */
+export class ZetaHelperMain {
+    /**
+     * Use absolute URLs or URLs relative to the root HTML document (location.href).
+     * @param threadJs - URL for JS code file running inside the office thread (web worker).
+     * @param options.threadJsType - 'classic' or 'module' (ES2015)
+     *   see: https://developer.mozilla.org/docs/Web/API/Worker/Worker#type
+     * @param options.wasmPkg - Which WASM binaries to use. Possible options:
+     *   'free', 'business', 'url:YOUR_CUSTOM_URL'
+     * @param options.blockPageScroll - Don't scroll the HTML page while the cursor is above
+     *   the canvas. (default: true)
+     */
+    constructor(threadJs, options) {
+        this.threadJsType = 'classic';
+        // Enable usage of LOWA builds with UI.
+        const canvas = document.getElementById('qtcanvas');
+        const thisFileUrl = import.meta.url;
+        const modUrlDir = thisFileUrl.substring(0, thisFileUrl.length - 'zetaHelper.js'.length);
+        if (threadJs)
+            threadJs = (new URL(threadJs, location.href)).toString();
+        const zetajsScript = modUrlDir + 'zeta.js';
+        const threadWrapScript = 'data:text/javascript;charset=UTF-8,' +
+            'import("' + import.meta.url + '").then(m => {m.zetaHelperWrapThread();});';
+        const wasmPkg = options.wasmPkg || 'free';
+        let soffice_base_url = ZetaHelperMain.wasmUrls[wasmPkg] || ZetaHelperMain.wasmUrls['free'];
+        if (wasmPkg?.substring(0, 4) === 'url:')
+            soffice_base_url = wasmPkg.substring(4, wasmPkg.length);
+        if (soffice_base_url === '')
+            soffice_base_url = './';
+        soffice_base_url = (new URL(soffice_base_url, location.href)).toString();
+        const Module = {
+            canvas,
+            uno_scripts: [zetajsScript, threadWrapScript],
+            locateFile: (path, prefix) => { return (prefix || soffice_base_url) + path; },
+            modUrlDir,
+        };
+        Module.mainScriptUrlOrBlob = new Blob(["importScripts('" + (new URL('soffice.js', soffice_base_url)) + "');"], { type: 'text/javascript' });
+        let lastDevicePixelRatio = window.devicePixelRatio;
+        addEventListener('resize', () => {
+            // Workaround to inform Qt5 about changed browser zoom.
+            setTimeout(() => {
+                if (lastDevicePixelRatio != -1) {
+                    if (lastDevicePixelRatio != window.devicePixelRatio) {
+                        lastDevicePixelRatio = -1;
+                        this.widthPxAdd(canvas.style, +1);
+                        window.dispatchEvent(new Event('resize'));
+                    }
+                }
+                else {
+                    lastDevicePixelRatio = window.devicePixelRatio;
+                    this.widthPxAdd(canvas.style, -1);
+                    window.dispatchEvent(new Event('resize'));
+                }
+            }, 100);
+        });
+        // Scroll only the canvas while the mouse cursor is above it.
+        if (options.blockPageScroll != false)
+            canvas.addEventListener('wheel', (event) => {
+                event.preventDefault();
+            }, { passive: false });
+        window.Module = Module; // window.* is global
+        this.canvas = canvas;
+        this.Module = Module;
+        this.threadJs = threadJs?.toString() || null;
+        if (options.threadJsType === 'module')
+            this.threadJsType = 'module';
+        this.soffice_base_url = soffice_base_url;
+    }
+    start(app_init) {
+        const zHM = this;
+        const soffice_js = document.createElement("script");
+        soffice_js.src = zHM.soffice_base_url + "soffice.js";
+        // "onload" runs after the loaded script has run.
+        soffice_js.onload = () => {
+            console.log('zetaHelper: Configuring Module');
+            zHM.Module.uno_main.then((pThrPort) => {
+                zHM.thrPort = pThrPort;
+                zHM.FS = window.FS;
+                zHM.thrPort.onmessage = (e) => {
+                    switch (e.data.cmd) {
+                        case 'ZetaHelper::thr_started':
+                            // Trigger resize of the embedded window to match the canvas size.
+                            // May somewhen be obsoleted by:
+                            //   https://gerrit.libreoffice.org/c/core/+/174040
+                            window.dispatchEvent(new Event('resize'));
+                            zHM.thrPort.postMessage({
+                                cmd: 'ZetaHelper::run_thr_script',
+                                threadJs: zHM.threadJs,
+                                threadJsType: zHM.threadJsType
+                            });
+                            app_init();
+                            break;
+                        default:
+                            throw Error('Unknown message command: ' + e.data.cmd);
+                    }
+                    ;
+                };
+            });
+        };
+        console.log('zetaHelper: Loading WASM binaries for ZetaJS from: ' + zHM.soffice_base_url);
+        // Hint: The global objects "canvas" and "Module" must exist before the next line.
+        document.body.appendChild(soffice_js);
+    }
+    widthPxAdd(obj, value) {
+        if (/\A\d+px\z/.test(obj.width)) {
+            obj.width = parseInt(obj.width) + value + 'px';
+        }
+    }
+}
+ZetaHelperMain.wasmUrls = {
+    free: 'https://cdn.zetaoffice.net/zetaoffice_latest/',
+    business: 'https://business-cdn.zetaoffice.net/zetaoffice_latest/',
+};
+/**
+ * Initializes zetajs in the office thread (web worker).
+ * Will be called by ZetaHelperMain.
+ * NOT MEANT FOR DIRECT USE
+ * @beta
+ */
+export function zetaHelperWrapThread() {
+    const zJsModule = globalThis.Module;
+    zJsModule.zetajs.then((zetajs) => {
+        const port = zetajs.mainPort;
+        port.onmessage = (e) => {
+            switch (e.data.cmd) {
+                case 'ZetaHelper::run_thr_script':
+                    port.onmessage = null;
+                    globalThis.zetajsStore = { zetajs, zJsModule };
+                    let threadJs = e.data.threadJs;
+                    if (threadJs) {
+                        if (e.data.threadJsType === 'module') {
+                            console.log('zetaHelper: Loading threadJs as module from: ' + threadJs);
+                            import(threadJs).then(module => {
+                                // Make exports of threadJs accessible for debugging.
+                                globalThis.zetajsStore.threadJsContext = module;
+                            });
+                        }
+                        else { // classic
+                            console.log('zetaHelper: Loading threadJs as script from: ' + threadJs);
+                            importScripts(threadJs);
+                        }
+                    }
+                    else {
+                        console.log('zetaHelper: Office loaded. No threadJs given.');
+                    }
+                    break;
+                default:
+                    throw Error('Unknown message command: ' + e.data.cmd);
+            }
+            ;
+        };
+        port.postMessage({
+            cmd: 'ZetaHelper::thr_started'
+        });
+    });
+}
+/**
+ * Helper for inside the office thread (web worker).
+ * @beta
+ */
+export class ZetaHelperThread {
+    constructor() {
+        this.zetajs = globalThis.zetajsStore.zetajs;
+        this.zJsModule = globalThis.zetajsStore.zJsModule;
+        this.thrPort = this.zetajs.mainPort;
+        this.css = this.zetajs.uno.com.sun.star;
+        this.context = this.zetajs.getUnoComponentContext();
+        this.desktop = this.css.frame.Desktop.create(this.context);
+        this.config = this.css.configuration.ReadWriteAccess.create(this.context, 'en-US');
+    }
+    /**
+     * Turn off toolbars.
+     * @param officeModules - ["Base", "Calc", "Draw", "Impress", "Math", "Writer"];
+     */
+    configDisableToolbars(officeModules) {
+        for (const mod of officeModules) {
+            const modName = "/org.openoffice.Office.UI." + mod + "WindowState/UIElements/States";
+            const uielems = this.config.getByHierarchicalName(modName);
+            for (const i of uielems.getElementNames()) {
+                if (i.startsWith("private:resource/toolbar/")) {
+                    const uielem = uielems.getByName(i); // SLOW OPERATION
+                    if (uielem.getByName('Visible')) {
+                        uielem.setPropertyValue('Visible', false);
+                    }
+                }
+            }
+        }
+        this.config.commitChanges();
+    }
+    /**
+     * @param unoUrl - string following ".uno:" (e.g. "Bold")
+     */
+    transformUrl(unoUrl) {
+        const ioparam = { val: new this.css.util.URL({ Complete: '.uno:' + unoUrl }) };
+        this.css.util.URLTransformer.create(this.context).parseStrict(ioparam);
+        return ioparam.val;
+    }
+    queryDispatch(ctrl, urlObj) {
+        return ctrl.queryDispatch(urlObj, '_self', 0);
+    }
+    dispatch(ctrl, unoUrl, params = []) {
+        const urlObj = this.transformUrl(unoUrl);
+        this.queryDispatch(ctrl, urlObj).dispatch(urlObj, params);
+    }
+}
diff --git a/src/tests/pdf-tools.test.ts b/src/tests/pdf-tools.test.ts
index 6370e755..8c01723c 100644
--- a/src/tests/pdf-tools.test.ts
+++ b/src/tests/pdf-tools.test.ts
@@ -19,7 +19,7 @@ describe('Tool Configuration Arrays', () => {
 
     it('should have the correct number of tools', () => {
       // This acts as a snapshot test to catch unexpected additions/removals.
-      expect(singlePdfLoadTools).toHaveLength(39);
+      expect(singlePdfLoadTools).toHaveLength(40);
     });
 
     it('should not contain any duplicate tools', () => {
diff --git a/src/types/globals.d.ts b/src/types/globals.d.ts
index 48c971c3..f8fc6c9f 100644
--- a/src/types/globals.d.ts
+++ b/src/types/globals.d.ts
@@ -1 +1,9 @@
 declare const __SIMPLE_MODE__: boolean;
+
+interface Window {
+  FS: {
+    writeFile: (path: string, data: Uint8Array) => void;
+    readFile: (path: string) => Uint8Array;
+    unlink: (path: string) => void;
+  };
+}
\ No newline at end of file
diff --git a/vite.config.ts b/vite.config.ts
index a13454ed..4cf02f59 100644
--- a/vite.config.ts
+++ b/vite.config.ts
@@ -39,6 +39,12 @@ export default defineConfig(({ mode }) => ({
       },
     },
   },
+  server: {
+    headers: {
+      'Cross-Origin-Opener-Policy': 'same-origin',
+      'Cross-Origin-Embedder-Policy': 'require-corp',
+    },
+  },
   test: {
     globals: true,
     environment: 'jsdom',
@@ -55,4 +61,4 @@ export default defineConfig(({ mode }) => ({
       ],
     },
   },
-}));
+}));
\ No newline at end of file