From 6b076b2d42a746881b32a23b29e336450ec846a1 Mon Sep 17 00:00:00 2001
From: TomasPalsson <tomas2212042710@gmail.com>
Date: Fri, 2 Oct 2026 14:01:23 +0000
Subject: [PATCH] =?UTF-8?q?=F0=9F=96=BC=EF=B8=8F=20fix:=20Show=20EMF=20and?=
 =?UTF-8?q?=20WMF=20Pictures=20in=20PowerPoint=20Previews?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

pptx-preview turns EMF/WMF media into data:image/x-emf and
data:image/x-wmf URIs, which no browser decodes, so template logos
stored as Windows metafiles render as broken images in the artifact
panel. Convert them to SVG on the server with emf-converter (pinned
4.8.7, Apache-2.0, no dependencies), embed the SVGs keyed by a hash of
each entry's base64, and swap them into the rendered <img> elements
when the bootstrap finalizes.

Conversion is bounded per entry (512 KB, 10,000 records) and per deck
(64 entries, 8 MB input, 1 s, 384 KB of SVG). If the map would push a
deck past the preview cap, the deck is rendered without it, so no deck
that previews today changes path.
---
 api/package.json                              |   1 +
 package-lock.json                             |  30 ++++
 packages/api/package.json                     |   1 +
 .../files/documents/__tests__/emf.helper.ts   |  82 +++++++++
 packages/api/src/files/documents/html.spec.ts |  42 +++++
 packages/api/src/files/documents/html.ts      |  45 ++++-
 .../files/documents/metafiles.runtime.spec.ts |  86 +++++++++
 .../api/src/files/documents/metafiles.spec.ts |  97 +++++++++++
 packages/api/src/files/documents/metafiles.ts | 164 ++++++++++++++++++
 9 files changed, 543 insertions(+), 5 deletions(-)
 create mode 100644 packages/api/src/files/documents/__tests__/emf.helper.ts
 create mode 100644 packages/api/src/files/documents/metafiles.runtime.spec.ts
 create mode 100644 packages/api/src/files/documents/metafiles.spec.ts
 create mode 100644 packages/api/src/files/documents/metafiles.ts

diff --git a/api/package.json b/api/package.json
index 6e9c002a699..d0e65fc8ad0 100644
--- a/api/package.json
+++ b/api/package.json
@@ -76,6 +76,7 @@
     "dedent": "^1.5.3",
     "dompurify": "^3.4.16",
     "dotenv": "^16.0.3",
+    "emf-converter": "4.8.7",
     "eventsource": "^3.0.2",
     "express": "^5.2.1",
     "express-mongo-sanitize": "^2.2.0",
diff --git a/package-lock.json b/package-lock.json
index acf939a340f..1b1e53b3b57 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -95,6 +95,7 @@
         "dedent": "^1.5.3",
         "dompurify": "^3.4.16",
         "dotenv": "^16.0.3",
+        "emf-converter": "4.8.7",
         "eventsource": "^3.0.2",
         "express": "^5.2.1",
         "express-mongo-sanitize": "^2.2.0",
@@ -730,6 +731,20 @@
         "node": ">= 0.8.0"
       }
     },
+    "api/node_modules/emf-converter": {
+      "version": "4.8.7",
+      "resolved": "https://registry.npmjs.org/emf-converter/-/emf-converter-4.8.7.tgz",
+      "integrity": "sha512-oxnd2LVALXdVsIDlwInIH+kSYBB4+qSJsg0pPF5JqArSnH7G/FdbMwbdL4lHlYIWsX+VAOdt1bYlXLyZcuAqRw==",
+      "license": "Apache-2.0",
+      "peerDependencies": {
+        "@napi-rs/canvas": "^1.0.9"
+      },
+      "peerDependenciesMeta": {
+        "@napi-rs/canvas": {
+          "optional": true
+        }
+      }
+    },
     "api/node_modules/file-type": {
       "version": "21.3.2",
       "resolved": "https://registry.npmjs.org/file-type/-/file-type-21.3.2.tgz",
@@ -40763,6 +40778,7 @@
         "@simplewebauthn/server": "^13.3.2",
         "cluster-key-slot": "^1.1.2",
         "croner": "^10.0.1",
+        "emf-converter": "4.8.7",
         "express-rate-limit": "^8.5.1",
         "helmet": "^8.3.0",
         "proxy-from-env": "^2.1.0",
@@ -41250,6 +41266,20 @@
         "node": "^20.19.0 || >=22.12.0"
       }
     },
