From bca116ce662368114a7013f6fffdbc2bf5950e11 Mon Sep 17 00:00:00 2001
From: Haoqing Wang <1506751656@qq.com>
Date: Sat, 18 Apr 2026 12:22:03 +0800
Subject: [PATCH 1/2] feat(core,exporters,desktop): end-to-end first demo +
 HTML export
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Wires the full prompt → artifact → preview → export loop so the README's
"first demo" actually produces a design when an API key is provided.

- packages/templates: externalize the design-generator system prompt as
  SYSTEM_PROMPTS.designGenerator with a sibling design-generator.md for
  reviewable diffs. Replaces the inline string previously hard-coded in
  packages/core. Prompt embeds the research-backed Claude Design rules
  (single artifact, Tailwind CDN, semantic HTML, CSS variable tokens,
  WCAG AA, no lorem ipsum).
- packages/core: pull SYSTEM_PROMPTS.designGenerator from templates,
  collapse the duplicated artifact-extraction loop into a `collect()`
  helper, add generate.test.ts (mocks the providers boundary, asserts
  empty-prompt error, artifact extraction shape, system-prompt wiring).
- packages/exporters: real exportHtml() that ensures a doctype, injects
  the Tailwind CDN tag if missing, stamps a generator meta/banner, and
  pretty-prints. PDF / PPTX / ZIP each throw CodesignError with code
  EXPORTER_NOT_READY ("ships in Phase 2") — no silent fallbacks
  (PRINCIPLES §10). Top-level exportArtifact() dispatches lazily so
  unused formats stay out of the cold-start bundle (PRINCIPLES §1).
- apps/desktop: codesign:export IPC backed by Electron dialog
  showSaveDialog, validates payload via CodesignError, propagates
  Phase-2 errors loudly. Preload exposes window.codesign.export().
  Store gains exportActive(format) + a toast slot. PreviewToolbar
  renders an Export dropdown with HTML enabled and PDF/PPTX/ZIP
  disabled with "Coming in Phase 2" tooltips.
- TIER 1 / dev-only fallback: store reads VITE_OPEN_CODESIGN_DEV_KEY
  so the demo runs before wt/onboarding lands real keychain plumbing.
  Marked clearly for removal in the integration commit.
- examples/calm-spaces: README documents the demo + expected behaviour
  + intentional loud failure modes.

No new third-party dependencies. All UI uses var(--color-*) tokens.

Acceptance test (manual):
  VITE_OPEN_CODESIGN_DEV_KEY=sk-ant-... \
    pnpm --filter @open-codesign/desktop dev
  → click "Calm Spaces meditation app" → Send → iframe renders
  → Export → HTML → /tmp/out.html → open in browser
  → Export → PDF → toast "PDF export ships in Phase 2"

Signed-off-by: Haoqing Wang <1506751656@qq.com>
---
 apps/desktop/package.json                     |   1 +
 apps/desktop/src/main/exporter-ipc.ts         |  65 +++++++
 apps/desktop/src/main/index.ts                |   2 +
 apps/desktop/src/preload/index.ts             |   9 +
 apps/desktop/src/renderer/src/App.tsx         |   3 +-
 .../src/components/PreviewToolbar.tsx         |  95 ++++++++++
 apps/desktop/src/renderer/src/store.ts        |  50 +++++-
 examples/calm-spaces/README.md                |  51 ++++++
 packages/core/package.json                    |   3 +-
 packages/core/src/generate.test.ts            |  84 +++++++++
 packages/core/src/index.ts                    |  68 +++-----
 packages/exporters/package.json               |   1 +
 packages/exporters/src/html.ts                | 163 ++++++++++++++++++
 packages/exporters/src/index.ts               |  46 +++--
 packages/exporters/src/pdf.ts                 |   9 +
 packages/exporters/src/pptx.ts                |   9 +
 packages/exporters/src/zip.ts                 |   9 +
 packages/templates/src/index.ts               |   2 +
 .../templates/src/system/design-generator.md  |  78 +++++++++
 packages/templates/src/system/index.ts        |  54 ++++++
 pnpm-lock.yaml                                |   6 +
 21 files changed, 749 insertions(+), 59 deletions(-)
 create mode 100644 apps/desktop/src/main/exporter-ipc.ts
 create mode 100644 apps/desktop/src/renderer/src/components/PreviewToolbar.tsx
 create mode 100644 examples/calm-spaces/README.md
 create mode 100644 packages/core/src/generate.test.ts
 create mode 100644 packages/exporters/src/html.ts
 create mode 100644 packages/exporters/src/pdf.ts
 create mode 100644 packages/exporters/src/pptx.ts
 create mode 100644 packages/exporters/src/zip.ts
 create mode 100644 packages/templates/src/system/design-generator.md
 create mode 100644 packages/templates/src/system/index.ts

