@@ -5,6 +5,7 @@ import { afterEach, describe, expect, it, vi } from 'vitest'
 import * as XLSX from 'xlsx'
 import {
   readXlsxPreviewData,
+  readXlsxWorkbook,
   XLSX_MAX_COLUMNS,
   XLSX_MAX_ROWS,
 } from '@/app/workspace/[workspaceId]/files/components/file-viewer/xlsx-preview-data'
@@ -75,19 +76,35 @@ describe('readXlsxPreviewData', () => {
   })
 
   /**
-   * The viewer reads the workbook without `cellDates`, so a date arrives as a
-   * number carrying the file's formatted text; `raw: false` shows that text
-   * instead of the serial, and a General number keeps its full digits.
+   * Built through the viewer's own read path rather than by hand-setting `z`,
+   * so the assertions cover the read options as well as the conversion.
    */
+  function typedWorkbook(): ArrayBuffer {
+    const sheet = XLSX.utils.aoa_to_sheet([['Issued', 'Rate', 'Card', 'Elapsed']])
+    sheet.A2 = { t: 'd', v: new Date(Date.UTC(2026, 2, 4)), z: 'm/d/yyyy' }
+    sheet.B2 = { t: 'n', v: 0.2, z: '0%' }
+    sheet.C2 = { t: 'n', v: 4111111111111111 }
+    sheet.D2 = { t: 'n', v: 1.25, z: '[h]:mm' }
+    sheet['!ref'] = 'A1:D2'
+    const book = XLSX.utils.book_new()
+    XLSX.utils.book_append_sheet(book, sheet, 'Ledger')
+    const bytes = XLSX.write(book, { type: 'buffer', bookType: 'xlsx' }) as Buffer
+    return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength) as ArrayBuffer
+  }
+
   it('shows display text rather than stored values', () => {
-    const sheet = XLSX.utils.aoa_to_sheet([['Issued', 'Rate', 'Card']])
-    sheet.A2 = { t: 'n', v: 46085, z: 'yyyy-mm-dd', w: '2026-03-04' }
-    sheet.B2 = { t: 'n', v: 0.2, z: '0%', w: '20%' }
-    sheet.C2 = { t: 'n', v: 4111111111111111, z: 'General', w: '4.11111E+15' }
-    sheet['!ref'] = 'A1:C2'
+    const workbook = readXlsxWorkbook(XLSX, typedWorkbook())
 
-    const result = readXlsxPreviewData(XLSX, sheet)
+    const result = readXlsxPreviewData(XLSX, workbook.Sheets.Ledger)
+
+    expect(result.rows).toEqual([['2026-03-04', '20%', '4111111111111111', '30:00']])
+  })
+
+  it('reads the workbook with the display-text options', () => {
+    const read = vi.fn(XLSX.read)
+
+    readXlsxWorkbook({ read, utils: XLSX.utils }, typedWorkbook())
 
-    expect(result.rows).toEqual([['2026-03-04', '20%', '4111111111111111']])
+    expect(read.mock.calls[0][1]).toMatchObject({ type: 'array', cellDates: true, cellNF: true })
   })
 })
@@ -1,13 +1,27 @@
-import type { WorkSheet } from 'xlsx'
-import { normalizeSheetDisplayText } from '@/lib/file-parsers/sheet-display-text'
+import type { WorkBook, WorkSheet } from 'xlsx'
+import {
+  normalizeSheetDisplayText,
+  SHEET_DISPLAY_READ_OPTIONS,
+} from '@/lib/file-parsers/sheet-display-text'
 
 export const XLSX_MAX_ROWS = 1_000
 export const XLSX_MAX_COLUMNS = 200
 
 interface XlsxModule {
+  read: typeof import('xlsx').read
   utils: Pick<typeof import('xlsx').utils, 'decode_range' | 'encode_cell' | 'sheet_to_json'>
 }
 