+    "packages/api/node_modules/emf-converter": {
+      "version": "4.8.7",
+      "resolved": "https://registry.npmjs.org/emf-converter/-/emf-converter-4.8.7.tgz",
+      "integrity": "sha512-oxnd2LVALXdVsIDlwInIH+kSYBB4+qSJsg0pPF5JqArSnH7G/FdbMwbdL4lHlYIWsX+VAOdt1bYlXLyZcuAqRw==",
+      "license": "Apache-2.0",
+      "peerDependencies": {
+        "@napi-rs/canvas": "^1.0.9"
+      },
+      "peerDependenciesMeta": {
+        "@napi-rs/canvas": {
+          "optional": true
+        }
+      }
+    },
     "packages/api/node_modules/get-tsconfig": {
       "version": "5.0.0-beta.5",
       "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-5.0.0-beta.5.tgz",
diff --git a/packages/api/package.json b/packages/api/package.json
index 39924f4ba15..7466c26761b 100644
--- a/packages/api/package.json
+++ b/packages/api/package.json
@@ -182,6 +182,7 @@
     "@simplewebauthn/server": "^13.3.2",
     "cluster-key-slot": "^1.1.2",
     "croner": "^10.0.1",
+    "emf-converter": "4.8.7",
     "express-rate-limit": "^8.5.1",
     "helmet": "^8.3.0",
     "proxy-from-env": "^2.1.0",
diff --git a/packages/api/src/files/documents/__tests__/emf.helper.ts b/packages/api/src/files/documents/__tests__/emf.helper.ts
new file mode 100644
index 00000000000..8a849077452
--- /dev/null
+++ b/packages/api/src/files/documents/__tests__/emf.helper.ts
@@ -0,0 +1,82 @@
+/** Minimal valid little-endian EMF: header, brush, select, rectangle, EOF. */
+export function buildEmf(): Buffer {
+  const parts: Buffer[] = [];
+  const rec = (type: number, size: number, ...ints: number[]): Buffer => {
+    const b = Buffer.alloc(size);
+    b.writeUInt32LE(type, 0);
+    b.writeUInt32LE(size, 4);
+    ints.forEach((v, i) => b.writeInt32LE(v | 0, 8 + i * 4));
+    return b;
+  };
+  const header = rec(
+    1,
+    108,
+    0,
+    0,
+    99,
+    49, // bounds
+    0,
+    0,
+    2645,
+    1322, // frame
+    0x464d4520, // signature
+    0x10000, // version
+    0, // bytes (patched below)
+    5, // records
+    2, // handles (u32 + reserved u16 packed)
+    0, // nDescription
+    0, // offDescription
+    0, // nPalEntries
+    1920,
+    1080, // device
+    508,
+    286, // millimeters
+  );
+  parts.push(header);
+  parts.push(rec(39, 24, 1, 0, 0x00ff0000, 0));
+  parts.push(rec(37, 12, 1));
+  parts.push(rec(43, 24, 0, 0, 99, 49));
+  parts.push(rec(14, 20, 0, 16, 20));
+  const out = Buffer.concat(parts);
+  out.writeUInt32LE(out.length, 48);
+  return out;
+}
+
+/** Placeable WMF: header, SETWINDOWEXT, RECTANGLE, EOF. */
+export function buildWmf(): Buffer {
+  const rec = (func: number, ...words: number[]): Buffer => {
+    const b = Buffer.alloc(6 + words.length * 2);
+    b.writeUInt32LE(b.length / 2, 0);
+    b.writeUInt16LE(func, 4);
+    words.forEach((w, i) => b.writeInt16LE(w, 6 + i * 2));
+    return b;
+  };
+  const placeable = Buffer.alloc(22);
+  placeable.writeUInt32LE(0x9ac6cdd7, 0);
+  placeable.writeInt16LE(99, 10);
+  placeable.writeInt16LE(49, 12);
+  placeable.writeUInt16LE(1440, 14);
+  const header = Buffer.alloc(18);
+  header.writeUInt16LE(1, 0);
+  header.writeUInt16LE(9, 2);
+  header.writeUInt16LE(0x300, 4);
+  const body = Buffer.concat([rec(0x020c, 49, 99), rec(0x041b, 49, 99, 0, 0), rec(0)]);
+  header.writeUInt32LE((18 + body.length) / 2, 6);
+  return Buffer.concat([placeable, header, body]);
+}
+
+/** EMF with `n` no-output SETBKMODE records between the header and EOF. */
+export function buildEmfWithRecords(n: number): Buffer {
+  const base = buildEmf();
+  const ellipse = Buffer.alloc(12);
+  ellipse.writeUInt32LE(18, 0);
+  ellipse.writeUInt32LE(12, 4);
+  ellipse.writeUInt32LE(1, 8);
+  const out = Buffer.concat([
+    base.subarray(0, base.length - 20),
+    ...Array(n).fill(ellipse),
+    base.subarray(base.length - 20),
+  ]);
+  out.writeUInt32LE(out.length, 48);
+  return out;
+}
diff --git a/packages/api/src/files/documents/html.spec.ts b/packages/api/src/files/documents/html.spec.ts
index e320abddf9c..c6577e1dde3 100644
--- a/packages/api/src/files/documents/html.spec.ts
+++ b/packages/api/src/files/documents/html.spec.ts
@@ -14,6 +14,8 @@ import {
   wordDocToHtml,
 } from './html';
 import { ZipBombError } from './zipSafety';
+import * as metafiles from './metafiles';
+import { buildEmf } from './__tests__/emf.helper';
 
 const fixturesDir = __dirname;
 const readFixture = (name: string): Buffer => fs.readFileSync(path.join(fixturesDir, name));
@@ -412,6 +414,46 @@ describe('Office HTML producers', () => {
       return zip.generateAsync({ type: 'nodebuffer' });
     };
 
+    describe('EMF/WMF metafile swap', () => {
+      const withEmf = async (): Promise<Buffer> => {
+        const zip = await JSZip.loadAsync(await buildPptx([{ title: 'T' }]));
+        zip.file('ppt/media/image1.emf', buildEmf());
+        return zip.generateAsync({ type: 'nodebuffer' });
+      };
+
+      afterEach(() => jest.restoreAllMocks());
+
+      test('embeds converted SVGs for pptx metafiles', async () => {
+        const html = await pptxToHtml(await withEmf());
+        expect(html).toContain('id="lc-metafiles"');
+        expect(html).toContain(metafiles.metafileKey(buildEmf().toString('base64')));
+        expect(html).toContain('swapMetafiles');
+      });
+
+      test('escapes < in the JSON block so </script> cannot break out', async () => {
+        const html = await _internal.pptxToHtmlViaCdn(await buildPptx([{ title: 'X' }]), '', {
+          k: 'data:x</script><b>',
+        });
+        const block = html.split('id="lc-metafiles"')[1].split('</script>')[0];
+        expect(block).toContain('\\u003c/script>');
+        expect(block).not.toContain('</script>');
+        expect(html).toContain('\\u003c/script>');
+      });
+
+      test('omits the block when there are no metafiles', async () => {
+        const html = await pptxToHtml(await buildPptx([{ title: 'T' }]));
+        expect(html).not.toContain('id="lc-metafiles"');
+      });
+
+      test('drops the map, keeping the CDN doc, when it would exceed the output cap', async () => {
+        const huge = { k: 'a'.repeat(_internal.OFFICE_HTML_OUTPUT_CAP) };
+        jest.spyOn(metafiles, 'extractPptxMetafileSvgs').mockResolvedValue(huge);
+        const html = await pptxToHtml(await buildPptx([{ title: 'T' }]));
+        expect(html).toContain('cdn.jsdelivr.net/npm/pptx-preview@');
+        expect(html).not.toContain('id="lc-metafiles"');
+      });
+    });
+
     test('routes a small pptx (≤ cap) through the CDN-rendered path', async () => {
       const pptx = await buildPptx([{ title: 'Hello', body: ['First slide'] }]);
       const html = await pptxToHtml(pptx);
diff --git a/packages/api/src/files/documents/html.ts b/packages/api/src/files/documents/html.ts
index 2ee0ff163b9..88b10e1eeb0 100644
--- a/packages/api/src/files/documents/html.ts
+++ b/packages/api/src/files/documents/html.ts
@@ -1,6 +1,7 @@
 import yauzl from 'yauzl';
 import { excelMimeTypes, megabyte } from 'librechat-data-provider';
 import { tryLibreOfficePreview } from './libreoffice';
+import { METAFILE_KEY_JS, extractPptxMetafileSvgs } from './metafiles';
 import { assertSafeZipSize } from './zipSafety';
 
 /**
@@ -1080,7 +1081,17 @@ const MAX_PPTX_CDN_BINARY_BYTES = 350 * 1024;
  * iframe via `transform: scale(...)`. The slides scroll vertically
  * once the renderer paints them.
  */
-function buildPptxCdnDocument(base64: string, slideListFallbackBody: string): string {
+function buildPptxCdnDocument(
+  base64: string,
+  slideListFallbackBody: string,
+  metafileSvgs: Record<string, string> = {},
+): string {
+  /* Server-converted EMF/WMF → SVG map. `<` is escaped so a value can
+   * never close the script element. */
+  const metafileBlock =
+    Object.keys(metafileSvgs).length > 0
+      ? `<script id="lc-metafiles" type="application/json">${JSON.stringify(metafileSvgs).replace(/</g, '\\u003c')}</script>\n`
+      : '';
   /* PPTX-specific CSP relaxations vs DOCX:
    *   - `worker-src blob:` — pptx-preview's bundled echarts dep spins up
    *     Web Workers via blob: URLs for chart rendering. Without this,
@@ -1172,9 +1183,10 @@ ${PPTX_SLIDE_LIST_CSS}
   </details>
 </div>
 <script id="lc-doc-data" type="application/octet-stream;base64">${base64}</script>
-<script>
+${metafileBlock}<script>
 (function () {
   var settled = false;
+  var metafileKey = ${METAFILE_KEY_JS};
   function showFallback(reason) {
     if (settled) { return; }
     settled = true;
@@ -1341,8 +1353,19 @@ ${PPTX_SLIDE_LIST_CSS}
       return false;
     }
 
+    function swapMetafiles() {
+      try {
+        var m = JSON.parse(document.getElementById('lc-metafiles').textContent);
+        container.querySelectorAll('img[src^="data:image/x-emf;"],img[src^="data:image/x-wmf;"]').forEach(function (i) {
+          var u = m[metafileKey(i.getAttribute('src').split(',')[1])];
+          if (u) { i.src = u; }
+        });
+      } catch (e) {}
+    }
+
     function finalize() {
       wrapSlides();
+      swapMetafiles();
       if (!hasRenderedContent()) {
         showFallback('renderer-empty-slide-list');
         return;
@@ -1403,8 +1426,12 @@ async function renderPptxSlidesBodyForBuffer(buffer: Buffer): Promise<string> {
   return renderPptxSlidesBody(slides);
 }
 
-async function pptxToHtmlViaCdn(buffer: Buffer, slideListFallbackBody: string): Promise<string> {
-  return buildPptxCdnDocument(buffer.toString('base64'), slideListFallbackBody);
+async function pptxToHtmlViaCdn(
+  buffer: Buffer,
+  slideListFallbackBody: string,
+  metafileSvgs: Record<string, string> = {},
+): Promise<string> {
+  return buildPptxCdnDocument(buffer.toString('base64'), slideListFallbackBody, metafileSvgs);
 }
 
 /**
@@ -1446,12 +1473,20 @@ export async function pptxToHtml(buffer: Buffer): Promise<string> {
    * the empty-render case and reveals this slide-list fallback so the
    * user always gets readable content. Manual e2e on PR #12934. */
   const slideListBody = await renderPptxSlidesBodyForBuffer(buffer);
-  const cdnDoc = await pptxToHtmlViaCdn(buffer, slideListBody);
+  const metafileSvgs = await extractPptxMetafileSvgs(buffer);
+  const cdnDoc = await pptxToHtmlViaCdn(buffer, slideListBody, metafileSvgs);
   /* Combined size budget: if base64 binary + slide-list fallback +
    * wrapper would exceed the cache cap, drop CDN entirely and ship
    * the slide-list standalone. Same pattern as the DOCX dispatcher's
    * size budget. */
   if (Buffer.byteLength(cdnDoc, 'utf-8') > OFFICE_HTML_OUTPUT_CAP) {
+    const plainDoc = await pptxToHtmlViaCdn(buffer, slideListBody);
+    if (
+      Object.keys(metafileSvgs).length > 0 &&
+      Buffer.byteLength(plainDoc, 'utf-8') <= OFFICE_HTML_OUTPUT_CAP
+    ) {
+      return plainDoc;
+    }
     return pptxToSlideListHtmlInternal(buffer);
   }
   return cdnDoc;
diff --git a/packages/api/src/files/documents/metafiles.runtime.spec.ts b/packages/api/src/files/documents/metafiles.runtime.spec.ts
new file mode 100644
index 00000000000..49dac0c8710
--- /dev/null
+++ b/packages/api/src/files/documents/metafiles.runtime.spec.ts
@@ -0,0 +1,86 @@
+import JSZip from 'jszip';
+import { JSDOM } from 'jsdom';
+import { pptxToHtml } from './html';
+import { buildEmf } from './__tests__/emf.helper';
+
+const PNG = 'data:image/png;base64,iVBORw0KGgo=';
+
+const buildPptx = async (withEmf: boolean): Promise<Buffer> => {
+  const zip = new JSZip();
+  zip.file(
+    '[Content_Types].xml',
+    '<?xml version="1.0"?><Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"/>',
+  );
+  zip.file(
+    'ppt/slides/slide1.xml',
+    '<p:sld xmlns:p="p" xmlns:a="a"><a:p><a:r><a:t>Title</a:t></a:r></a:p></p:sld>',
+  );
+  if (withEmf) {
+    zip.file('ppt/media/image1.emf', buildEmf());
+  }
+  return zip.generateAsync({ type: 'nodebuffer' });
+};
+
+/**
+ * Loads the generated iframe document into jsdom with a fake `pptxPreview`
+ * that mimics pptx-preview's metafile output, and resolves once the
+ * bootstrap's finalize() has wrapped the slides.
+ */
+const doms: JSDOM[] = [];
+
+async function runIframe(html: string): Promise<Document> {
+  const emfB64 = buildEmf().toString('base64');
+  const doc = html.replace(/<script[^>]*src=[^>]*><\/script>/g, '');
+  const dom = new JSDOM(doc, {
+    runScripts: 'dangerously',
+    beforeParse(window) {
+      (window as unknown as Record<string, unknown>).pptxPreview = {
+        init: (container: HTMLElement) => ({
+          preview: async () => {
+            const wrapper = window.document.createElement('div');
+            wrapper.className = 'pptx-preview-slide-wrapper';
+            wrapper.innerHTML =
+              `<img id="emf" src="data:image/x-emf;base64,${emfB64}">` +
+              `<img id="png" src="${PNG}">`;
+            container.appendChild(wrapper);
+            return { slides: [{}] };
+          },
+        }),
+      };
+    },
+  });
+  doms.push(dom);
+  const { document } = dom.window;
+  for (let i = 0; i < 100 && !document.querySelector('.lc-slide-wrap'); i++) {
+    await new Promise((r) => setTimeout(r, 10));
+  }
+  expect(document.querySelector('.lc-slide-wrap')).not.toBeNull();
+  return document;
+}
+
+describe('pptx iframe metafile swap (runtime)', () => {
+  /* closing the window clears the bootstrap's 8s safety-net timer */
+  afterEach(() => doms.splice(0).forEach((d) => d.window.close()));
+
+  test('replaces the x-emf img src with the converted SVG and leaves other images alone', async () => {
+    const html = await pptxToHtml(await buildPptx(true));
+    expect(html).toContain('id="lc-metafiles"');
+    const document = await runIframe(html);
+    expect(document.getElementById('emf')?.getAttribute('src')).toMatch(
+      /^data:image\/svg\+xml;base64,/,
+    );
+    expect(document.getElementById('png')?.getAttribute('src')).toBe(PNG);
+    expect(document.getElementById('lc-fallback')?.hasAttribute('hidden')).toBe(true);
+  });
+
+  test('without a metafile map the emf src is unchanged and the fallback stays hidden', async () => {
+    const html = await pptxToHtml(await buildPptx(false));
+    expect(html).not.toContain('id="lc-metafiles"');
+    const document = await runIframe(html);
+    expect(document.getElementById('emf')?.getAttribute('src')).toMatch(
+      /^data:image\/x-emf;base64,/,
+    );
+    expect(document.getElementById('png')?.getAttribute('src')).toBe(PNG);
+    expect(document.getElementById('lc-fallback')?.hasAttribute('hidden')).toBe(true);
+  });
+});
diff --git a/packages/api/src/files/documents/metafiles.spec.ts b/packages/api/src/files/documents/metafiles.spec.ts
new file mode 100644
index 00000000000..d1493c2f560
--- /dev/null
+++ b/packages/api/src/files/documents/metafiles.spec.ts
@@ -0,0 +1,97 @@
+import JSZip from 'jszip';
+import { convertMetafileToSvg } from 'emf-converter';
+import { buildEmf, buildWmf, buildEmfWithRecords } from './__tests__/emf.helper';
+import {
+  extractPptxMetafileSvgs,
+  metafileKey,
+  METAFILE_KEY_JS,
+  withinRecordBudget,
+} from './metafiles';
+
+const buildZip = async (files: Record<string, Buffer | string>): Promise<Buffer> => {
+  const zip = new JSZip();
+  for (const [name, data] of Object.entries(files)) {
+    zip.file(name, data);
+  }
+  return zip.generateAsync({ type: 'nodebuffer' });
+};
+
+describe('metafiles', () => {
+  const emf = buildEmf();
+
+  test('fixture converts with emf-converter', async () => {
+    const ab = emf.buffer.slice(emf.byteOffset, emf.byteOffset + emf.byteLength);
+    const svg = await convertMetafileToSvg(ab as ArrayBuffer, { idPrefix: 'x-' });
+    expect(svg).toContain('<svg');
+  });
+
+  test('extracts only convertible emf/wmf entries, keyed by base64 hash', async () => {
+    const pptx = await buildZip({
+      'ppt/media/image1.emf': emf,
+      'ppt/media/image2.png': Buffer.from([1, 2, 3]),
+      'ppt/media/logo.emf': emf,
+      'ppt/media/image3.emf': Buffer.from('garbage bytes that are not an emf'),
+    });
+    const map = await extractPptxMetafileSvgs(pptx);
+    expect(Object.keys(map)).toEqual([metafileKey(emf.toString('base64'))]);
+    const value = Object.values(map)[0];
+    expect(value.startsWith('data:image/svg+xml;base64,')).toBe(true);
+    expect(
+      Buffer.from(value.slice('data:image/svg+xml;base64,'.length), 'base64').toString(),
+    ).toContain('<svg');
+  });
+
+  test('converts a .wmf entry', async () => {
+    const wmf = buildWmf();
+    const map = await extractPptxMetafileSvgs(await buildZip({ 'ppt/media/image1.wmf': wmf }));
+    expect(Object.keys(map)).toEqual([metafileKey(wmf.toString('base64'))]);
+  });
+
+  test('skips a metafile over the record budget without converting it', async () => {
+    const hostile = buildEmfWithRecords(10_001);
+    const ok = buildEmfWithRecords(100);
+    expect(withinRecordBudget(hostile)).toBe(false);
+    expect(withinRecordBudget(ok)).toBe(true);
+    const started = Date.now();
+    const map = await extractPptxMetafileSvgs(
+      await buildZip({ 'ppt/media/image1.emf': hostile, 'ppt/media/image2.emf': ok }),
+    );
+    expect(Object.keys(map)).toEqual([metafileKey(ok.toString('base64'))]);
+    expect(Date.now() - started).toBeLessThan(2000);
+  });
+
+  test('skips a metafile over the per-file byte cap', async () => {
+    const wmf = buildWmf();
+    const pptx = await buildZip({
+      'ppt/media/image2.wmf': wmf,
+      'ppt/media/image9.emf': Buffer.alloc(512 * 1024 + 1),
+    });
+    const map = await extractPptxMetafileSvgs(pptx);
+    expect(Object.keys(map)).toEqual([metafileKey(wmf.toString('base64'))]);
+  });
+
+  test('resolves {} for a non-zip buffer', async () => {
+    await expect(extractPptxMetafileSvgs(Buffer.from('not a zip'))).resolves.toEqual({});
+  });
+
+  test('stops converting once the time budget is spent', async () => {
+    const blue = Buffer.from(emf);
+    blue.writeInt32LE(0x000000ff, 108 + 16);
+    const pptx = await buildZip({ 'ppt/media/image1.emf': emf, 'ppt/media/image2.emf': blue });
+    const now = jest.spyOn(Date, 'now');
+    now.mockReturnValueOnce(0).mockReturnValueOnce(0).mockReturnValue(10_000);
+    try {
+      const map = await extractPptxMetafileSvgs(pptx);
+      expect(Object.keys(map)).toEqual([metafileKey(emf.toString('base64'))]);
+    } finally {
+      now.mockRestore();
+    }
+  });
+
+  test('METAFILE_KEY_JS matches metafileKey', () => {
+    const fn = new Function('return (' + METAFILE_KEY_JS + ')')() as (s: string) => string;
+    for (const s of ['', 'abc', Buffer.alloc(52500, 7).toString('base64')]) {
+      expect(fn(s)).toBe(metafileKey(s));
+    }
+  });
+});
diff --git a/packages/api/src/files/documents/metafiles.ts b/packages/api/src/files/documents/metafiles.ts
new file mode 100644
index 00000000000..cce60d60678
--- /dev/null
+++ b/packages/api/src/files/documents/metafiles.ts
@@ -0,0 +1,164 @@
+import yauzl from 'yauzl';
+import { logger } from '@librechat/data-schemas';
+import { convertMetafileToSvg } from 'emf-converter';
+import { megabyte } from 'librechat-data-provider';
+
+/* Browsers cannot decode EMF/WMF, so pptx-preview's `<img>` for them is
+ * broken. We convert on the server and let the iframe swap them in. */
+const METAFILE_NAME = /^ppt\/media\/image[^/]*\.(emf|wmf)$/i;
+const MAX_METAFILES = 64;
+const MAX_METAFILE_BYTES = 512 * 1024;
+const MAX_SVG_BYTES = 256 * 1024;
+const MAX_TOTAL_SVG_BYTES = 384 * 1024;
+/* Conversion is synchronous CPU work on the event loop; these bound a hostile
+ * deck. The time budget is only checked between entries, so a single entry is
+ * bounded up front by its byte size and by walking its record headers (cheap)
+ * against MAX_METAFILE_RECORDS: ~0.85 s worst measured for either limit. Real
+ * template logos are tens of KB and convert in a few ms. */
+const MAX_METAFILE_RECORDS = 10_000;
+const MAX_TOTAL_METAFILE_BYTES = 8 * megabyte;
+const MAX_CONVERT_MS = 1000;
+
+/** FNV-1a 32-bit over UTF-16 code units; must match `METAFILE_KEY_JS`. */
+export function metafileKey(base64: string): string {
+  let h = 0x811c9dc5;
+  for (let i = 0; i < base64.length; i++) {
+    h ^= base64.charCodeAt(i);
+    h = Math.imul(h, 0x01000193) >>> 0;
+  }
+  return h.toString(16) + ':' + base64.length;
+}
+
+/** Same algorithm as `metafileKey`, as ES5 source for the iframe bootstrap. */
+export const METAFILE_KEY_JS =
+  'function(s){var h=0x811c9dc5;for(var i=0;i<s.length;i++){h^=s.charCodeAt(i);h=Math.imul(h,0x01000193)>>>0}return h.toString(16)+":"+s.length}';
+
+function readEntryBuffer(zipfile: yauzl.ZipFile, entry: yauzl.Entry): Promise<Buffer | null> {
+  return new Promise((resolve) => {
+    zipfile.openReadStream(entry, (err, stream) => {
+      if (err || !stream) {
+        return resolve(null);
+      }
+      const chunks: Buffer[] = [];
+      let total = 0;
+      stream.on('data', (chunk: Buffer) => {
+        total += chunk.byteLength;
+        if (total > MAX_METAFILE_BYTES) {
+          stream.destroy();
+          return resolve(null);
+        }
+        chunks.push(chunk);
+      });
+      stream.on('end', () => resolve(Buffer.concat(chunks)));
+      stream.on('error', () => resolve(null));
+    });
+  });
+}
+
+/** True when the EMF/WMF record chain is walkable and has at most MAX_METAFILE_RECORDS. */
+export function withinRecordBudget(b: Buffer): boolean {
+  const isEmf = b.length >= 44 && b.readUInt32LE(0) === 1 && b.readUInt32LE(40) === 0x464d4520;
+  let offset = 0;
+  if (!isEmf) {
+    if (b.length >= 4 && b.readUInt32LE(0) === 0x9ac6cdd7) {
+      offset = 22; /* placeable header */
+    }
+    offset += 18; /* standard WMF header */
+  }
+  let count = 0;
+  while (offset + 8 <= b.length) {
+    const size = isEmf ? b.readUInt32LE(offset + 4) : b.readUInt32LE(offset) * 2;
+    if (++count > MAX_METAFILE_RECORDS) {
+      return false;
+    }
+    if (size < (isEmf ? 8 : 6)) {
+      break;
+    }
+    offset += size;
+  }
+  return true;
+}
+
+async function convertToDataUri(bytes: Buffer, index: number): Promise<string | null> {
+  if (!withinRecordBudget(bytes)) {
+    logger.debug('[pptx] skipping metafile over the record budget');
+    return null;
+  }
+  try {
+    const ab = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+    const svg = await convertMetafileToSvg(ab as ArrayBuffer, { idPrefix: `lc-mf${index}-` });
+    const svgBytes = svg ? Buffer.from(svg, 'utf-8') : null;
+    if (!svgBytes || svgBytes.length > MAX_SVG_BYTES) {
+      return null;
+    }
+    return 'data:image/svg+xml;base64,' + svgBytes.toString('base64');
+  } catch (err) {
+    logger.debug(`[pptx] skipping unconvertible metafile: ${(err as Error).message}`);
+    return null;
+  }
+}
+
+/**
+ * Convert the EMF/WMF media of a PPTX to SVG data URIs, keyed by
+ * `metafileKey` of the entry's base64 (what pptx-preview puts in `img.src`).
+ * Never rejects; unreadable zips and corrupt metafiles yield fewer entries.
+ */
+export function extractPptxMetafileSvgs(buffer: Buffer): Promise<Record<string, string>> {
+  return new Promise((resolve) => {
+    yauzl.fromBuffer(buffer, { lazyEntries: true }, (err, zipfile) => {
+      if (err || !zipfile) {
+        return resolve({});
+      }
+      const result: Record<string, string> = {};
+      let considered = 0;
+      let totalSvgBytes = 0;
+      let totalMetafileBytes = 0;
+      const startedAt = Date.now();
+      let settled = false;
+      const finish = () => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        try {
+          zipfile.close();
+        } catch {
+          /* best-effort, as in extractPptxSlideXml */
+        }
+        resolve(result);
+      };
+
+      zipfile.on('entry', async (entry: yauzl.Entry) => {
+        try {
+          if (
+            !/\/$/.test(entry.fileName) &&
+            METAFILE_NAME.test(entry.fileName) &&
+            considered < MAX_METAFILES &&
+            entry.uncompressedSize <= MAX_METAFILE_BYTES
+          ) {
+            totalMetafileBytes += entry.uncompressedSize;
+            if (
+              totalMetafileBytes > MAX_TOTAL_METAFILE_BYTES ||
+              Date.now() - startedAt > MAX_CONVERT_MS
+            ) {
+              return finish();
+            }
+            const index = considered++;
+            const bytes = await readEntryBuffer(zipfile, entry);
+            const uri = bytes && (await convertToDataUri(bytes, index));
+            if (bytes && uri && totalSvgBytes + uri.length <= MAX_TOTAL_SVG_BYTES) {
+              totalSvgBytes += uri.length;
+              result[metafileKey(bytes.toString('base64'))] = uri;
+            }
+          }
+        } catch (e) {
+          logger.debug(`[pptx] metafile extraction error: ${(e as Error).message}`);
+        }
+        zipfile.readEntry();
+      });
+      zipfile.on('end', finish);
+      zipfile.on('error', finish);
+      zipfile.readEntry();
+    });
+  });
+}