diff --git a/packages/pluggableWidgets/datagrid-web/CHANGELOG.md b/packages/pluggableWidgets/datagrid-web/CHANGELOG.md
index 9ad253ede0..178fb4a63d 100644
--- a/packages/pluggableWidgets/datagrid-web/CHANGELOG.md
+++ b/packages/pluggableWidgets/datagrid-web/CHANGELOG.md
@@ -12,6 +12,14 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 ### Fixed
 
+- We fixed an issue where custom content columns ignored the export type setting, causing numbers and dates to always export as text in Excel.
+
+- We fixed an issue where exported date values included a hidden time component even when the format specified date-only parts.
+
+- We fixed an issue where boolean values were not exported as proper Excel boolean cells. Both attribute and custom content columns now export as native booleans (TRUE/FALSE) recognized by Excel.
+
+- We fixed an issue where numbers with more than 15 significant digits lost precision during Excel export. Such values are now exported as text to preserve all digits.
+
 - We fixed an issue where the vertical scrollbar disappeared after hiding a wide column while virtual scrolling was enabled.
 - We fixed an issue where only the first page loaded when the grid had enough columns to require horizontal scrolling.
 
diff --git a/packages/pluggableWidgets/datagrid-web/e2e/DataGrid.spec.js b/packages/pluggableWidgets/datagrid-web/e2e/DataGrid.spec.js
index ab93e490c0..8caa1f8bad 100644
--- a/packages/pluggableWidgets/datagrid-web/e2e/DataGrid.spec.js
+++ b/packages/pluggableWidgets/datagrid-web/e2e/DataGrid.spec.js
@@ -20,20 +20,28 @@ test.describe("datagrid-web export to Excel", () => {
         // Read file and convert to JSON.
         const workbook = XLSX.readFile("./e2e/downloads/testFilename.xlsx");
         const worksheet = workbook.Sheets[workbook.SheetNames[0]];
-        const jsonData = XLSX.utils.sheet_to_json(worksheet);
+        const rawData = XLSX.utils.sheet_to_json(worksheet, { raw: true });
+        const formattedData = XLSX.utils.sheet_to_json(worksheet, { raw: false });
 
-        expect(jsonData).toHaveLength(50);
+        expect(rawData).toHaveLength(50);
 
-        expect(jsonData[0]).toEqual({
+        // Verify raw cell types — numbers must be t:"n", not t:"s"
+        expect(rawData[0]["Birth year"]).toBe(1983);
+        expect(typeof rawData[0]["Birth year"]).toBe("number");
+        expect(rawData[1]["Birth year"]).toBe(1970);
+        expect(typeof rawData[1]["Birth year"]).toBe("number");
+
+        // Verify formatted display values
+        expect(formattedData[0]).toEqual({
             "Birth date": "2/15/1983",
-            "Birth year": 1983,
+            "Birth year": "1983",
             "Color (enum)": "Black",
             "First name": "Loretta"
         });
 
-        expect(jsonData[1]).toEqual({
+        expect(formattedData[1]).toEqual({
             "Birth date": "9/30/1970",
-            "Birth year": 1970,
+            "Birth year": "1970",
             "Color (enum)": "Red",
             "First name": "Chad"
         });
diff --git a/packages/pluggableWidgets/datagrid-web/src/features/data-export/DSExportRequest.ts b/packages/pluggableWidgets/datagrid-web/src/features/data-export/DSExportRequest.ts
index a1f9e9ca4f..9932db5eaf 100644
--- a/packages/pluggableWidgets/datagrid-web/src/features/data-export/DSExportRequest.ts
+++ b/packages/pluggableWidgets/datagrid-web/src/features/data-export/DSExportRequest.ts
@@ -1,33 +1,8 @@
 import { isAvailable } from "@mendix/widget-plugin-platform/framework/is-available";
-import Big from "big.js";
-import { DynamicValue, ListValue, ObjectItem, ValueStatus } from "mendix";
+import { ListValue, ObjectItem, ValueStatus } from "mendix";
 import { createNanoEvents, Emitter, Unsubscribe } from "nanoevents";
-import { ColumnsType, ShowContentAsEnum } from "../../../typings/DatagridProps";
-
-/** Represents a single Excel cell (SheetJS compatible) */
-interface ExcelCell {
-    /** Cell type: 's' = string, 'n' = number, 'b' = boolean, 'd' = date */
-    t: "s" | "n" | "b" | "d";
-    /** Underlying value */
-    v: string | number | boolean | Date;
-    /** Optional Excel number/date format, e.g. "yyyy-mm-dd" or "$0.00" */
-    z?: string;
-    /** Optional pre-formatted display text */
-    w?: string;
-}
-
-type RowData = ExcelCell[];
-
-type HeaderDefinition = {
-    name: string;
-    type: string;
-};
-
-type ValueReader = (item: ObjectItem, props: ColumnsType) => ExcelCell;
-
-type ReadersByType = Record<ShowContentAsEnum, ValueReader>;
-
-type RowReader = (item: ObjectItem) => RowData;
+import { ColumnsType } from "../../../typings/DatagridProps";
+import { HeaderDefinition, RowData, readChunk } from "./cell-readers";
 
 type ColumnReader = (props: ColumnsType) => HeaderDefinition;
 
@@ -262,132 +237,6 @@ export class DSExportRequest {
     }
 }
 
-const readers: ReadersByType = {
-    attribute(item, props) {
-        const data = props.attribute?.get(item);
-
-        if (data?.status !== "available") {
-            return makeEmptyCell();
-        }
-
-        const value = data.value;
-        const format = getCellFormat({
-            exportType: props.exportType,
-            exportDateFormat: props.exportDateFormat,
-            exportNumberFormat: props.exportNumberFormat
-        });
-
-        if (value instanceof Date) {
-            return excelDate(format === undefined ? data.displayValue : value, format);
-        }
-
-        if (typeof value === "boolean") {
-            return excelBoolean(value);
-        }
-
-        if (value instanceof Big || typeof value === "number") {
-            const num = value instanceof Big ? value.toNumber() : value;
-            return excelNumber(num, format);
-        }
-
-        return excelString(data.displayValue ?? "");
-    },
-
-    dynamicText(item, props) {
-        const data = props.dynamicText?.get(item);
-
-        switch (data?.status) {
-            case "available":
-                const format = getCellFormat({
-                    exportType: props.exportType,
-                    exportDateFormat: props.exportDateFormat,
-                    exportNumberFormat: props.exportNumberFormat
-                });
-
-                return excelString(data.value ?? "", format);
-            case "unavailable":
-                return excelString("n/a");
-            default:
-                return makeEmptyCell();
-        }
-    },
-
-    customContent(item, props) {
-        const value = props.exportValue?.get(item).value ?? "";
-        const format = getCellFormat({
-            exportType: props.exportType,
-            exportDateFormat: props.exportDateFormat,
-            exportNumberFormat: props.exportNumberFormat
-        });
-
-        return excelString(value, format);
-    }
-};
-
-function makeEmptyCell(): ExcelCell {
-    return { t: "s", v: "" };
-}
-
-function excelNumber(value: number, format?: string): ExcelCell {
-    return {
-        t: "n",
-        v: value,
-        z: format
-    };
-}
-
-function excelString(value: string, format?: string): ExcelCell {
-    return {
-        t: "s",
-        v: value,
-        z: format ?? undefined
-    };
-}
-
-function excelDate(value: string | Date, format?: string): ExcelCell {
-    return {
-        t: format === undefined ? "s" : "d",
-        v: value,
-        z: format
-    };
-}
-
-function excelBoolean(value: boolean): ExcelCell {
-    return {
-        t: "b",
-        v: value,
-        w: value ? "TRUE" : "FALSE"
-    };
-}
-
-interface DataExportProps {
-    exportType: "default" | "number" | "date" | "boolean";
-    exportDateFormat?: DynamicValue<string>;
-    exportNumberFormat?: DynamicValue<string>;
-}
-
-function getCellFormat({ exportType, exportDateFormat, exportNumberFormat }: DataExportProps): string | undefined {
-    switch (exportType) {
-        case "date":
-            return exportDateFormat?.status === "available" ? exportDateFormat.value : undefined;
-        case "number":
-            return exportNumberFormat?.status === "available" ? exportNumberFormat.value : undefined;
-        default:
-            return undefined;
-    }
-}
-
-function createRowReader(columns: ColumnsType[]): RowReader {
-    return item =>
-        columns.map(col => {
-            return readers[col.showContentAs](item, col);
-        });
-}
-
-function readChunk(data: ObjectItem[], columns: ColumnsType[]): RowData[] {
-    return data.map(createRowReader(columns));
-}
-
 declare global {
     interface Window {
         scheduler: {
diff --git a/packages/pluggableWidgets/datagrid-web/src/features/data-export/__tests__/cell-readers.spec.ts b/packages/pluggableWidgets/datagrid-web/src/features/data-export/__tests__/cell-readers.spec.ts
new file mode 100644
index 0000000000..73f8c2ef1f
--- /dev/null
+++ b/packages/pluggableWidgets/datagrid-web/src/features/data-export/__tests__/cell-readers.spec.ts
@@ -0,0 +1,424 @@
+jest.mock("mendix", () => ({}), { virtual: true });
+
+import { Big } from "big.js";
+import { ObjectItem } from "mendix";
+import { listAttribute, listExpression, dynamic, obj } from "@mendix/widget-plugin-test-utils";
+import { column } from "../../../utils/test-utils";
+import { readChunk, ExcelCell } from "../cell-readers";
+
+function readSingleCell(col: ReturnType<typeof column>, item?: ObjectItem): ExcelCell {
+    const items = [item ?? obj()];
+    const result = readChunk(items, [col]);
+    return result[0][0];
+}
+
+describe("cell-readers", () => {
+    describe("attribute reader", () => {
+        it("exports string attribute as string cell (displayValue)", () => {
+            const col = column("Name", c => {
+                c.showContentAs = "attribute";
+                c.attribute = listAttribute(() => "hello");
+            });
+            const cell = readSingleCell(col);
+            expect(cell.t).toBe("s");
+            // attribute reader returns displayValue for strings, not raw value
+            expect(cell.v).toBe("Formatted hello");
+        });
+
+        it("exports number attribute as number cell", () => {
+            const col = column("Amount", c => {
+                c.showContentAs = "attribute";
+                c.attribute = listAttribute(() => new Big("42.5"));
+            });
+            const cell = readSingleCell(col);
+            expect(cell.t).toBe("n");
+            expect(cell.v).toBe(42.5);
+        });
+
+        it("exports number attribute with format", () => {
+            const col = column("Amount", c => {
+                c.showContentAs = "attribute";
+                c.attribute = listAttribute(() => new Big("1234.56"));
+                c.exportType = "number";
+                c.exportNumberFormat = dynamic("#,##0.00");
+            });
+            const cell = readSingleCell(col);
+            expect(cell.t).toBe("n");
+            expect(cell.v).toBe(1234.56);
+            expect(cell.z).toBe("#,##0.00");
+        });
+
+        it("exports boolean attribute as boolean cell", () => {
+            const col = column("Active", c => {
+                c.showContentAs = "attribute";
+                c.attribute = listAttribute(() => true);
+            });
+            const cell = readSingleCell(col);
+            expect(cell.t).toBe("b");
+            expect(cell.v).toBe(true);
+        });
+
+        it("exports false boolean attribute as boolean cell", () => {
+            const col = column("Active", c => {
+                c.showContentAs = "attribute";
+                c.attribute = listAttribute(() => false);
+            });
+            const cell = readSingleCell(col);
+            expect(cell.t).toBe("b");
+            expect(cell.v).toBe(false);
+        });
+
+        it("exports date attribute with format as date cell", () => {
+            const testDate = new Date("2024-06-15T10:30:00Z");
+            const col = column("Created", c => {
+                c.showContentAs = "attribute";
+                c.attribute = listAttribute(() => testDate);
+                c.exportType = "date";
+                c.exportDateFormat = dynamic("yyyy-mm-dd");
+            });
+            const cell = readSingleCell(col);
+            expect(cell.t).toBe("d");
+            expect(cell.v).toEqual(new Date(Date.UTC(2024, 5, 15)));
+            expect(cell.z).toBe("yyyy-mm-dd");
+        });
+
+        it("exports date attribute without format using default date format", () => {
+            const testDate = new Date("2024-06-15T10:30:00Z");
+            const col = column("Created", c => {
+                c.showContentAs = "attribute";
+                c.attribute = listAttribute(() => testDate);
+                c.exportType = "default";
+            });
+            const cell = readSingleCell(col);
+            expect(cell.t).toBe("d");
+            expect(cell.v).toEqual(new Date(Date.UTC(2024, 5, 15)));
+            expect(cell.z).toBe("dd-mm-yyyy");
+        });
+
+        it("returns empty cell when attribute is not available", () => {
+            const col = column("Missing", c => {
+                c.showContentAs = "attribute";
+                c.attribute = undefined;
+            });
+            const cell = readSingleCell(col);
+            expect(cell).toEqual({ t: "s", v: "" });
+        });
+    });
+
+    describe("dynamicText reader", () => {
+        it("exports dynamic text as string cell", () => {
+            const col = column("Label", c => {
+                c.showContentAs = "dynamicText";
+                c.dynamicText = listExpression(() => "formatted text");
+            });
+            const cell = readSingleCell(col);
+            expect(cell.t).toBe("s");
+            expect(cell.v).toBe("formatted text");
+        });
+
+        it("returns empty cell when dynamicText is undefined", () => {
+            const col = column("Label", c => {
+                c.showContentAs = "dynamicText";
+                c.dynamicText = undefined;
+            });
+            const cell = readSingleCell(col);
+            expect(cell).toEqual({ t: "s", v: "" });
+        });
+
+        it("returns n/a cell when dynamicText is unavailable", () => {
+            const col = column("Label", c => {
+                c.showContentAs = "dynamicText";
+                c.dynamicText = { get: () => ({ status: "unavailable", value: undefined }) } as any;
+            });
+            const cell = readSingleCell(col);
+            expect(cell.t).toBe("s");
+            expect(cell.v).toBe("n/a");
+        });
+    });
+
+    describe("customContent reader", () => {
+        it("exports custom content as string cell (current baseline)", () => {
+            const col = column("Custom", c => {
+                c.showContentAs = "customContent";
+                c.exportValue = listExpression(() => "42.50");
+                c.exportType = "default";
+            });
+            const cell = readSingleCell(col);
+            expect(cell.t).toBe("s");
+            expect(cell.v).toBe("42.50");
+        });
+
+        it("exports empty string when exportValue is undefined", () => {
+            const col = column("Custom", c => {
+                c.showContentAs = "customContent";
+                c.exportValue = undefined;
+                c.exportType = "default";
+            });
+            const cell = readSingleCell(col);
+            expect(cell.t).toBe("s");
+            expect(cell.v).toBe("");
+        });
+
+        it("exports as number cell when exportType is number", () => {
+            const col = column("Price", c => {
+                c.showContentAs = "customContent";
+                c.exportValue = listExpression(() => "1234.56");
+                c.exportType = "number";
+                c.exportNumberFormat = dynamic("#,##0.00");
+            });
+            const cell = readSingleCell(col);
+            expect(cell.t).toBe("n");
+            expect(cell.v).toBe(1234.56);
+            expect(cell.z).toBe("#,##0.00");
+        });
+
+        it("exports as number cell without format", () => {
+            const col = column("Count", c => {
+                c.showContentAs = "customContent";
+                c.exportValue = listExpression(() => "99");
+                c.exportType = "number";
+            });
+            const cell = readSingleCell(col);
+            expect(cell.t).toBe("n");
+            expect(cell.v).toBe(99);
+        });
+
+        it("falls back to string when number parse fails", () => {
+            const col = column("Bad", c => {
+                c.showContentAs = "customContent";
+                c.exportValue = listExpression(() => "not-a-number");
+                c.exportType = "number";
+            });
+            const cell = readSingleCell(col);
+            expect(cell.t).toBe("s");
+            expect(cell.v).toBe("not-a-number");
+        });
+
+        it("falls back to string for empty value with number exportType", () => {
+            const col = column("Empty", c => {
+                c.showContentAs = "customContent";
+                c.exportValue = listExpression(() => "");
+                c.exportType = "number";
+            });
+            const cell = readSingleCell(col);
+            expect(cell.t).toBe("s");
+            expect(cell.v).toBe("");
+        });
+
+        it("falls back to string for whitespace-only value with number exportType", () => {
+            const col = column("Ws", c => {
+                c.showContentAs = "customContent";
+                c.exportValue = listExpression(() => "   ");
+                c.exportType = "number";
+            });
+            const cell = readSingleCell(col);
+            expect(cell.t).toBe("s");
+            expect(cell.v).toBe("   ");
+        });
+
+        it("exports as date cell when exportType is date", () => {
+            const col = column("Created", c => {
+                c.showContentAs = "customContent";
+                c.exportValue = listExpression(() => "2024-06-15T00:00:00.000Z");
+                c.exportType = "date";
+                c.exportDateFormat = dynamic("yyyy-mm-dd");
+            });
+            const cell = readSingleCell(col);
+            expect(cell.t).toBe("d");
+            expect(cell.v).toEqual(new Date("2024-06-15T00:00:00.000Z"));
+            expect(cell.z).toBe("yyyy-mm-dd");
+        });
+
+        it("exports date with default format when no format provided", () => {
+            const col = column("Created", c => {
+                c.showContentAs = "customContent";
+                c.exportValue = listExpression(() => "2024-06-15T10:30:00Z");
+                c.exportType = "date";
+            });
+            const cell = readSingleCell(col);
+            expect(cell.t).toBe("d");
+            expect(cell.v).toEqual(new Date(Date.UTC(2024, 5, 15)));
+            expect(cell.z).toBe("dd-mm-yyyy");
+        });
+
+        it("falls back to string when date parse fails", () => {
+            const col = column("Bad", c => {
+                c.showContentAs = "customContent";
+                c.exportValue = listExpression(() => "not-a-date");
+                c.exportType = "date";
+                c.exportDateFormat = dynamic("yyyy-mm-dd");
+            });
+            const cell = readSingleCell(col);
+            expect(cell.t).toBe("s");
+            expect(cell.v).toBe("not-a-date");
+        });
+
+        it("falls back to string for empty value with date exportType", () => {
+            const col = column("Empty", c => {
+                c.showContentAs = "customContent";
+                c.exportValue = listExpression(() => "");
+                c.exportType = "date";
+                c.exportDateFormat = dynamic("yyyy-mm-dd");
+            });
+            const cell = readSingleCell(col);
+            expect(cell.t).toBe("s");
+            expect(cell.v).toBe("");
+        });
+
+        it("exports as boolean true when exportType is boolean and value is 'true'", () => {
+            const col = column("Active", c => {
+                c.showContentAs = "customContent";
+                c.exportValue = listExpression(() => "true");
+                c.exportType = "boolean";
+            });
+            const cell = readSingleCell(col);
+            expect(cell.t).toBe("b");
+            expect(cell.v).toBe(true);
+        });
+
+        it("exports as boolean false when exportType is boolean and value is 'false'", () => {
+            const col = column("Active", c => {
+                c.showContentAs = "customContent";
+                c.exportValue = listExpression(() => "false");
+                c.exportType = "boolean";
+            });
+            const cell = readSingleCell(col);
+            expect(cell.t).toBe("b");
+            expect(cell.v).toBe(false);
+        });
+
+        it("exports boolean true for case-insensitive values", () => {
+            for (const val of ["True", "YES", "1"]) {
+                const col = column("Active", c => {
+                    c.showContentAs = "customContent";
+                    c.exportValue = listExpression(() => val);
+                    c.exportType = "boolean";
+                });
+                const cell = readSingleCell(col);
+                expect(cell.t).toBe("b");
+                expect(cell.v).toBe(true);
+            }
+        });
+
+        it("exports boolean false for case-insensitive values", () => {
+            for (const val of ["False", "NO", "0"]) {
+                const col = column("Active", c => {
+                    c.showContentAs = "customContent";
+                    c.exportValue = listExpression(() => val);
+                    c.exportType = "boolean";
+                });
+                const cell = readSingleCell(col);
+                expect(cell.t).toBe("b");
+                expect(cell.v).toBe(false);
+            }
+        });
+
+        it("falls back to string for unrecognized boolean value", () => {
+            const col = column("Active", c => {
+                c.showContentAs = "customContent";
+                c.exportValue = listExpression(() => "maybe");
+                c.exportType = "boolean";
+            });
+            const cell = readSingleCell(col);
+            expect(cell.t).toBe("s");
+            expect(cell.v).toBe("maybe");
+        });
+    });
+
+    describe("long number precision", () => {
+        it("exports Big with >15 significant digits as string to preserve precision", () => {
+            const col = column("LongId", c => {
+                c.showContentAs = "attribute";
+                c.attribute = listAttribute(() => new Big("1234567890123456789"));
+            });
+            const cell = readSingleCell(col);
+            expect(cell.t).toBe("s");
+            expect(cell.v).toBe("1234567890123456789");
+        });
+
+        it("exports Big with <=15 significant digits as number", () => {
+            const col = column("NormalNum", c => {
+                c.showContentAs = "attribute";
+                c.attribute = listAttribute(() => new Big("123456789012345"));
+            });
+            const cell = readSingleCell(col);
+            expect(cell.t).toBe("n");
+            expect(cell.v).toBe(123456789012345);
+        });
+
+        it("exports Big with >15 digits and format as string with format", () => {
+            const col = column("LongFormatted", c => {
+                c.showContentAs = "attribute";
+                c.attribute = listAttribute(() => new Big("9999999999999999999"));
+                c.exportType = "number";
+                c.exportNumberFormat = dynamic("0");
+            });
+            const cell = readSingleCell(col);
+            expect(cell.t).toBe("s");
+            expect(cell.v).toBe("9999999999999999999");
+        });
+
+        it("handles Big decimal with many significant digits", () => {
+            const col = column("Precise", c => {
+                c.showContentAs = "attribute";
+                c.attribute = listAttribute(() => new Big("1234567890.1234567890"));
+            });
+            const cell = readSingleCell(col);
+            expect(cell.t).toBe("s");
+            expect(cell.v).toBe("1234567890.123456789");
+        });
+    });
+
+    describe("date time stripping", () => {
+        it("strips time from attribute date when format has no time components", () => {
+            const testDate = new Date("2024-06-15T10:30:00Z");
+            const col = column("DateOnly", c => {
+                c.showContentAs = "attribute";
+                c.attribute = listAttribute(() => testDate);
+                c.exportType = "date";
+                c.exportDateFormat = dynamic("dd-mmm-yyyy");
+            });
+            const cell = readSingleCell(col);
+            expect(cell.t).toBe("d");
+            expect(cell.v).toEqual(new Date(Date.UTC(2024, 5, 15)));
+            expect(cell.z).toBe("dd-mmm-yyyy");
+        });
+
+        it("preserves time in attribute date when format has time components", () => {
+            const testDate = new Date("2024-06-15T10:30:00Z");
+            const col = column("DateTime", c => {
+                c.showContentAs = "attribute";
+                c.attribute = listAttribute(() => testDate);
+                c.exportType = "date";
+                c.exportDateFormat = dynamic("yyyy-mm-dd hh:mm:ss");
+            });
+            const cell = readSingleCell(col);
+            expect(cell.t).toBe("d");
+            expect(cell.v).toEqual(testDate);
+        });
+
+        it("strips time from customContent date when format has no time components", () => {
+            const col = column("DateOnly", c => {
+                c.showContentAs = "customContent";
+                c.exportValue = listExpression(() => "2024-06-15T10:30:00Z");
+                c.exportType = "date";
+                c.exportDateFormat = dynamic("dd-mmm-yyyy");
+            });
+            const cell = readSingleCell(col);
+            expect(cell.t).toBe("d");
+            expect(cell.v).toEqual(new Date(Date.UTC(2024, 5, 15)));
+        });
+
+        it("preserves time in customContent date when format has time components", () => {
+            const col = column("DateTime", c => {
+                c.showContentAs = "customContent";
+                c.exportValue = listExpression(() => "2024-06-15T10:30:00Z");
+                c.exportType = "date";
+                c.exportDateFormat = dynamic("yyyy-mm-dd hh:mm:ss");
+            });
+            const cell = readSingleCell(col);
+            expect(cell.t).toBe("d");
+            expect(cell.v).toEqual(new Date("2024-06-15T10:30:00Z"));
+        });
+    });
+});
diff --git a/packages/pluggableWidgets/datagrid-web/src/features/data-export/cell-readers.ts b/packages/pluggableWidgets/datagrid-web/src/features/data-export/cell-readers.ts
new file mode 100644
index 0000000000..c1227592b9
--- /dev/null
+++ b/packages/pluggableWidgets/datagrid-web/src/features/data-export/cell-readers.ts
@@ -0,0 +1,215 @@
+import { Big } from "big.js";
+import { DynamicValue, ObjectItem } from "mendix";
+import { ColumnsType, ShowContentAsEnum } from "../../../typings/DatagridProps";
+
+/** Represents a single Excel cell (SheetJS compatible) */
+export interface ExcelCell {
+    /** Cell type: 's' = string, 'n' = number, 'b' = boolean, 'd' = date */
+    t: "s" | "n" | "b" | "d";
+    /** Underlying value */
+    v: string | number | boolean | Date;
+    /** Optional Excel number/date format, e.g. "yyyy-mm-dd" or "$0.00" */
+    z?: string;
+    /** Optional pre-formatted display text */
+    w?: string;
+}
+
+export type RowData = ExcelCell[];
+
+export type HeaderDefinition = {
+    name: string;
+    type: string;
+};
+
+type ValueReader = (item: ObjectItem, props: ColumnsType) => ExcelCell;
+
+type ReadersByType = Record<ShowContentAsEnum, ValueReader>;
+
+type RowReader = (item: ObjectItem) => RowData;
+
+export interface DataExportProps {
+    exportType: "default" | "number" | "date" | "boolean";
+    exportDateFormat?: DynamicValue<string>;
+    exportNumberFormat?: DynamicValue<string>;
+}
+
+export function getCellFormat({
+    exportType,
+    exportDateFormat,
+    exportNumberFormat
+}: DataExportProps): string | undefined {
+    switch (exportType) {
+        case "date":
+            return exportDateFormat?.status === "available" ? exportDateFormat.value : undefined;
+        case "number":
+            return exportNumberFormat?.status === "available" ? exportNumberFormat.value : undefined;
+        default:
+            return undefined;
+    }
+}
+
+export function makeEmptyCell(): ExcelCell {
+    return { t: "s", v: "" };
+}
+
+export function excelNumber(value: number, format?: string): ExcelCell {
+    return {
+        t: "n",
+        v: value,
+        z: format
+    };
+}
+
+export function excelString(value: string, format?: string): ExcelCell {
+    return {
+        t: "s",
+        v: value,
+        z: format
+    };
+}
+
+const FALLBACK_DATE_FORMAT = "dd-mm-yyyy";
+
+function getDefaultDateFormat(): string {
+    const pattern = window.mx?.session.getConfig().locale.patterns.date;
+    if (!pattern) {
+        return FALLBACK_DATE_FORMAT;
+    }
+    return pattern.replace(/M/g, "m");
+}
+
+export function excelDate(value: Date, format?: string): ExcelCell {
+    return {
+        t: "d",
+        v: value,
+        z: format ?? getDefaultDateFormat()
+    };
+}
+
+export function excelBoolean(value: boolean): ExcelCell {
+    return {
+        t: "b",
+        v: value
+    };
+}
+
+function hasTimeComponent(format: string): boolean {
+    // Strip locale tags like [$-en-US] before checking — "S" in locale codes would otherwise match.
+    const stripped = format.replace(/\[.*?\]/g, "");
+    return /[hs]/i.test(stripped);
+}
+
+function stripTime(date: Date): Date {
+    return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+}
+
+const MAX_SAFE_SIGNIFICANT_DIGITS = 15;
+
+function countSignificantDigits(value: Big): number {
+    const str = value.toFixed();
+    const unsigned = str.replace("-", "");
+    const noDecimal = unsigned.replace(".", "");
+    const stripped = noDecimal.replace(/^0+/, "");
+    return stripped.length || 1;
+}
+
+const readers: ReadersByType = {
+    attribute(item, props) {
+        const data = props.attribute?.get(item);
+
+        if (data?.status !== "available") {
+            return makeEmptyCell();
+        }
+
+        const value = data.value;
+        const format = getCellFormat({
+            exportType: props.exportType,
+            exportDateFormat: props.exportDateFormat,
+            exportNumberFormat: props.exportNumberFormat
+        });
+
+        if (value instanceof Date) {
+            const dateValue = format && hasTimeComponent(format) ? value : stripTime(value);
+            return excelDate(dateValue, format);
+        }
+
+        if (typeof value === "boolean") {
+            return excelBoolean(value);
+        }
+
+        // Mendix numeric attributes always surface as Big; plain JS number is not expected here.
+        if (value instanceof Big) {
+            if (countSignificantDigits(value) > MAX_SAFE_SIGNIFICANT_DIGITS) {
+                return excelString(value.toFixed(), format);
+            }
+            return excelNumber(value.toNumber(), format);
+        }
+
+        return excelString(data.displayValue ?? "");
+    },
+
+    dynamicText(item, props) {
+        const data = props.dynamicText?.get(item);
+
+        switch (data?.status) {
+            case "available":
+                return excelString(data.value ?? "");
+            case "unavailable":
+                return excelString("n/a");
+            default:
+                return makeEmptyCell();
+        }
+    },
+
+    customContent(item, props) {
+        const raw = props.exportValue?.get(item);
+        if (!raw || raw.status !== "available") {
+            return makeEmptyCell();
+        }
+        const value = raw.value ?? "";
+        const { exportType } = props;
+        const format = getCellFormat({
+            exportType,
+            exportDateFormat: props.exportDateFormat,
+            exportNumberFormat: props.exportNumberFormat
+        });
+
+        if (exportType === "number" && value.trim() !== "") {
+            const parsed = Number(value);
+            if (!Number.isNaN(parsed)) {
+                return excelNumber(parsed, format);
+            }
+        }
+
+        if (exportType === "date" && value !== "") {
+            const parsed = new Date(value);
+            if (!isNaN(parsed.getTime())) {
+                const dateValue = format && hasTimeComponent(format) ? parsed : stripTime(parsed);
+                return excelDate(dateValue, format);
+            }
+        }
+
+        if (exportType === "boolean") {
+            const lower = value.trim().toLowerCase();
+            if (lower === "true" || lower === "yes" || lower === "1") {
+                return excelBoolean(true);
+            }
+            if (lower === "false" || lower === "no" || lower === "0") {
+                return excelBoolean(false);
+            }
+        }
+
+        return excelString(value);
+    }
+};
+
+function createRowReader(columns: ColumnsType[]): RowReader {
+    return item =>
+        columns.map(col => {
+            return readers[col.showContentAs](item, col);
+        });
+}
+
+export function readChunk(data: ObjectItem[], columns: ColumnsType[]): RowData[] {
+    return data.map(createRowReader(columns));
+}
diff --git a/packages/pluggableWidgets/datagrid-web/typings/DatagridProps.d.ts b/packages/pluggableWidgets/datagrid-web/typings/DatagridProps.d.ts
index c1da56eccf..d1a3761b3c 100644
--- a/packages/pluggableWidgets/datagrid-web/typings/DatagridProps.d.ts
+++ b/packages/pluggableWidgets/datagrid-web/typings/DatagridProps.d.ts
@@ -3,8 +3,8 @@
  * WARNING: All changes made to this file will be overwritten
  * @author Mendix Widgets Framework Team
  */
+import { ActionValue, DynamicValue, EditableValue, ListActionValue, ListAttributeListValue, ListAttributeValue, ListExpressionValue, ListValue, ListWidgetValue, SelectionMultiValue, SelectionSingleValue } from "mendix";
 import { ComponentType, CSSProperties, ReactNode } from "react";
-import { ActionValue, DynamicValue, EditableValue, ListValue, ListActionValue, ListAttributeValue, ListAttributeListValue, ListExpressionValue, ListWidgetValue, SelectionSingleValue, SelectionMultiValue } from "mendix";
 import { Big } from "big.js";
 
 export type ShowContentAsEnum = "attribute" | "dynamicText" | "customContent";
diff --git a/packages/pluggableWidgets/datagrid-web/typings/global.d.ts b/packages/pluggableWidgets/datagrid-web/typings/global.d.ts
new file mode 100644
index 0000000000..d9c5fc4d9a
--- /dev/null
+++ b/packages/pluggableWidgets/datagrid-web/typings/global.d.ts
@@ -0,0 +1,21 @@
+interface MXSessionLocale {
+    patterns: {
+        date: string;
+        datetime: string;
+        time: string;
+    };
+}
+
+interface MXGlobalObject {
+    session: {
+        getConfig(): { locale: MXSessionLocale };
+    };
+}
+
+declare global {
+    interface Window {
+        mx?: MXGlobalObject;
+    }
+}
+
+export {};
diff --git a/packages/pluggableWidgets/line-chart-web/e2e/LineChart.spec.js b/packages/pluggableWidgets/line-chart-web/e2e/LineChart.spec.js
index 0dd4e57447..f98891d1c3 100644
--- a/packages/pluggableWidgets/line-chart-web/e2e/LineChart.spec.js
+++ b/packages/pluggableWidgets/line-chart-web/e2e/LineChart.spec.js
@@ -1,15 +1,14 @@
 import { test, expect } from "@mendix/run-e2e/fixtures";
-import { waitForMendixApp } from "@mendix/run-e2e/mendix-helpers";
 
 test.describe("line-chart-web", () => {
     test.beforeEach(async ({ page }) => {
         await page.goto("/");
-        await waitForMendixApp(page);
     });
 
     test.describe("line style", () => {
         test("renders basic line chart and compares with a screenshot baseline", async ({ page }) => {
             const basicLineChartElement = await page.locator(".mx-name-containerBasic");
+            await basicLineChartElement.scrollIntoViewIfNeeded();
             await expect(basicLineChartElement).toBeVisible();
             await expect(
                 page.locator(".mx-name-containerBasic > .widget-chart > .mx-react-plotly-chart")
@@ -137,6 +136,9 @@ test.describe("line-chart-web", () => {
             const dimensionPixelsElement = await page.locator(".mx-name-containerDimensionPixels");
             await dimensionPixelsElement.scrollIntoViewIfNeeded();
             await expect(dimensionPixelsElement).toBeVisible();
+            await expect(
+                page.locator(".mx-name-containerDimensionPixels > .widget-chart > .mx-react-plotly-chart")
+            ).toBeVisible();
             await expect(dimensionPixelsElement).toHaveScreenshot(`lineChartDimensionPixels.png`);
         });
 
diff --git a/packages/pluggableWidgets/video-player-web/e2e/VideoPlayer.spec.js b/packages/pluggableWidgets/video-player-web/e2e/VideoPlayer.spec.js
index 5d593e4e21..8ba37034a7 100644
--- a/packages/pluggableWidgets/video-player-web/e2e/VideoPlayer.spec.js
+++ b/packages/pluggableWidgets/video-player-web/e2e/VideoPlayer.spec.js
@@ -1,4 +1,5 @@
 import { test, expect } from "@mendix/run-e2e/fixtures";
+import { waitForDataReady } from "@mendix/run-e2e/mendix-helpers";
 
 test.describe("Video Player", () => {
     test.beforeEach(async ({ page }) => {
@@ -108,18 +109,10 @@ test.describe("External video", () => {
     test("renders a poster", async ({ page }) => {
         const widget = page.locator(".widget-video-player");
         const videoLocator = page.locator(".widget-video-player video");
+        await widget.scrollIntoViewIfNeeded();
         await expect(widget).toBeVisible();
         await expect(videoLocator).toHaveAttribute("poster", /.+/);
-        const posterUrl = await videoLocator.getAttribute("poster");
-        await page.evaluate(url => {
-            return new Promise(resolve => {
-                const img = new Image();
-                img.onload = () => resolve(undefined);
-                img.onerror = () => resolve(undefined);
-                img.src = url;
-                if (img.complete && img.naturalWidth !== 0) resolve(undefined);
-            });
-        }, posterUrl);
+        await waitForDataReady(page);
         await expect(widget).toHaveScreenshot("videoPlayerExternalPoster.png");
     });