+/**
+ * Reads a workbook for preview with the options that make its cells carry
+ * display text: without `cellDates` a date arrives as a bare serial and
+ * without `cellNF` no cell has a format, so every rendered `w` would be
+ * overwritten as a General number.
+ */
+export function readXlsxWorkbook(XLSX: XlsxModule, data: ArrayBuffer): WorkBook {
+  return XLSX.read(new Uint8Array(data), { type: 'array', ...SHEET_DISPLAY_READ_OPTIONS })
+}
+
 interface XlsxPreviewData {
   headers: string[]
   rows: string[][]
@@ -19,20 +33,21 @@ export function readXlsxPreviewData(XLSX: XlsxModule, sheet: WorkSheet): XlsxPre
   const declaredRange = XLSX.utils.decode_range(sheet['!ref'] || 'A1')
   const lastPreviewRow = Math.min(declaredRange.e.r, declaredRange.s.r + XLSX_MAX_ROWS)
   const lastPreviewColumn = Math.min(declaredRange.e.c, declaredRange.s.c + XLSX_MAX_COLUMNS - 1)
-  const window = {
+  const previewRange = {
     s: declaredRange.s,
     e: { r: lastPreviewRow, c: lastPreviewColumn },
   }
 
   /**
    * Shown as the text a user sees in Excel: `raw: false` emits each cell's
-   * formatted text so a date cell reads as a date rather than its serial.
+   * formatted text, so a sheet read through {@link readXlsxWorkbook} shows a
+   * date as ISO text and `20%` rather than a serial and `0.2`.
    */
-  normalizeSheetDisplayText(sheet, window, XLSX.utils)
+  normalizeSheetDisplayText(sheet, previewRange, XLSX.utils)
   const previewRows = XLSX.utils.sheet_to_json<string[]>(sheet, {
     header: 1,
     raw: false,
-    range: window,
+    range: previewRange,
   })
 
   return {
 
@@ -10,6 +10,7 @@ import type { WorkspaceFileRecord } from '@/lib/uploads/contexts/workspace'
 import { useHorizontalWheelScroll } from '@/app/workspace/[workspaceId]/files/components/file-viewer/use-horizontal-wheel-scroll'
 import {
   readXlsxPreviewData,
+  readXlsxWorkbook,
   XLSX_MAX_COLUMNS,
   XLSX_MAX_ROWS,
 } from '@/app/workspace/[workspaceId]/files/components/file-viewer/xlsx-preview-data'
@@ -55,7 +56,7 @@ export const XlsxPreview = memo(function XlsxPreview({
         setRenderError(null)
         await assertOoxmlPreviewWithinLimits(data)
         const XLSX = await import('xlsx')
-        const workbook = XLSX.read(new Uint8Array(data), { type: 'array' })
+        const workbook = readXlsxWorkbook(XLSX, data)
         if (!cancelled) {
           workbookRef.current = workbook
           setSheetNames(workbook.SheetNames)
 
@@ -3,7 +3,12 @@
  */
 import { describe, expect, it } from 'vitest'
 import * as XLSX from 'xlsx'
-import { isoDateText, normalizeSheetDisplayText } from '@/lib/file-parsers/sheet-display-text'
+import {
+  generalNumberText,
+  isoDateText,
+  isTimeOnlyFormat,
+  normalizeSheetDisplayText,
+} from '@/lib/file-parsers/sheet-display-text'
 import { XlsxParser } from '@/lib/file-parsers/xlsx-parser'
 
 /**
@@ -54,9 +59,8 @@ describe('XlsxParser display text', () => {
       'TRUE',
       '$2,500.00',
       '4111111111111111',
-      '0.30000000000000004',
-      'left',
-      'right',
+      '0.3',
+      'left right',
     ])
   })
 
@@ -66,6 +70,60 @@ describe('XlsxParser display text', () => {
     expect(dataRow(result.content).slice(0, 2)).toEqual(['2026-03-04', '2026-03-04T12:00:00'])
   })
 
+  /**
+   * A time-of-day serial lands on 1899-12-31 in a 1900 workbook and on
+   * 1904-01-01 in a 1904 one, so the decision must come from the format, not
+   * the epoch date. Elapsed formats are durations Excel shows as `30:00`.
+   */
+  describe.each([
+    ['xlsx', false],
+    ['xlsx', true],
+    ['xls', false],
+    ['xls', true],
+    ['xlsb', false],
+    ['xlsb', true],
+  ] as const)('time cells in %s (date1904: %s)', (bookType, date1904) => {
+    function timeWorkbook(): Buffer {
+      const sheet = XLSX.utils.aoa_to_sheet([['Clock', 'Meridiem', 'Elapsed', 'Minutes', 'Month']])
+      sheet.A2 = { t: 'n', v: 0.520821759, z: 'h:mm:ss' }
+      sheet.B2 = { t: 'n', v: 0.75, z: 'hh:mm AM/PM' }
+      sheet.C2 = { t: 'n', v: 1.25, z: '[h]:mm' }
+      sheet.D2 = { t: 'n', v: 0.5, z: '[mm]:ss' }
+      sheet.E2 = { t: 'n', v: 46085, z: 'mmm' }
+      sheet['!ref'] = 'A1:E2'
+      const book = XLSX.utils.book_new()
+      XLSX.utils.book_append_sheet(book, sheet, 'Times')
+      if (date1904) book.Workbook = { WBProps: { date1904: true } }
+      return XLSX.write(book, { type: 'buffer', bookType }) as Buffer
+    }
+
+    it('renders time-only cells as times and elapsed cells as durations', async () => {
+      const result = await new XlsxParser().parseBuffer(timeWorkbook())
+
+      const row = dataRow(result.content)
+      expect(row.slice(0, 4)).toEqual(['12:29:59', '18:00:00', '30:00', '720:00'])
+      expect(row[4]).toMatch(/^\d{4}-\d{2}-\d{2}$/)
+    })
+  })
+
+  /**
+   * The SheetJS ODS writer stores each serial as the cell text, so an elapsed
+   * cell reads back its serial; time-only cells still come from the format.
+   */
+  it.each([false, true])('renders time-only cells from ods (date1904: %s)', async (date1904) => {
+    const sheet = XLSX.utils.aoa_to_sheet([['Clock']])
+    sheet.A2 = { t: 'n', v: 0.520821759, z: 'h:mm:ss' }
+    sheet['!ref'] = 'A1:A2'
+    const book = XLSX.utils.book_new()
+    XLSX.utils.book_append_sheet(book, sheet, 'Times')
+    if (date1904) book.Workbook = { WBProps: { date1904: true } }
+    const buffer = XLSX.write(book, { type: 'buffer', bookType: 'ods' }) as Buffer
+
+    const result = await new XlsxParser().parseBuffer(buffer)
+
+    expect(dataRow(result.content)).toEqual(['12:29:59'])
+  })
+
   it.each(['xls', 'xlsb'] as const)('renders the same display text from %s', async (bookType) => {
     const result = await new XlsxParser().parseBuffer(typedWorkbook(bookType))
 
@@ -116,10 +174,43 @@ describe('isoDateText', () => {
     expect(isoDateText(new Date(Number.NaN))).toBe('')
   })
 
-  it('renders a duration or time-of-day cell without the 1899 epoch date', () => {
+  it('renders a formatless date before 1900 as a time of day', () => {
     expect(isoDateText(new Date(Date.UTC(1899, 11, 30, 0, 30, 0)))).toBe('00:30:00')
     expect(isoDateText(new Date(Date.UTC(1899, 11, 31, 13, 5, 9)))).toBe('13:05:09')
   })
+
+  it('decides time of day from the format whatever the epoch date', () => {
+    expect(isoDateText(new Date(Date.UTC(1904, 0, 1, 12, 29, 59)), 'h:mm:ss')).toBe('12:29:59')
+    expect(isoDateText(new Date(Date.UTC(1899, 11, 31, 12, 0, 0)), 'yyyy-mm-dd')).toBe(
+      '1899-12-31T12:00:00'
+    )
+  })
+})
+
+describe('isTimeOnlyFormat', () => {
+  it.each(['h:mm:ss', 'hh:mm AM/PM', 'h:mm', 'mm:ss', '[$-409]h:mm:ss', 'hh"h"mm'])(
+    'treats %s as time only',
+    (format) => {
+      expect(isTimeOnlyFormat(format)).toBe(true)
+    }
+  )
+
+  it.each(['m/d/yyyy', 'yyyy-mm-dd hh:mm', 'mmm', 'd-mmm', 'mmmm yyyy', 'General'])(
+    'treats %s as a date',
+    (format) => {
+      expect(isTimeOnlyFormat(format)).toBe(false)
+    }
+  )
+})
+
+describe('generalNumberText', () => {
+  it('keeps integers exact and rounds fractions to 15 significant digits', () => {
+    expect(generalNumberText(4111111111111111)).toBe('4111111111111111')
+    expect(generalNumberText(Number.MAX_SAFE_INTEGER)).toBe('9007199254740991')
+    expect(generalNumberText(0.1 + 0.2)).toBe('0.3')
+    expect(generalNumberText(1063.8425)).toBe('1063.8425')
+    expect(generalNumberText(1.22464679914735e-16)).toBe('1.22464679914735e-16')
+  })
 })
 
 describe('normalizeSheetDisplayText', () => {
@@ -139,6 +230,18 @@ describe('normalizeSheetDisplayText', () => {
     expect(sheet.D1.w).toBe('9')
   })
 
+  it('keeps the rendered duration of an elapsed-time cell', () => {
+    const sheet = XLSX.utils.aoa_to_sheet([['a']])
+    sheet.A1 = { t: 'd', v: new Date(Date.UTC(1900, 0, 1, 6)), z: '[h]:mm', w: '30:00' }
+    sheet.B1 = { t: 'd', v: new Date(Date.UTC(1899, 11, 31, 12)), z: '[mm]:ss', w: '720:00' }
+    sheet['!ref'] = 'A1:B1'
+
+    normalizeSheetDisplayText(sheet, XLSX.utils.decode_range('A1:B1'), XLSX.utils)
+
+    expect(sheet.A1.w).toBe('30:00')
+    expect(sheet.B1.w).toBe('720:00')
+  })
+
   it('touches only the window on a dense sheet', () => {
     const sheet = XLSX.utils.aoa_to_sheet([['a']], { dense: true })
     const inside = { t: 'd', v: new Date(Date.UTC(2026, 2, 4)), w: '3/4/2026' } as XLSX.CellObject
 
@@ -18,18 +18,70 @@ interface CellLookup {
   encode_cell: (address: CellAddress) => string
 }
 
+/** Excel shows 15 significant digits for a General-formatted number. */
+const GENERAL_SIGNIFICANT_DIGITS = 15
+
+const ELAPSED_TOKEN = /\[(h+|m+|s+)\]/i
+
+/**
+ * Strips the parts of a number format that carry no date tokens: quoted
+ * literals, backslash escapes, bracketed colour/condition/elapsed sections and
+ * the AM/PM markers whose `m` is not a month.
+ */
+function dateTokensOf(format: string): string {
+  return format
+    .replace(/"[^"]*"/g, '')
+    .replace(/\\./g, '')
+    .replace(/\[[^\]]*\]/g, '')
+    .replace(/am\/pm|a\/p/gi, '')
+    .toLowerCase()
+}
+
+/**
+ * Whether a date format shows a time of day and nothing else, such as
+ * `h:mm:ss` or `hh:mm AM/PM`. Any `y` or `d` token is a date, and so is an `m`
+ * run that is not next to hours or seconds, which is how Excel tells a month
+ * from minutes.
+ */
+export function isTimeOnlyFormat(format: string): boolean {
+  const tokens = dateTokensOf(format)
+  if (/[yd]/.test(tokens)) return false
+  if (!/[hms]/.test(tokens)) return false
+  for (const match of tokens.matchAll(/m+/g)) {
+    const before = tokens.slice(0, match.index).replace(/[:\s]+$/, '')
+    const after = tokens.slice(match.index + match[0].length).replace(/^[:\s]+/, '')
+    const isMinutes = before.endsWith('h') || after.startsWith('s')
+    if (!isMinutes) return false
+  }
+  return true
+}
+
 /**
  * Excel dates carry no zone. Emit the UTC fields SheetJS parsed the serial
  * into, without a trailing `Z`, and drop the time when it is midnight.
+ *
+ * A time-of-day cell is decided from its format, because the epoch date its
+ * serial lands on differs between 1900 and 1904 workbooks. Without a format,
+ * a date before 1900 can only be a fraction of a day and is shown as a time.
  */
-export function isoDateText(date: Date): string {
+export function isoDateText(date: Date, format?: string): string {
   if (Number.isNaN(date.getTime())) return ''
   const iso = date.toISOString()
-  /** A serial below 1 is a duration or time of day; Excel shows it without the 1899 epoch date. */
-  if (date.getUTCFullYear() < 1900) return iso.slice(11, 19)
+  const timeOnly = format === undefined ? date.getUTCFullYear() < 1900 : isTimeOnlyFormat(format)
+  if (timeOnly) return iso.slice(11, 19)
   return iso.endsWith('T00:00:00.000Z') ? iso.slice(0, 10) : iso.slice(0, 19)
 }
 
+/**
+ * Renders a General-formatted number the way Excel displays it: integers in
+ * full, so 16-digit identifiers keep every digit, and fractions rounded to 15
+ * significant digits, so `=0.1+0.2` reads `0.3`.
+ */
+export function generalNumberText(value: number): string {
+  if (Number.isInteger(value)) return String(value)
+  return String(Number(value.toPrecision(GENERAL_SIGNIFICANT_DIGITS)))
+}
+
 function isGeneralFormat(format: unknown): boolean {
   return format === undefined || format === 'General'
 }
@@ -42,7 +94,10 @@ function isGeneralFormat(format: unknown): boolean {
  * percent, boolean and text cells, but not for dates (locale-shaped, such as
  * `3/4/2026`) or General-formatted numbers (Excel's 11-character rendering
  * turns `4111111111111111` into `4.11111E+15`, losing digits of numeric IDs).
- * Dates become ISO text and General numbers print their full stored value.
+ * Dates become ISO text and General numbers print as Excel displays them.
+ *
+ * Elapsed-time formats (`[h]:mm`, `[mm]:ss`) are durations, not moments;
+ * `cellDates` still parses them into a `Date`, so their `w` (`30:00`) is kept.
  *
  * A number with no format at all is treated as General too. Every other
  * number keeps the text the file rendered for it, so a LibreOffice workbook
@@ -70,9 +125,11 @@ export function normalizeSheetDisplayText(
       if (!cell) continue
 
       if (cell.t === 'd' && cell.v instanceof Date) {
-        cell.w = isoDateText(cell.v)
+        const format = typeof cell.z === 'string' ? cell.z : undefined
+        if (format !== undefined && ELAPSED_TOKEN.test(format)) continue
+        cell.w = isoDateText(cell.v, format)
       } else if (cell.t === 'n' && typeof cell.v === 'number' && isGeneralFormat(cell.z)) {
-        cell.w = String(cell.v)
+        cell.w = generalNumberText(cell.v)
       }
     }
   }