diff --git a/scripts/fetch-fixtures.ts b/scripts/fetch-fixtures.ts
index b377025..f023509 100644
--- a/scripts/fetch-fixtures.ts
+++ b/scripts/fetch-fixtures.ts
@@ -11,13 +11,53 @@
 import fs from "node:fs";
 import path from "node:path";
 
+function parseEnvValue(value: string): string {
+  const trimmed = value.trim();
+  if (!trimmed) return "";
+
+  const quote = trimmed[0];
+  if ((quote === '"' || quote === "'") && trimmed.endsWith(quote)) {
+    return trimmed
+      .slice(1, -1)
+      .replace(/\\n/g, "\n")
+      .replace(/\\"/g, '"')
+      .replace(/\\'/g, "'");
+  }
+
+  const commentStart = trimmed.search(/\s#/);
+  return commentStart === -1 ? trimmed : trimmed.slice(0, commentStart).trim();
+}
+
+function loadEnvFile(filePath: string) {
+  for (const line of fs.readFileSync(filePath, "utf8").split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+
+    const match = trimmed.match(/^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
+    if (!match) continue;
+
+    process.env[match[1]] = parseEnvValue(match[2]);
+  }
+}
+
+async function parseJsonResponse<T>(res: Response, label: string): Promise<T> {
+  const text = await res.text();
+
+  if (!res.ok) {
+    throw new Error(`${label} failed (${res.status}): ${text.slice(0, 200)}`);
+  }
+
+  try {
+    return JSON.parse(text) as T;
+  } catch {
+    throw new Error(`${label} returned non-JSON: ${text.slice(0, 200)}`);
+  }
+}
+
 // Load .env.local manually
 const envPath = path.resolve(process.cwd(), ".env.local");
 if (fs.existsSync(envPath)) {
-  for (const line of fs.readFileSync(envPath, "utf8").split("\n")) {
-    const m = line.match(/^([^#=]+)=(.*)$/);
-    if (m) process.env[m[1].trim()] = m[2].trim();
-  }
+  loadEnvFile(envPath);
 }
 
 const TOKEN = process.env.FASTMAIL_API_TOKEN;
@@ -43,14 +83,16 @@ async function jmap(apiUrl: string, methodCalls: unknown[]) {
     },
     body: JSON.stringify({ using: JMAP_USING, methodCalls }),
   });
-  if (!res.ok) throw new Error(`JMAP error: ${res.statusText}`);
-  return res.json() as Promise<{ methodResponses: [string, Record<string, unknown>, string][] }>;
+  return parseJsonResponse<{ methodResponses: [string, Record<string, unknown>, string][] }>(
+    res,
+    "JMAP request"
+  );
 }
 
 async function main() {
   const session = await fetch(SESSION_URL, {
     headers: { Authorization: `Bearer ${TOKEN}` },
-  }).then((r) => r.json()) as Record<string, unknown>;
+  }).then((r) => parseJsonResponse<Record<string, unknown>>(r, "JMAP session"));
 
   const apiUrl = session.apiUrl as string;
   const accountId = (session.primaryAccounts as Record<string, string>)[
diff --git a/src/app/(inbox)/attachment/spreadsheet/page.tsx b/src/app/(inbox)/attachment/spreadsheet/page.tsx
new file mode 100644
index 0000000..44622e2
--- /dev/null
+++ b/src/app/(inbox)/attachment/spreadsheet/page.tsx
@@ -0,0 +1,47 @@
+import MobileBackButton from "@/components/MobileBackButton";
+import SpreadsheetViewer from "@/components/SpreadsheetViewer";
+import { notFound } from "next/navigation";
+
+export const dynamic = "force-dynamic";
+
+interface Props {
+  searchParams: Promise<{
+    blobId?: string;
+    name?: string;
+    type?: string;
+    size?: string;
+  }>;
+}
+
+export default async function SpreadsheetAttachmentPage({ searchParams }: Props) {
+  const { blobId, name, type, size } = await searchParams;
+
+  if (!blobId) return notFound();
+
+  const attachmentName = name ?? "spreadsheet.xlsx";
+  const attachmentType =
+    type ?? "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+  const attachmentSize = Number(size ?? "0");
+  const encodedName = encodeURIComponent(attachmentName);
+  const encodedType = encodeURIComponent(attachmentType);
+  const encodedBlobId = encodeURIComponent(blobId);
+  const downloadHref = `/api/download?blobId=${encodedBlobId}&name=${encodedName}&type=${encodedType}`;
+  const previewHref = `${downloadHref}&inline=true`;
+
+  return (
+    <div className="overflow-y-auto h-full bg-stone-50 dark:bg-stone-900">
+      <div className="max-w-6xl mx-auto px-4 sm:px-8 py-8 h-full min-h-0 flex flex-col">
+        <MobileBackButton label="Back" />
+        <div className="flex-1 min-h-0 rounded-xl overflow-hidden border border-stone-200 dark:border-stone-700 shadow-sm">
+          <SpreadsheetViewer
+            attachmentName={attachmentName}
+            attachmentSize={Number.isFinite(attachmentSize) ? attachmentSize : 0}
+            downloadHref={downloadHref}
+            previewHref={previewHref}
+            chrome="page"
+          />
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/src/components/AttachmentList.tsx b/src/components/AttachmentList.tsx
index b589264..c977a1b 100644
--- a/src/components/AttachmentList.tsx
+++ b/src/components/AttachmentList.tsx
@@ -1,6 +1,8 @@
 "use client";
 
 import { useState, useEffect } from "react";
+import SpreadsheetViewer from "@/components/SpreadsheetViewer";
+import { isSpreadsheetAttachment } from "@/lib/spreadsheet";
 import { EmailBodyPart } from "@/lib/types";
 
 function formatSize(bytes: number): string {
@@ -15,8 +17,8 @@ function fileIcon(type: string): string {
   if (type.startsWith("video/")) return "🎬";
   if (type.startsWith("audio/")) return "🎵";
   if (type.includes("zip") || type.includes("tar") || type.includes("gzip")) return "🗜";
-  if (type.includes("word") || type.includes("document")) return "📝";
   if (type.includes("spreadsheet") || type.includes("excel")) return "📊";
+  if (type.includes("word") || type.includes("document")) return "📝";
   return "📎";
 }
 
@@ -102,6 +104,7 @@ interface Props {
 
 export default function AttachmentList({ attachments }: Props) {
   const [previewPdf, setPreviewPdf] = useState<EmailBodyPart | null>(null);
+  const [previewSpreadsheet, setPreviewSpreadsheet] = useState<EmailBodyPart | null>(null);
 
   const visible = attachments.filter((a) => a.type !== "text/calendar" && a.blobId);
   if (visible.length === 0) return null;
@@ -116,9 +119,11 @@ export default function AttachmentList({ attachments }: Props) {
           {visible.map((a) => {
             const name = a.name ?? "attachment";
             const isPdf = a.type === "application/pdf";
+            const isSpreadsheet = isSpreadsheetAttachment(a);
             return isPdf ? (
               <button
                 key={a.blobId}
+                type="button"
                 onClick={() => setPreviewPdf(a)}
                 className="flex items-center gap-2 px-3 py-2 rounded-lg border border-stone-200 dark:border-stone-700 hover:bg-stone-50 dark:hover:bg-stone-800 transition-colors text-sm text-stone-700 dark:text-stone-300 max-w-xs"
               >
@@ -128,6 +133,19 @@ export default function AttachmentList({ attachments }: Props) {
                   {formatSize(a.size)}
                 </span>
               </button>
+            ) : isSpreadsheet ? (
+              <button
+                key={a.blobId}
+                type="button"
+                onClick={() => setPreviewSpreadsheet(a)}
+                className="flex items-center gap-2 px-3 py-2 rounded-lg border border-stone-200 dark:border-stone-700 hover:bg-stone-50 dark:hover:bg-stone-800 transition-colors text-sm text-stone-700 dark:text-stone-300 max-w-xs"
+              >
+                <span className="text-base leading-none">{fileIcon(a.type)}</span>
+                <span className="truncate">{name}</span>
+                <span className="text-xs text-stone-400 dark:text-stone-500 shrink-0">
+                  {formatSize(a.size)}
+                </span>
+              </button>
             ) : (
               <a
                 key={a.blobId}
@@ -149,6 +167,16 @@ export default function AttachmentList({ attachments }: Props) {
       {previewPdf && (
         <PdfModal attachment={previewPdf} onClose={() => setPreviewPdf(null)} />
       )}
+      {previewSpreadsheet && (
+        <SpreadsheetViewer
+          attachmentName={previewSpreadsheet.name}
+          attachmentSize={previewSpreadsheet.size}
+          downloadHref={downloadUrl(previewSpreadsheet)}
+          previewHref={downloadUrl(previewSpreadsheet, true)}
+          chrome="modal"
+          onClose={() => setPreviewSpreadsheet(null)}
+        />
+      )}
     </>
   );
 }
diff --git a/src/components/EmailBody.tsx b/src/components/EmailBody.tsx
index 07a9d86..e497ee8 100644
--- a/src/components/EmailBody.tsx
+++ b/src/components/EmailBody.tsx
@@ -66,7 +66,7 @@ export default function EmailBody({ body, type, stripQuotes }: Props) {
       : prepareTextBody(body, { stripQuotes });
 
   return (
-    <div ref={wrapperRef} className="bg-white dark:bg-stone-900" style={{ minHeight: "200px", overflow: "hidden", position: "relative", zIndex: 10000 }}>
+    <div ref={wrapperRef} className="bg-white dark:bg-stone-900" style={{ minHeight: "200px", overflow: "hidden", position: "relative" }}>
       <iframe
         ref={iframeRef}
         srcDoc={srcDoc}
diff --git a/src/components/InboxPanelLayout.tsx b/src/components/InboxPanelLayout.tsx
index db255b3..c324c0d 100644
--- a/src/components/InboxPanelLayout.tsx
+++ b/src/components/InboxPanelLayout.tsx
@@ -12,6 +12,7 @@ export default function InboxPanelLayout({ list, children }: Props) {
   const showDetail =
     pathname.startsWith("/email/") ||
     pathname.startsWith("/thread/") ||
+    pathname.startsWith("/attachment/") ||
     pathname.startsWith("/settings") ||
     pathname.startsWith("/sent");
 
diff --git a/src/components/SpreadsheetViewer.tsx b/src/components/SpreadsheetViewer.tsx
new file mode 100644
index 0000000..8cfff4f
--- /dev/null
+++ b/src/components/SpreadsheetViewer.tsx
@@ -0,0 +1,311 @@
+"use client";
+
+import { CSSProperties, useEffect, useMemo, useState } from "react";
+import {
+  SpreadsheetCellStyle,
+  SpreadsheetPreviewError,
+  SpreadsheetWorkbook,
+  columnNumberToName,
+  parseSpreadsheetWorkbook,
+} from "@/lib/spreadsheet";
+
+interface Props {
+  attachmentName?: string;
+  attachmentSize: number;
+  downloadHref: string;
+  previewHref: string;
+  onClose?: () => void;
+  chrome?: "modal" | "page";
+}
+
+function formatSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(0)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+export default function SpreadsheetViewer({
+  attachmentName,
+  attachmentSize,
+  downloadHref,
+  previewHref,
+  onClose,
+  chrome = "page",
+}: Props) {
+  const [workbook, setWorkbook] = useState<SpreadsheetWorkbook | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const [activeSheetIndex, setActiveSheetIndex] = useState(0);
+  const [loading, setLoading] = useState(true);
+
+  useEffect(() => {
+    if (!onClose) return;
+    const close = onClose;
+
+    function onKey(event: KeyboardEvent) {
+      if (event.key === "Escape") close();
+    }
+
+    window.addEventListener("keydown", onKey);
+    return () => window.removeEventListener("keydown", onKey);
+  }, [onClose]);
+
+  useEffect(() => {
+    let cancelled = false;
+
+    async function loadWorkbook() {
+      setLoading(true);
+      setWorkbook(null);
+      setError(null);
+      setActiveSheetIndex(0);
+
+      try {
+        const response = await fetch(previewHref, { cache: "no-store" });
+        if (!response.ok) {
+          throw new SpreadsheetPreviewError(
+            `Couldn't load the spreadsheet preview (${response.status}).`
+          );
+        }
+
+        const parsedWorkbook = await parseSpreadsheetWorkbook(await response.arrayBuffer());
+        if (parsedWorkbook.sheets.length === 0) {
+          throw new SpreadsheetPreviewError(
+            "This spreadsheet doesn't contain any visible sheets to preview."
+          );
+        }
+
+        if (!cancelled) {
+          setWorkbook(parsedWorkbook);
+        }
+      } catch (loadError) {
+        if (!cancelled) {
+          setError(
+            loadError instanceof SpreadsheetPreviewError
+              ? loadError.message
+              : "Couldn't preview this spreadsheet."
+          );
+        }
+      } finally {
+        if (!cancelled) {
+          setLoading(false);
+        }
+      }
+    }
+
+    void loadWorkbook();
+    return () => {
+      cancelled = true;
+    };
+  }, [previewHref]);
+
+  const activeSheet = workbook?.sheets[activeSheetIndex] ?? null;
+  const columns = useMemo(
+    () =>
+      activeSheet
+        ? Array.from({ length: activeSheet.maxColumn }, (_, index) => index + 1)
+        : [],
+    [activeSheet]
+  );
+  const rows = useMemo(
+    () =>
+      activeSheet ? Array.from({ length: activeSheet.maxRow }, (_, index) => index + 1) : [],
+    [activeSheet]
+  );
+  const name = attachmentName ?? "spreadsheet.xlsx";
+
+  const body = (
+    <div className="flex flex-col min-h-0 flex-1 bg-stone-100 dark:bg-stone-950">
+      {workbook && workbook.sheets.length > 1 && (
+        <div className="flex gap-2 px-4 pt-3 overflow-x-auto shrink-0">
+          {workbook.sheets.map((sheet, index) => (
+            <button
+              key={sheet.name}
+              type="button"
+              onClick={() => setActiveSheetIndex(index)}
+              className={`px-3 py-1.5 rounded-t-lg border text-sm whitespace-nowrap transition-colors ${
+                index === activeSheetIndex
+                  ? "bg-white text-stone-900 border-stone-300 dark:bg-white dark:text-stone-900 dark:border-stone-300"
+                  : "bg-stone-200/80 text-stone-600 border-transparent hover:bg-stone-200 dark:bg-stone-800 dark:text-stone-300 dark:hover:bg-stone-700"
+              }`}
+            >
+              {sheet.name}
+            </button>
+          ))}
+        </div>
+      )}
+
+      <div className="min-h-0 flex-1 px-4 pb-4">
+        {loading && (
+          <div className="h-full flex items-center justify-center text-sm text-stone-500 dark:text-stone-400">
+            Loading spreadsheet preview...
+          </div>
+        )}
+
+        {!loading && error && (
+          <div className="h-full flex items-center justify-center">
+            <div className="max-w-md rounded-xl border border-stone-200 dark:border-stone-700 bg-white dark:bg-stone-900 p-6 text-center shadow-sm">
+              <div className="text-2xl mb-3">📊</div>
+              <p className="text-sm font-medium text-stone-800 dark:text-stone-200">
+                Preview unavailable
+              </p>
+              <p className="mt-2 text-sm text-stone-500 dark:text-stone-400">{error}</p>
+              <a
+                href={downloadHref}
+                download={name}
+                className="inline-flex mt-4 items-center gap-2 rounded-md border border-stone-200 dark:border-stone-700 px-3 py-2 text-sm text-stone-700 dark:text-stone-300 hover:bg-stone-50 dark:hover:bg-stone-800 transition-colors"
+              >
+                Download instead
+              </a>
+            </div>
+          </div>
+        )}
+
+        {!loading && !error && activeSheet && (
+          <div className="h-full flex flex-col rounded-xl border border-stone-200 shadow-sm overflow-hidden bg-white">
+            <div className="flex items-center justify-between gap-3 px-4 py-2 border-b border-stone-200 shrink-0">
+              <div>
+                <p className="text-sm font-medium text-stone-800">{activeSheet.name}</p>
+                <p className="text-xs text-stone-500">
+                  {activeSheet.maxRow.toLocaleString()} rows x{" "}
+                  {activeSheet.maxColumn.toLocaleString()} columns
+                </p>
+              </div>
+            </div>
+
+            <div className="min-h-0 flex-1 overflow-auto bg-stone-50">
+              <table className="border-separate border-spacing-0 text-sm">
+                <thead className="sticky top-0 z-20">
+                  <tr>
+                    <th className="sticky left-0 z-30 bg-stone-100 border-b border-r border-stone-200 px-3 py-2 text-right text-xs font-medium text-stone-500 min-w-14" />
+                    {columns.map((column) => (
+                      <th
+                        key={column}
+                        className="bg-stone-100 border-b border-r border-stone-200 px-3 py-2 text-center text-xs font-medium text-stone-500"
+                        style={{
+                          minWidth: activeSheet.columnWidths[column] ?? 120,
+                          width: activeSheet.columnWidths[column] ?? 120,
+                        }}
+                      >
+                        {columnNumberToName(column)}
+                      </th>
+                    ))}
+                  </tr>
+                </thead>
+                <tbody>
+                  {rows.map((row) => (
+                    <tr key={row}>
+                      <th className="sticky left-0 z-10 bg-stone-100 border-b border-r border-stone-200 px-3 py-2 text-right text-xs font-medium text-stone-500 min-w-14">
+                        {row}
+                      </th>
+                      {columns.map((column) => {
+                        const cell = activeSheet.cells[`${row}:${column}`];
+                        return (
+                          <td
+                            key={`${row}:${column}`}
+                            className="border-r border-b border-stone-200 px-3 py-2 align-top"
+                            style={cellStyle(cell?.style, activeSheet.columnWidths[column])}
+                            title={cell?.value ?? ""}
+                          >
+                            {cell?.value ?? ""}
+                          </td>
+                        );
+                      })}
+                    </tr>
+                  ))}
+                </tbody>
+              </table>
+            </div>
+          </div>
+        )}
+      </div>
+    </div>
+  );
+
+  if (chrome === "modal") {
+    return (
+      <div
+        className="fixed inset-0 z-50 flex flex-col bg-black/60 backdrop-blur-sm"
+        onClick={(event) => {
+          if (event.target === event.currentTarget) onClose?.();
+        }}
+      >
+        <div className="flex items-center gap-3 px-4 py-3 bg-white dark:bg-stone-900 border-b border-stone-200 dark:border-stone-700 shrink-0">
+          <span className="text-base leading-none">📊</span>
+          <span className="flex-1 text-sm font-medium text-stone-800 dark:text-stone-200 truncate">
+            {name}
+          </span>
+          <span className="text-xs text-stone-400 dark:text-stone-500 shrink-0">
+            {formatSize(attachmentSize)}
+          </span>
+          <a
+            href={downloadHref}
+            download={name}
+            className="flex items-center gap-1.5 text-xs px-3 py-1.5 rounded-md border border-stone-200 dark:border-stone-700 text-stone-600 dark:text-stone-400 hover:bg-stone-100 dark:hover:bg-stone-800 hover:text-stone-900 dark:hover:text-stone-100 transition-colors shrink-0"
+          >
+            <svg viewBox="0 0 20 20" fill="currentColor" className="w-3.5 h-3.5">
+              <path d="M10.75 2.75a.75.75 0 0 0-1.5 0v8.614L6.295 8.235a.75.75 0 1 0-1.09 1.03l4.25 4.5a.75.75 0 0 0 1.09 0l4.25-4.5a.75.75 0 0 0-1.09-1.03l-2.955 3.129V2.75Z" />
+              <path d="M3.5 12.75a.75.75 0 0 0-1.5 0v2.5A2.75 2.75 0 0 0 4.75 18h10.5A2.75 2.75 0 0 0 18 15.25v-2.5a.75.75 0 0 0-1.5 0v2.5c0 .69-.56 1.25-1.25 1.25H4.75c-.69 0-1.25-.56-1.25-1.25v-2.5Z" />
+            </svg>
+            Download
+          </a>
+          <button
+            type="button"
+            onClick={onClose}
+            className="p-1.5 rounded-md text-stone-400 dark:text-stone-500 hover:bg-stone-100 dark:hover:bg-stone-800 hover:text-stone-700 dark:hover:text-stone-300 transition-colors shrink-0"
+            aria-label="Close"
+          >
+            <svg viewBox="0 0 20 20" fill="currentColor" className="w-4 h-4">
+              <path d="M6.28 5.22a.75.75 0 0 0-1.06 1.06L8.94 10l-3.72 3.72a.75.75 0 1 0 1.06 1.06L10 11.06l3.72 3.72a.75.75 0 1 0 1.06-1.06L11.06 10l3.72-3.72a.75.75 0 0 0-1.06-1.06L10 8.94 6.28 5.22Z" />
+            </svg>
+          </button>
+        </div>
+        {body}
+      </div>
+    );
+  }
+
+  return (
+    <div className="h-full min-h-0 flex flex-col">
+      <div className="flex items-center gap-3 px-4 py-3 bg-white dark:bg-stone-900 border-b border-stone-200 dark:border-stone-700 shrink-0">
+        <span className="text-base leading-none">📊</span>
+        <span className="flex-1 text-sm font-medium text-stone-800 dark:text-stone-200 truncate">
+          {name}
+        </span>
+        <span className="text-xs text-stone-400 dark:text-stone-500 shrink-0">
+          {formatSize(attachmentSize)}
+        </span>
+        <a
+          href={downloadHref}
+          download={name}
+          className="flex items-center gap-1.5 text-xs px-3 py-1.5 rounded-md border border-stone-200 dark:border-stone-700 text-stone-600 dark:text-stone-400 hover:bg-stone-100 dark:hover:bg-stone-800 hover:text-stone-900 dark:hover:text-stone-100 transition-colors shrink-0"
+        >
+          <svg viewBox="0 0 20 20" fill="currentColor" className="w-3.5 h-3.5">
+            <path d="M10.75 2.75a.75.75 0 0 0-1.5 0v8.614L6.295 8.235a.75.75 0 1 0-1.09 1.03l4.25 4.5a.75.75 0 0 0 1.09 0l4.25-4.5a.75.75 0 0 0-1.09-1.03l-2.955 3.129V2.75Z" />
+            <path d="M3.5 12.75a.75.75 0 0 0-1.5 0v2.5A2.75 2.75 0 0 0 4.75 18h10.5A2.75 2.75 0 0 0 18 15.25v-2.5a.75.75 0 0 0-1.5 0v2.5c0 .69-.56 1.25-1.25 1.25H4.75c-.69 0-1.25-.56-1.25-1.25v-2.5Z" />
+          </svg>
+          Download
+        </a>
+      </div>
+      {body}
+    </div>
+  );
+}
+
+function cellStyle(
+  style: SpreadsheetCellStyle | undefined,
+  width: number | undefined
+): CSSProperties {
+  return {
+    minWidth: width ?? 120,
+    width: width ?? 120,
+    backgroundColor: style?.backgroundColor ?? "#FFFFFF",
+    color: style?.color ?? "#111827",
+    fontWeight: style?.bold ? 700 : 400,
+    fontStyle: style?.italic ? "italic" : "normal",
+    textDecoration: style?.underline ? "underline" : "none",
+    fontSize: style?.fontSize ? `${style.fontSize}px` : undefined,
+    fontFamily: style?.fontFamily ? `${style.fontFamily}, sans-serif` : undefined,
+    textAlign: style?.horizontalAlign,
+    verticalAlign: style?.verticalAlign ?? "top",
+    whiteSpace: style?.wrapText ? "pre-wrap" : "nowrap",
+  };
+}
diff --git a/src/lib/__tests__/spreadsheet.test.ts b/src/lib/__tests__/spreadsheet.test.ts
new file mode 100644
index 0000000..7381eb1
--- /dev/null
+++ b/src/lib/__tests__/spreadsheet.test.ts
@@ -0,0 +1,286 @@
+import assert from "node:assert/strict";
+import { Buffer } from "node:buffer";
+import { describe, it } from "node:test";
+import { deflateRawSync } from "node:zlib";
+import {
+  excelSerialToDate,
+  isSpreadsheetAttachment,
+  parseSpreadsheetWorkbook,
+  readZipEntries,
+} from "../spreadsheet";
+
+interface ZipEntryInput {
+  name: string;
+  contents: string;
+  compress?: boolean;
+}
+
+describe("isSpreadsheetAttachment", () => {
+  it("detects spreadsheet attachments from MIME type and file name", () => {
+    assert.equal(
+      isSpreadsheetAttachment({
+        name: "budget.xlsx",
+        type: "application/octet-stream",
+      }),
+      true
+    );
+    assert.equal(
+      isSpreadsheetAttachment({
+        name: "document.pdf",
+        type: "application/pdf",
+      }),
+      false
+    );
+  });
+
+  it("handles MIME parameters, aliases, and filenames with trailing whitespace", () => {
+    assert.equal(
+      isSpreadsheetAttachment({
+        name: "quarterly-report.xlsx ",
+        type: "application/octet-stream; charset=binary",
+      }),
+      true
+    );
+    assert.equal(
+      isSpreadsheetAttachment({
+        name: "report",
+        type: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet; charset=utf-8",
+      }),
+      true
+    );
+    assert.equal(
+      isSpreadsheetAttachment({
+        name: "legacy-sheet",
+        type: "application/xlsx",
+      }),
+      true
+    );
+  });
+});
+
+describe("readZipEntries", () => {
+  it("reads stored and deflated entries from a zip archive", async () => {
+    const archive = buildZipArchive([
+      { name: "plain.txt", contents: "stored data", compress: false },
+      { name: "compressed.txt", contents: "deflated data" },
+    ]);
+
+    const entries = await readZipEntries(archive);
+
+    assert.equal(new TextDecoder().decode(entries.get("plain.txt")), "stored data");
+    assert.equal(new TextDecoder().decode(entries.get("compressed.txt")), "deflated data");
+  });
+});
+
+describe("parseSpreadsheetWorkbook", () => {
+  it("parses sheets, cell values, widths, and styles from an xlsx workbook", async () => {
+    const workbook = await parseSpreadsheetWorkbook(buildFixtureWorkbook());
+    assert.equal(workbook.sheets.length, 1);
+
+    const sheet = workbook.sheets[0];
+    assert.equal(sheet.name, "Styled Sheet");
+    assert.equal(sheet.maxRow, 3);
+    assert.equal(sheet.maxColumn, 3);
+    assert.equal(sheet.columnWidths[1], 138);
+
+    const styledCell = sheet.cells["1:1"];
+    assert.equal(styledCell.value, "Hello");
+    assert.equal(styledCell.style.bold, true);
+    assert.equal(styledCell.style.color, "#4F81BD");
+    assert.equal(styledCell.style.backgroundColor, "#FFF2CC");
+    assert.equal(styledCell.style.horizontalAlign, "center");
+    assert.equal(styledCell.style.verticalAlign, "middle");
+    assert.equal(styledCell.style.wrapText, true);
+
+    const inlineCell = sheet.cells["1:2"];
+    assert.equal(inlineCell.value, "Inline");
+
+    const booleanCell = sheet.cells["2:1"];
+    assert.equal(booleanCell.value, "TRUE");
+
+    const dateCell = sheet.cells["2:2"];
+    assert.match(dateCell.value, /2024/);
+  });
+});
+
+describe("excelSerialToDate", () => {
+  it("converts Excel serial dates using the 1900 date system", () => {
+    const date = excelSerialToDate(45292, false);
+    assert.equal(date.toISOString(), "2024-01-01T00:00:00.000Z");
+  });
+});
+
+function buildFixtureWorkbook(): ArrayBuffer {
+  return buildZipArchive([
+    {
+      name: "_rels/.rels",
+      contents: `<?xml version="1.0" encoding="UTF-8"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+  <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="xl/workbook.xml"/>
+</Relationships>`,
+    },
+    {
+      name: "xl/workbook.xml",
+      contents: `<?xml version="1.0" encoding="UTF-8"?>
+<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
+  <workbookPr date1904="0"/>
+  <sheets>
+    <sheet name="Styled Sheet" sheetId="1" r:id="rId1"/>
+  </sheets>
+</workbook>`,
+    },
+    {
+      name: "xl/_rels/workbook.xml.rels",
+      contents: `<?xml version="1.0" encoding="UTF-8"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+  <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/sheet1.xml"/>
+</Relationships>`,
+    },
+    {
+      name: "xl/sharedStrings.xml",
+      contents: `<?xml version="1.0" encoding="UTF-8"?>
+<sst xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" count="1" uniqueCount="1">
+  <si><t>Hello</t></si>
+</sst>`,
+    },
+    {
+      name: "xl/styles.xml",
+      contents: `<?xml version="1.0" encoding="UTF-8"?>
+<styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+  <fonts count="3">
+    <font><sz val="11"/><name val="Calibri"/></font>
+    <font><b/><sz val="12"/><name val="Aptos"/><color theme="4"/></font>
+    <font><sz val="11"/><name val="Calibri"/></font>
+  </fonts>
+  <fills count="3">
+    <fill><patternFill patternType="none"/></fill>
+    <fill><patternFill patternType="gray125"/></fill>
+    <fill><patternFill patternType="solid"><fgColor rgb="FFFFF2CC"/></patternFill></fill>
+  </fills>
+  <borders count="1"><border/></borders>
+  <cellStyleXfs count="1"><xf numFmtId="0" fontId="0" fillId="0" borderId="0"/></cellStyleXfs>
+  <cellXfs count="3">
+    <xf numFmtId="0" fontId="0" fillId="0" borderId="0" xfId="0"/>
+    <xf numFmtId="0" fontId="1" fillId="2" borderId="0" xfId="0" applyFill="1" applyFont="1">
+      <alignment horizontal="center" vertical="center" wrapText="1"/>
+    </xf>
+    <xf numFmtId="14" fontId="2" fillId="0" borderId="0" xfId="0" applyNumberFormat="1"/>
+  </cellXfs>
+</styleSheet>`,
+    },
+    {
+      name: "xl/theme/theme1.xml",
+      contents: `<?xml version="1.0" encoding="UTF-8"?>
+<a:theme xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main">
+  <a:themeElements>
+    <a:clrScheme name="Office">
+      <a:lt1><a:sysClr val="window" lastClr="FFFFFF"/></a:lt1>
+      <a:dk1><a:srgbClr val="000000"/></a:dk1>
+      <a:lt2><a:srgbClr val="EEECE1"/></a:lt2>
+      <a:dk2><a:srgbClr val="1F497D"/></a:dk2>
+      <a:accent1><a:srgbClr val="4F81BD"/></a:accent1>
+      <a:accent2><a:srgbClr val="C0504D"/></a:accent2>
+      <a:accent3><a:srgbClr val="9BBB59"/></a:accent3>
+      <a:accent4><a:srgbClr val="8064A2"/></a:accent4>
+      <a:accent5><a:srgbClr val="4BACC6"/></a:accent5>
+      <a:accent6><a:srgbClr val="F79646"/></a:accent6>
+      <a:hlink><a:srgbClr val="0000FF"/></a:hlink>
+      <a:folHlink><a:srgbClr val="800080"/></a:folHlink>
+    </a:clrScheme>
+  </a:themeElements>
+</a:theme>`,
+    },
+    {
+      name: "xl/worksheets/sheet1.xml",
+      contents: `<?xml version="1.0" encoding="UTF-8"?>
+<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+  <dimension ref="A1:C3"/>
+  <cols>
+    <col min="1" max="1" width="18"/>
+  </cols>
+  <sheetData>
+    <row r="1">
+      <c r="A1" t="s" s="1"><v>0</v></c>
+      <c r="B1" t="inlineStr"><is><t>Inline</t></is></c>
+    </row>
+    <row r="2">
+      <c r="A2" t="b"><v>1</v></c>
+      <c r="B2" s="2"><v>45292</v></c>
+    </row>
+  </sheetData>
+</worksheet>`,
+    },
+  ]);
+}
+
+function buildZipArchive(entries: ZipEntryInput[]): ArrayBuffer {
+  const localFileParts: Buffer[] = [];
+  const centralDirectoryParts: Buffer[] = [];
+  let offset = 0;
+
+  for (const entry of entries) {
+    const name = Buffer.from(entry.name, "utf8");
+    const contents = Buffer.from(entry.contents, "utf8");
+    const compressedContents =
+      entry.compress === false ? contents : deflateRawSync(contents);
+    const compressionMethod = entry.compress === false ? 0 : 8;
+
+    const localHeader = Buffer.alloc(30);
+    localHeader.writeUInt32LE(0x04034b50, 0);
+    localHeader.writeUInt16LE(20, 4);
+    localHeader.writeUInt16LE(0, 6);
+    localHeader.writeUInt16LE(compressionMethod, 8);
+    localHeader.writeUInt32LE(0, 10);
+    localHeader.writeUInt32LE(0, 14);
+    localHeader.writeUInt32LE(compressedContents.length, 18);
+    localHeader.writeUInt32LE(contents.length, 22);
+    localHeader.writeUInt16LE(name.length, 26);
+    localHeader.writeUInt16LE(0, 28);
+
+    localFileParts.push(localHeader, name, compressedContents);
+
+    const centralDirectoryHeader = Buffer.alloc(46);
+    centralDirectoryHeader.writeUInt32LE(0x02014b50, 0);
+    centralDirectoryHeader.writeUInt16LE(20, 4);
+    centralDirectoryHeader.writeUInt16LE(20, 6);
+    centralDirectoryHeader.writeUInt16LE(0, 8);
+    centralDirectoryHeader.writeUInt16LE(compressionMethod, 10);
+    centralDirectoryHeader.writeUInt32LE(0, 12);
+    centralDirectoryHeader.writeUInt32LE(0, 16);
+    centralDirectoryHeader.writeUInt32LE(compressedContents.length, 20);
+    centralDirectoryHeader.writeUInt32LE(contents.length, 24);
+    centralDirectoryHeader.writeUInt16LE(name.length, 28);
+    centralDirectoryHeader.writeUInt16LE(0, 30);
+    centralDirectoryHeader.writeUInt16LE(0, 32);
+    centralDirectoryHeader.writeUInt16LE(0, 34);
+    centralDirectoryHeader.writeUInt16LE(0, 36);
+    centralDirectoryHeader.writeUInt32LE(0, 38);
+    centralDirectoryHeader.writeUInt32LE(offset, 42);
+
+    centralDirectoryParts.push(centralDirectoryHeader, name);
+    offset += localHeader.length + name.length + compressedContents.length;
+  }
+
+  const centralDirectoryStart = offset;
+  const centralDirectory = Buffer.concat(centralDirectoryParts);
+
+  const endOfCentralDirectory = Buffer.alloc(22);
+  endOfCentralDirectory.writeUInt32LE(0x06054b50, 0);
+  endOfCentralDirectory.writeUInt16LE(0, 4);
+  endOfCentralDirectory.writeUInt16LE(0, 6);
+  endOfCentralDirectory.writeUInt16LE(entries.length, 8);
+  endOfCentralDirectory.writeUInt16LE(entries.length, 10);
+  endOfCentralDirectory.writeUInt32LE(centralDirectory.length, 12);
+  endOfCentralDirectory.writeUInt32LE(centralDirectoryStart, 16);
+  endOfCentralDirectory.writeUInt16LE(0, 20);
+
+  const archive = Buffer.concat([
+    ...localFileParts,
+    centralDirectory,
+    endOfCentralDirectory,
+  ]);
+  return archive.buffer.slice(
+    archive.byteOffset,
+    archive.byteOffset + archive.byteLength
+  );
+}
diff --git a/src/lib/spreadsheet.ts b/src/lib/spreadsheet.ts
new file mode 100644
index 0000000..218f8f5
--- /dev/null
+++ b/src/lib/spreadsheet.ts
@@ -0,0 +1,913 @@
+import { EmailBodyPart } from "./types";
+
+const ZIP_LOCAL_FILE_HEADER_SIGNATURE = 0x04034b50;
+const ZIP_CENTRAL_DIRECTORY_SIGNATURE = 0x02014b50;
+const ZIP_END_OF_CENTRAL_DIRECTORY_SIGNATURE = 0x06054b50;
+
+const ROOT_RELATIONSHIP_TYPE =
+  "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument";
+
+const THEME_COLOR_ORDER = [
+  "lt1",
+  "dk1",
+  "lt2",
+  "dk2",
+  "accent1",
+  "accent2",
+  "accent3",
+  "accent4",
+  "accent5",
+  "accent6",
+  "hlink",
+  "folHlink",
+] as const;
+
+const BUILTIN_NUMBER_FORMATS: Record<number, string> = {
+  14: "m/d/yyyy",
+  15: "d-mmm-yy",
+  16: "d-mmm",
+  17: "mmm-yy",
+  18: "h:mm AM/PM",
+  19: "h:mm:ss AM/PM",
+  20: "h:mm",
+  21: "h:mm:ss",
+  22: "m/d/yyyy h:mm",
+  45: "mm:ss",
+  46: "[h]:mm:ss",
+  47: "mmss.0",
+};
+
+const BUILTIN_DATE_FORMAT_IDS = new Set([14, 15, 16, 17, 18, 19, 20, 21, 22, 45, 46, 47]);
+
+const INDEXED_COLORS = [
+  "#000000",
+  "#FFFFFF",
+  "#FF0000",
+  "#00FF00",
+  "#0000FF",
+  "#FFFF00",
+  "#FF00FF",
+  "#00FFFF",
+  "#000000",
+  "#FFFFFF",
+  "#FF0000",
+  "#00FF00",
+  "#0000FF",
+  "#FFFF00",
+  "#FF00FF",
+  "#00FFFF",
+  "#800000",
+  "#008000",
+  "#000080",
+  "#808000",
+  "#800080",
+  "#008080",
+  "#C0C0C0",
+  "#808080",
+  "#9999FF",
+  "#993366",
+  "#FFFFCC",
+  "#CCFFFF",
+  "#660066",
+  "#FF8080",
+  "#0066CC",
+  "#CCCCFF",
+  "#000080",
+  "#FF00FF",
+  "#FFFF00",
+  "#00FFFF",
+  "#800080",
+  "#800000",
+  "#008080",
+  "#0000FF",
+  "#00CCFF",
+  "#CCFFFF",
+  "#CCFFCC",
+  "#FFFF99",
+  "#99CCFF",
+  "#FF99CC",
+  "#CC99FF",
+  "#FFCC99",
+  "#3366FF",
+  "#33CCCC",
+  "#99CC00",
+  "#FFCC00",
+  "#FF9900",
+  "#FF6600",
+  "#666699",
+  "#969696",
+  "#003366",
+  "#339966",
+  "#003300",
+  "#333300",
+  "#993300",
+  "#993366",
+  "#333399",
+  "#333333",
+] as const;
+
+const SPREADSHEET_EXTENSIONS = new Set(["xlsx", "xlsm", "xltx", "xltm", "xlsb", "xls"]);
+const SPREADSHEET_MIME_TYPES = new Set([
+  "application/vnd.ms-excel",
+  "application/msexcel",
+  "application/x-excel",
+  "application/x-msexcel",
+  "application/x-xls",
+  "application/xls",
+  "application/xlsx",
+  "application/vnd.ms-excel.sheet.macroenabled.12",
+  "application/vnd.ms-excel.template.macroenabled.12",
+  "application/vnd.ms-excel.sheet.binary.macroenabled.12",
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.template",
+]);
+
+const textDecoder = new TextDecoder();
+
+interface XmlBlock {
+  attributes: Record<string, string>;
+  inner: string;
+}
+
+interface FontStyle {
+  bold?: boolean;
+  italic?: boolean;
+  underline?: boolean;
+  fontSize?: number;
+  fontFamily?: string;
+  color?: string;
+}
+
+interface FillStyle {
+  backgroundColor?: string;
+}
+
+interface CellFormatStyle extends SpreadsheetCellStyle {
+  numberFormat?: string;
+  isDate?: boolean;
+}
+
+export interface SpreadsheetCellStyle {
+  bold?: boolean;
+  italic?: boolean;
+  underline?: boolean;
+  fontSize?: number;
+  fontFamily?: string;
+  color?: string;
+  backgroundColor?: string;
+  horizontalAlign?: "left" | "center" | "right" | "justify";
+  verticalAlign?: "top" | "middle" | "bottom";
+  wrapText?: boolean;
+}
+
+export interface SpreadsheetCell {
+  ref: string;
+  row: number;
+  column: number;
+  value: string;
+  style: SpreadsheetCellStyle;
+}
+
+export interface SpreadsheetSheet {
+  name: string;
+  maxRow: number;
+  maxColumn: number;
+  cells: Record<string, SpreadsheetCell>;
+  columnWidths: Record<number, number>;
+}
+
+export interface SpreadsheetWorkbook {
+  sheets: SpreadsheetSheet[];
+}
+
+export class SpreadsheetPreviewError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "SpreadsheetPreviewError";
+  }
+}
+
+export function isSpreadsheetAttachment(
+  attachment: Pick<EmailBodyPart, "name" | "type">
+): boolean {
+  const type = normalizeMimeType(attachment.type);
+  const extension = extensionFromName(attachment.name);
+  return (
+    SPREADSHEET_MIME_TYPES.has(type) ||
+    type.includes("spreadsheet") ||
+    type.includes("excel") ||
+    (extension !== null && SPREADSHEET_EXTENSIONS.has(extension))
+  );
+}
+
+export function columnNumberToName(column: number): string {
+  let current = column;
+  let result = "";
+  while (current > 0) {
+    current -= 1;
+    result = String.fromCharCode(65 + (current % 26)) + result;
+    current = Math.floor(current / 26);
+  }
+  return result;
+}
+
+export function excelSerialToDate(serial: number, uses1904DateSystem: boolean): Date {
+  const baseUtc = uses1904DateSystem
+    ? Date.UTC(1904, 0, 1)
+    : Date.UTC(1899, 11, 30);
+  return new Date(baseUtc + serial * 24 * 60 * 60 * 1000);
+}
+
+export async function readZipEntries(buffer: ArrayBuffer): Promise<Map<string, Uint8Array>> {
+  const bytes = new Uint8Array(buffer);
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const eocdOffset = findEndOfCentralDirectory(view);
+  const totalEntries = view.getUint16(eocdOffset + 10, true);
+  const centralDirectoryOffset = view.getUint32(eocdOffset + 16, true);
+  const entries = new Map<string, Uint8Array>();
+
+  let cursor = centralDirectoryOffset;
+  for (let index = 0; index < totalEntries; index += 1) {
+    if (view.getUint32(cursor, true) !== ZIP_CENTRAL_DIRECTORY_SIGNATURE) {
+      throw new SpreadsheetPreviewError("The spreadsheet archive is malformed.");
+    }
+
+    const compressionMethod = view.getUint16(cursor + 10, true);
+    const compressedSize = view.getUint32(cursor + 20, true);
+    const fileNameLength = view.getUint16(cursor + 28, true);
+    const extraFieldLength = view.getUint16(cursor + 30, true);
+    const commentLength = view.getUint16(cursor + 32, true);
+    const localHeaderOffset = view.getUint32(cursor + 42, true);
+    const fileName = decodeText(bytes.subarray(cursor + 46, cursor + 46 + fileNameLength));
+
+    const localHeaderView = new DataView(bytes.buffer, bytes.byteOffset + localHeaderOffset);
+    if (localHeaderView.getUint32(0, true) !== ZIP_LOCAL_FILE_HEADER_SIGNATURE) {
+      throw new SpreadsheetPreviewError("The spreadsheet archive is malformed.");
+    }
+
+    const localFileNameLength = localHeaderView.getUint16(26, true);
+    const localExtraFieldLength = localHeaderView.getUint16(28, true);
+    const dataStart = localHeaderOffset + 30 + localFileNameLength + localExtraFieldLength;
+    const compressedBytes = bytes.subarray(dataStart, dataStart + compressedSize);
+
+    if (!fileName.endsWith("/")) {
+      entries.set(fileName, await decompressEntry(compressedBytes, compressionMethod));
+    }
+
+    cursor += 46 + fileNameLength + extraFieldLength + commentLength;
+  }
+
+  return entries;
+}
+
+export async function parseSpreadsheetWorkbook(
+  buffer: ArrayBuffer
+): Promise<SpreadsheetWorkbook> {
+  const bytes = new Uint8Array(buffer);
+  if (isLegacyCompoundDocument(bytes)) {
+    throw new SpreadsheetPreviewError(
+      "Legacy .xls files cannot be previewed here yet. Download the file to open it in Excel."
+    );
+  }
+  if (!isZipArchive(bytes)) {
+    throw new SpreadsheetPreviewError("This spreadsheet format is not supported for preview.");
+  }
+
+  const entries = await readZipEntries(buffer);
+  const workbookPath = findWorkbookPath(entries);
+  if (workbookPath.endsWith(".bin")) {
+    throw new SpreadsheetPreviewError(
+      "Binary Excel workbooks (.xlsb) are not supported for preview."
+    );
+  }
+  if (!workbookPath.endsWith(".xml")) {
+    throw new SpreadsheetPreviewError("This spreadsheet format is not supported for preview.");
+  }
+
+  const workbookXml = getEntryText(entries, workbookPath);
+  const workbookRelationships = parseRelationships(
+    getEntryText(entries, relationshipPathFor(workbookPath), "")
+  );
+  const sharedStrings = parseSharedStrings(
+    getEntryText(entries, resolveRelativePath(workbookPath, "sharedStrings.xml"), "")
+  );
+  const themeColors = parseThemeColors(
+    getEntryText(entries, resolveRelativePath(workbookPath, "theme/theme1.xml"), "")
+  );
+  const styles = parseStyles(
+    getEntryText(entries, resolveRelativePath(workbookPath, "styles.xml"), ""),
+    themeColors
+  );
+  const uses1904DateSystem = /<workbookPr\b[^>]*date1904="(?:1|true)"/i.test(workbookXml);
+
+  const sheets = collectElementBlocks(workbookXml, "sheet")
+    .map((sheetBlock) => {
+      const relationshipId = sheetBlock.attributes["r:id"];
+      if (!relationshipId) return null;
+      const target = workbookRelationships.get(relationshipId);
+      if (!target) return null;
+      const path = resolveRelativePath(workbookPath, target);
+      return {
+        name: decodeXmlEntities(sheetBlock.attributes.name ?? "Sheet"),
+        hidden:
+          sheetBlock.attributes.state === "hidden" ||
+          sheetBlock.attributes.state === "veryHidden",
+        path,
+      };
+    })
+    .filter((sheet): sheet is { name: string; hidden: boolean; path: string } => sheet !== null);
+
+  const visibleSheets = sheets.filter((sheet) => !sheet.hidden);
+  const sheetsToRender = visibleSheets.length > 0 ? visibleSheets : sheets;
+
+  return {
+    sheets: sheetsToRender.map((sheet) =>
+      parseSheet(
+        sheet.name,
+        getEntryText(entries, sheet.path),
+        sharedStrings,
+        styles,
+        uses1904DateSystem
+      )
+    ),
+  };
+}
+
+function extensionFromName(name?: string): string | null {
+  if (!name) return null;
+  const normalizedName = name.trim().toLowerCase();
+  const match = /\.([^.]+)$/.exec(normalizedName);
+  return match?.[1] ?? null;
+}
+
+function normalizeMimeType(type?: string): string {
+  return type?.split(";")[0]?.trim().toLowerCase() ?? "";
+}
+
+function isZipArchive(bytes: Uint8Array): boolean {
+  return (
+    bytes.length >= 4 &&
+    bytes[0] === 0x50 &&
+    bytes[1] === 0x4b &&
+    (bytes[2] === 0x03 || bytes[2] === 0x05 || bytes[2] === 0x07) &&
+    (bytes[3] === 0x04 || bytes[3] === 0x06 || bytes[3] === 0x08)
+  );
+}
+
+function isLegacyCompoundDocument(bytes: Uint8Array): boolean {
+  const signature = [0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1];
+  return signature.every((value, index) => bytes[index] === value);
+}
+
+function findEndOfCentralDirectory(view: DataView): number {
+  const minimumOffset = Math.max(0, view.byteLength - 0xffff - 22);
+  for (let offset = view.byteLength - 22; offset >= minimumOffset; offset -= 1) {
+    if (view.getUint32(offset, true) === ZIP_END_OF_CENTRAL_DIRECTORY_SIGNATURE) {
+      return offset;
+    }
+  }
+  throw new SpreadsheetPreviewError("The spreadsheet archive is malformed.");
+}
+
+async function decompressEntry(
+  compressedBytes: Uint8Array,
+  compressionMethod: number
+): Promise<Uint8Array> {
+  if (compressionMethod === 0) return compressedBytes;
+  if (compressionMethod !== 8) {
+    throw new SpreadsheetPreviewError("The spreadsheet uses an unsupported compression method.");
+  }
+
+  const payload = new ArrayBuffer(compressedBytes.byteLength);
+  new Uint8Array(payload).set(compressedBytes);
+  const stream = new Blob([payload])
+    .stream()
+    .pipeThrough(new DecompressionStream("deflate-raw"));
+  const decompressed = await new Response(stream).arrayBuffer();
+  return new Uint8Array(decompressed);
+}
+
+function decodeText(bytes: Uint8Array): string {
+  return textDecoder.decode(bytes);
+}
+
+function getEntryText(
+  entries: Map<string, Uint8Array>,
+  path: string,
+  fallback?: string
+): string {
+  const entry = entries.get(path);
+  if (!entry) {
+    if (fallback !== undefined) return fallback;
+    throw new SpreadsheetPreviewError(`Missing spreadsheet entry: ${path}`);
+  }
+  return decodeText(entry);
+}
+
+function findWorkbookPath(entries: Map<string, Uint8Array>): string {
+  const rootRelationshipsXml = getEntryText(entries, "_rels/.rels", "");
+  const rootRelationships = parseRelationships(rootRelationshipsXml);
+  const rootRelationshipTypes = parseRelationshipTypes(rootRelationshipsXml);
+  const officeDocumentTarget = [...rootRelationships.entries()]
+    .map(([id, target]) => ({
+      type: rootRelationshipTypes.get(id),
+      target,
+    }))
+    .find((relationship) => relationship.type === ROOT_RELATIONSHIP_TYPE)?.target;
+  if (officeDocumentTarget) {
+    return resolveRelativePath("", officeDocumentTarget);
+  }
+  if (entries.has("xl/workbook.xml")) return "xl/workbook.xml";
+  throw new SpreadsheetPreviewError("This spreadsheet does not contain a workbook.xml file.");
+}
+
+function relationshipPathFor(filePath: string): string {
+  const lastSlash = filePath.lastIndexOf("/");
+  const directory = lastSlash === -1 ? "" : filePath.slice(0, lastSlash + 1);
+  const fileName = lastSlash === -1 ? filePath : filePath.slice(lastSlash + 1);
+  return `${directory}_rels/${fileName}.rels`;
+}
+
+function resolveRelativePath(baseFilePath: string, target: string): string {
+  if (target.startsWith("/")) return target.slice(1);
+  const lastSlash = baseFilePath.lastIndexOf("/");
+  const baseDirectory = lastSlash === -1 ? "" : baseFilePath.slice(0, lastSlash + 1);
+  const normalized: string[] = [];
+  for (const part of `${baseDirectory}${target}`.split("/")) {
+    if (part === "" || part === ".") continue;
+    if (part === "..") {
+      normalized.pop();
+      continue;
+    }
+    normalized.push(part);
+  }
+  return normalized.join("/");
+}
+
+function parseRelationships(xml: string): Map<string, string> {
+  const relationships = new Map<string, string>();
+  for (const block of collectElementBlocks(xml, "Relationship")) {
+    if (block.attributes.Id && block.attributes.Target) {
+      relationships.set(block.attributes.Id, block.attributes.Target);
+    }
+  }
+  return relationships;
+}
+
+function parseRelationshipTypes(xml: string): Map<string, string> {
+  const relationships = new Map<string, string>();
+  for (const block of collectElementBlocks(xml, "Relationship")) {
+    if (block.attributes.Id && block.attributes.Type) {
+      relationships.set(block.attributes.Id, block.attributes.Type);
+    }
+  }
+  return relationships;
+}
+
+function parseSharedStrings(xml: string): string[] {
+  if (!xml) return [];
+  return collectElementBlocks(xml, "si").map((stringItem) => extractTextRuns(stringItem.inner));
+}
+
+function parseThemeColors(xml: string): string[] {
+  if (!xml) return [];
+  const colorSchemeMatch = /<a:clrScheme\b[^>]*>([\s\S]*?)<\/a:clrScheme>/i.exec(xml);
+  if (!colorSchemeMatch) return [];
+  return THEME_COLOR_ORDER.map((name) => {
+    const match = new RegExp(`<a:${name}\\b[^>]*>([\\s\\S]*?)<\\/a:${name}>`, "i").exec(
+      colorSchemeMatch[1]
+    );
+    if (!match) return "";
+    const srgb = /<a:srgbClr\b[^>]*val="([0-9A-Fa-f]{6})"/i.exec(match[1])?.[1];
+    const systemColor = /<a:sysClr\b[^>]*lastClr="([0-9A-Fa-f]{6})"/i.exec(match[1])?.[1];
+    return srgb ? `#${srgb.toUpperCase()}` : systemColor ? `#${systemColor.toUpperCase()}` : "";
+  });
+}
+
+function parseStyles(xml: string, themeColors: string[]): CellFormatStyle[] {
+  if (!xml) return [{}];
+
+  const customNumberFormats = new Map<number, string>();
+  const numberFormatsSection = firstInnerTag(xml, "numFmts");
+  if (numberFormatsSection) {
+    for (const numFmt of collectElementBlocks(numberFormatsSection, "numFmt")) {
+      const id = toNumber(numFmt.attributes.numFmtId);
+      const formatCode = numFmt.attributes.formatCode
+        ? decodeXmlEntities(numFmt.attributes.formatCode)
+        : undefined;
+      if (id !== undefined && formatCode) {
+        customNumberFormats.set(id, formatCode);
+      }
+    }
+  }
+
+  const fonts = parseFonts(firstInnerTag(xml, "fonts") ?? "", themeColors);
+  const fills = parseFills(firstInnerTag(xml, "fills") ?? "", themeColors);
+  const xfs = collectElementBlocks(firstInnerTag(xml, "cellXfs") ?? "", "xf");
+
+  if (xfs.length === 0) return [{}];
+
+  return xfs.map((xf) => {
+    const font = fonts[toNumber(xf.attributes.fontId) ?? 0] ?? {};
+    const fill = fills[toNumber(xf.attributes.fillId) ?? 0] ?? {};
+    const numFmtId = toNumber(xf.attributes.numFmtId);
+    const alignmentTag = firstTagAttributes(xf.inner, "alignment");
+    const numberFormat =
+      numFmtId !== undefined
+        ? customNumberFormats.get(numFmtId) ?? BUILTIN_NUMBER_FORMATS[numFmtId]
+        : undefined;
+
+    return {
+      ...font,
+      ...fill,
+      horizontalAlign: normalizeHorizontalAlignment(alignmentTag?.horizontal),
+      verticalAlign: normalizeVerticalAlignment(alignmentTag?.vertical),
+      wrapText: alignmentTag?.wrapText === "1",
+      numberFormat,
+      isDate: isDateNumberFormat(numberFormat, numFmtId),
+    };
+  });
+}
+
+function parseFonts(xml: string, themeColors: string[]): FontStyle[] {
+  return collectElementBlocks(xml, "font").map((font) => ({
+    bold: hasTruthyElement(font.inner, "b"),
+    italic: hasTruthyElement(font.inner, "i"),
+    underline: hasTruthyElement(font.inner, "u"),
+    fontSize: toNumber(firstTagAttributes(font.inner, "sz")?.val),
+    fontFamily: firstTagAttributes(font.inner, "name")?.val,
+    color: resolveColor(firstTagAttributes(font.inner, "color"), themeColors),
+  }));
+}
+
+function parseFills(xml: string, themeColors: string[]): FillStyle[] {
+  return collectElementBlocks(xml, "fill").map((fill) => {
+    const patternFill = firstTagBlock(fill.inner, "patternFill");
+    if (!patternFill) return {};
+    if (
+      patternFill.attributes.patternType === "none" ||
+      patternFill.attributes.patternType === "gray125"
+    ) {
+      return {};
+    }
+
+    return {
+      backgroundColor:
+        resolveColor(firstTagAttributes(patternFill.inner, "fgColor"), themeColors) ??
+        resolveColor(firstTagAttributes(patternFill.inner, "bgColor"), themeColors),
+    };
+  });
+}
+
+function parseSheet(
+  name: string,
+  xml: string,
+  sharedStrings: string[],
+  styles: CellFormatStyle[],
+  uses1904DateSystem: boolean
+): SpreadsheetSheet {
+  const cells: Record<string, SpreadsheetCell> = {};
+  const columnWidths = parseColumnWidths(xml);
+  let maxRow = 0;
+  let maxColumn = 0;
+  const sheetData = firstInnerTag(xml, "sheetData") ?? "";
+
+  for (const rowBlock of collectElementBlocks(sheetData, "row")) {
+    const rowNumber = toNumber(rowBlock.attributes.r);
+    for (const cellBlock of collectElementBlocks(rowBlock.inner, "c")) {
+      const ref = cellBlock.attributes.r;
+      const coordinates = ref ? parseCellReference(ref) : null;
+      if (!coordinates) continue;
+
+      const style = styles[toNumber(cellBlock.attributes.s) ?? 0] ?? {};
+      const value = resolveCellValue(
+        cellBlock,
+        style,
+        sharedStrings,
+        uses1904DateSystem
+      );
+
+      cells[`${coordinates.row}:${coordinates.column}`] = {
+        ref,
+        row: coordinates.row,
+        column: coordinates.column,
+        value,
+        style: {
+          bold: style.bold,
+          italic: style.italic,
+          underline: style.underline,
+          fontSize: style.fontSize,
+          fontFamily: style.fontFamily,
+          color: style.color,
+          backgroundColor: style.backgroundColor,
+          horizontalAlign: style.horizontalAlign,
+          verticalAlign: style.verticalAlign,
+          wrapText: style.wrapText,
+        },
+      };
+
+      maxRow = Math.max(maxRow, coordinates.row, rowNumber ?? 0);
+      maxColumn = Math.max(maxColumn, coordinates.column);
+    }
+  }
+
+  const dimension = parseDimension(xml);
+  if (dimension) {
+    maxRow = Math.max(maxRow, dimension.maxRow);
+    maxColumn = Math.max(maxColumn, dimension.maxColumn);
+  }
+
+  return {
+    name,
+    maxRow,
+    maxColumn,
+    cells,
+    columnWidths,
+  };
+}
+
+function parseColumnWidths(xml: string): Record<number, number> {
+  const widths: Record<number, number> = {};
+  const columnsSection = firstInnerTag(xml, "cols");
+  if (!columnsSection) return widths;
+
+  for (const column of collectElementBlocks(columnsSection, "col")) {
+    const min = toNumber(column.attributes.min);
+    const max = toNumber(column.attributes.max);
+    const width = toNumber(column.attributes.width);
+    if (min === undefined || max === undefined || width === undefined) continue;
+
+    const pixels = Math.max(72, Math.round(width * 7 + 12));
+    for (let index = min; index <= max; index += 1) {
+      widths[index] = pixels;
+    }
+  }
+
+  return widths;
+}
+
+function resolveCellValue(
+  cell: XmlBlock,
+  style: CellFormatStyle,
+  sharedStrings: string[],
+  uses1904DateSystem: boolean
+): string {
+  const cellType = cell.attributes.t;
+  const value = firstInnerTag(cell.inner, "v") ?? "";
+
+  if (cellType === "inlineStr") return extractTextRuns(firstInnerTag(cell.inner, "is") ?? "");
+  if (cellType === "s") {
+    const index = toNumber(value);
+    return index !== undefined ? sharedStrings[index] ?? "" : "";
+  }
+  if (cellType === "str") return decodeXmlEntities(value);
+  if (cellType === "b") return value === "1" ? "TRUE" : "FALSE";
+  if (cellType === "e") return value ? `#${value}` : "";
+  if (style.isDate && value) {
+    const serial = Number(value);
+    if (!Number.isNaN(serial)) {
+      return formatDateCell(serial, uses1904DateSystem, style.numberFormat);
+    }
+  }
+
+  return decodeXmlEntities(value);
+}
+
+function formatDateCell(
+  serial: number,
+  uses1904DateSystem: boolean,
+  numberFormat?: string
+): string {
+  const date = excelSerialToDate(serial, uses1904DateSystem);
+  if (Number.isNaN(date.getTime())) return String(serial);
+
+  const normalizedFormat = sanitizeNumberFormat(numberFormat);
+  const hasDate = /[ymd]/i.test(normalizedFormat);
+  const hasTime = /[hs]/i.test(normalizedFormat);
+  const formatOptions = { timeZone: "UTC" as const };
+
+  if (hasDate && hasTime) {
+    return new Intl.DateTimeFormat(undefined, {
+      ...formatOptions,
+      dateStyle: "medium",
+      timeStyle: "short",
+    }).format(date);
+  }
+  if (hasTime) {
+    return new Intl.DateTimeFormat(undefined, {
+      ...formatOptions,
+      timeStyle: "short",
+    }).format(date);
+  }
+  return new Intl.DateTimeFormat(undefined, {
+    ...formatOptions,
+    dateStyle: "medium",
+  }).format(date);
+}
+
+function sanitizeNumberFormat(formatCode?: string): string {
+  if (!formatCode) return "";
+  return formatCode.replace(/"[^"]*"|\[[^\]]*]/g, "");
+}
+
+function isDateNumberFormat(formatCode?: string, numFmtId?: number): boolean {
+  if (numFmtId !== undefined && BUILTIN_DATE_FORMAT_IDS.has(numFmtId)) return true;
+  if (!formatCode) return false;
+  return /[ymdhHs]/i.test(sanitizeNumberFormat(formatCode));
+}
+
+function normalizeHorizontalAlignment(
+  alignment?: string
+): SpreadsheetCellStyle["horizontalAlign"] | undefined {
+  if (alignment === "left" || alignment === "center" || alignment === "right" || alignment === "justify") {
+    return alignment;
+  }
+  return undefined;
+}
+
+function normalizeVerticalAlignment(
+  alignment?: string
+): SpreadsheetCellStyle["verticalAlign"] | undefined {
+  if (alignment === "top" || alignment === "bottom") return alignment;
+  if (alignment === "center") return "middle";
+  return undefined;
+}
+
+function parseDimension(
+  xml: string
+): { maxRow: number; maxColumn: number } | null {
+  const ref = firstTagAttributes(xml, "dimension")?.ref;
+  if (!ref) return null;
+  const match = /([A-Z]+)(\d+)(?::([A-Z]+)(\d+))?/i.exec(ref);
+  if (!match) return null;
+  return {
+    maxRow: Number(match[4] ?? match[2]),
+    maxColumn: columnNameToNumber(match[3] ?? match[1]),
+  };
+}
+
+function parseCellReference(
+  reference: string
+): { row: number; column: number } | null {
+  const match = /^([A-Z]+)(\d+)$/i.exec(reference);
+  if (!match) return null;
+  return {
+    column: columnNameToNumber(match[1]),
+    row: Number(match[2]),
+  };
+}
+
+function columnNameToNumber(name: string): number {
+  let value = 0;
+  for (const char of name.toUpperCase()) {
+    value = value * 26 + (char.charCodeAt(0) - 64);
+  }
+  return value;
+}
+
+function resolveColor(
+  attributes: Record<string, string> | undefined,
+  themeColors: string[]
+): string | undefined {
+  if (!attributes) return undefined;
+  if (attributes.rgb) {
+    return normalizeHexColor(attributes.rgb);
+  }
+
+  const themeIndex = toNumber(attributes.theme);
+  if (themeIndex !== undefined) {
+    const themeColor = themeColors[themeIndex];
+    if (themeColor) {
+      return applyTint(themeColor, Number(attributes.tint ?? "0"));
+    }
+  }
+
+  const indexed = toNumber(attributes.indexed);
+  if (indexed !== undefined) {
+    return INDEXED_COLORS[indexed];
+  }
+
+  return undefined;
+}
+
+function normalizeHexColor(value: string): string | undefined {
+  const normalized = value.replace(/^#/, "");
+  if (!/^[0-9A-Fa-f]{6}([0-9A-Fa-f]{2})?$/.test(normalized)) return undefined;
+  return `#${(normalized.length === 8 ? normalized.slice(2) : normalized).toUpperCase()}`;
+}
+
+function applyTint(color: string, tint: number): string {
+  if (Number.isNaN(tint) || tint === 0) return color;
+
+  const normalized = normalizeHexColor(color);
+  if (!normalized) return color;
+  const rgb = [1, 3, 5].map((offset) =>
+    Number.parseInt(normalized.slice(offset, offset + 2), 16)
+  );
+  const adjusted = rgb.map((channel) =>
+    tint < 0
+      ? Math.round(channel * (1 + tint))
+      : Math.round(channel * (1 - tint) + 255 * tint)
+  );
+  return `#${adjusted
+    .map((channel) => Math.max(0, Math.min(255, channel)).toString(16).padStart(2, "0"))
+    .join("")
+    .toUpperCase()}`;
+}
+
+function firstInnerTag(xml: string, tagName: string): string | undefined {
+  return firstTagBlock(xml, tagName)?.inner;
+}
+
+function firstTagAttributes(
+  xml: string,
+  tagName: string
+): Record<string, string> | undefined {
+  return firstTagBlock(xml, tagName)?.attributes;
+}
+
+function firstTagBlock(xml: string, tagName: string): XmlBlock | undefined {
+  return collectElementBlocks(xml, tagName)[0];
+}
+
+function collectElementBlocks(xml: string, tagName: string): XmlBlock[] {
+  if (!xml) return [];
+
+  const blocks: XmlBlock[] = [];
+  const pattern = new RegExp(
+    `<${tagName}\\b([^>]*?)(?:\\/\\s*>|>([\\s\\S]*?)<\\/${tagName}>)`,
+    "gi"
+  );
+
+  let match = pattern.exec(xml);
+  while (match) {
+    blocks.push({
+      attributes: parseAttributes(match[1] ?? ""),
+      inner: match[2] ?? "",
+    });
+    match = pattern.exec(xml);
+  }
+
+  return blocks;
+}
+
+function parseAttributes(attributesSource: string): Record<string, string> {
+  const attributes: Record<string, string> = {};
+  const pattern = /([A-Za-z_][\w:.-]*)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+
+  let match = pattern.exec(attributesSource);
+  while (match) {
+    attributes[match[1]] = decodeXmlEntities(match[2] ?? match[3] ?? "");
+    match = pattern.exec(attributesSource);
+  }
+
+  return attributes;
+}
+
+function extractTextRuns(xml: string): string {
+  const textPattern = /<t\b[^>]*>([\s\S]*?)<\/t>/gi;
+  let result = "";
+  let match = textPattern.exec(xml);
+  while (match) {
+    result += decodeXmlEntities(match[1]);
+    match = textPattern.exec(xml);
+  }
+  return result;
+}
+
+function hasTruthyElement(xml: string, tagName: string): boolean {
+  const block = firstTagBlock(xml, tagName);
+  if (!block) return false;
+  return block.attributes.val !== "0" && block.attributes.val !== "false";
+}
+
+function decodeXmlEntities(value: string): string {
+  return value.replace(
+    /&(?:lt|gt|amp|quot|apos|#\d+|#x[0-9A-Fa-f]+);/g,
+    (entity) => {
+      switch (entity) {
+        case "&lt;":
+          return "<";
+        case "&gt;":
+          return ">";
+        case "&amp;":
+          return "&";
+        case "&quot;":
+          return '"';
+        case "&apos;":
+          return "'";
+        default:
+          if (entity.startsWith("&#x")) {
+            return String.fromCodePoint(Number.parseInt(entity.slice(3, -1), 16));
+          }
+          return String.fromCodePoint(Number.parseInt(entity.slice(2, -1), 10));
+      }
+    }
+  );
+}
+
+function toNumber(value?: string): number | undefined {
+  if (value === undefined || value === "") return undefined;
+  const parsed = Number(value);
+  return Number.isNaN(parsed) ? undefined : parsed;
+}