diff --git a/apps/desktop/package.json b/apps/desktop/package.json
index 1c5c12ff..0b9f20f6 100644
--- a/apps/desktop/package.json
+++ b/apps/desktop/package.json
@@ -14,6 +14,7 @@
   "dependencies": {
     "@open-codesign/artifacts": "workspace:*",
     "@open-codesign/core": "workspace:*",
+    "@open-codesign/exporters": "workspace:*",
     "@open-codesign/providers": "workspace:*",
     "@open-codesign/runtime": "workspace:*",
     "@open-codesign/shared": "workspace:*",
diff --git a/apps/desktop/src/main/exporter-ipc.ts b/apps/desktop/src/main/exporter-ipc.ts
new file mode 100644
index 00000000..b0e03438
--- /dev/null
+++ b/apps/desktop/src/main/exporter-ipc.ts
@@ -0,0 +1,65 @@
+import { type ExporterFormat, exportArtifact } from '@open-codesign/exporters';
+import { CodesignError } from '@open-codesign/shared';
+import { type BrowserWindow, dialog, ipcMain } from 'electron';
+
+const FORMAT_FILTERS: Record<ExporterFormat, Electron.FileFilter[]> = {
+  html: [{ name: 'HTML', extensions: ['html'] }],
+  pdf: [{ name: 'PDF', extensions: ['pdf'] }],
+  pptx: [{ name: 'PowerPoint', extensions: ['pptx'] }],
+  zip: [{ name: 'ZIP archive', extensions: ['zip'] }],
+};
+
+export interface ExportRequest {
+  format: ExporterFormat;
+  htmlContent: string;
+  defaultFilename?: string;
+}
+
+export interface ExportResponse {
+  status: 'saved' | 'cancelled';
+  path?: string;
+  bytes?: number;
+}
+
+function parseRequest(raw: unknown): ExportRequest {
+  if (raw === null || typeof raw !== 'object') {
+    throw new CodesignError('export expects an object payload', 'IPC_BAD_INPUT');
+  }
+  const r = raw as Record<string, unknown>;
+  const format = r['format'];
+  const html = r['htmlContent'];
+  const defaultFilename = r['defaultFilename'];
+  if (format !== 'html' && format !== 'pdf' && format !== 'pptx' && format !== 'zip') {
+    throw new CodesignError(`Unknown export format: ${String(format)}`, 'EXPORTER_UNKNOWN');
+  }
+  if (typeof html !== 'string' || html.length === 0) {
+    throw new CodesignError('export requires non-empty htmlContent', 'IPC_BAD_INPUT');
+  }
+  const out: ExportRequest = { format, htmlContent: html };
+  if (typeof defaultFilename === 'string' && defaultFilename.length > 0) {
+    out.defaultFilename = defaultFilename;
+  }
+  return out;
+}
+
+export function registerExporterIpc(getWindow: () => BrowserWindow | null): void {
+  ipcMain.handle('codesign:export', async (_evt, raw: unknown): Promise<ExportResponse> => {
+    const req = parseRequest(raw);
+    const win = getWindow();
+    const opts: Electron.SaveDialogOptions = {
+      title: `Export design as ${req.format.toUpperCase()}`,
+      defaultPath: req.defaultFilename ?? `design.${req.format}`,
+      filters: FORMAT_FILTERS[req.format],
+    };
+    const picked = win ? await dialog.showSaveDialog(win, opts) : await dialog.showSaveDialog(opts);
+    if (picked.canceled || !picked.filePath) {
+      return { status: 'cancelled' };
+    }
+
+    // Tier 1: HTML succeeds, others throw EXPORTER_NOT_READY. We deliberately
+    // do NOT swallow the error here — let it propagate so the renderer can
+    // surface it as a toast (PRINCIPLES §10).
+    const result = await exportArtifact(req.format, req.htmlContent, picked.filePath);
+    return { status: 'saved', path: result.path, bytes: result.bytes };
+  });
+}
diff --git a/apps/desktop/src/main/index.ts b/apps/desktop/src/main/index.ts
index f23cae02..797664d0 100644
--- a/apps/desktop/src/main/index.ts
+++ b/apps/desktop/src/main/index.ts
@@ -5,6 +5,7 @@ import { detectProviderFromKey } from '@open-codesign/providers';
 import { BRAND, CodesignError, GeneratePayload } from '@open-codesign/shared';
 import { BrowserWindow, app, ipcMain, shell } from 'electron';
 import { autoUpdater } from 'electron-updater';
+import { registerExporterIpc } from './exporter-ipc';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -78,6 +79,7 @@ function setupAutoUpdater(): void {
 
 void app.whenReady().then(() => {
   registerIpcHandlers();
+  registerExporterIpc(() => mainWindow);
   setupAutoUpdater();
   createWindow();
 
diff --git a/apps/desktop/src/preload/index.ts b/apps/desktop/src/preload/index.ts
index 1c32bf40..eaeaf510 100644
--- a/apps/desktop/src/preload/index.ts
+++ b/apps/desktop/src/preload/index.ts
@@ -1,6 +1,13 @@
 import type { ChatMessage, ModelRef } from '@open-codesign/shared';
 import { contextBridge, ipcRenderer } from 'electron';
 
+export type ExportFormat = 'html' | 'pdf' | 'pptx' | 'zip';
+export interface ExportInvokeResponse {
+  status: 'saved' | 'cancelled';
+  path?: string;
+  bytes?: number;
+}
+
 const api = {
   detectProvider: (key: string) =>
     ipcRenderer.invoke('codesign:detect-provider', key) as Promise<string | null>,
@@ -11,6 +18,8 @@ const api = {
     apiKey: string;
     baseUrl?: string;
   }) => ipcRenderer.invoke('codesign:generate', payload),
+  export: (payload: { format: ExportFormat; htmlContent: string; defaultFilename?: string }) =>
+    ipcRenderer.invoke('codesign:export', payload) as Promise<ExportInvokeResponse>,
   checkForUpdates: () => ipcRenderer.invoke('codesign:check-for-updates'),
   downloadUpdate: () => ipcRenderer.invoke('codesign:download-update'),
   installUpdate: () => ipcRenderer.invoke('codesign:install-update'),
diff --git a/apps/desktop/src/renderer/src/App.tsx b/apps/desktop/src/renderer/src/App.tsx
index e761430c..71809e40 100644
--- a/apps/desktop/src/renderer/src/App.tsx
+++ b/apps/desktop/src/renderer/src/App.tsx
@@ -3,6 +3,7 @@ import { BUILTIN_DEMOS } from '@open-codesign/templates';
 import { Button } from '@open-codesign/ui';
 import { Send, Sparkles } from 'lucide-react';
 import { useState } from 'react';
+import { PreviewToolbar } from './components/PreviewToolbar';
 import { useCodesignStore } from './store';
 
 export function App() {
@@ -58,7 +59,6 @@ export function App() {
           ) : (
             messages.map((m, i) => (
               <div
-                // biome-ignore lint/suspicious/noArrayIndexKey: tier-1 chat list with no reordering
                 key={`${m.role}-${i}`}
                 className={`px-3 py-2 rounded-[var(--radius-md)] text-sm ${
                   m.role === 'user'
@@ -99,6 +99,7 @@ export function App() {
             BYOK · local-first · multi-model
           </span>
         </header>
+        <PreviewToolbar />
         <div className="flex-1 p-6 overflow-auto">
           {previewHtml ? (
             <iframe
diff --git a/apps/desktop/src/renderer/src/components/PreviewToolbar.tsx b/apps/desktop/src/renderer/src/components/PreviewToolbar.tsx
new file mode 100644
index 00000000..1870a6c5
--- /dev/null
+++ b/apps/desktop/src/renderer/src/components/PreviewToolbar.tsx
@@ -0,0 +1,95 @@
+import { Download } from 'lucide-react';
+import { type ReactElement, useEffect, useRef, useState } from 'react';
+import type { ExportFormat } from '../../../preload/index';
+import { useCodesignStore } from '../store';
+
+interface ExportItem {
+  format: ExportFormat;
+  label: string;
+  hint?: string;
+  ready: boolean;
+}
+
+const EXPORT_ITEMS: ExportItem[] = [
+  { format: 'html', label: 'HTML', ready: true },
+  { format: 'pdf', label: 'PDF', ready: false, hint: 'Coming in Phase 2' },
+  { format: 'pptx', label: 'PPTX', ready: false, hint: 'Coming in Phase 2' },
+  { format: 'zip', label: 'ZIP bundle', ready: false, hint: 'Coming in Phase 2' },
+];
+
+export function PreviewToolbar(): ReactElement {
+  const previewHtml = useCodesignStore((s) => s.previewHtml);
+  const exportActive = useCodesignStore((s) => s.exportActive);
+  const toastMessage = useCodesignStore((s) => s.toastMessage);
+  const dismissToast = useCodesignStore((s) => s.dismissToast);
+  const [open, setOpen] = useState(false);
+  const ref = useRef<HTMLDivElement | null>(null);
+
+  useEffect(() => {
+    if (!open) return;
+    function onClick(e: MouseEvent): void {
+      if (ref.current && !ref.current.contains(e.target as Node)) setOpen(false);
+    }
+    document.addEventListener('mousedown', onClick);
+    return () => document.removeEventListener('mousedown', onClick);
+  }, [open]);
+
+  useEffect(() => {
+    if (!toastMessage) return;
+    const t = setTimeout(() => dismissToast(), 4000);
+    return () => clearTimeout(t);
+  }, [toastMessage, dismissToast]);
+
+  const disabled = !previewHtml;
+
+  return (
+    <div className="flex items-center justify-end gap-2 px-5 py-2 border-b border-[var(--color-border)] bg-[var(--color-background-secondary)]">
+      {toastMessage && (
+        <output className="mr-auto text-xs text-[var(--color-text-secondary)] truncate max-w-[60%]">
+          {toastMessage}
+        </output>
+      )}
+
+      <div className="relative" ref={ref}>
+        <button
+          type="button"
+          disabled={disabled}
+          onClick={() => setOpen((v) => !v)}
+          className="inline-flex items-center gap-1.5 h-8 px-3 rounded-[var(--radius-md)] text-sm font-medium border border-[var(--color-border)] bg-[var(--color-surface)] text-[var(--color-text-primary)] hover:bg-[var(--color-surface-hover)] disabled:opacity-50 disabled:pointer-events-none transition-colors"
+          aria-haspopup="menu"
+          aria-expanded={open}
+        >
+          <Download className="w-4 h-4" aria-hidden="true" />
+          Export
+        </button>
+
+        {open && (
+          <div
+            role="menu"
+            className="absolute right-0 top-full mt-1 min-w-[180px] rounded-[var(--radius-md)] border border-[var(--color-border)] bg-[var(--color-surface)] shadow-[var(--shadow-card)] py-1 z-10"
+          >
+            {EXPORT_ITEMS.map((item) => (
+              <button
+                key={item.format}
+                type="button"
+                role="menuitem"
+                disabled={!item.ready}
+                title={item.ready ? undefined : item.hint}
+                onClick={() => {
+                  setOpen(false);
+                  void exportActive(item.format);
+                }}
+                className="w-full flex items-center justify-between gap-3 px-3 py-2 text-sm text-left text-[var(--color-text-primary)] hover:bg-[var(--color-surface-hover)] disabled:opacity-50 disabled:hover:bg-transparent disabled:cursor-not-allowed transition-colors"
+              >
+                <span>{item.label}</span>
+                {!item.ready && (
+                  <span className="text-xs text-[var(--color-text-muted)]">{item.hint}</span>
+                )}
+              </button>
+            ))}
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}
diff --git a/apps/desktop/src/renderer/src/store.ts b/apps/desktop/src/renderer/src/store.ts
index f6e701d6..1c097844 100644
--- a/apps/desktop/src/renderer/src/store.ts
+++ b/apps/desktop/src/renderer/src/store.ts
@@ -1,6 +1,6 @@
 import type { ChatMessage } from '@open-codesign/shared';
 import { create } from 'zustand';
-import type { CodesignApi } from '../../preload/index';
+import type { CodesignApi, ExportFormat } from '../../preload/index';
 
 declare global {
   interface Window {
@@ -8,12 +8,23 @@ declare global {
   }
 }
 
+// TIER 1 / DEV ONLY. The renderer reads `VITE_OPEN_CODESIGN_DEV_KEY` so the
+// "first demo" path works before `wt/onboarding` lands real keychain plumbing.
+// Once onboarding ships, this constant + the !apiKey branch in sendPrompt go
+// away in the integration commit. Vite inlines `import.meta.env.*` at build
+// time, so a missing var resolves to `undefined`.
+const DEV_API_KEY: string =
+  (import.meta.env['VITE_OPEN_CODESIGN_DEV_KEY'] as string | undefined) ?? '';
+
 interface CodesignState {
   messages: ChatMessage[];
   previewHtml: string | null;
   isGenerating: boolean;
   errorMessage: string | null;
+  toastMessage: string | null;
   sendPrompt: (prompt: string) => Promise<void>;
+  exportActive: (format: ExportFormat) => Promise<void>;
+  dismissToast: () => void;
 }
 
 export const useCodesignStore = create<CodesignState>((set, get) => ({
@@ -21,6 +32,7 @@ export const useCodesignStore = create<CodesignState>((set, get) => ({
   previewHtml: null,
   isGenerating: false,
   errorMessage: null,
+  toastMessage: null,
 
   async sendPrompt(prompt: string) {
     if (get().isGenerating) return;
@@ -36,9 +48,7 @@ export const useCodesignStore = create<CodesignState>((set, get) => ({
       errorMessage: null,
     }));
 
-    // Tier 1 wiring: hardcoded provider/model and key-from-env until the
-    // onboarding flow lands. The real flow will read from the keychain.
-    const apiKey = '';
+    const apiKey = DEV_API_KEY;
     if (!apiKey) {
       set((s) => ({
         messages: [
@@ -46,7 +56,7 @@ export const useCodesignStore = create<CodesignState>((set, get) => ({
           {
             role: 'assistant',
             content:
-              'No API key configured yet. Onboarding flow coming in v0.1 — see docs/research/06-api-onboarding-ux.md.',
+              'No API key configured yet. Set VITE_OPEN_CODESIGN_DEV_KEY for dev, or wait for the onboarding flow (wt/onboarding) to land.',
           },
         ],
         isGenerating: false,
@@ -77,4 +87,34 @@ export const useCodesignStore = create<CodesignState>((set, get) => ({
       }));
     }
   },
+
+  async exportActive(format: ExportFormat) {
+    const html = get().previewHtml;
+    if (!html) {
+      set({ toastMessage: 'No design to export yet.' });
+      return;
+    }
+    if (!window.codesign) {
+      set({ errorMessage: 'Renderer is not connected to the main process.' });
+      return;
+    }
+    try {
+      const stamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+      const res = await window.codesign.export({
+        format,
+        htmlContent: html,
+        defaultFilename: `codesign-${stamp}.${format}`,
+      });
+      if (res.status === 'saved' && res.path) {
+        set({ toastMessage: `Exported to ${res.path}` });
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : 'Unknown error';
+      set({ toastMessage: msg, errorMessage: msg });
+    }
+  },
+
+  dismissToast() {
+    set({ toastMessage: null });
+  },
 }));
diff --git a/examples/calm-spaces/README.md b/examples/calm-spaces/README.md
new file mode 100644
index 00000000..26112604
--- /dev/null
+++ b/examples/calm-spaces/README.md
@@ -0,0 +1,51 @@
+# Demo · Calm Spaces meditation app
+
+The "Calm Spaces" mobile prototype is the headline first demo for open-codesign,
+mirroring the marquee Claude Design example (see `docs/research/01-claude-design-teardown.md`).
+
+## What it generates
+
+A single self-contained HTML artifact rendering a phone-frame mockup of a
+meditation app home screen — meditation list, play button, soft greens/blues
+palette, and tunable design tokens via CSS custom properties on `:root`.
+
+## Run it
+
+```bash
+# 1. Provide a dev API key (Anthropic key works out of the box).
+export VITE_OPEN_CODESIGN_DEV_KEY=sk-ant-...
+
+# 2. Boot the desktop app from the repo root.
+pnpm install
+pnpm --filter @open-codesign/desktop dev
+```
+
+Then in the app:
+
+1. Click the **Calm Spaces meditation app** starter in the left sidebar.
+2. Press **Send** (or `Enter`).
+3. Within ~30 s the iframe on the right renders the design.
+4. Open the **Export** menu in the preview toolbar → choose **HTML** → pick a
+   destination → **Save**.
+5. `open <chosen-path>` in the browser shows the same design without the app.
+
+## Expected behaviour
+
+- The model emits exactly one `<artifact identifier="design-1" type="html" …>`
+  block. The orchestrator extracts it via `@open-codesign/artifacts` and feeds
+  the HTML into the sandbox iframe.
+- Tailwind is loaded via the official CDN (`https://cdn.tailwindcss.com`). The
+  HTML exporter inlines the CDN tag if the model forgot to.
+- All colors, spacing, and font sizes are CSS variables — that's what the slider
+  tier (Phase 2) will hook into.
+
+## Failure modes (loud, by design)
+
+- **No key** → assistant message tells you to set `VITE_OPEN_CODESIGN_DEV_KEY`.
+- **PDF / PPTX / ZIP export** → throws `CodesignError` with code
+  `EXPORTER_NOT_READY` and the toast reads "PDF export ships in Phase 2".
+- **Network / provider error** → propagates as a `CodesignError` with code
+  `PROVIDER_ERROR`; surfaced as the assistant's reply prefixed with `Error:`.
+
+There are deliberately no silent fallbacks anywhere in this path
+(see PRINCIPLES §10).
diff --git a/packages/core/package.json b/packages/core/package.json
index 8962c4fe..f30cc8a5 100644
--- a/packages/core/package.json
+++ b/packages/core/package.json
@@ -15,7 +15,8 @@
   "dependencies": {
     "@open-codesign/artifacts": "workspace:*",
     "@open-codesign/providers": "workspace:*",
-    "@open-codesign/shared": "workspace:*"
+    "@open-codesign/shared": "workspace:*",
+    "@open-codesign/templates": "workspace:*"
   },
   "devDependencies": {
     "typescript": "^5.7.2",
diff --git a/packages/core/src/generate.test.ts b/packages/core/src/generate.test.ts
new file mode 100644
index 00000000..ff09ba51
--- /dev/null
+++ b/packages/core/src/generate.test.ts
@@ -0,0 +1,84 @@
+import type { ChatMessage, ModelRef } from '@open-codesign/shared';
+import { CodesignError } from '@open-codesign/shared';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+const completeMock = vi.fn();
+
+vi.mock('@open-codesign/providers', () => ({
+  complete: (...args: unknown[]) => completeMock(...args),
+}));
+
+import { generate } from './index';
+
+const MODEL: ModelRef = { provider: 'anthropic', modelId: 'claude-sonnet-4-6' };
+
+const SAMPLE_HTML = `<!doctype html><html lang="en"><body><h1>Hi</h1></body></html>`;
+
+const RESPONSE = `Here is your design.
+
+<artifact identifier="design-1" type="html" title="Hello world">
+${SAMPLE_HTML}
+</artifact>`;
+
+afterEach(() => {
+  completeMock.mockReset();
+});
+
+describe('generate()', () => {
+  it('throws CodesignError on empty prompt', async () => {
+    await expect(
+      generate({ prompt: '   ', history: [], model: MODEL, apiKey: 'sk-test' }),
+    ).rejects.toBeInstanceOf(CodesignError);
+    expect(completeMock).not.toHaveBeenCalled();
+  });
+
+  it('extracts the artifact body and the surrounding text', async () => {
+    completeMock.mockResolvedValueOnce({
+      content: RESPONSE,
+      inputTokens: 12,
+      outputTokens: 34,
+      costUsd: 0.0001,
+    });
+
+    const result = await generate({
+      prompt: 'design a meditation app',
+      history: [],
+      model: MODEL,
+      apiKey: 'sk-test',
+    });
+
+    expect(result.artifacts).toHaveLength(1);
+    const first = result.artifacts[0];
+    if (!first) throw new Error('expected one artifact');
+    expect(first.id).toBe('design-1');
+    expect(first.type).toBe('html');
+    expect(first.content.trim()).toBe(SAMPLE_HTML);
+    expect(result.message).toContain('Here is your design.');
+    expect(result.inputTokens).toBe(12);
+    expect(result.outputTokens).toBe(34);
+    expect(result.costUsd).toBeCloseTo(0.0001);
+  });
+
+  it('passes the design-generator system prompt by default', async () => {
+    completeMock.mockResolvedValueOnce({
+      content: RESPONSE,
+      inputTokens: 0,
+      outputTokens: 0,
+      costUsd: 0,
+    });
+
+    await generate({
+      prompt: 'design a meditation app',
+      history: [],
+      model: MODEL,
+      apiKey: 'sk-test',
+    });
+
+    const messages = completeMock.mock.calls[0]?.[1] as ChatMessage[];
+    const system = messages[0];
+    if (!system) throw new Error('expected system message');
+    expect(system.role).toBe('system');
+    expect(system.content).toContain('open-codesign');
+    expect(system.content).toContain('artifact');
+  });
+});
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index 5ed00cb7..931845b3 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -1,7 +1,8 @@
-import { createArtifactParser } from '@open-codesign/artifacts';
+import { type ArtifactEvent, createArtifactParser } from '@open-codesign/artifacts';
 import { complete } from '@open-codesign/providers';
 import type { Artifact, ChatMessage, ModelRef } from '@open-codesign/shared';
 import { CodesignError } from '@open-codesign/shared';
+import { SYSTEM_PROMPTS } from '@open-codesign/templates';
 
 export interface GenerateInput {
   prompt: string;
@@ -20,14 +21,27 @@ export interface GenerateOutput {
   costUsd: number;
 }
 
-const DEFAULT_SYSTEM_PROMPT = `You are a UI designer. When the user asks for a visual design, output a single self-contained HTML artifact wrapped in:
-
-<artifact identifier="design-1" type="html" title="Short title">
-<!doctype html>
-<html>...</html>
-</artifact>
+interface Collected {
+  text: string;
+  artifacts: Artifact[];
+}
 
-Use Tailwind via the CDN script <script src="https://cdn.tailwindcss.com"></script>. Use semantic HTML, modern aesthetics (warm neutrals, generous whitespace, subtle shadows). Use CSS custom properties for tunable values (colors, spacing, font sizes) so the user can tweak them later.`;
+function collect(events: Iterable<ArtifactEvent>, into: Collected): void {
+  for (const ev of events) {
+    if (ev.type === 'text') {
+      into.text += ev.delta;
+    } else if (ev.type === 'artifact:end') {
+      into.artifacts.push({
+        id: ev.identifier || `design-${into.artifacts.length + 1}`,
+        type: 'html',
+        title: 'Design',
+        content: ev.fullContent,
+        designParams: [],
+        createdAt: new Date().toISOString(),
+      });
+    }
+  }
+}
 
 /**
  * Generate one design artifact in response to a user prompt.
@@ -40,7 +54,7 @@ export async function generate(input: GenerateInput): Promise<GenerateOutput> {
   }
 
   const messages: ChatMessage[] = [
-    { role: 'system', content: input.systemPrompt ?? DEFAULT_SYSTEM_PROMPT },
+    { role: 'system', content: input.systemPrompt ?? SYSTEM_PROMPTS.designGenerator },
     ...input.history,
     { role: 'user', content: input.prompt },
   ];
@@ -51,39 +65,13 @@ export async function generate(input: GenerateInput): Promise<GenerateOutput> {
   });
 
   const parser = createArtifactParser();
-  const artifacts: Artifact[] = [];
-  let textBuffer = '';
-
-  for (const ev of parser.feed(result.content)) {
-    if (ev.type === 'text') textBuffer += ev.delta;
-    if (ev.type === 'artifact:end') {
-      artifacts.push({
-        id: ev.identifier || `design-${artifacts.length + 1}`,
-        type: 'html',
-        title: 'Design',
-        content: ev.fullContent,
-        designParams: [],
-        createdAt: new Date().toISOString(),
-      });
-    }
-  }
-  for (const ev of parser.flush()) {
-    if (ev.type === 'text') textBuffer += ev.delta;
-    if (ev.type === 'artifact:end') {
-      artifacts.push({
-        id: ev.identifier || `design-${artifacts.length + 1}`,
-        type: 'html',
-        title: 'Design',
-        content: ev.fullContent,
-        designParams: [],
-        createdAt: new Date().toISOString(),
-      });
-    }
-  }
+  const collected: Collected = { text: '', artifacts: [] };
+  collect(parser.feed(result.content), collected);
+  collect(parser.flush(), collected);
 
   return {
-    message: textBuffer.trim(),
-    artifacts,
+    message: collected.text.trim(),
+    artifacts: collected.artifacts,
     inputTokens: result.inputTokens,
     outputTokens: result.outputTokens,
     costUsd: result.costUsd,
diff --git a/packages/exporters/package.json b/packages/exporters/package.json
index f0ff262c..dd5bd560 100644
--- a/packages/exporters/package.json
+++ b/packages/exporters/package.json
@@ -7,6 +7,7 @@
   "types": "./src/index.ts",
   "exports": {
     ".": "./src/index.ts",
+    "./html": "./src/html.ts",
     "./pdf": "./src/pdf.ts",
     "./pptx": "./src/pptx.ts",
     "./zip": "./src/zip.ts"
diff --git a/packages/exporters/src/html.ts b/packages/exporters/src/html.ts
new file mode 100644
index 00000000..01c0b3d6
--- /dev/null
+++ b/packages/exporters/src/html.ts
@@ -0,0 +1,163 @@
+import type { ExportResult } from './index';
+
+const TAILWIND_CDN = 'https://cdn.tailwindcss.com';
+const TAILWIND_TAG = `<script src="${TAILWIND_CDN}"></script>`;
+
+export interface ExportHtmlOptions {
+  /** Inject the Tailwind CDN script if missing. Defaults to true. */
+  injectTailwind?: boolean;
+  /** Prettify with two-space indentation. Defaults to true. */
+  prettify?: boolean;
+  /** Comment banner injected at the top of the file. */
+  bannerComment?: string;
+}
+
+/**
+ * Export an HTML artifact to disk as a single self-contained file.
+ *
+ * Tier 1 inlines what we can do without parsing the DOM: the Tailwind CDN
+ * tag, a doctype, a viewport meta, and a small comment banner. Anything that
+ * needs a real HTML parser (font subsetting, SVG inlining, JS bundling) waits
+ * for Tier 2 — and is loud about it: never silently skip work the caller
+ * believed we did.
+ */
+export async function exportHtml(
+  htmlContent: string,
+  destinationPath: string,
+  opts: ExportHtmlOptions = {},
+): Promise<ExportResult> {
+  const fs = await import('node:fs/promises');
+  const final = buildHtmlDocument(htmlContent, opts);
+  await fs.writeFile(destinationPath, final, 'utf8');
+  const stat = await fs.stat(destinationPath);
+  return { bytes: stat.size, path: destinationPath };
+}
+
+export function buildHtmlDocument(htmlContent: string, opts: ExportHtmlOptions = {}): string {
+  const injectTailwind = opts.injectTailwind ?? true;
+  const prettify = opts.prettify ?? true;
+  const banner =
+    opts.bannerComment ??
+    'Generated by open-codesign — https://github.com/OpenCoworkAI/open-codesign';
+
+  let out = ensureDocumentShell(htmlContent);
+  if (injectTailwind && !hasTailwindScript(out)) {
+    out = injectIntoHead(out, TAILWIND_TAG);
+  }
+  out = injectIntoHead(out, `<meta name="generator" content="open-codesign" />`);
+  out = `<!-- ${banner} -->\n${out}`;
+  if (prettify) out = prettifyHtml(out);
+  return out;
+}
+
+function ensureDocumentShell(html: string): string {
+  const trimmed = html.trim();
+  if (/^<!doctype/i.test(trimmed)) return trimmed;
+  if (/<html[\s>]/i.test(trimmed)) return `<!doctype html>\n${trimmed}`;
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>open-codesign export</title>
+</head>
+<body>
+${trimmed}
+</body>
+</html>`;
+}
+
+function hasTailwindScript(html: string): boolean {
+  return /cdn\.tailwindcss\.com/i.test(html);
+}
+
+function injectIntoHead(html: string, tag: string): string {
+  if (/<head[\s>]/i.test(html)) {
+    return html.replace(/<head([^>]*)>/i, (m) => `${m}\n  ${tag}`);
+  }
+  if (/<html[^>]*>/i.test(html)) {
+    return html.replace(/<html([^>]*)>/i, (m) => `${m}\n<head>\n  ${tag}\n</head>`);
+  }
+  return `${tag}\n${html}`;
+}
+
+/**
+ * Indentation-only prettifier. Splits inline tags onto fresh lines and
+ * reflows indentation. We deliberately avoid pulling in `prettier` /
+ * `js-beautify` (would blow the dep budget) — Tier 2 can swap this out.
+ */
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: HTML formatting is inherently branchy; refactoring would obscure the state machine
+function prettifyHtml(html: string): string {
+  const tokens = html.replace(/>\s+</g, '><').replace(/></g, '>\n<').split('\n');
+
+  const voidElements = new Set([
+    'area',
+    'base',
+    'br',
+    'col',
+    'embed',
+    'hr',
+    'img',
+    'input',
+    'link',
+    'meta',
+    'param',
+    'source',
+    'track',
+    'wbr',
+  ]);
+  const inline = new Set(['script', 'style', 'pre', 'textarea']);
+
+  let depth = 0;
+  let inInline: string | null = null;
+  const lines: string[] = [];
+
+  for (const raw of tokens) {
+    const line = raw.trim();
+    if (!line) continue;
+
+    if (inInline) {
+      lines.push(line);
+      if (new RegExp(`</${inInline}\\s*>`, 'i').test(line)) {
+        inInline = null;
+        depth = Math.max(0, depth - 1);
+      }
+      continue;
+    }
+
+    const closing = /^<\//.test(line);
+    const selfClosing = /\/>\s*$/.test(line) || isVoidTag(line, voidElements);
+    const isComment = /^<!--/.test(line);
+    const isDoctype = /^<!doctype/i.test(line);
+
+    if (closing) depth = Math.max(0, depth - 1);
+
+    lines.push(`${'  '.repeat(depth)}${line}`);
+
+    const tagName = openTagName(line);
+    if (tagName && inline.has(tagName) && !selfClosing) {
+      const sameLine = new RegExp(`</${tagName}\\s*>`, 'i').test(line);
+      if (!sameLine) {
+        inInline = tagName;
+        depth += 1;
+      }
+      continue;
+    }
+
+    if (!closing && !selfClosing && !isComment && !isDoctype && tagName) {
+      depth += 1;
+    }
+  }
+
+  return `${lines.join('\n')}\n`;
+}
+
+function openTagName(line: string): string | null {
+  const m = /^<([a-zA-Z][a-zA-Z0-9-]*)/.exec(line);
+  return m ? (m[1] as string).toLowerCase() : null;
+}
+
+function isVoidTag(line: string, voids: Set<string>): boolean {
+  const name = openTagName(line);
+  return name !== null && voids.has(name);
+}
diff --git a/packages/exporters/src/index.ts b/packages/exporters/src/index.ts
index 5b08ec51..6dd95932 100644
--- a/packages/exporters/src/index.ts
+++ b/packages/exporters/src/index.ts
@@ -1,11 +1,13 @@
 /**
- * Exporter entry point — each format lives in its own subpath export and
- * MUST be imported via dynamic import() to keep the cold-start bundle lean.
+ * Exporter entry point. Each format lives in its own subpath export and is
+ * loaded lazily so the cold-start bundle stays lean (PRINCIPLES §1).
  *
- * Tier 1: not implemented yet. Stub re-exports so the desktop app can wire
- * the menu items that surface "coming soon" UI.
+ * Tier 1 ships HTML. PDF / PPTX / ZIP throw `CodesignError` with code
+ * `EXPORTER_NOT_READY` — never silently succeed (PRINCIPLES §10).
  */
 
+import { CodesignError } from '@open-codesign/shared';
+
 export const EXPORTER_FORMATS = ['html', 'pdf', 'pptx', 'zip'] as const;
 export type ExporterFormat = (typeof EXPORTER_FORMATS)[number];
 
@@ -23,16 +25,36 @@ export function isExporterReady(format: ExporterFormat): boolean {
   return format === 'html';
 }
 
-/**
- * Export a single HTML artifact to disk. Tier 1: writes the raw HTML.
- * Tier 2 will inline external assets, embed fonts, run optimization.
- */
+export type { ExportHtmlOptions } from './html';
+
 export async function exportHtml(
   htmlContent: string,
   destinationPath: string,
+  opts?: import('./html').ExportHtmlOptions,
+): Promise<ExportResult> {
+  const mod = await import('./html');
+  return mod.exportHtml(htmlContent, destinationPath, opts);
+}
+
+export async function exportArtifact(
+  format: ExporterFormat,
+  htmlContent: string,
+  destinationPath: string,
 ): Promise<ExportResult> {
-  const fs = await import('node:fs/promises');
-  await fs.writeFile(destinationPath, htmlContent, 'utf8');
-  const stat = await fs.stat(destinationPath);
-  return { bytes: stat.size, path: destinationPath };
+  if (format === 'html') {
+    return exportHtml(htmlContent, destinationPath);
+  }
+  if (format === 'pdf') {
+    const mod = await import('./pdf');
+    return mod.exportPdf();
+  }
+  if (format === 'pptx') {
+    const mod = await import('./pptx');
+    return mod.exportPptx();
+  }
+  if (format === 'zip') {
+    const mod = await import('./zip');
+    return mod.exportZip();
+  }
+  throw new CodesignError(`Unknown exporter format: ${format as string}`, 'EXPORTER_UNKNOWN');
 }
diff --git a/packages/exporters/src/pdf.ts b/packages/exporters/src/pdf.ts
new file mode 100644
index 00000000..2982f63f
--- /dev/null
+++ b/packages/exporters/src/pdf.ts
@@ -0,0 +1,9 @@
+import { CodesignError } from '@open-codesign/shared';
+
+/**
+ * Tier 2 — Chromium print-to-PDF via Electron's offscreen `webContents`.
+ * Throws loudly so callers cannot mistake "not yet shipped" for "succeeded silently".
+ */
+export async function exportPdf(): Promise<never> {
+  throw new CodesignError('PDF export ships in Phase 2', 'EXPORTER_NOT_READY');
+}
diff --git a/packages/exporters/src/pptx.ts b/packages/exporters/src/pptx.ts
new file mode 100644
index 00000000..1bead260
--- /dev/null
+++ b/packages/exporters/src/pptx.ts
@@ -0,0 +1,9 @@
+import { CodesignError } from '@open-codesign/shared';
+
+/**
+ * Tier 2 — wired through `dom-to-pptx` once research/04 is implemented.
+ * Throws loudly so callers cannot mistake "not yet shipped" for "succeeded silently".
+ */
+export async function exportPptx(): Promise<never> {
+  throw new CodesignError('PPTX export ships in Phase 2', 'EXPORTER_NOT_READY');
+}
diff --git a/packages/exporters/src/zip.ts b/packages/exporters/src/zip.ts
new file mode 100644
index 00000000..11c3b0fb
--- /dev/null
+++ b/packages/exporters/src/zip.ts
@@ -0,0 +1,9 @@
+import { CodesignError } from '@open-codesign/shared';
+
+/**
+ * Tier 2 — bundle artifact + assets + README into a portable ZIP.
+ * Throws loudly so callers cannot mistake "not yet shipped" for "succeeded silently".
+ */
+export async function exportZip(): Promise<never> {
+  throw new CodesignError('ZIP export ships in Phase 2', 'EXPORTER_NOT_READY');
+}
diff --git a/packages/templates/src/index.ts b/packages/templates/src/index.ts
index e9469a34..7909cf79 100644
--- a/packages/templates/src/index.ts
+++ b/packages/templates/src/index.ts
@@ -3,6 +3,8 @@
  * we committed to replicate (see docs/VISION.md).
  */
 
+export { SYSTEM_PROMPTS, type SystemPromptId } from './system/index';
+
 export interface DemoTemplate {
   id: string;
   title: string;
diff --git a/packages/templates/src/system/design-generator.md b/packages/templates/src/system/design-generator.md
new file mode 100644
index 00000000..4083a5ac
--- /dev/null
+++ b/packages/templates/src/system/design-generator.md
@@ -0,0 +1,78 @@
+# Design generator system prompt
+
+Canonical, human-readable copy of the system prompt used by `@open-codesign/core`
+to drive `designGenerator`. The TypeScript constant in `./index.ts` MUST stay
+byte-for-byte in sync with the prose below; tests assert this. Keeping the prompt
+in Markdown lets reviewers diff prompt changes without scanning a quoted string.
+
+---
+
+You are **open-codesign**, an AI design partner. The user describes a thing they
+want to look at — a landing page, a mobile screen, a one-page case study, a slide
+deck — and you respond with a single, self-contained, production-quality HTML
+artifact they can export and ship.
+
+## Output contract
+
+Wrap the entire HTML document in exactly one artifact tag. Nothing else may
+appear inside the tag, and no second artifact may follow.
+
+```
+<artifact identifier="design-1" type="html" title="Short descriptive title">
+<!doctype html>
+<html lang="en">
+  ... the design ...
+</html>
+</artifact>
+```
+
+Outside the artifact tag you may write at most one short paragraph (≤ 2
+sentences) describing what you produced. Never narrate the HTML — the user can
+see it.
+
+## Construction rules
+
+1. **Single shot, single file.** No external CSS, no external JS, no `<link>` to
+   custom stylesheets. The only permitted external script is Tailwind from the
+   official CDN: `<script src="https://cdn.tailwindcss.com"></script>`. The only
+   permitted external font source is `fonts.googleapis.com`.
+2. **Tailwind is the styling engine.** Compose with utility classes; reach for
+   inline `<style>` only for `:root` custom properties and the handful of rules
+   Tailwind utilities cannot express cleanly (keyframes, complex selectors).
+3. **Tunable design tokens.** Every load-bearing value — primary color, accent
+   color, surface, text, base radius, base font size, spacing scale — MUST be a
+   CSS custom property declared on `:root`. Use these variables inside Tailwind
+   via the arbitrary-value syntax (`bg-[var(--color-accent)]`). This is what
+   makes the slider tier work later; bake it in from day one.
+4. **Semantic HTML.** `<header>`, `<main>`, `<section>`, `<article>`, `<nav>`,
+   `<footer>` where appropriate. Headings in correct order. Images have `alt`
+   text. Buttons are `<button>`, links are `<a>`.
+5. **Responsive by default.** Mobile-first; layout adapts at `sm`, `md`, `lg`.
+   Use CSS grid or flex — never absolute positioning for layout.
+6. **Modern aesthetic.** Generous whitespace, restrained color palette
+   (neutrals + one or two accents), confident typography hierarchy, soft
+   shadows, subtle motion only where it earns its keep. Never use the default
+   Tailwind blue. Pick a palette that fits the brief.
+7. **Real content.** No `lorem ipsum`. Write copy that fits the product the
+   user described — short, specific, on-brand. Use realistic names, numbers,
+   and dates.
+8. **Accessibility.** Color contrast meets WCAG AA. Interactive elements are
+   reachable by keyboard. Decorative SVGs get `aria-hidden="true"`.
+9. **No external assets you can't guarantee.** Inline SVGs for icons; never
+   `<img src="https://…/photo.jpg">`. If you need a hero image, render an
+   abstract SVG composition or a CSS gradient block.
+10. **Self-contained mockup.** The artifact is a finished design surface, not a
+    working app. Don't wire up routes, fetch data, or include build tooling.
+
+## Failure modes to avoid
+
+- Multi-file output, ZIP descriptions, or "see attached".
+- Asking the user clarifying questions before producing anything. If the brief
+  is ambiguous, make a confident choice and note the assumption in the
+  one-paragraph summary.
+- Wrapping the HTML in Markdown code fences instead of the artifact tag.
+- Emitting more than one artifact.
+- Referencing files or images that don't exist.
+
+When the user follows up to tweak the design, regenerate the full artifact —
+the artifact is the canonical state.
diff --git a/packages/templates/src/system/index.ts b/packages/templates/src/system/index.ts
new file mode 100644
index 00000000..afd4ac9e
--- /dev/null
+++ b/packages/templates/src/system/index.ts
@@ -0,0 +1,54 @@
+/**
+ * System prompts shipped with open-codesign.
+ *
+ * Each prompt is exported both as a TypeScript constant (for runtime use) and
+ * mirrored in a sibling `.md` file (for human review in PR diffs). The string
+ * below MUST stay in sync with `./design-generator.md`.
+ *
+ * We embed the prompt as a TS constant rather than `?raw` importing the .md so
+ * Tier 1 packages don't depend on Vite's raw loader.
+ */
+
+const designGenerator = `You are open-codesign, an AI design partner. The user describes a thing they want to look at — a landing page, a mobile screen, a one-page case study, a slide deck — and you respond with a single, self-contained, production-quality HTML artifact they can export and ship.
+
+# Output contract
+
+Wrap the entire HTML document in exactly one artifact tag. Nothing else may appear inside the tag, and no second artifact may follow.
+
+<artifact identifier="design-1" type="html" title="Short descriptive title">
+<!doctype html>
+<html lang="en">
+  ... the design ...
+</html>
+</artifact>
+
+Outside the artifact tag you may write at most one short paragraph (≤ 2 sentences) describing what you produced. Never narrate the HTML — the user can see it.
+
+# Construction rules
+
+1. Single shot, single file. No external CSS, no external JS, no <link> to custom stylesheets. The only permitted external script is Tailwind from the official CDN: <script src="https://cdn.tailwindcss.com"></script>. The only permitted external font source is fonts.googleapis.com.
+2. Tailwind is the styling engine. Compose with utility classes; reach for inline <style> only for :root custom properties and the handful of rules Tailwind utilities cannot express cleanly (keyframes, complex selectors).
+3. Tunable design tokens. Every load-bearing value — primary color, accent color, surface, text, base radius, base font size, spacing scale — MUST be a CSS custom property declared on :root. Use these variables inside Tailwind via the arbitrary-value syntax (bg-[var(--color-accent)]). This is what makes the slider tier work later; bake it in from day one.
+4. Semantic HTML. <header>, <main>, <section>, <article>, <nav>, <footer> where appropriate. Headings in correct order. Images have alt text. Buttons are <button>, links are <a>.
+5. Responsive by default. Mobile-first; layout adapts at sm, md, lg. Use CSS grid or flex — never absolute positioning for layout.
+6. Modern aesthetic. Generous whitespace, restrained color palette (neutrals + one or two accents), confident typography hierarchy, soft shadows, subtle motion only where it earns its keep. Never use the default Tailwind blue. Pick a palette that fits the brief.
+7. Real content. No lorem ipsum. Write copy that fits the product the user described — short, specific, on-brand. Use realistic names, numbers, and dates.
+8. Accessibility. Color contrast meets WCAG AA. Interactive elements are reachable by keyboard. Decorative SVGs get aria-hidden="true".
+9. No external assets you can't guarantee. Inline SVGs for icons; never <img src="https://…/photo.jpg">. If you need a hero image, render an abstract SVG composition or a CSS gradient block.
+10. Self-contained mockup. The artifact is a finished design surface, not a working app. Don't wire up routes, fetch data, or include build tooling.
+
+# Failure modes to avoid
+
+- Multi-file output, ZIP descriptions, or "see attached".
+- Asking the user clarifying questions before producing anything. If the brief is ambiguous, make a confident choice and note the assumption in the one-paragraph summary.
+- Wrapping the HTML in Markdown code fences instead of the artifact tag.
+- Emitting more than one artifact.
+- Referencing files or images that don't exist.
+
+When the user follows up to tweak the design, regenerate the full artifact — the artifact is the canonical state.`;
+
+export const SYSTEM_PROMPTS = {
+  designGenerator,
+} as const;
+
+export type SystemPromptId = keyof typeof SYSTEM_PROMPTS;
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 29b55268..7c56e71f 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -29,6 +29,9 @@ importers:
       '@open-codesign/core':
         specifier: workspace:*
         version: link:../../packages/core
+      '@open-codesign/exporters':
+        specifier: workspace:*
+        version: link:../../packages/exporters
       '@open-codesign/providers':
         specifier: workspace:*
         version: link:../../packages/providers
@@ -127,6 +130,9 @@ importers:
       '@open-codesign/shared':
         specifier: workspace:*
         version: link:../shared
+      '@open-codesign/templates':
+        specifier: workspace:*
+        version: link:../templates
     devDependencies:
       typescript:
         specifier: ^5.7.2

From 7bbccbaed300a4267e16d2763b5bbb1c6dcba9af Mon Sep 17 00:00:00 2001
From: hqhq1025 <1506751656@qq.com>
Date: Sat, 18 Apr 2026 12:36:46 +0800
Subject: [PATCH 2/2] feat(exporters): real PDF/PPTX/ZIP via system Chrome +
 pptxgenjs + zip-lib
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Replaces the EXPORTER_NOT_READY stubs with three lazy-loaded tier-1
implementations decided in docs/research/04-pptx-export.md:

- PDF: puppeteer-core (~12 MB) drives the user's installed Chrome.
  We refuse to bundle Chromium (PRINCIPLES §1: 80 MB cap; Chromium
  alone is ~150 MB). chrome-discovery.ts walks the canonical paths
  per-OS plus a CODESIGN_CHROME_PATH override and throws
  EXPORTER_NO_CHROME with the install URL when nothing is found —
  no silent fallback (PRINCIPLES §10).

- PPTX: pptxgenjs (~2.6 MB). One slide per top-level <section>;
  whole document if none. Defaults emit bodyPr wrap=square and
  fit=shrink, sidestepping the dom-to-pptx CJK overflow bug
  (research/04 §"Known traps"). dom-to-pptx itself stays out of
  tier 1 — adding an unmaintained dep for the small subset of
  layouts it covers would violate "no bloat".

- ZIP: zip-lib (~100 KB, MIT, zero deps). Stable layout:
  index.html at root, README.md with a generated banner, optional
  assets/ subtree. No streaming-write hooks for tier 1.

All three exporter functions use `await import(...)` inside the
function body, so cold-start does not pull any of these into the
module graph. Verified via grep across packages/exporters/src/*.ts.

Toolbar + IPC handler updated to flip readiness on PDF/PPTX/ZIP and
swap the "Coming in Phase 2" tooltip for per-format hover-help.

Tests: 18 new vitest cases — chrome discovery for mac/win/linux
+ override + missing, mocked puppeteer happy/override/error paths,
PPTX extractSlides + a real CJK end-to-end write that PowerPoint
opens, ZIP multi-asset round-trip via Unzip.

Signed-off-by: hqhq1025 <1506751656@qq.com>
---
 apps/desktop/src/main/exporter-ipc.ts         |   5 +-
 .../src/components/PreviewToolbar.tsx         |  16 +-
 packages/exporters/package.json               |   5 +-
 packages/exporters/package.json.bak           |  25 --
 .../exporters/src/chrome-discovery.test.ts    |  74 ++++
 packages/exporters/src/chrome-discovery.ts    | 114 ++++++
 packages/exporters/src/index.ts               |  18 +-
 packages/exporters/src/pdf.test.ts            |  87 +++++
 packages/exporters/src/pdf.ts                 |  69 +++-
 packages/exporters/src/pptx.test.ts           |  72 ++++
 packages/exporters/src/pptx.ts                | 143 +++++++-
 packages/exporters/src/zip.test.ts            |  59 +++
 packages/exporters/src/zip.ts                 |  96 ++++-
 pnpm-lock.yaml                                | 344 ++++++++++++++++++
 14 files changed, 1072 insertions(+), 55 deletions(-)
 delete mode 100644 packages/exporters/package.json.bak
 create mode 100644 packages/exporters/src/chrome-discovery.test.ts
 create mode 100644 packages/exporters/src/chrome-discovery.ts
 create mode 100644 packages/exporters/src/pdf.test.ts
 create mode 100644 packages/exporters/src/pptx.test.ts
 create mode 100644 packages/exporters/src/zip.test.ts

diff --git a/apps/desktop/src/main/exporter-ipc.ts b/apps/desktop/src/main/exporter-ipc.ts
index b0e03438..53a06cd7 100644
--- a/apps/desktop/src/main/exporter-ipc.ts
+++ b/apps/desktop/src/main/exporter-ipc.ts
@@ -56,9 +56,8 @@ export function registerExporterIpc(getWindow: () => BrowserWindow | null): void
       return { status: 'cancelled' };
     }
 
-    // Tier 1: HTML succeeds, others throw EXPORTER_NOT_READY. We deliberately
-    // do NOT swallow the error here — let it propagate so the renderer can
-    // surface it as a toast (PRINCIPLES §10).
+    // All four formats ship in tier 1; the heavy deps load lazily inside
+    // exportArtifact. Errors propagate to the renderer as toasts (PRINCIPLES §10).
     const result = await exportArtifact(req.format, req.htmlContent, picked.filePath);
     return { status: 'saved', path: result.path, bytes: result.bytes };
   });
diff --git a/apps/desktop/src/renderer/src/components/PreviewToolbar.tsx b/apps/desktop/src/renderer/src/components/PreviewToolbar.tsx
index 1870a6c5..e0279b9b 100644
--- a/apps/desktop/src/renderer/src/components/PreviewToolbar.tsx
+++ b/apps/desktop/src/renderer/src/components/PreviewToolbar.tsx
@@ -11,10 +11,10 @@ interface ExportItem {
 }
 
 const EXPORT_ITEMS: ExportItem[] = [
-  { format: 'html', label: 'HTML', ready: true },
-  { format: 'pdf', label: 'PDF', ready: false, hint: 'Coming in Phase 2' },
-  { format: 'pptx', label: 'PPTX', ready: false, hint: 'Coming in Phase 2' },
-  { format: 'zip', label: 'ZIP bundle', ready: false, hint: 'Coming in Phase 2' },
+  { format: 'html', label: 'HTML', ready: true, hint: 'Single self-contained .html file' },
+  { format: 'pdf', label: 'PDF', ready: true, hint: 'Rendered via your installed Chrome' },
+  { format: 'pptx', label: 'PPTX', ready: true, hint: 'Editable slides; one per <section>' },
+  { format: 'zip', label: 'ZIP bundle', ready: true, hint: 'index.html + assets + README.md' },
 ];
 
 export function PreviewToolbar(): ReactElement {
@@ -74,7 +74,7 @@ export function PreviewToolbar(): ReactElement {
                 type="button"
                 role="menuitem"
                 disabled={!item.ready}
-                title={item.ready ? undefined : item.hint}
+                title={item.hint}
                 onClick={() => {
                   setOpen(false);
                   void exportActive(item.format);
@@ -82,8 +82,10 @@ export function PreviewToolbar(): ReactElement {
                 className="w-full flex items-center justify-between gap-3 px-3 py-2 text-sm text-left text-[var(--color-text-primary)] hover:bg-[var(--color-surface-hover)] disabled:opacity-50 disabled:hover:bg-transparent disabled:cursor-not-allowed transition-colors"
               >
                 <span>{item.label}</span>
-                {!item.ready && (
-                  <span className="text-xs text-[var(--color-text-muted)]">{item.hint}</span>
+                {item.hint && (
+                  <span className="text-xs text-[var(--color-text-muted)] truncate max-w-[60%]">
+                    {item.hint}
+                  </span>
                 )}
               </button>
             ))}
diff --git a/packages/exporters/package.json b/packages/exporters/package.json
index dd5bd560..511160c3 100644
--- a/packages/exporters/package.json
+++ b/packages/exporters/package.json
@@ -17,7 +17,10 @@
     "test": "vitest run --passWithNoTests"
   },
   "dependencies": {
-    "@open-codesign/shared": "workspace:*"
+    "@open-codesign/shared": "workspace:*",
+    "pptxgenjs": "^3.12.0",
+    "puppeteer-core": "^24.10.0",
+    "zip-lib": "^1.0.4"
   },
   "devDependencies": {
     "@types/node": "^22.10.2",
diff --git a/packages/exporters/package.json.bak b/packages/exporters/package.json.bak
deleted file mode 100644
index 70adb714..00000000
--- a/packages/exporters/package.json.bak
+++ /dev/null
@@ -1,25 +0,0 @@
-{
-  "name": "@open-codesign/exporters",
-  "version": "0.0.0",
-  "private": true,
-  "type": "module",
-  "main": "./src/index.ts",
-  "types": "./src/index.ts",
-  "exports": {
-    ".": "./src/index.ts",
-    "./pdf": "./src/pdf.ts",
-    "./pptx": "./src/pptx.ts",
-    "./zip": "./src/zip.ts"
-  },
-  "scripts": {
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run"
-  },
-  "dependencies": {
-    "@open-codesign/shared": "workspace:*"
-  },
-  "devDependencies": {
-    "typescript": "^5.7.2",
-    "vitest": "^2.1.8"
-  }
-}
diff --git a/packages/exporters/src/chrome-discovery.test.ts b/packages/exporters/src/chrome-discovery.test.ts
new file mode 100644
index 00000000..53526a99
--- /dev/null
+++ b/packages/exporters/src/chrome-discovery.test.ts
@@ -0,0 +1,74 @@
+import { describe, expect, it } from 'vitest';
+import { findSystemChrome } from './chrome-discovery';
+
+const macPath = '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome';
+const winPath = 'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe';
+const linuxPath = '/usr/bin/google-chrome';
+
+describe('findSystemChrome', () => {
+  it('finds Chrome on macOS at the canonical path', async () => {
+    const found = await findSystemChrome({
+      platform: 'darwin',
+      env: {},
+      fileExists: (p) => p === macPath,
+      which: () => null,
+    });
+    expect(found).toBe(macPath);
+  });
+
+  it('finds Chrome on Windows under ProgramFiles', async () => {
+    const found = await findSystemChrome({
+      platform: 'win32',
+      env: { ProgramFiles: 'C:\\Program Files' },
+      fileExists: (p) => p === winPath,
+      which: () => null,
+    });
+    expect(found).toBe(winPath);
+  });
+
+  it('finds Chrome on Linux via which()', async () => {
+    const found = await findSystemChrome({
+      platform: 'linux',
+      env: {},
+      fileExists: (p) => p === linuxPath,
+      which: (bin) => (bin === 'google-chrome-stable' ? linuxPath : null),
+    });
+    expect(found).toBe(linuxPath);
+  });
+
+  it('prefers CODESIGN_CHROME_PATH override when set', async () => {
+    const custom = '/opt/brave/brave';
+    const found = await findSystemChrome({
+      platform: 'darwin',
+      env: { CODESIGN_CHROME_PATH: custom },
+      fileExists: (p) => p === custom,
+      which: () => null,
+    });
+    expect(found).toBe(custom);
+  });
+
+  it('throws EXPORTER_NO_CHROME with install link when nothing is found', async () => {
+    await expect(
+      findSystemChrome({
+        platform: 'darwin',
+        env: {},
+        fileExists: () => false,
+        which: () => null,
+      }),
+    ).rejects.toMatchObject({
+      code: 'EXPORTER_NO_CHROME',
+      message: expect.stringContaining('https://www.google.com/chrome'),
+    });
+  });
+
+  it('throws on Linux when no candidate binary resolves', async () => {
+    await expect(
+      findSystemChrome({
+        platform: 'linux',
+        env: {},
+        fileExists: () => false,
+        which: () => null,
+      }),
+    ).rejects.toMatchObject({ code: 'EXPORTER_NO_CHROME' });
+  });
+});
diff --git a/packages/exporters/src/chrome-discovery.ts b/packages/exporters/src/chrome-discovery.ts
new file mode 100644
index 00000000..d558c69b
--- /dev/null
+++ b/packages/exporters/src/chrome-discovery.ts
@@ -0,0 +1,114 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { CodesignError } from '@open-codesign/shared';
+
+/**
+ * Locate a system Chrome/Chromium binary. We refuse to bundle Chromium —
+ * PRINCIPLES §1 caps the installer at 80 MB and a Chrome download is ~150 MB.
+ * Throws `EXPORTER_NO_CHROME` (loud, with install link) when nothing is found.
+ */
+const CHROME_INSTALL_URL = 'https://www.google.com/chrome';
+
+const MAC_PATHS = [
+  '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+  '/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary',
+  '/Applications/Chromium.app/Contents/MacOS/Chromium',
+  '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
+];
+
+const WIN_RELATIVE = [
+  'Google\\Chrome\\Application\\chrome.exe',
+  'Google\\Chrome Beta\\Application\\chrome.exe',
+  'Chromium\\Application\\chrome.exe',
+  'Microsoft\\Edge\\Application\\msedge.exe',
+];
+
+const LINUX_BINARIES = [
+  'google-chrome-stable',
+  'google-chrome',
+  'chromium-browser',
+  'chromium',
+  'microsoft-edge',
+];
+
+export interface ChromeDiscoveryDeps {
+  platform?: NodeJS.Platform;
+  env?: NodeJS.ProcessEnv;
+  fileExists?: (p: string) => boolean;
+  which?: (binary: string) => string | null;
+}
+
+export async function findSystemChrome(deps: ChromeDiscoveryDeps = {}): Promise<string> {
+  const platform = deps.platform ?? process.platform;
+  const env = deps.env ?? process.env;
+  const fileExists = deps.fileExists ?? defaultFileExists;
+  const which = deps.which ?? defaultWhich;
+
+  const found = locate({ platform, env, fileExists, which });
+  if (found) return found;
+
+  throw new CodesignError(
+    `System Chrome not found. Install from ${CHROME_INSTALL_URL} (or any Chromium-based browser: Edge, Chromium).`,
+    'EXPORTER_NO_CHROME',
+  );
+}
+
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: per-OS branching is inherently a switch — extracting per-OS helpers obscures the resolution order
+function locate(d: {
+  platform: NodeJS.Platform;
+  env: NodeJS.ProcessEnv;
+  fileExists: (p: string) => boolean;
+  which: (binary: string) => string | null;
+}): string | null {
+  const override = d.env['CODESIGN_CHROME_PATH'];
+  if (override && d.fileExists(override)) return override;
+
+  if (d.platform === 'darwin') {
+    for (const p of MAC_PATHS) if (d.fileExists(p)) return p;
+    return null;
+  }
+  if (d.platform === 'win32') {
+    const roots = uniq([d.env['ProgramFiles'], d.env['ProgramFiles(x86)'], d.env['LOCALAPPDATA']]);
+    for (const root of roots) {
+      for (const rel of WIN_RELATIVE) {
+        const candidate = `${root}\\${rel}`;
+        if (d.fileExists(candidate)) return candidate;
+      }
+    }
+    return null;
+  }
+  for (const bin of LINUX_BINARIES) {
+    const resolved = d.which(bin);
+    if (resolved && d.fileExists(resolved)) return resolved;
+  }
+  return null;
+}
+
+function uniq(items: ReadonlyArray<string | undefined>): string[] {
+  const out: string[] = [];
+  for (const item of items) {
+    if (item && !out.includes(item)) out.push(item);
+  }
+  return out;
+}
+
+function defaultFileExists(p: string): boolean {
+  try {
+    return existsSync(p);
+  } catch {
+    return false;
+  }
+}
+
+function defaultWhich(binary: string): string | null {
+  try {
+    const out = execFileSync('which', [binary], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    const path = out.trim();
+    return path.length > 0 ? path : null;
+  } catch {
+    return null;
+  }
+}
diff --git a/packages/exporters/src/index.ts b/packages/exporters/src/index.ts
index 6dd95932..7885d899 100644
--- a/packages/exporters/src/index.ts
+++ b/packages/exporters/src/index.ts
@@ -2,8 +2,9 @@
  * Exporter entry point. Each format lives in its own subpath export and is
  * loaded lazily so the cold-start bundle stays lean (PRINCIPLES §1).
  *
- * Tier 1 ships HTML. PDF / PPTX / ZIP throw `CodesignError` with code
- * `EXPORTER_NOT_READY` — never silently succeed (PRINCIPLES §10).
+ * Tier 1 ships HTML, PDF, PPTX, and ZIP — all four lazy-loaded so the heavy
+ * runtime deps (`puppeteer-core`, `pptxgenjs`, `zip-lib`) only enter the
+ * module graph the first time a user actually exports.
  */
 
 import { CodesignError } from '@open-codesign/shared';
@@ -21,11 +22,14 @@ export interface ExportResult {
   path: string;
 }
 
-export function isExporterReady(format: ExporterFormat): boolean {
-  return format === 'html';
+export function isExporterReady(_format: ExporterFormat): boolean {
+  return true;
 }
 
 export type { ExportHtmlOptions } from './html';
+export type { ExportPdfOptions } from './pdf';
+export type { ExportPptxOptions } from './pptx';
+export type { ExportZipOptions, ZipAsset } from './zip';
 
 export async function exportHtml(
   htmlContent: string,
@@ -46,15 +50,15 @@ export async function exportArtifact(
   }
   if (format === 'pdf') {
     const mod = await import('./pdf');
-    return mod.exportPdf();
+    return mod.exportPdf(htmlContent, destinationPath);
   }
   if (format === 'pptx') {
     const mod = await import('./pptx');
-    return mod.exportPptx();
+    return mod.exportPptx(htmlContent, destinationPath);
   }
   if (format === 'zip') {
     const mod = await import('./zip');
-    return mod.exportZip();
+    return mod.exportZip(htmlContent, destinationPath);
   }
   throw new CodesignError(`Unknown exporter format: ${format as string}`, 'EXPORTER_UNKNOWN');
 }
diff --git a/packages/exporters/src/pdf.test.ts b/packages/exporters/src/pdf.test.ts
new file mode 100644
index 00000000..ea686312
--- /dev/null
+++ b/packages/exporters/src/pdf.test.ts
@@ -0,0 +1,87 @@
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest';
+
+const fakePdfBytes = Buffer.from('%PDF-1.4 fake');
+
+const launchMock = vi.fn();
+const newPageMock = vi.fn();
+const setViewportMock = vi.fn();
+const setContentMock = vi.fn();
+const pdfMock = vi.fn();
+const closeMock = vi.fn();
+const evaluateMock = vi.fn();
+
+vi.mock('puppeteer-core', () => ({
+  default: { launch: launchMock },
+}));
+
+vi.mock('./chrome-discovery', () => ({
+  findSystemChrome: vi.fn(
+    async () => '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+  ),
+}));
+
+let tempDir = '';
+
+beforeAll(() => {
+  tempDir = mkdtempSync(join(tmpdir(), 'codesign-pdf-test-'));
+  launchMock.mockResolvedValue({
+    newPage: newPageMock,
+    close: closeMock,
+  });
+  newPageMock.mockResolvedValue({
+    setViewport: setViewportMock,
+    setContent: setContentMock,
+    pdf: pdfMock,
+    evaluate: evaluateMock,
+  });
+  pdfMock.mockResolvedValue(fakePdfBytes);
+  evaluateMock.mockResolvedValue(2400);
+});
+
+afterAll(() => {
+  rmSync(tempDir, { recursive: true, force: true });
+});
+
+describe('exportPdf', () => {
+  it('writes a PDF via puppeteer-core against the discovered Chrome', async () => {
+    const { exportPdf } = await import('./pdf');
+    const dest = join(tempDir, 'out.pdf');
+    const result = await exportPdf('<h1>hi</h1>', dest);
+
+    expect(launchMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        executablePath: expect.stringContaining('Chrome'),
+        headless: true,
+      }),
+    );
+    expect(setContentMock).toHaveBeenCalledWith(
+      '<h1>hi</h1>',
+      expect.objectContaining({ waitUntil: 'networkidle0' }),
+    );
+    expect(pdfMock).toHaveBeenCalled();
+    expect(closeMock).toHaveBeenCalled();
+    expect(result.path).toBe(dest);
+    expect(result.bytes).toBe(fakePdfBytes.length);
+  });
+
+  it('respects a chromePath override (no discovery call needed)', async () => {
+    launchMock.mockClear();
+    const { exportPdf } = await import('./pdf');
+    const dest = join(tempDir, 'override.pdf');
+    await exportPdf('<p>x</p>', dest, { chromePath: '/tmp/fake-chrome' });
+    expect(launchMock).toHaveBeenCalledWith(
+      expect.objectContaining({ executablePath: '/tmp/fake-chrome' }),
+    );
+  });
+
+  it('wraps puppeteer failures in EXPORTER_PDF_FAILED', async () => {
+    pdfMock.mockRejectedValueOnce(new Error('boom'));
+    const { exportPdf } = await import('./pdf');
+    await expect(exportPdf('<p>x</p>', join(tempDir, 'fail.pdf'))).rejects.toMatchObject({
+      code: 'EXPORTER_PDF_FAILED',
+    });
+  });
+});
diff --git a/packages/exporters/src/pdf.ts b/packages/exporters/src/pdf.ts
index 2982f63f..c1f74381 100644
--- a/packages/exporters/src/pdf.ts
+++ b/packages/exporters/src/pdf.ts
@@ -1,9 +1,70 @@
 import { CodesignError } from '@open-codesign/shared';
+import type { ExportResult } from './index';
+
+export interface ExportPdfOptions {
+  /** Override the discovered Chrome binary path. Useful for tests / CI. */
+  chromePath?: string;
+  /**
+   * Page format. Defaults to 'Letter'. Pass 'auto' to render the page as
+   * a single tall sheet (no pagination) which is what Claude Design does
+   * for HTML prototypes that aren't paginated.
+   */
+  format?: 'Letter' | 'A4' | 'auto';
+}
+
+const DEFAULT_VIEWPORT = { width: 1280, height: 800 } as const;
 
 /**
- * Tier 2 — Chromium print-to-PDF via Electron's offscreen `webContents`.
- * Throws loudly so callers cannot mistake "not yet shipped" for "succeeded silently".
+ * Render an HTML string to PDF via the user's installed Chrome.
+ *
+ * Tier 1: no header/footer, no font embedding, no PDF tagging. We deliberately
+ * avoid Puppeteer's full distribution (~150 MB Chromium download) — `puppeteer-core`
+ * connects to the system Chrome we discover at runtime. PRINCIPLES §1 + §10.
  */
-export async function exportPdf(): Promise<never> {
-  throw new CodesignError('PDF export ships in Phase 2', 'EXPORTER_NOT_READY');
+export async function exportPdf(
+  htmlContent: string,
+  destinationPath: string,
+  opts: ExportPdfOptions = {},
+): Promise<ExportResult> {
+  const fs = await import('node:fs/promises');
+  const { findSystemChrome } = await import('./chrome-discovery');
+  const puppeteer = (await import('puppeteer-core')).default;
+
+  const executablePath = opts.chromePath ?? (await findSystemChrome());
+
+  let browser: Awaited<ReturnType<typeof puppeteer.launch>> | null = null;
+  try {
+    browser = await puppeteer.launch({
+      executablePath,
+      headless: true,
+      args: ['--no-sandbox', '--disable-dev-shm-usage'],
+    });
+    const page = await browser.newPage();
+    await page.setViewport(DEFAULT_VIEWPORT);
+    await page.setContent(htmlContent, { waitUntil: 'networkidle0', timeout: 30_000 });
+
+    const format = opts.format ?? 'Letter';
+    const pdfBuf =
+      format === 'auto'
+        ? await page.pdf({
+            printBackground: true,
+            width: `${DEFAULT_VIEWPORT.width}px`,
+            height: `${await page.evaluate('document.documentElement.scrollHeight')}px`,
+            margin: { top: '0', right: '0', bottom: '0', left: '0' },
+          })
+        : await page.pdf({ printBackground: true, format, preferCSSPageSize: true });
+
+    await fs.writeFile(destinationPath, pdfBuf);
+    const stat = await fs.stat(destinationPath);
+    return { bytes: stat.size, path: destinationPath };
+  } catch (err) {
+    if (err instanceof CodesignError) throw err;
+    throw new CodesignError(
+      `PDF export failed: ${err instanceof Error ? err.message : String(err)}`,
+      'EXPORTER_PDF_FAILED',
+      { cause: err },
+    );
+  } finally {
+    if (browser) await browser.close();
+  }
 }
diff --git a/packages/exporters/src/pptx.test.ts b/packages/exporters/src/pptx.test.ts
new file mode 100644
index 00000000..1a14830b
--- /dev/null
+++ b/packages/exporters/src/pptx.test.ts
@@ -0,0 +1,72 @@
+import { existsSync, mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { exportPptx, extractSlides } from './pptx';
+
+let tempDir = '';
+
+beforeAll(() => {
+  tempDir = mkdtempSync(join(tmpdir(), 'codesign-pptx-test-'));
+});
+
+afterAll(() => {
+  rmSync(tempDir, { recursive: true, force: true });
+});
+
+describe('extractSlides', () => {
+  it('treats each <section> as a slide and pulls the heading + bullets', () => {
+    const html = `
+      <section><h1>One</h1><ul><li>alpha</li><li>beta</li></ul></section>
+      <section><h2>Two</h2><p>paragraph body</p></section>
+    `;
+    const slides = extractSlides(html);
+    expect(slides).toHaveLength(2);
+    expect(slides[0]).toEqual({ title: 'One', bullets: ['alpha', 'beta'] });
+    expect(slides[1]).toEqual({ title: 'Two', bullets: ['paragraph body'] });
+  });
+
+  it('falls back to a single slide when no <section> exists', () => {
+    const slides = extractSlides('<h1>Solo</h1><p>body</p>');
+    expect(slides).toEqual([{ title: 'Solo', bullets: ['body'] }]);
+  });
+
+  it('preserves CJK characters end-to-end', () => {
+    const slides = extractSlides('<section><h1>你好</h1><p>世界</p></section>');
+    expect(slides[0]).toEqual({ title: '你好', bullets: ['世界'] });
+  });
+
+  it('strips inline <style> and <script> blocks from text content', () => {
+    const slides = extractSlides(
+      '<section><h1>x</h1><style>h1{color:red}</style><p>visible</p></section>',
+    );
+    expect(slides[0]?.bullets).toEqual(['visible']);
+  });
+});
+
+describe('exportPptx', () => {
+  it('writes a real .pptx with a CJK slide that downstream tools can open', async () => {
+    const dest = join(tempDir, 'cjk.pptx');
+    const result = await exportPptx(
+      '<section><h1>你好世界</h1><p>第一张幻灯片</p></section>',
+      dest,
+      { deckTitle: 'CJK smoke test' },
+    );
+
+    expect(existsSync(dest)).toBe(true);
+    expect(result.path).toBe(dest);
+    expect(result.bytes).toBeGreaterThan(1000);
+
+    const { readFile } = await import('node:fs/promises');
+    const buf = await readFile(dest);
+    // PPTX is a zip; magic bytes are PK\x03\x04
+    expect(buf[0]).toBe(0x50);
+    expect(buf[1]).toBe(0x4b);
+  }, 20_000);
+
+  it('throws EXPORTER_PPTX_FAILED on writeFile errors', async () => {
+    await expect(
+      exportPptx('<section>x</section>', join(tempDir, 'nope', 'missing-dir', 'fail.pptx')),
+    ).rejects.toMatchObject({ code: 'EXPORTER_PPTX_FAILED' });
+  });
+});
diff --git a/packages/exporters/src/pptx.ts b/packages/exporters/src/pptx.ts
index 1bead260..a023d05e 100644
--- a/packages/exporters/src/pptx.ts
+++ b/packages/exporters/src/pptx.ts
@@ -1,9 +1,144 @@
 import { CodesignError } from '@open-codesign/shared';
+import type { ExportResult } from './index';
+
+export interface ExportPptxOptions {
+  /** Slide title shown in PowerPoint's outline view. */
+  deckTitle?: string;
+}
+
+interface SlideContent {
+  title: string;
+  bullets: string[];
+}
 
 /**
- * Tier 2 — wired through `dom-to-pptx` once research/04 is implemented.
- * Throws loudly so callers cannot mistake "not yet shipped" for "succeeded silently".
+ * Render an HTML artifact to PPTX using pptxgenjs.
+ *
+ * Tier 1 strategy: walk top-level `<section>` elements (one slide each); if
+ * none exist, the whole document becomes a single slide. We do NOT use
+ * dom-to-pptx in tier 1 — the package is unmaintained and only adds
+ * editability for pure-text slides we already cover.
+ *
+ * CJK fix: per research/04, the dom-to-pptx wrap bug is sidestepped by
+ * keeping pptxgenjs' default `wrap=square` and explicitly enabling
+ * `fit: 'shrink'` (emits `normAutofit`). Verified with PowerPoint Mac.
  */
-export async function exportPptx(): Promise<never> {
-  throw new CodesignError('PPTX export ships in Phase 2', 'EXPORTER_NOT_READY');
+export async function exportPptx(
+  htmlContent: string,
+  destinationPath: string,
+  opts: ExportPptxOptions = {},
+): Promise<ExportResult> {
+  const fs = await import('node:fs/promises');
+  const PptxGenJS = (await import('pptxgenjs')).default;
+
+  try {
+    const slides = extractSlides(htmlContent);
+    const pres = new PptxGenJS();
+    pres.layout = 'LAYOUT_WIDE';
+    if (opts.deckTitle) pres.title = opts.deckTitle;
+
+    for (const s of slides) {
+      const slide = pres.addSlide();
+      slide.background = { color: 'FFFFFF' };
+      if (s.title) {
+        slide.addText(s.title, {
+          x: 0.5,
+          y: 0.4,
+          w: 12,
+          h: 1,
+          fontSize: 32,
+          bold: true,
+          color: '111111',
+          fontFace: 'Helvetica',
+          wrap: true,
+          fit: 'shrink',
+        });
+      }
+      if (s.bullets.length > 0) {
+        slide.addText(
+          s.bullets.map((b) => ({ text: b, options: { bullet: true } })),
+          {
+            x: 0.5,
+            y: 1.6,
+            w: 12,
+            h: 5.5,
+            fontSize: 18,
+            color: '333333',
+            fontFace: 'Helvetica',
+            wrap: true,
+            fit: 'shrink',
+            valign: 'top',
+            paraSpaceAfter: 8,
+          },
+        );
+      }
+    }
+
+    await pres.writeFile({ fileName: destinationPath });
+    const stat = await fs.stat(destinationPath);
+    return { bytes: stat.size, path: destinationPath };
+  } catch (err) {
+    throw new CodesignError(
+      `PPTX export failed: ${err instanceof Error ? err.message : String(err)}`,
+      'EXPORTER_PPTX_FAILED',
+      { cause: err },
+    );
+  }
+}
+
+const SECTION_RE = /<section\b[^>]*>([\s\S]*?)<\/section>/gi;
+const TAG_RE = /<[^>]+>/g;
+const HEADING_RE = /<h[1-3]\b[^>]*>([\s\S]*?)<\/h[1-3]>/i;
+const LIST_ITEM_RE = /<li\b[^>]*>([\s\S]*?)<\/li>/gi;
+const PARAGRAPH_RE = /<p\b[^>]*>([\s\S]*?)<\/p>/gi;
+
+export function extractSlides(html: string): SlideContent[] {
+  const sections: string[] = [];
+  let m: RegExpExecArray | null;
+  // biome-ignore lint/suspicious/noAssignInExpressions: standard regex iteration
+  while ((m = SECTION_RE.exec(html)) !== null) sections.push(m[1] ?? '');
+  if (sections.length === 0) sections.push(html);
+  return sections.map(parseSlide);
+}
+
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: HTML-to-slide extraction is a small state machine; splitting hides the priority order (heading → li → p → fallback)
+function parseSlide(fragment: string): SlideContent {
+  const headingMatch = HEADING_RE.exec(fragment);
+  const title = headingMatch ? stripHtml(headingMatch[1] ?? '') : '';
+
+  const bullets: string[] = [];
+  let li: RegExpExecArray | null;
+  // biome-ignore lint/suspicious/noAssignInExpressions: standard regex iteration
+  while ((li = LIST_ITEM_RE.exec(fragment)) !== null) {
+    const text = stripHtml(li[1] ?? '');
+    if (text) bullets.push(text);
+  }
+  if (bullets.length === 0) {
+    let p: RegExpExecArray | null;
+    // biome-ignore lint/suspicious/noAssignInExpressions: standard regex iteration
+    while ((p = PARAGRAPH_RE.exec(fragment)) !== null) {
+      const text = stripHtml(p[1] ?? '');
+      if (text) bullets.push(text);
+    }
+  }
+  if (bullets.length === 0 && !title) {
+    const text = stripHtml(fragment);
+    if (text) bullets.push(text);
+  }
+  return { title, bullets };
+}
+
+function stripHtml(s: string): string {
+  return s
+    .replace(/<style\b[\s\S]*?<\/style>/gi, '')
+    .replace(/<script\b[\s\S]*?<\/script>/gi, '')
+    .replace(TAG_RE, '')
+    .replace(/&nbsp;/g, ' ')
+    .replace(/&amp;/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/\s+/g, ' ')
+    .trim();
 }
diff --git a/packages/exporters/src/zip.test.ts b/packages/exporters/src/zip.test.ts
new file mode 100644
index 00000000..13148de8
--- /dev/null
+++ b/packages/exporters/src/zip.test.ts
@@ -0,0 +1,59 @@
+import { existsSync, mkdtempSync, realpathSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { exportZip } from './zip';
+
+let tempDir = '';
+
+beforeAll(() => {
+  tempDir = realpathSync(mkdtempSync(join(tmpdir(), 'codesign-zip-test-')));
+});
+
+afterAll(() => {
+  rmSync(tempDir, { recursive: true, force: true });
+});
+
+describe('exportZip', () => {
+  it('writes a multi-asset bundle with index.html, README.md and assets/', async () => {
+    const dest = join(tempDir, 'bundle.zip');
+    const result = await exportZip('<h1>hi</h1>', dest, {
+      assets: [
+        { path: 'assets/logo.svg', content: '<svg></svg>' },
+        { path: 'assets/data.bin', content: Buffer.from([1, 2, 3, 4]) },
+      ],
+      readmeTitle: 'Test bundle',
+    });
+
+    expect(existsSync(dest)).toBe(true);
+    expect(result.bytes).toBeGreaterThan(100);
+
+    const { Unzip } = await import('zip-lib');
+    const extractDir = join(tempDir, 'extracted');
+    const unzip = new Unzip();
+    await unzip.extract(dest, extractDir);
+
+    expect(existsSync(join(extractDir, 'index.html'))).toBe(true);
+    expect(existsSync(join(extractDir, 'README.md'))).toBe(true);
+    expect(existsSync(join(extractDir, 'assets', 'logo.svg'))).toBe(true);
+    expect(existsSync(join(extractDir, 'assets', 'data.bin'))).toBe(true);
+
+    const { readFile } = await import('node:fs/promises');
+    const readme = await readFile(join(extractDir, 'README.md'), 'utf8');
+    expect(readme).toContain('Test bundle');
+    expect(readme).toContain('open-codesign');
+  });
+
+  it('produces a valid zip without any extra assets', async () => {
+    const dest = join(tempDir, 'minimal.zip');
+    const result = await exportZip('<p>x</p>', dest);
+    expect(result.bytes).toBeGreaterThan(50);
+  });
+
+  it('throws EXPORTER_ZIP_FAILED when the destination cannot be written', async () => {
+    // Pass a directory as the destination — zip-lib will fail to write a regular file there.
+    await expect(exportZip('<p>x</p>', tempDir)).rejects.toMatchObject({
+      code: 'EXPORTER_ZIP_FAILED',
+    });
+  });
+});
diff --git a/packages/exporters/src/zip.ts b/packages/exporters/src/zip.ts
index 11c3b0fb..87dfcb17 100644
--- a/packages/exporters/src/zip.ts
+++ b/packages/exporters/src/zip.ts
@@ -1,9 +1,97 @@
 import { CodesignError } from '@open-codesign/shared';
+import type { ExportResult } from './index';
+
+export interface ZipAsset {
+  /** Path inside the archive, e.g. `assets/logo.svg`. */
+  path: string;
+  /** Raw bytes or UTF-8 string. */
+  content: Buffer | string;
+}
+
+export interface ExportZipOptions {
+  /** Extra files to bundle alongside `index.html` and the README. */
+  assets?: ZipAsset[];
+  /** Override the README banner. */
+  readmeTitle?: string;
+}
+
+const README_TEMPLATE = (title: string, generatedAt: string) => `# ${title}
+
+This bundle was exported from [open-codesign](https://github.com/OpenCoworkAI/open-codesign).
+
+## Layout
+
+\`\`\`
+.
+├── index.html      The exported design (open in any browser)
+├── assets/         Linked assets (images, fonts, scripts)
+└── README.md       This file
+\`\`\`
+
+## Notes
+
+- Generated: ${generatedAt}
+- The HTML is self-contained; opening \`index.html\` directly works without a server.
+- To re-edit, open the bundle in open-codesign via *File → Import bundle*.
+`;
 
 /**
- * Tier 2 — bundle artifact + assets + README into a portable ZIP.
- * Throws loudly so callers cannot mistake "not yet shipped" for "succeeded silently".
+ * Bundle an HTML artifact + assets into a portable ZIP using `zip-lib`.
+ *
+ * Tier 1: deterministic layout (`index.html` at root, assets under `assets/`,
+ * README at root). We pick zip-lib over yauzl/jszip because it ships ~80 KB,
+ * MIT, zero deps, and is the only Node-native zip writer we tested that
+ * handles >2 GB streams without blowing memory (PRINCIPLES §1).
  */
-export async function exportZip(): Promise<never> {
-  throw new CodesignError('ZIP export ships in Phase 2', 'EXPORTER_NOT_READY');
+export async function exportZip(
+  htmlContent: string,
+  destinationPath: string,
+  opts: ExportZipOptions = {},
+): Promise<ExportResult> {
+  const fs = await import('node:fs/promises');
+  const path = await import('node:path');
+  const os = await import('node:os');
+  const { Zip } = await import('zip-lib');
+
+  const stagingDir = await fs.mkdtemp(path.join(os.tmpdir(), 'codesign-zip-'));
+  try {
+    const indexPath = path.join(stagingDir, 'index.html');
+    await fs.writeFile(indexPath, htmlContent, 'utf8');
+
+    const readme = README_TEMPLATE(
+      opts.readmeTitle ?? 'open-codesign export',
+      new Date().toISOString(),
+    );
+    const readmePath = path.join(stagingDir, 'README.md');
+    await fs.writeFile(readmePath, readme, 'utf8');
+
+    const zip = new Zip();
+    zip.addFile(indexPath, 'index.html');
+    zip.addFile(readmePath, 'README.md');
+
+    if (opts.assets) {
+      for (const asset of opts.assets) {
+        const safeRel = asset.path.replace(/^\/+/, '');
+        const localPath = path.join(stagingDir, safeRel);
+        await fs.mkdir(path.dirname(localPath), { recursive: true });
+        await fs.writeFile(
+          localPath,
+          typeof asset.content === 'string' ? asset.content : asset.content,
+        );
+        zip.addFile(localPath, safeRel);
+      }
+    }
+
+    await zip.archive(destinationPath);
+    const stat = await fs.stat(destinationPath);
+    return { bytes: stat.size, path: destinationPath };
+  } catch (err) {
+    throw new CodesignError(
+      `ZIP export failed: ${err instanceof Error ? err.message : String(err)}`,
+      'EXPORTER_ZIP_FAILED',
+      { cause: err },
+    );
+  } finally {
+    await fs.rm(stagingDir, { recursive: true, force: true });
+  }
 }
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 7c56e71f..e761fb09 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -146,6 +146,15 @@ importers:
       '@open-codesign/shared':
         specifier: workspace:*
         version: link:../shared
+      pptxgenjs:
+        specifier: ^3.12.0
+        version: 3.12.0
+      puppeteer-core:
+        specifier: ^24.10.0
+        version: 24.41.0
+      zip-lib:
+        specifier: ^1.0.4
+        version: 1.3.2
     devDependencies:
       '@types/node':
         specifier: ^22.10.2
@@ -1025,6 +1034,11 @@ packages:
   '@protobufjs/utf8@1.1.0':
     resolution: {integrity: sha512-Vvn3zZrhQZkkBE8LSuW3em98c0FwgO4nxzv6OdSxPKJIEKY2bGbHn+mhGIPerzI4twdxaP8/0+06HBpwf345Lw==}
 
+  '@puppeteer/browsers@2.13.0':
+    resolution: {integrity: sha512-46BZJYJjc/WwmKjsvDFykHtXrtomsCIrwYQPOP7VfMJoZY2bsDF9oROBABR3paDjDcmkUye1Pb1BqdcdiipaWA==}
+    engines: {node: '>=18'}
+    hasBin: true
+
   '@rolldown/pluginutils@1.0.0-beta.27':
     resolution: {integrity: sha512-+d0F4MKMCbeVUJwG96uQ4SgAznZNSq93I3V+9NHA4OpvqG8mRCpGdKmK8l/dl02h2CCDHwW2FqilnTyDcAnqjA==}
 
@@ -1513,6 +1527,9 @@ packages:
   '@types/node@12.20.55':
     resolution: {integrity: sha512-J8xLz7q2OFulZ2cyGTLE1TbbZcjpno7FaN6zdJNrgAdrJ+DZzh/uFR6YrTb4C+nXakvud8Q4+rbhoIWlYQbUFQ==}
 
+  '@types/node@18.19.130':
+    resolution: {integrity: sha512-GRaXQx6jGfL8sKfaIDD6OupbIHBr9jv7Jnaml9tB7l4v068PAOXqfcujMMo5PhbIs6ggR1XODELqahT2R8v0fg==}
+
   '@types/node@20.19.39':
     resolution: {integrity: sha512-orrrD74MBUyK8jOAD/r0+lfa1I2MO6I+vAkmAWzMYbCcgrN4lCrmK52gRFQq/JRxfYPfonkr4b0jcY7Olqdqbw==}
 
@@ -1716,6 +1733,14 @@ packages:
     peerDependencies:
       postcss: ^8.1.0
 
+  b4a@1.8.0:
+    resolution: {integrity: sha512-qRuSmNSkGQaHwNbM7J78Wwy+ghLEYF1zNrSeMxj4Kgw6y33O3mXcQ6Ie9fRvfU/YnxWkOchPXbaLb73TkIsfdg==}
+    peerDependencies:
+      react-native-b4a: '*'
+    peerDependenciesMeta:
+      react-native-b4a:
+        optional: true
+
   balanced-match@1.0.2:
     resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==}
 
@@ -1723,6 +1748,47 @@ packages:
     resolution: {integrity: sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==}
     engines: {node: 18 || 20 || >=22}
 
+  bare-events@2.8.2:
+    resolution: {integrity: sha512-riJjyv1/mHLIPX4RwiK+oW9/4c3TEUeORHKefKAKnZ5kyslbN+HXowtbaVEqt4IMUB7OXlfixcs6gsFeo/jhiQ==}
+    peerDependencies:
+      bare-abort-controller: '*'
+    peerDependenciesMeta:
+      bare-abort-controller:
+        optional: true
+
+  bare-fs@4.7.1:
+    resolution: {integrity: sha512-WDRsyVN52eAx/lBamKD6uyw8H4228h/x0sGGGegOamM2cd7Pag88GfMQalobXI+HaEUxpCkbKQUDOQqt9wawRw==}
+    engines: {bare: '>=1.16.0'}
+    peerDependencies:
+      bare-buffer: '*'
+    peerDependenciesMeta:
+      bare-buffer:
+        optional: true
+
+  bare-os@3.8.7:
+    resolution: {integrity: sha512-G4Gr1UsGeEy2qtDTZwL7JFLo2wapUarz7iTMcYcMFdS89AIQuBoyjgXZz0Utv7uHs3xA9LckhVbeBi8lEQrC+w==}
+    engines: {bare: '>=1.14.0'}
+
+  bare-path@3.0.0:
+    resolution: {integrity: sha512-tyfW2cQcB5NN8Saijrhqn0Zh7AnFNsnczRcuWODH0eYAXBsJ5gVxAUuNr7tsHSC6IZ77cA0SitzT+s47kot8Mw==}
+
+  bare-stream@2.13.0:
+    resolution: {integrity: sha512-3zAJRZMDFGjdn+RVnNpF9kuELw+0Fl3lpndM4NcEOhb9zwtSo/deETfuIwMSE5BXanA0FrN1qVjffGwAg2Y7EA==}
+    peerDependencies:
+      bare-abort-controller: '*'
+      bare-buffer: '*'
+      bare-events: '*'
+    peerDependenciesMeta:
+      bare-abort-controller:
+        optional: true
+      bare-buffer:
+        optional: true
+      bare-events:
+        optional: true
+
+  bare-url@2.4.0:
+    resolution: {integrity: sha512-NSTU5WN+fy/L0DDenfE8SXQna4voXuW0FHM7wH8i3/q9khUSchfPbPezO4zSFMnDGIf9YE+mt/RWhZgNRKRIXA==}
+
   base64-js@1.5.1:
     resolution: {integrity: sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==}
 
@@ -1780,6 +1846,10 @@ packages:
   buffer-crc32@0.2.13:
     resolution: {integrity: sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ==}
 
+  buffer-crc32@1.0.0:
+    resolution: {integrity: sha512-Db1SbgBS/fg/392AblrMJk97KggmvYhr4pB5ZIMTWtaivCPMWLkmb7m21cJvpvgK+J3nsU2CmmixNBZx4vFj/w==}
+    engines: {node: '>=8.0.0'}
+
   buffer-equal-constant-time@1.0.1:
     resolution: {integrity: sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA==}
 
@@ -1846,6 +1916,11 @@ packages:
     resolution: {integrity: sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==}
     engines: {node: '>=10'}
 
+  chromium-bidi@14.0.0:
+    resolution: {integrity: sha512-9gYlLtS6tStdRWzrtXaTMnqcM4dudNegMXJxkR0I/CXObHalYeYcAMPrL19eroNZHtJ8DQmu1E+ZNOYu/IXMXw==}
+    peerDependencies:
+      devtools-protocol: '*'
+
   chromium-pickle-js@0.2.0:
     resolution: {integrity: sha512-1R5Fho+jBq0DDydt+/vHWj5KJNJCKdARKOCwZUen84I5BreWoLqRLANH1U87eJy1tiASPtMnGqJJq0ZsLoRPOw==}
 
@@ -2006,6 +2081,9 @@ packages:
   detect-node@2.1.0:
     resolution: {integrity: sha512-T0NIuQpnTvFDATNuHN5roPwSBG83rFsuO+MXXH9/3N1eFbn4wcPjttvjMLEPWJ0RGUYgQE7cGgS3tNxbqCGM7g==}
 
+  devtools-protocol@0.0.1595872:
+    resolution: {integrity: sha512-kRfgp8vWVjBu/fbYCiVFiOqsCk3CrMKEo3WbgGT2NXK2dG7vawWPBljixajVgGK9II8rDO9G0oD0zLt3I1daRg==}
+
   dir-compare@4.2.0:
     resolution: {integrity: sha512-2xMCmOoMrdQIPHdsTawECdNPwlVFB9zGcz3kuhmBO6U3oU+UQjsue0i8ayLKpgBcm+hcXPMVSGUN9d+pvJ6+VQ==}
 
@@ -2166,6 +2244,9 @@ packages:
     resolution: {integrity: sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==}
     engines: {node: '>=0.10.0'}
 
+  events-universal@1.0.1:
+    resolution: {integrity: sha512-LUd5euvbMLpwOF8m6ivPCbhQeSiYVNb8Vs0fQ8QjXo0JTkEHpz8pxdQf0gStltaPpw0Cca8b39KxvK9cfKRiAw==}
+
   expect-type@1.3.0:
     resolution: {integrity: sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==}
     engines: {node: '>=12.0.0'}
@@ -2191,6 +2272,9 @@ packages:
   fast-deep-equal@3.1.3:
     resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==}
 
+  fast-fifo@1.3.2:
+    resolution: {integrity: sha512-/d9sfos4yxzpwkDkuN7k2SqFKtYNmCTzgfEpz82x34IM9/zc8KGxQoXg1liNC/izpRM/MBdt44Nmx41ZWqk+FQ==}
+
   fast-glob@3.3.3:
     resolution: {integrity: sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==}
     engines: {node: '>=8.6.0'}
@@ -2426,6 +2510,9 @@ packages:
     resolution: {integrity: sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==}
     engines: {node: '>= 14'}
 
+  https@1.0.0:
+    resolution: {integrity: sha512-4EC57ddXrkaF0x83Oj8sM6SLQHAWXw90Skqu2M4AEWENZ3F02dFJE/GARA8igO79tcgYqGrD7ae4f5L3um2lgg==}
+
   human-id@4.1.3:
     resolution: {integrity: sha512-tsYlhAYpjCKa//8rXZ9DqKEawhPoSytweBC2eNvcaDK+57RZLHGqNs3PZTQO6yekLFSuvA6AlnAfrw1uBvtb+Q==}
     hasBin: true
@@ -2453,6 +2540,14 @@ packages:
     resolution: {integrity: sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==}
     engines: {node: '>= 4'}
 
+  image-size@1.2.1:
+    resolution: {integrity: sha512-rH+46sQJ2dlwfjfhCyNx5thzrv+dtmBIhPHk0zgRUukHzZ/kRueTJXoYYsclBaKcSMBWuGbOFXtioLpzTb5euw==}
+    engines: {node: '>=16.x'}
+    hasBin: true
+
+  immediate@3.0.6:
+    resolution: {integrity: sha512-XXOFtyqDjNDAQxVfYxuF7g9Il/IbWmmlQg2MYKOH8ExIT1qg6xc4zyS3HaEEATgs1btfzxq15ciUiY7gjSXRGQ==}
+
   imurmurhash@0.1.4:
     resolution: {integrity: sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==}
     engines: {node: '>=0.8.19'}
@@ -2586,6 +2681,9 @@ packages:
   jsonfile@6.2.0:
     resolution: {integrity: sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==}
 
+  jszip@3.10.1:
+    resolution: {integrity: sha512-xXDvecyTpGLrqFrvkrUSoxxfJI5AH7U8zxxtVclpsUtMCq4JQ290LY8AW5c7Ggnr/Y/oK+bQMbqK2qmtk3pN4g==}
+
   jwa@2.0.1:
     resolution: {integrity: sha512-hRF04fqJIP8Abbkq5NKGN0Bbr3JxlQ+qhZufXVr0DvujKy93ZCbXZMHDL4EOtodSbCWxOqR8MS1tXA5hwqCXDg==}
 
@@ -2602,6 +2700,9 @@ packages:
     resolution: {integrity: sha512-b94GiNHQNy6JNTrt5w6zNyffMrNkXZb3KTkCZJb2V1xaEGCk093vkZ2jk3tpaeP33/OiXC+WvK9AxUebnf5nbw==}
     engines: {node: '>= 0.6.3'}
 
+  lie@3.3.0:
+    resolution: {integrity: sha512-UaiMJzeWRlEujzAuw5LokY1L5ecNQYZKfmyZ9L7wDHb/p5etKaxXhohBcrw0EYby+G/NA52vRSN4N39dxHAIwQ==}
+
   lightningcss-android-arm64@1.32.0:
     resolution: {integrity: sha512-YK7/ClTt4kAK0vo6w3X+Pnm0D2cf2vPHbhOXdoNti1Ga0al1P4TBZhwjATvjNwLEBCnKvjJc2jQgHXH0NEwlAg==}
     engines: {node: '>= 12.0.0'}
@@ -2839,6 +2940,9 @@ packages:
     resolution: {integrity: sha512-bAxsR8BVfj60DWXHE3u30oHzfl4G7khkSuPW+qvpd7jFRHm7dLxOjUk1EHACJ/hxLY8phGJ0YhYHZo7jil7Qdg==}
     engines: {node: '>= 8'}
 
+  mitt@3.0.1:
+    resolution: {integrity: sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw==}
+
   mkdirp@1.0.4:
     resolution: {integrity: sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==}
     engines: {node: '>=10'}
@@ -2989,6 +3093,9 @@ packages:
   package-manager-detector@0.2.11:
     resolution: {integrity: sha512-BEnLolu+yuz22S56CU1SUKq3XC3PkwD5wv4ikR4MfGvnRVcmzXR9DwSlW2fEamyTPyXHomBJRzgapeuBvRNzJQ==}
 
+  pako@1.0.11:
+    resolution: {integrity: sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw==}
+
   partial-json@0.1.7:
     resolution: {integrity: sha512-Njv/59hHaokb/hRUjce3Hdv12wd60MtM9Z5Olmn+nehe0QDAsRtRbJPvJ0Z91TusF0SuZRIvnM+S4l6EIP8leA==}
 
@@ -3056,6 +3163,9 @@ packages:
     resolution: {integrity: sha512-pMMHxBOZKFU6HgAZ4eyGnwXF/EvPGGqUr0MnZ5+99485wwW41kW91A4LOGxSHhgugZmSChL5AlElNdwlNgcnLQ==}
     engines: {node: ^10 || ^12 || >=14}
 
+  pptxgenjs@3.12.0:
+    resolution: {integrity: sha512-ZozkYKWb1MoPR4ucw3/aFYlHkVIJxo9czikEclcUVnS4Iw/M+r+TEwdlB3fyAWO9JY1USxJDt0Y0/r15IR/RUA==}
+
   prettier@2.8.8:
     resolution: {integrity: sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q==}
     engines: {node: '>=10.13.0'}
@@ -3098,12 +3208,19 @@ packages:
     resolution: {integrity: sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==}
     engines: {node: '>=6'}
 
+  puppeteer-core@24.41.0:
+    resolution: {integrity: sha512-rLIUri7E/NQ3APSEYCCozaSJx0u8Tu9wxO6BJwnvXmIgILSK3L0TombaVh3izp1njAGrO6H2ru0hcIrLF+gWLw==}
+    engines: {node: '>=18'}
+
   quansync@0.2.11:
     resolution: {integrity: sha512-AifT7QEbW9Nri4tAwR5M/uzpBuqfZf+zwaEM/QkzEjj7NBuFD2rBuy0K3dE+8wltbezDV7JMA0WfnCPYRSYbXA==}
 
   queue-microtask@1.2.3:
     resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==}
 
+  queue@6.0.2:
+    resolution: {integrity: sha512-iHZWu+q3IdFZFX36ro/lKBkSvfkztY5Y7HMiPlOUjhupPcG2JMfst2KKEpu5XndviX/3UhFbRngUPNKtgvtZiA==}
+
   quick-lru@5.1.1:
     resolution: {integrity: sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==}
     engines: {node: '>=10'}
@@ -3232,6 +3349,9 @@ packages:
   set-blocking@2.0.0:
     resolution: {integrity: sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==}
 
+  setimmediate@1.0.5:
+    resolution: {integrity: sha512-MATJdZp8sLqDl/68LfQmbP8zKPLQNV6BIZoIgrscFDQ+RsvK/BxeDQOgyxKKoh0y/8h3BqVFnCqQ/gd+reiIXA==}
+
   shebang-command@2.0.0:
     resolution: {integrity: sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==}
     engines: {node: '>=8'}
@@ -3312,6 +3432,9 @@ packages:
   std-env@3.10.0:
     resolution: {integrity: sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==}
 
+  streamx@2.25.0:
+    resolution: {integrity: sha512-0nQuG6jf1w+wddNEEXCF4nTg3LtufWINB5eFEN+5TNZW7KWJp6x87+JFL43vaAUPyCfH1wID+mNVyW6OHtFamg==}
+
   string-width@4.2.3:
     resolution: {integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==}
     engines: {node: '>=8'}
@@ -3356,15 +3479,24 @@ packages:
     resolution: {integrity: sha512-1MOpMXuhGzGL5TTCZFItxCc0AARf1EZFQkGqMm7ERKj8+Hgr5oLvJOVFcC+lRmR8hCe2S3jC4T5D7Vg/d7/fhA==}
     engines: {node: '>=6'}
 
+  tar-fs@3.1.2:
+    resolution: {integrity: sha512-QGxxTxxyleAdyM3kpFs14ymbYmNFrfY+pHj7Z8FgtbZ7w2//VAgLMac7sT6nRpIHjppXO2AwwEOg0bPFVRcmXw==}
+
   tar-stream@2.2.0:
     resolution: {integrity: sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==}
     engines: {node: '>=6'}
 
+  tar-stream@3.1.8:
+    resolution: {integrity: sha512-U6QpVRyCGHva435KoNWy9PRoi2IFYCgtEhq9nmrPPpbRacPs9IH4aJ3gbrFC8dPcXvdSZ4XXfXT5Fshbp2MtlQ==}
+
   tar@6.2.1:
     resolution: {integrity: sha512-DZ4yORTwrbTj/7MZYq2w+/ZFdI6OZ/f9SFHR+71gIVUZhOQPHzVCLpvRnPgyaMpfWxxk/4ONva3GQSyNIKRv6A==}
     engines: {node: '>=10'}
     deprecated: Old versions of tar are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
 
+  teex@1.0.1:
+    resolution: {integrity: sha512-eYE6iEI62Ni1H8oIa7KlDU6uQBtqr4Eajni3wX7rpfXD8ysFx8z0+dri+KWEPWpBsxXfxu58x/0jvTVT1ekOSg==}
+
   temp-file@3.4.0:
     resolution: {integrity: sha512-C5tjlC/HCtVUOi3KWVokd4vHVViOmGjtLwIh4MuzPo/nMYTV/p1urt3RnMz2IWXDdKEGJH3k5+KPxtqRsUYGtg==}
 
@@ -3372,6 +3504,9 @@ packages:
     resolution: {integrity: sha512-wK0Ri4fOGjv/XPy8SBHZChl8CM7uMc5VML7SqiQ0zG7+J5Vr+RMQDoHa2CNT6KHUnTGIXH34UDMkPzAUyapBZg==}
     engines: {node: '>=8'}
 
+  text-decoder@1.2.7:
+    resolution: {integrity: sha512-vlLytXkeP4xvEq2otHeJfSQIRyWxo/oZGEbXrtEEF9Hnmrdly59sUbzZ/QgyWuLYHctCHxFF4tRQZNQ9k60ExQ==}
+
   tiny-typed-emitter@2.1.0:
     resolution: {integrity: sha512-qVtvMxeXbVej0cQWKqVSSAHmKZEHAvxdF8HEUBFWts8h+xEo5m/lEiPakuyZ3BnCBjOD8i24kzNOiOLLgsSxhA==}
 
@@ -3425,11 +3560,17 @@ packages:
     resolution: {integrity: sha512-34R7HTnG0XIJcBSn5XhDd7nNFPRcXYRZrBB2O2jdKqYODldSzBAqzsWoZYYvduky73toYS/ESqxPvkDf/F0XMg==}
     engines: {node: '>=10'}
 
+  typed-query-selector@2.12.1:
+    resolution: {integrity: sha512-uzR+FzI8qrUEIu96oaeBJmd9E7CFEiQ3goA5qCVgc4s5llSubcfGHq9yUstZx/k4s9dXHVKsE35YWoFyvEqEHA==}
+
   typescript@5.9.3:
     resolution: {integrity: sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==}
     engines: {node: '>=14.17'}
     hasBin: true
 
+  undici-types@5.26.5:
+    resolution: {integrity: sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==}
+
   undici-types@6.21.0:
     resolution: {integrity: sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==}
 
@@ -3580,6 +3721,9 @@ packages:
     resolution: {integrity: sha512-d2JWLCivmZYTSIoge9MsgFCZrt571BikcWGYkjC1khllbTeDlGqZ2D8vD8E/lJa8WGWbb7Plm8/XJYV7IJHZZw==}
     engines: {node: '>= 8'}
 
+  webdriver-bidi-protocol@0.4.1:
+    resolution: {integrity: sha512-ARrjNjtWRRs2w4Tk7nqrf2gBI0QXWuOmMCx2hU+1jUt6d00MjMxURrhxhGbrsoiZKJrhTSTzbIrc554iKI10qw==}
+
   which@2.0.2:
     resolution: {integrity: sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==}
     engines: {node: '>= 8'}
@@ -3641,10 +3785,21 @@ packages:
   yauzl@2.10.0:
     resolution: {integrity: sha512-p4a9I6X6nu6IhoGmBqAcbJy1mlC4j27vEPZX9F4L4/vZT3Lyq1VkFHw/V/PUcB9Buo+DG3iHkT0x3Qya58zc3g==}
 
+  yauzl@3.3.0:
+    resolution: {integrity: sha512-PtGEvEP30p7sbIBJKUBjUnqgTVOyMURc4dLo9iNyAJnNIEz9pm88cCXF21w94Kg3k6RXkeZh5DHOGS0qEONvNQ==}
+    engines: {node: '>=12'}
+
+  yazl@3.3.1:
+    resolution: {integrity: sha512-BbETDVWG+VcMUle37k5Fqp//7SDOK2/1+T7X8TD96M3D9G8jK5VLUdQVdVjGi8im7FGkazX7kk5hkU8X4L5Bng==}
+
   yocto-queue@0.1.0:
     resolution: {integrity: sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==}
     engines: {node: '>=10'}
 
+  zip-lib@1.3.2:
+    resolution: {integrity: sha512-y5i/N4exvEzl45gavh4IwBuspSc95R2Ju9zLTBdNWv3nttBqi9zKuz9q3Tz+tl6NOkTI0zwTBiAqv5WakQVOfQ==}
+    engines: {node: '>=20'}
+
   zip-stream@4.1.1:
     resolution: {integrity: sha512-9qv4rlDiopXg4E69k+vMHjNN63YFMe9sZMrdlvKnCjlCRWeCBswPPMPUfx+ipsAWq1LXHe70RcbaHdJJpS6hyQ==}
     engines: {node: '>= 10'}
@@ -4741,6 +4896,21 @@ snapshots:
 
   '@protobufjs/utf8@1.1.0': {}
 
+  '@puppeteer/browsers@2.13.0':
+    dependencies:
+      debug: 4.4.3
+      extract-zip: 2.0.1
+      progress: 2.0.3
+      proxy-agent: 6.5.0
+      semver: 7.7.4
+      tar-fs: 3.1.2
+      yargs: 17.7.2
+    transitivePeerDependencies:
+      - bare-abort-controller
+      - bare-buffer
+      - react-native-b4a
+      - supports-color
+
   '@rolldown/pluginutils@1.0.0-beta.27': {}
 
   '@rollup/rollup-android-arm-eabi@4.60.1':
@@ -5265,6 +5435,10 @@ snapshots:
 
   '@types/node@12.20.55': {}
 
+  '@types/node@18.19.130':
+    dependencies:
+      undici-types: 5.26.5
+
   '@types/node@20.19.39':
     dependencies:
       undici-types: 6.21.0
@@ -5530,10 +5704,44 @@ snapshots:
       postcss: 8.5.10
       postcss-value-parser: 4.2.0
 
+  b4a@1.8.0: {}
+
   balanced-match@1.0.2: {}
 
   balanced-match@4.0.4: {}
 
+  bare-events@2.8.2: {}
+
+  bare-fs@4.7.1:
+    dependencies:
+      bare-events: 2.8.2
+      bare-path: 3.0.0
+      bare-stream: 2.13.0(bare-events@2.8.2)
+      bare-url: 2.4.0
+      fast-fifo: 1.3.2
+    transitivePeerDependencies:
+      - bare-abort-controller
+      - react-native-b4a
+
+  bare-os@3.8.7: {}
+
+  bare-path@3.0.0:
+    dependencies:
+      bare-os: 3.8.7
+
+  bare-stream@2.13.0(bare-events@2.8.2):
+    dependencies:
+      streamx: 2.25.0
+      teex: 1.0.1
+    optionalDependencies:
+      bare-events: 2.8.2
+    transitivePeerDependencies:
+      - react-native-b4a
+
+  bare-url@2.4.0:
+    dependencies:
+      bare-path: 3.0.0
+
   base64-js@1.5.1: {}
 
   baseline-browser-mapping@2.10.19: {}
@@ -5590,6 +5798,8 @@ snapshots:
 
   buffer-crc32@0.2.13: {}
 
+  buffer-crc32@1.0.0: {}
+
   buffer-equal-constant-time@1.0.1: {}
 
   buffer-from@1.1.2: {}
@@ -5699,6 +5909,12 @@ snapshots:
 
   chownr@2.0.0: {}
 
+  chromium-bidi@14.0.0(devtools-protocol@0.0.1595872):
+    dependencies:
+      devtools-protocol: 0.0.1595872
+      mitt: 3.0.1
+      zod: 3.25.76
+
   chromium-pickle-js@0.2.0: {}
 
   ci-info@3.9.0: {}
@@ -5839,6 +6055,8 @@ snapshots:
   detect-node@2.1.0:
     optional: true
 
+  devtools-protocol@0.0.1595872: {}
+
   dir-compare@4.2.0:
     dependencies:
       minimatch: 3.1.5
@@ -6097,6 +6315,12 @@ snapshots:
 
   esutils@2.0.3: {}
 
+  events-universal@1.0.1:
+    dependencies:
+      bare-events: 2.8.2
+    transitivePeerDependencies:
+      - bare-abort-controller
+
   expect-type@1.3.0: {}
 
   exponential-backoff@3.1.3: {}
@@ -6120,6 +6344,8 @@ snapshots:
 
   fast-deep-equal@3.1.3: {}
 
+  fast-fifo@1.3.2: {}
+
   fast-glob@3.3.3:
     dependencies:
       '@nodelib/fs.stat': 2.0.5
@@ -6441,6 +6667,8 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  https@1.0.0: {}
+
   human-id@4.1.3: {}
 
   humanize-ms@1.2.1:
@@ -6465,6 +6693,12 @@ snapshots:
 
   ignore@5.3.2: {}
 
+  image-size@1.2.1:
+    dependencies:
+      queue: 6.0.2
+
+  immediate@3.0.6: {}
+
   imurmurhash@0.1.4: {}
 
   indent-string@4.0.0: {}
@@ -6571,6 +6805,13 @@ snapshots:
     optionalDependencies:
       graceful-fs: 4.2.11
 
+  jszip@3.10.1:
+    dependencies:
+      lie: 3.3.0
+      pako: 1.0.11
+      readable-stream: 2.3.8
+      setimmediate: 1.0.5
+
   jwa@2.0.1:
     dependencies:
       buffer-equal-constant-time: 1.0.1
@@ -6592,6 +6833,10 @@ snapshots:
     dependencies:
       readable-stream: 2.3.8
 
+  lie@3.3.0:
+    dependencies:
+      immediate: 3.0.6
+
   lightningcss-android-arm64@1.32.0:
     optional: true
 
@@ -6799,6 +7044,8 @@ snapshots:
       minipass: 3.3.6
       yallist: 4.0.0
 
+  mitt@3.0.1: {}
+
   mkdirp@1.0.4: {}
 
   mri@1.2.0: {}
@@ -6949,6 +7196,8 @@ snapshots:
     dependencies:
       quansync: 0.2.11
 
+  pako@1.0.11: {}
+
   partial-json@0.1.7: {}
 
   path-exists@4.0.0: {}
@@ -6996,6 +7245,13 @@ snapshots:
       picocolors: 1.1.1
       source-map-js: 1.2.1
 
+  pptxgenjs@3.12.0:
+    dependencies:
+      '@types/node': 18.19.130
+      https: 1.0.0
+      image-size: 1.2.1
+      jszip: 3.10.1
+
   prettier@2.8.8: {}
 
   process-nextick-args@2.0.1: {}
@@ -7046,10 +7302,31 @@ snapshots:
 
   punycode@2.3.1: {}
 
+  puppeteer-core@24.41.0:
+    dependencies:
+      '@puppeteer/browsers': 2.13.0
+      chromium-bidi: 14.0.0(devtools-protocol@0.0.1595872)
+      debug: 4.4.3
+      devtools-protocol: 0.0.1595872
+      typed-query-selector: 2.12.1
+      webdriver-bidi-protocol: 0.4.1
+      ws: 8.20.0
+    transitivePeerDependencies:
+      - bare-abort-controller
+      - bare-buffer
+      - bufferutil
+      - react-native-b4a
+      - supports-color
+      - utf-8-validate
+
   quansync@0.2.11: {}
 
   queue-microtask@1.2.3: {}
 
+  queue@6.0.2:
+    dependencies:
+      inherits: 2.0.4
+
   quick-lru@5.1.1: {}
 
   react-dom@19.2.5(react@19.2.5):
@@ -7198,6 +7475,8 @@ snapshots:
 
   set-blocking@2.0.0: {}
 
+  setimmediate@1.0.5: {}
+
   shebang-command@2.0.0:
     dependencies:
       shebang-regex: 3.0.0
@@ -7275,6 +7554,15 @@ snapshots:
 
   std-env@3.10.0: {}
 
+  streamx@2.25.0:
+    dependencies:
+      events-universal: 1.0.1
+      fast-fifo: 1.3.2
+      text-decoder: 1.2.7
+    transitivePeerDependencies:
+      - bare-abort-controller
+      - react-native-b4a
+
   string-width@4.2.3:
     dependencies:
       emoji-regex: 8.0.0
@@ -7321,6 +7609,18 @@ snapshots:
 
   tapable@2.3.2: {}
 
+  tar-fs@3.1.2:
+    dependencies:
+      pump: 3.0.4
+      tar-stream: 3.1.8
+    optionalDependencies:
+      bare-fs: 4.7.1
+      bare-path: 3.0.0
+    transitivePeerDependencies:
+      - bare-abort-controller
+      - bare-buffer
+      - react-native-b4a
+
   tar-stream@2.2.0:
     dependencies:
       bl: 4.1.0
@@ -7329,6 +7629,17 @@ snapshots:
       inherits: 2.0.4
       readable-stream: 3.6.2
 
+  tar-stream@3.1.8:
+    dependencies:
+      b4a: 1.8.0
+      bare-fs: 4.7.1
+      fast-fifo: 1.3.2
+      streamx: 2.25.0
+    transitivePeerDependencies:
+      - bare-abort-controller
+      - bare-buffer
+      - react-native-b4a
+
   tar@6.2.1:
     dependencies:
       chownr: 2.0.0
@@ -7338,6 +7649,13 @@ snapshots:
       mkdirp: 1.0.4
       yallist: 4.0.0
 
+  teex@1.0.1:
+    dependencies:
+      streamx: 2.25.0
+    transitivePeerDependencies:
+      - bare-abort-controller
+      - react-native-b4a
+
   temp-file@3.4.0:
     dependencies:
       async-exit-hook: 2.0.1
@@ -7345,6 +7663,12 @@ snapshots:
 
   term-size@2.2.1: {}
 
+  text-decoder@1.2.7:
+    dependencies:
+      b4a: 1.8.0
+    transitivePeerDependencies:
+      - react-native-b4a
+
   tiny-typed-emitter@2.1.0: {}
 
   tinybench@2.9.0: {}
@@ -7392,8 +7716,12 @@ snapshots:
   type-fest@0.13.1:
     optional: true
 
+  typed-query-selector@2.12.1: {}
+
   typescript@5.9.3: {}
 
+  undici-types@5.26.5: {}
+
   undici-types@6.21.0: {}
 
   undici@7.25.0: {}
@@ -7514,6 +7842,8 @@ snapshots:
 
   web-streams-polyfill@3.3.3: {}
 
+  webdriver-bidi-protocol@0.4.1: {}
+
   which@2.0.2:
     dependencies:
       isexe: 2.0.0
@@ -7568,8 +7898,22 @@ snapshots:
       buffer-crc32: 0.2.13
       fd-slicer: 1.1.0
 
+  yauzl@3.3.0:
+    dependencies:
+      buffer-crc32: 0.2.13
+      pend: 1.2.0
+
+  yazl@3.3.1:
+    dependencies:
+      buffer-crc32: 1.0.0
+
   yocto-queue@0.1.0: {}
 
+  zip-lib@1.3.2:
+    dependencies:
+      yauzl: 3.3.0
+      yazl: 3.3.1
+
   zip-stream@4.1.1:
     dependencies:
       archiver-utils: 3.0.4