@beyondwork/docx-react-component 1.0.0

package/test/formats/xlsx/io/xlsx-import.test.ts

@@ -0,0 +1,766 @@
+/**
+ * SpreadsheetML import tests.
+ *
+ * Each test builds a minimal in-memory xlsx OPC package, calls loadXlsxWorkbook,
+ * and asserts correctness on the resulting CanonicalWorkbook.
+ *
+ * Fixtures are constructed programmatically using writeOpcPackage so that no
+ * binary files need to be stored in the repo for this baseline proof layer.
+ */
+
+import assert from "node:assert/strict";
+import { mkdirSync, writeFileSync } from "node:fs";
+import test from "node:test";
+
+import type { OpcPackageManifest, OpcPackagePart } from "../../../../src/io/ooxml/part-manifest.ts";
+import { getRelationshipsPartPath } from "../../../../src/io/ooxml/part-manifest.ts";
+import type { OpcRelationship } from "../../../../src/io/ooxml/part-manifest.ts";
+import { writeOpcPackage } from "../../../../src/io/opc/package-writer.ts";
+
+import { loadXlsxWorkbook, XLSX_OFFICE_DOCUMENT_REL_TYPE } from "../../../../src/formats/xlsx/io/xlsx-session.ts";
+import { getCell, getSheetExtent } from "../../../../src/formats/xlsx/model/sheet.ts";
+import { listSheets } from "../../../../src/formats/xlsx/model/workbook.ts";
+
+// ---------------------------------------------------------------------------
+// Proof bundle accumulator
+// ---------------------------------------------------------------------------
+
+const PROOF_DIR = ".tmp/wave-25-xlsx-proof";
+const PROOF_PATH = `${PROOF_DIR}/import-tests.json`;
+
+interface TestResult {
+  id: string;
+  description: string;
+  passed: boolean;
+  detail?: string;
+}
+
+const results: TestResult[] = [];
+
+function record(id: string, description: string, passed: boolean, detail?: string): void {
+  results.push({ id, description, passed, detail });
+}
+
+// ---------------------------------------------------------------------------
+// Test fixture builder
+// ---------------------------------------------------------------------------
+
+interface SheetFixture {
+  /** Relationship ID referenced in workbook.xml. */
+  relId: string;
+  /** Sheet name. */
+  name: string;
+  /** sheetId attribute in workbook.xml. */
+  sheetId: string;
+  /** Part path within the package, e.g. "/xl/worksheets/sheet1.xml". */
+  partPath: string;
+  /** Raw worksheet XML. */
+  xml: string;
+  /** Visibility state. Defaults to "visible". */
+  state?: "visible" | "hidden" | "veryHidden";
+}
+
+interface XlsxFixtureOptions {
+  sheets: SheetFixture[];
+  sharedStringsXml?: string;
+  stylesXml?: string;
+  date1904?: boolean;
+}
+
+const WB_NS = 'xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"';
+const WB_R_NS = 'xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"';
+const WS_NS = 'xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"';
+const SS_NS = 'xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"';
+const STYLES_NS = 'xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"';
+
+const REL_WORKSHEET = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet";
+const REL_SHARED_STRINGS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings";
+const REL_STYLES = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles";
+
+const CT_WORKBOOK = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml";
+const CT_WORKSHEET = "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml";
+const CT_SHARED_STRINGS = "application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml";
+const CT_STYLES = "application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml";
+
+function buildWorkbookXml(sheets: SheetFixture[], date1904: boolean): string {
+  const sheetElements = sheets.map((s) => {
+    const stateAttr = s.state && s.state !== "visible" ? ` state="${s.state}"` : "";
+    return `    <sheet name="${s.name}" sheetId="${s.sheetId}"${stateAttr} r:id="${s.relId}"/>`;
+  });
+  const workbookPr = date1904 ? `\n  <workbookPr date1904="1"/>` : "";
+  return [
+    `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
+    `<workbook ${WB_NS} ${WB_R_NS}>${workbookPr}`,
+    `  <sheets>`,
+    ...sheetElements,
+    `  </sheets>`,
+    `</workbook>`,
+  ].join("\n");
+}
+
+function buildXlsxFixture(opts: XlsxFixtureOptions): Uint8Array {
+  const encoder = new TextEncoder();
+  const workbookPath = "/xl/workbook.xml";
+  const parts = new Map<string, OpcPackagePart>();
+
+  // Build workbook relationships
+  const workbookRels: OpcRelationship[] = [];
+
+  for (const sheet of opts.sheets) {
+    // Relationship target is relative to workbook part (/xl/)
+    const relativeTarget = sheet.partPath.replace(/^\/xl\//, "");
+    workbookRels.push({
+      id: sheet.relId,
+      type: REL_WORKSHEET,
+      target: relativeTarget,
+      targetMode: "internal",
+    });
+
+    parts.set(sheet.partPath, {
+      path: sheet.partPath,
+      surfaceKind: "content",
+      contentType: CT_WORKSHEET,
+      relationshipsPartPath: getRelationshipsPartPath(sheet.partPath),
+      relationships: [],
+      compression: "store",
+      bytes: encoder.encode(sheet.xml),
+      crc32: 0,
+    });
+  }
+
+  if (opts.sharedStringsXml) {
+    const ssPath = "/xl/sharedStrings.xml";
+    workbookRels.push({
+      id: "rIdSS",
+      type: REL_SHARED_STRINGS,
+      target: "sharedStrings.xml",
+      targetMode: "internal",
+    });
+    parts.set(ssPath, {
+      path: ssPath,
+      surfaceKind: "content",
+      contentType: CT_SHARED_STRINGS,
+      relationshipsPartPath: getRelationshipsPartPath(ssPath),
+      relationships: [],
+      compression: "store",
+      bytes: encoder.encode(opts.sharedStringsXml),
+      crc32: 0,
+    });
+  }
+
+  if (opts.stylesXml) {
+    const stylesPath = "/xl/styles.xml";
+    workbookRels.push({
+      id: "rIdStyles",
+      type: REL_STYLES,
+      target: "styles.xml",
+      targetMode: "internal",
+    });
+    parts.set(stylesPath, {
+      path: stylesPath,
+      surfaceKind: "content",
+      contentType: CT_STYLES,
+      relationshipsPartPath: getRelationshipsPartPath(stylesPath),
+      relationships: [],
+      compression: "store",
+      bytes: encoder.encode(opts.stylesXml),
+      crc32: 0,
+    });
+  }
+
+  const workbookXml = buildWorkbookXml(opts.sheets, opts.date1904 ?? false);
+
+  parts.set(workbookPath, {
+    path: workbookPath,
+    surfaceKind: "content",
+    contentType: CT_WORKBOOK,
+    relationshipsPartPath: getRelationshipsPartPath(workbookPath),
+    relationships: workbookRels,
+    compression: "store",
+    bytes: encoder.encode(workbookXml),
+    crc32: 0,
+  });
+
+  const manifest: OpcPackageManifest = {
+    contentTypes: {
+      defaults: {
+        rels: "application/vnd.openxmlformats-package.relationships+xml",
+        xml: "application/xml",
+      },
+      overrides: {},
+    },
+    packageRelationships: [
+      {
+        id: "rId1",
+        type: XLSX_OFFICE_DOCUMENT_REL_TYPE,
+        target: "xl/workbook.xml",
+        targetMode: "internal",
+      },
+    ],
+    parts: [...parts.values()].map((p) => ({
+      path: p.path,
+      surfaceKind: p.surfaceKind,
+      contentType: p.contentType,
+      relationshipsPartPath: p.relationshipsPartPath,
+      relationships: p.relationships,
+      compression: p.compression,
+      byteLength: p.bytes.byteLength,
+    })),
+  };
+
+  return writeOpcPackage({ manifest, parts });
+}
+
+function makeMinimalSheet(xml?: string): string {
+  const body = xml ?? "<sheetData/>";
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<worksheet ${WS_NS}>${body}</worksheet>`;
+}
+
+function makeSharedStrings(strings: string[]): string {
+  const sis = strings.map((s) => `  <si><t>${escapeXml(s)}</t></si>`).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<sst ${SS_NS} count="${strings.length}" uniqueCount="${strings.length}">\n${sis}\n</sst>`;
+}
+
+function makeMinimalStyles(xfs: Array<{ numFmtId?: number; fontId?: number; fillId?: number; borderId?: number }>): string {
+  const xfElements = xfs.map((xf) => {
+    const attrs = [
+      `numFmtId="${xf.numFmtId ?? 0}"`,
+      `fontId="${xf.fontId ?? 0}"`,
+      `fillId="${xf.fillId ?? 0}"`,
+      `borderId="${xf.borderId ?? 0}"`,
+    ].join(" ");
+    return `    <xf ${attrs}/>`;
+  });
+  return [
+    `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
+    `<styleSheet ${STYLES_NS}>`,
+    `  <cellXfs count="${xfs.length}">`,
+    ...xfElements,
+    `  </cellXfs>`,
+    `</styleSheet>`,
+  ].join("\n");
+}
+
+function escapeXml(s: string): string {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+test("xlsx-import: minimal single-sheet workbook imports correctly", () => {
+  const bytes = buildXlsxFixture({
+    sheets: [
+      {
+        relId: "rId1",
+        name: "Sheet1",
+        sheetId: "1",
+        partPath: "/xl/worksheets/sheet1.xml",
+        xml: makeMinimalSheet(),
+      },
+    ],
+  });
+
+  const { workbook, warnings } = loadXlsxWorkbook(bytes);
+  assert.equal(warnings.length, 0, `Unexpected warnings: ${warnings.join(", ")}`);
+  assert.equal(workbook.sheets.size, 1);
+  assert.deepEqual(workbook.sheetOrder, ["1"]);
+  const sheet = workbook.sheets.get("1");
+  assert.ok(sheet, "Sheet '1' should exist");
+  assert.equal(sheet.name, "Sheet1");
+  assert.equal(sheet.hidden, false);
+  record("minimal-single-sheet", "minimal single-sheet workbook imports correctly", true);
+});
+
+test("xlsx-import: shared string cells are resolved during import", () => {
+  const sheetXml = makeMinimalSheet(`
+<sheetData>
+  <row r="1">
+    <c r="A1" t="s"><v>0</v></c>
+    <c r="B1" t="s"><v>1</v></c>
+  </row>
+</sheetData>`);
+
+  const bytes = buildXlsxFixture({
+    sheets: [
+      {
+        relId: "rId1",
+        name: "Data",
+        sheetId: "1",
+        partPath: "/xl/worksheets/sheet1.xml",
+        xml: sheetXml,
+      },
+    ],
+    sharedStringsXml: makeSharedStrings(["Hello", "World"]),
+  });
+
+  const { workbook } = loadXlsxWorkbook(bytes);
+  const sheet = workbook.sheets.get("1")!;
+  const a1 = getCell(sheet, 0, 0);
+  const b1 = getCell(sheet, 0, 1);
+  assert.ok(a1, "A1 should be present");
+  assert.ok(b1, "B1 should be present");
+  assert.equal(a1.kind, "text");
+  assert.equal(b1.kind, "text");
+  assert.equal((a1 as { kind: "text"; value: string }).value, "Hello");
+  assert.equal((b1 as { kind: "text"; value: string }).value, "World");
+  record("shared-string-cells", "shared string cells are resolved during import", true);
+});
+
+test("xlsx-import: number cells are imported correctly", () => {
+  const sheetXml = makeMinimalSheet(`
+<sheetData>
+  <row r="1">
+    <c r="A1"><v>42</v></c>
+    <c r="B1"><v>3.14</v></c>
+  </row>
+</sheetData>`);
+
+  const bytes = buildXlsxFixture({
+    sheets: [
+      {
+        relId: "rId1",
+        name: "Sheet1",
+        sheetId: "1",
+        partPath: "/xl/worksheets/sheet1.xml",
+        xml: sheetXml,
+      },
+    ],
+  });
+
+  const { workbook } = loadXlsxWorkbook(bytes);
+  const sheet = workbook.sheets.get("1")!;
+  const a1 = getCell(sheet, 0, 0);
+  const b1 = getCell(sheet, 0, 1);
+  assert.equal(a1?.kind, "number");
+  assert.equal((a1 as { kind: "number"; value: number }).value, 42);
+  assert.equal(b1?.kind, "number");
+  assert.ok(Math.abs((b1 as { kind: "number"; value: number }).value - 3.14) < 1e-10);
+  record("number-cells", "number cells are imported correctly", true);
+});
+
+test("xlsx-import: boolean cells are imported correctly", () => {
+  const sheetXml = makeMinimalSheet(`
+<sheetData>
+  <row r="1">
+    <c r="A1" t="b"><v>1</v></c>
+    <c r="B1" t="b"><v>0</v></c>
+  </row>
+</sheetData>`);
+
+  const bytes = buildXlsxFixture({
+    sheets: [
+      {
+        relId: "rId1",
+        name: "Sheet1",
+        sheetId: "1",
+        partPath: "/xl/worksheets/sheet1.xml",
+        xml: sheetXml,
+      },
+    ],
+  });
+
+  const { workbook } = loadXlsxWorkbook(bytes);
+  const sheet = workbook.sheets.get("1")!;
+  const a1 = getCell(sheet, 0, 0);
+  const b1 = getCell(sheet, 0, 1);
+  assert.equal(a1?.kind, "boolean");
+  assert.equal((a1 as { kind: "boolean"; value: boolean }).value, true);
+  assert.equal(b1?.kind, "boolean");
+  assert.equal((b1 as { kind: "boolean"; value: boolean }).value, false);
+  record("boolean-cells", "boolean cells are imported correctly", true);
+});
+
+test("xlsx-import: error cells are imported with canonical error codes", () => {
+  const sheetXml = makeMinimalSheet(`
+<sheetData>
+  <row r="1">
+    <c r="A1" t="e"><v>#DIV/0!</v></c>
+    <c r="B1" t="e"><v>#N/A</v></c>
+    <c r="C1" t="e"><v>#REF!</v></c>
+  </row>
+</sheetData>`);
+
+  const bytes = buildXlsxFixture({
+    sheets: [
+      {
+        relId: "rId1",
+        name: "Sheet1",
+        sheetId: "1",
+        partPath: "/xl/worksheets/sheet1.xml",
+        xml: sheetXml,
+      },
+    ],
+  });
+
+  const { workbook } = loadXlsxWorkbook(bytes);
+  const sheet = workbook.sheets.get("1")!;
+  assert.equal(getCell(sheet, 0, 0)?.kind, "error");
+  assert.equal((getCell(sheet, 0, 0) as { kind: "error"; errorCode: string }).errorCode, "#DIV/0!");
+  assert.equal((getCell(sheet, 0, 1) as { kind: "error"; errorCode: string }).errorCode, "#N/A");
+  assert.equal((getCell(sheet, 0, 2) as { kind: "error"; errorCode: string }).errorCode, "#REF!");
+  record("error-cells", "error cells imported with canonical error codes", true);
+});
+
+test("xlsx-import: formula cells with cached numeric values are imported", () => {
+  const sheetXml = makeMinimalSheet(`
+<sheetData>
+  <row r="1">
+    <c r="A1"><f>SUM(B1:B3)</f><v>100</v></c>
+    <c r="B1"><v>30</v></c>
+    <c r="B2"><v>40</v></c>
+    <c r="B3"><v>30</v></c>
+  </row>
+</sheetData>`);
+
+  const bytes = buildXlsxFixture({
+    sheets: [
+      {
+        relId: "rId1",
+        name: "Sheet1",
+        sheetId: "1",
+        partPath: "/xl/worksheets/sheet1.xml",
+        xml: sheetXml,
+      },
+    ],
+  });
+
+  const { workbook } = loadXlsxWorkbook(bytes);
+  const sheet = workbook.sheets.get("1")!;
+  const a1 = getCell(sheet, 0, 0);
+  assert.equal(a1?.kind, "formula");
+  type FormulaCell = { kind: "formula"; formula: string; cachedValue?: { type: string; value: unknown } };
+  const fc = a1 as FormulaCell;
+  assert.equal(fc.formula, "SUM(B1:B3)");
+  assert.ok(fc.cachedValue, "Formula should have cached value");
+  assert.equal(fc.cachedValue?.type, "number");
+  assert.equal(fc.cachedValue?.value, 100);
+  record("formula-cells-cached-numeric", "formula cells with cached numeric values imported", true);
+});
+
+test("xlsx-import: merge ranges are imported", () => {
+  const sheetXml = makeMinimalSheet(`
+<sheetData>
+  <row r="1">
+    <c r="A1" t="s"><v>0</v></c>
+  </row>
+</sheetData>
+<mergeCells count="1">
+  <mergeCell ref="A1:C3"/>
+</mergeCells>`);
+
+  const bytes = buildXlsxFixture({
+    sheets: [
+      {
+        relId: "rId1",
+        name: "Sheet1",
+        sheetId: "1",
+        partPath: "/xl/worksheets/sheet1.xml",
+        xml: sheetXml,
+      },
+    ],
+    sharedStringsXml: makeSharedStrings(["Title"]),
+  });
+
+  const { workbook } = loadXlsxWorkbook(bytes);
+  const sheet = workbook.sheets.get("1")!;
+  assert.equal(sheet.merges.length, 1);
+  const merge = sheet.merges[0];
+  assert.ok(merge, "Merge should exist");
+  // A1:C3 → row 0..2, col 0..2
+  assert.equal(merge.startRow, 0);
+  assert.equal(merge.startCol, 0);
+  assert.equal(merge.endRow, 2);
+  assert.equal(merge.endCol, 2);
+  record("merge-ranges", "merge ranges are imported correctly", true);
+});
+
+test("xlsx-import: multiple sheets are imported in declared order", () => {
+  const makeSheet = (label: string) =>
+    makeMinimalSheet(`<sheetData><row r="1"><c r="A1" t="inlineStr"><is><t>${label}</t></is></c></row></sheetData>`);
+
+  const bytes = buildXlsxFixture({
+    sheets: [
+      { relId: "rId1", name: "Alpha", sheetId: "1", partPath: "/xl/worksheets/sheet1.xml", xml: makeSheet("A") },
+      { relId: "rId2", name: "Beta",  sheetId: "2", partPath: "/xl/worksheets/sheet2.xml", xml: makeSheet("B") },
+      { relId: "rId3", name: "Gamma", sheetId: "3", partPath: "/xl/worksheets/sheet3.xml", xml: makeSheet("C") },
+    ],
+  });
+
+  const { workbook } = loadXlsxWorkbook(bytes);
+  assert.equal(workbook.sheets.size, 3);
+  const sheets = listSheets(workbook);
+  assert.equal(sheets[0].name, "Alpha");
+  assert.equal(sheets[1].name, "Beta");
+  assert.equal(sheets[2].name, "Gamma");
+  assert.deepEqual(workbook.sheetOrder, ["1", "2", "3"]);
+  record("multiple-sheets-order", "multiple sheets imported in declared order", true);
+});
+
+test("xlsx-import: hidden sheets are marked correctly", () => {
+  const bytes = buildXlsxFixture({
+    sheets: [
+      {
+        relId: "rId1",
+        name: "Visible",
+        sheetId: "1",
+        partPath: "/xl/worksheets/sheet1.xml",
+        xml: makeMinimalSheet(),
+      },
+      {
+        relId: "rId2",
+        name: "Hidden",
+        sheetId: "2",
+        partPath: "/xl/worksheets/sheet2.xml",
+        xml: makeMinimalSheet(),
+        state: "hidden",
+      },
+    ],
+  });
+
+  const { workbook } = loadXlsxWorkbook(bytes);
+  assert.equal(workbook.sheets.get("1")?.hidden, false);
+  assert.equal(workbook.sheets.get("2")?.hidden, true);
+  record("hidden-sheets", "hidden sheets are marked correctly", true);
+});
+
+test("xlsx-import: workbook without shared strings part imports without warnings", () => {
+  const sheetXml = makeMinimalSheet(`
+<sheetData>
+  <row r="1"><c r="A1"><v>99</v></c></row>
+</sheetData>`);
+
+  const bytes = buildXlsxFixture({
+    sheets: [
+      {
+        relId: "rId1",
+        name: "Sheet1",
+        sheetId: "1",
+        partPath: "/xl/worksheets/sheet1.xml",
+        xml: sheetXml,
+      },
+    ],
+    // No sharedStringsXml — this is valid for workbooks with no string cells
+  });
+
+  const { workbook, warnings } = loadXlsxWorkbook(bytes);
+  assert.equal(warnings.length, 0);
+  assert.equal(workbook.sharedStrings.strings.length, 0);
+  const sheet = workbook.sheets.get("1")!;
+  assert.equal(getCell(sheet, 0, 0)?.kind, "number");
+  record("no-shared-strings", "workbook without shared strings part imports cleanly", true);
+});
+
+test("xlsx-import: style indices are preserved on cells", () => {
+  const sheetXml = makeMinimalSheet(`
+<sheetData>
+  <row r="1">
+    <c r="A1" s="0"><v>1</v></c>
+    <c r="B1" s="1"><v>2</v></c>
+  </row>
+</sheetData>`);
+
+  const bytes = buildXlsxFixture({
+    sheets: [
+      {
+        relId: "rId1",
+        name: "Sheet1",
+        sheetId: "1",
+        partPath: "/xl/worksheets/sheet1.xml",
+        xml: sheetXml,
+      },
+    ],
+    stylesXml: makeMinimalStyles([
+      { numFmtId: 0, fontId: 0, fillId: 0, borderId: 0 },
+      { numFmtId: 14, fontId: 0, fillId: 0, borderId: 0 },
+    ]),
+  });
+
+  const { workbook } = loadXlsxWorkbook(bytes);
+  const sheet = workbook.sheets.get("1")!;
+  const a1 = getCell(sheet, 0, 0);
+  const b1 = getCell(sheet, 0, 1);
+  assert.equal((a1 as { styleRef?: { xfIndex: number } }).styleRef?.xfIndex, 0);
+  assert.equal((b1 as { styleRef?: { xfIndex: number } }).styleRef?.xfIndex, 1);
+  // Verify style registry
+  assert.equal(workbook.styles.cellFormats.length, 2);
+  assert.equal(workbook.styles.cellFormats[1]?.numFmtId, 14);
+  record("style-indices-preserved", "style indices preserved on cells and in registry", true);
+});
+
+test("xlsx-import: date1904 flag is parsed from workbookPr", () => {
+  const bytes = buildXlsxFixture({
+    sheets: [
+      {
+        relId: "rId1",
+        name: "Sheet1",
+        sheetId: "1",
+        partPath: "/xl/worksheets/sheet1.xml",
+        xml: makeMinimalSheet(),
+      },
+    ],
+    date1904: true,
+  });
+
+  const { workbook } = loadXlsxWorkbook(bytes);
+  assert.equal(workbook.metadata.date1904, true);
+  record("date1904-flag", "date1904 flag is parsed from workbookPr", true);
+});
+
+test("xlsx-import: default date1904 is false when workbookPr is absent", () => {
+  const bytes = buildXlsxFixture({
+    sheets: [
+      {
+        relId: "rId1",
+        name: "Sheet1",
+        sheetId: "1",
+        partPath: "/xl/worksheets/sheet1.xml",
+        xml: makeMinimalSheet(),
+      },
+    ],
+    date1904: false,
+  });
+
+  const { workbook } = loadXlsxWorkbook(bytes);
+  assert.equal(workbook.metadata.date1904, false);
+  record("date1904-default-false", "date1904 defaults to false (1900 base)", true);
+});
+
+test("xlsx-import: inline string cells (inlineStr type) are imported correctly", () => {
+  const sheetXml = makeMinimalSheet(`
+<sheetData>
+  <row r="1">
+    <c r="A1" t="inlineStr"><is><t>Inline text</t></is></c>
+  </row>
+</sheetData>`);
+
+  const bytes = buildXlsxFixture({
+    sheets: [
+      {
+        relId: "rId1",
+        name: "Sheet1",
+        sheetId: "1",
+        partPath: "/xl/worksheets/sheet1.xml",
+        xml: sheetXml,
+      },
+    ],
+  });
+
+  const { workbook } = loadXlsxWorkbook(bytes);
+  const sheet = workbook.sheets.get("1")!;
+  const a1 = getCell(sheet, 0, 0);
+  assert.equal(a1?.kind, "text");
+  assert.equal((a1 as { kind: "text"; value: string }).value, "Inline text");
+  record("inline-string-cells", "inline string cells imported correctly", true);
+});
+
+test("xlsx-import: sheet extent is computed correctly after import", () => {
+  const sheetXml = makeMinimalSheet(`
+<sheetData>
+  <row r="1">
+    <c r="A1"><v>1</v></c>
+    <c r="C1"><v>3</v></c>
+  </row>
+  <row r="5">
+    <c r="B5"><v>10</v></c>
+  </row>
+</sheetData>`);
+
+  const bytes = buildXlsxFixture({
+    sheets: [
+      {
+        relId: "rId1",
+        name: "Sheet1",
+        sheetId: "1",
+        partPath: "/xl/worksheets/sheet1.xml",
+        xml: sheetXml,
+      },
+    ],
+  });
+
+  const { workbook } = loadXlsxWorkbook(bytes);
+  const sheet = workbook.sheets.get("1")!;
+  const extent = getSheetExtent(sheet);
+  assert.ok(extent, "Extent should not be null");
+  assert.equal(extent.minRow, 0);
+  assert.equal(extent.maxRow, 4); // row 5 is index 4 (zero-based)
+  assert.equal(extent.minCol, 0);
+  assert.equal(extent.maxCol, 2); // C is col 2
+  record("sheet-extent", "sheet extent computed correctly after import", true);
+});
+
+test("xlsx-import: custom numFmt records from styles.xml are loaded into registry", () => {
+  const stylesXml = [
+    `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
+    `<styleSheet ${STYLES_NS}>`,
+    `  <numFmts count="1">`,
+    `    <numFmt numFmtId="164" formatCode="dd/mm/yyyy"/>`,
+    `  </numFmts>`,
+    `  <cellXfs count="1">`,
+    `    <xf numFmtId="164" fontId="0" fillId="0" borderId="0"/>`,
+    `  </cellXfs>`,
+    `</styleSheet>`,
+  ].join("\n");
+
+  const bytes = buildXlsxFixture({
+    sheets: [
+      {
+        relId: "rId1",
+        name: "Sheet1",
+        sheetId: "1",
+        partPath: "/xl/worksheets/sheet1.xml",
+        xml: makeMinimalSheet(),
+      },
+    ],
+    stylesXml,
+  });
+
+  const { workbook } = loadXlsxWorkbook(bytes);
+  const fmt = workbook.styles.numFormats.get(164);
+  assert.ok(fmt, "Custom numFmt 164 should be present in registry");
+  assert.equal(fmt.formatCode, "dd/mm/yyyy");
+  record("custom-numfmt", "custom numFmt records loaded into style registry", true);
+});
+
+test("xlsx-import: schemaVersion is set on imported workbook", () => {
+  const bytes = buildXlsxFixture({
+    sheets: [
+      {
+        relId: "rId1",
+        name: "Sheet1",
+        sheetId: "1",
+        partPath: "/xl/worksheets/sheet1.xml",
+        xml: makeMinimalSheet(),
+      },
+    ],
+  });
+
+  const { workbook } = loadXlsxWorkbook(bytes);
+  assert.equal(workbook.schemaVersion, "workbook/1");
+  record("schema-version", "schemaVersion is set on imported workbook", true);
+});
+
+// ---------------------------------------------------------------------------
+// Write proof bundle (deferred to process exit so all test records are captured)
+// ---------------------------------------------------------------------------
+
+process.on("exit", () => {
+  const passed = results.filter((r) => r.passed).length;
+  const failed = results.filter((r) => !r.passed).length;
+
+  const proofBundle = {
+    reportVersion: "wave-25-import/1",
+    component: "xlsx-import-and-normalization",
+    generatedAt: new Date().toISOString(),
+    summary: {
+      total: results.length,
+      passed,
+      failed,
+    },
+    tests: results,
+  };
+
+  mkdirSync(PROOF_DIR, { recursive: true });
+  writeFileSync(PROOF_PATH, JSON.stringify(proofBundle, null, 2), "utf8");
+});