fix: broken export

ui/lib/io/pagesIo.ts

@@ -68,7 +68,16 @@ export async function exportCurrentProjectAs(
   format: 'khr' | 'psd' | 'rendered' | 'inpainted',
   pages?: string[],
 ): Promise<void> {
-  const blob = await exportProject({ format, pages })
-  const base = sanitiseBaseName(currentProjectName())
-  await saveBlob(blob, `${base}.${exportExtension[format]}`)
+  try {
+    const { blob, filename } = await exportProject({ format, pages })
+    const base = sanitiseBaseName(currentProjectName())
+    // Prefer the server's Content-Disposition filename (matches the actual
+    // bytes — a raw PNG/PSD for single-file responses, a zip for multi).
+    // Fall back to our guess only if the header is missing/unparseable.
+    const defaultName = filename ?? `${base}.${exportExtension[format]}`
+    await saveBlob(blob, defaultName)
+  } catch (err) {
+    console.error('Export failed:', err)
+    throw err
+  }
 }

ui/lib/io/saveBlob.ts

@@ -18,7 +18,10 @@
 import { isTauri } from '@/lib/backend'
 
 export async function saveBlob(blob: Blob, defaultName: string): Promise<boolean> {
-  const isZip = blob.type === 'application/zip' || defaultName.toLowerCase().endsWith('.zip')
+  // Zip detection must come from the actual content type — a single-file
+  // export (PNG/PSD/khr) whose filename happens to end in `.zip` would
+  // otherwise be fed to `unzipSync` and throw.
+  const isZip = blob.type === 'application/zip'
 
   if (isTauri()) {
     const { open, save } = await import('@tauri-apps/plugin-dialog')

ui/lib/io/scene.ts

@@ -6,8 +6,8 @@ import {
   createPagesFromPaths,
   createProject,
   deleteCurrentProject,
-  exportCurrentProject,
   getConfig,
+  getExportCurrentProjectUrl,
   getGetConfigQueryKey,
   getGetCurrentLlmQueryKey,
   getGetSceneJsonQueryKey,
@@ -18,6 +18,7 @@ import {
   startPipeline,
   undo,
 } from '@/lib/api/default/default'
+import { ApiError } from '@/lib/api/fetch'
 import type {
   ConfigPatch,
   CreateProjectRequest,
@@ -27,6 +28,7 @@ import type {
   ProjectSummary,
   SceneSnapshot,
 } from '@/lib/api/schemas'
+import { filenameFromContentDisposition } from '@/lib/io/saveBlob'
 import { queryClient } from '@/lib/queryClient'
 import { useSelectionStore } from '@/lib/stores/selectionStore'
 
@@ -168,8 +170,37 @@ export async function uploadKhrArchive(file: File): Promise<ProjectSummary> {
 
 // Export ---------------------------------------------------------------------
 
-export async function exportProject(req: ExportProjectRequest): Promise<Blob> {
-  return exportCurrentProject(req)
+/**
+ * Export wrapper that keeps the server-supplied filename.
+ *
+ * The backend returns the raw file for single-page exports (e.g. a PNG or
+ * PSD with `Content-Type: image/png`), and a zip when the format produces
+ * multiple files. The raw-file shortcut means we can't hardcode `.zip` in
+ * the UI — we'd end up feeding a PNG to `unzipSync` and crashing. Read
+ * the `Content-Disposition` filename so the caller gets the correct
+ * extension + `blob.type` to drive the save path.
+ */
+export async function exportProject(
+  req: ExportProjectRequest,
+): Promise<{ blob: Blob; filename?: string }> {
+  const res = await fetch(getExportCurrentProjectUrl(), {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(req),
+  })
+  if (!res.ok) {
+    const body = await res.json().catch(() => null)
+    const message =
+      (body && typeof body === 'object' && 'message' in body && typeof body.message === 'string'
+        ? body.message
+        : null) ??
+      res.statusText ??
+      `HTTP ${res.status}`
+    throw new ApiError(res.status, message, body)
+  }
+  const blob = await res.blob()
+  const filename = filenameFromContentDisposition(res.headers.get('content-disposition'))
+  return { blob, filename }
 }
 
 // Config ---------------------------------------------------------------------

ui/tests/lib/io/pagesIo.test.ts

@@ -13,10 +13,16 @@ vi.mock('@/lib/io/openFiles', () => ({
   openImageFolder: vi.fn(),
   openKhrFile: vi.fn(),
 }))
-vi.mock('@/lib/io/saveBlob', () => ({
-  saveBlob: vi.fn().mockResolvedValue(true),
-  filenameFromContentDisposition: () => undefined,
-}))
+vi.mock('@/lib/io/saveBlob', async () => {
+  // Keep the real `filenameFromContentDisposition` so the export flow can
+  // read server-provided filenames from `Content-Disposition`. Only stub
+  // `saveBlob` itself, since it touches the filesystem / Tauri dialog.
+  const actual = await vi.importActual<typeof import('@/lib/io/saveBlob')>('@/lib/io/saveBlob')
+  return {
+    ...actual,
+    saveBlob: vi.fn().mockResolvedValue(true),
+  }
+})
 
 import { openImageFiles, openImageFolder, openKhrFile } from '@/lib/io/openFiles'
 import { exportCurrentProjectAs, importKhrFile, importPages } from '@/lib/io/pagesIo'
@@ -183,4 +189,25 @@ describe('exportCurrentProjectAs', () => {
     const [, filename] = asMock(saveBlob).mock.calls[0]
     expect(filename).toBe('koharu-export.khr')
   })
+
+  it('uses the server-provided filename for single-file exports', async () => {
+    // Regression: the backend returns a raw PNG (Content-Type: image/png,
+    // Content-Disposition: page-001-abc.png) for single-page exports. The
+    // UI previously forced `.zip` into the filename which caused saveBlob
+    // to try `unzipSync` on a PNG and silently fail.
+    server.use(
+      http.post('/api/v1/projects/current/export', () =>
+        HttpResponse.arrayBuffer(new Uint8Array([137, 80, 78, 71]).buffer, {
+          headers: {
+            'content-type': 'image/png',
+            'content-disposition': 'attachment; filename="page-001-abc.png"',
+          },
+        }),
+      ),
+    )
+    await exportCurrentProjectAs('rendered', ['p1'])
+    const [blob, filename] = asMock(saveBlob).mock.calls[0]
+    expect(filename).toBe('page-001-abc.png')
+    expect((blob as Blob).type).toBe('image/png')
+  })
 })

ui/tests/lib/io/scene.test.ts

@@ -147,21 +147,57 @@ describe('pages + archive uploads', () => {
 })
 
 describe('export', () => {
-  it('returns a Blob without invalidating any cache', async () => {
+  it('returns a Blob + filename without invalidating any cache', async () => {
     server.use(
       http.post('/api/v1/projects/current/export', () =>
         HttpResponse.arrayBuffer(new Uint8Array([9, 9, 9]).buffer, {
-          headers: { 'content-type': 'application/zip' },
+          headers: {
+            'content-type': 'application/zip',
+            'content-disposition': 'attachment; filename="project-rendered.zip"',
+          },
         }),
       ),
     )
 
-    const blob = await exportProject({ format: 'rendered' })
+    const { blob, filename } = await exportProject({ format: 'rendered' })
     expect(Object.prototype.toString.call(blob)).toBe('[object Blob]')
     expect(blob.type).toBe('application/zip')
     expect(blob.size).toBe(3)
+    expect(filename).toBe('project-rendered.zip')
     expect(isInvalidated(getGetSceneJsonQueryKey())).toBe(false)
   })
+
+  it('returns the raw file type + single-file filename for single-page exports', async () => {
+    server.use(
+      http.post('/api/v1/projects/current/export', () =>
+        HttpResponse.arrayBuffer(new Uint8Array([137, 80, 78, 71]).buffer, {
+          headers: {
+            'content-type': 'image/png',
+            'content-disposition': 'attachment; filename="page-001-abc.png"',
+          },
+        }),
+      ),
+    )
+
+    const { blob, filename } = await exportProject({
+      format: 'rendered',
+      pages: ['p1'],
+    })
+    expect(blob.type).toBe('image/png')
+    expect(filename).toBe('page-001-abc.png')
+  })
+
+  it('throws a structured error when the server returns 400', async () => {
+    server.use(
+      http.post('/api/v1/projects/current/export', () =>
+        HttpResponse.json({ message: 'no project open' }, { status: 400 }),
+      ),
+    )
+    await expect(exportProject({ format: 'khr' })).rejects.toMatchObject({
+      status: 400,
+      message: 'no project open',
+    })
+  })
 })
 
 describe('config + llm invalidation', () => {