Migrate ExcelIO from ClosedXML to NPOI

NEW/src/JdeScoping.ExcelIO/ExcelExportService.cs

@@ -1,4 +1,3 @@
-using ClosedXML.Excel;
 using JdeScoping.Core.Interfaces;
 using JdeScoping.Core.Models.SearchResults;
 using JdeScoping.ExcelIO.Options;
@@ -7,10 +6,10 @@ using JdeScoping.ExcelIO.Generators;
 using JdeScoping.ExcelIO.Mapping;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
+using NPOI.SS.UserModel;
+using NPOI.XSSF.UserModel;
 
-// Use Core's SearchModel for the public interface
 using CoreSearchModel = JdeScoping.Core.Models.SearchResults.SearchModel;
-// Use ExcelIO's SearchModel which contains criteria filter properties for CriteriaSheetGenerator
 using ExcelSearchModel = JdeScoping.ExcelIO.Models.Reporting.SearchModel;
 
 namespace JdeScoping.ExcelIO;
@@ -53,7 +52,6 @@ public class ExcelExportService : IExcelExportService
     {
         ArgumentNullException.ThrowIfNull(search);
 
-        // Map Core SearchModel to ExcelIO SearchModel for internal processing
         var excelModel = MapToExcelModel(search);
         return await GenerateInternalAsync(excelModel, cancellationToken);
     }
@@ -94,26 +92,23 @@ public class ExcelExportService : IExcelExportService
 
         _logger.LogInformation("Starting Excel export generation");
 
-        // ClosedXML operations are synchronous, wrap in Task.Run for non-blocking
+        // NPOI operations are synchronous, wrap in Task.Run for non-blocking.
         return await Task.Run(() =>
         {
             cancellationToken.ThrowIfCancellationRequested();
 
-            using var workbook = new XLWorkbook();
+            using IWorkbook workbook = new XSSFWorkbook();
 
-            // 1. Always generate Search Criteria sheet (first tab)
             _logger.LogDebug("Generating Search Criteria sheet");
             _criteriaGenerator.Generate(workbook, search);
 
             cancellationToken.ThrowIfCancellationRequested();
 
-            // 2. Always generate Search Results sheet (second tab)
             _logger.LogDebug("Generating Search Results sheet");
             GenerateResultsSheet(workbook, search.Results);
 
             cancellationToken.ThrowIfCancellationRequested();
 
-            // 3. Conditionally generate MIS Info sheet
             if (search.ExtractMisData && search.MisResults != null && search.MisResults.Count > 0)
             {
                 _logger.LogDebug("Generating MIS Info sheet with {Count} records", search.MisResults.Count);
@@ -126,7 +121,6 @@ public class ExcelExportService : IExcelExportService
 
             cancellationToken.ThrowIfCancellationRequested();
 
-            // 4. Conditionally generate Investigation sheet
             if (search.ExtractMisData && search.MisNonMatchResults != null && search.MisNonMatchResults.Count > 0)
             {
                 _logger.LogDebug("Generating Investigation sheet with {Count} records", search.MisNonMatchResults.Count);
@@ -135,77 +129,62 @@ public class ExcelExportService : IExcelExportService
 
             cancellationToken.ThrowIfCancellationRequested();
 
-            // Save to byte array
             using var stream = new MemoryStream();
-            workbook.SaveAs(stream);
+            workbook.Write(stream, leaveOpen: true);
             var result = stream.ToArray();
 
             _logger.LogInformation("Excel export generation completed. Size: {Size} bytes", result.Length);
 
-            // Optional: write debug copy to disk
             if (_options.Value.DebugWriteToFile)
             {
                 WriteDebugCopy(search.Id, result);
             }
 
             return result;
-
         }, cancellationToken);
     }
 
-    private void GenerateResultsSheet(XLWorkbook workbook, List<SearchResult> results)
+    private void GenerateResultsSheet(IWorkbook workbook, List<SearchResult> results)
     {
         var map = _registry.GetMap<SearchResult>();
         var tabName = map.TabName ?? "Search Results";
 
-        var worksheet = workbook.Worksheets.Add(tabName);
+        var worksheet = workbook.CreateSheet(tabName);
         var table = _tableWriter.WriteTable(worksheet, 1, 1, results);
 
         if (table != null)
         {
-            // Apply protection with editable extension area
+            WorksheetProtector.UnlockExtensionArea(worksheet, table.LastRow, table.LastCol);
-            var lastRow = table.RangeAddress.LastAddress.RowNumber;
-            var lastCol = table.RangeAddress.LastAddress.ColumnNumber;
-
-            WorksheetProtector.UnlockExtensionArea(worksheet, lastRow, lastCol);
             WorksheetProtector.ApplyProtection(worksheet, _options.Value.DataSheetPassword);
         }
     }
 
-    private void GenerateMisInfoSheet(XLWorkbook workbook, List<MisSearchResult> misResults)
+    private void GenerateMisInfoSheet(IWorkbook workbook, List<MisSearchResult> misResults)
     {
         var map = _registry.GetMap<MisSearchResult>();
         var tabName = map.TabName ?? "MIS Info";
 
-        var worksheet = workbook.Worksheets.Add(tabName);
+        var worksheet = workbook.CreateSheet(tabName);
         var table = _tableWriter.WriteTable(worksheet, 1, 1, misResults);
 
         if (table != null)
         {
-            // Apply protection with editable extension area
+            WorksheetProtector.UnlockExtensionArea(worksheet, table.LastRow, table.LastCol);
-            var lastRow = table.RangeAddress.LastAddress.RowNumber;
-            var lastCol = table.RangeAddress.LastAddress.ColumnNumber;
-
-            WorksheetProtector.UnlockExtensionArea(worksheet, lastRow, lastCol);
             WorksheetProtector.ApplyProtection(worksheet, _options.Value.DataSheetPassword);
         }
     }
 
-    private void GenerateInvestigationSheet(XLWorkbook workbook, List<MisNonMatchSearchResult> misNonMatchResults)
+    private void GenerateInvestigationSheet(IWorkbook workbook, List<MisNonMatchSearchResult> misNonMatchResults)
     {
         var map = _registry.GetMap<MisNonMatchSearchResult>();
         var tabName = map.TabName ?? "Investigation";
 
-        var worksheet = workbook.Worksheets.Add(tabName);
+        var worksheet = workbook.CreateSheet(tabName);
         var table = _tableWriter.WriteTable(worksheet, 1, 1, misNonMatchResults);
 
         if (table != null)
         {
-            // Apply protection with editable extension area
+            WorksheetProtector.UnlockExtensionArea(worksheet, table.LastRow, table.LastCol);
-            var lastRow = table.RangeAddress.LastAddress.RowNumber;
-            var lastCol = table.RangeAddress.LastAddress.ColumnNumber;
-
-            WorksheetProtector.UnlockExtensionArea(worksheet, lastRow, lastCol);
             WorksheetProtector.ApplyProtection(worksheet, _options.Value.DataSheetPassword);
         }
     }

NEW/src/JdeScoping.ExcelIO/Formatting/HeaderFormatter.cs

@@ -1,4 +1,6 @@
-using ClosedXML.Excel;
+using NPOI.SS.UserModel;
+using NPOI.SS.Util;
+using NPOI.XSSF.UserModel;
 
 namespace JdeScoping.ExcelIO.Formatting;
 
@@ -7,43 +9,82 @@ namespace JdeScoping.ExcelIO.Formatting;
 /// </summary>
 public static class HeaderFormatter
 {
+    private static readonly byte[] GainsboroRgb = [0xDC, 0xDC, 0xDC];
+
     /// <summary>
     /// Applies header formatting to a cell.
     /// </summary>
     /// <param name="cell">The cell to format.</param>
     /// <param name="text">Optional text to set in the cell.</param>
-    public static void ApplyHeaderFormat(IXLCell cell, string? text = null)
+    public static void ApplyHeaderFormat(ICell cell, string? text = null)
     {
-        cell.Style.Alignment.Horizontal = XLAlignmentHorizontalValues.Center;
+        var workbook = cell.Sheet.Workbook;
-        cell.Style.Font.Bold = true;
+        var style = workbook.CreateCellStyle();
-        cell.Style.Fill.BackgroundColor = XLColor.Gainsboro;
+        style.Alignment = HorizontalAlignment.Center;
+        style.FillPattern = FillPattern.SolidForeground;
+
+        if (style is XSSFCellStyle xssfStyle)
+        {
+            var color = new XSSFColor();
+            color.SetRgb(GainsboroRgb);
+            xssfStyle.SetFillForegroundColor(color);
+        }
+        else
+        {
+            style.FillForegroundColor = IndexedColors.Grey25Percent.Index;
+        }
+
+        var font = workbook.CreateFont();
+        font.IsBold = true;
+        style.SetFont(font);
+
+        cell.CellStyle = style;
 
         if (!string.IsNullOrEmpty(text))
         {
-            cell.Value = text;
+            cell.SetCellValue(text);
         }
     }
 
     /// <summary>
     /// Applies header formatting to a range.
     /// </summary>
-    /// <param name="range">The range to format.</param>
+    /// <param name="sheet">The worksheet containing the range.</param>
+    /// <param name="firstRow">First row number (1-based).</param>
+    /// <param name="firstCol">First column number (1-based).</param>
+    /// <param name="lastRow">Last row number (1-based).</param>
+    /// <param name="lastCol">Last column number (1-based).</param>
     /// <param name="text">Optional text to set in the first cell.</param>
     /// <param name="merge">Whether to merge the range.</param>
-    public static void ApplyHeaderFormat(IXLRange range, string? text = null, bool merge = false)
+    public static void ApplyHeaderFormat(
+        ISheet sheet,
+        int firstRow,
+        int firstCol,
+        int lastRow,
+        int lastCol,
+        string? text = null,
+        bool merge = false)
     {
-        range.Style.Alignment.Horizontal = XLAlignmentHorizontalValues.Center;
+        for (var row = firstRow; row <= lastRow; row++)
-        range.Style.Font.Bold = true;
+        {
-        range.Style.Fill.BackgroundColor = XLColor.Gainsboro;
+            var npoiRow = sheet.GetRow(row - 1) ?? sheet.CreateRow(row - 1);
+            for (var col = firstCol; col <= lastCol; col++)
+            {
+                var cell = npoiRow.GetCell(col - 1) ?? npoiRow.CreateCell(col - 1);
+                ApplyHeaderFormat(cell);
+            }
+        }
 
         if (merge)
         {
-            range.Merge();
+            sheet.AddMergedRegion(new CellRangeAddress(firstRow - 1, lastRow - 1, firstCol - 1, lastCol - 1));
         }
 
         if (!string.IsNullOrEmpty(text))
         {
-            range.FirstCell().Value = text;
+            var row = sheet.GetRow(firstRow - 1) ?? sheet.CreateRow(firstRow - 1);
+            var cell = row.GetCell(firstCol - 1) ?? row.CreateCell(firstCol - 1);
+            cell.SetCellValue(text);
         }
     }
 }

NEW/src/JdeScoping.ExcelIO/Formatting/WorksheetProtector.cs

@@ -1,4 +1,5 @@
-using ClosedXML.Excel;
+using NPOI.SS.UserModel;
+using NPOI.XSSF.UserModel;
 
 namespace JdeScoping.ExcelIO.Formatting;
 
@@ -12,21 +13,27 @@ public static class WorksheetProtector
     /// </summary>
     /// <param name="worksheet">The worksheet to protect.</param>
     /// <param name="password">The protection password.</param>
-    public static void ApplyProtection(IXLWorksheet worksheet, string password)
+    public static void ApplyProtection(ISheet worksheet, string password)
     {
-        var protection = worksheet.Protect(password);
+        worksheet.ProtectSheet(password);
 
-        // Allow these operations
+        if (worksheet is not XSSFSheet xssfSheet)
-        protection.AllowElement(XLSheetProtectionElements.DeleteColumns);
+        {
-        protection.AllowElement(XLSheetProtectionElements.DeleteRows);
+            return;
-        protection.AllowElement(XLSheetProtectionElements.AutoFilter);
+        }
-        protection.AllowElement(XLSheetProtectionElements.FormatCells);
+
-        protection.AllowElement(XLSheetProtectionElements.FormatColumns);
+        // Set to false to allow these operations while sheet protection is enabled.
-        protection.AllowElement(XLSheetProtectionElements.FormatRows);
+        xssfSheet.LockDeleteColumns(false);
-        protection.AllowElement(XLSheetProtectionElements.SelectLockedCells);
+        xssfSheet.LockDeleteRows(false);
-        protection.AllowElement(XLSheetProtectionElements.SelectUnlockedCells);
+        xssfSheet.LockAutoFilter(false);
-        protection.AllowElement(XLSheetProtectionElements.EditObjects);
+        xssfSheet.LockFormatCells(false);
-        protection.AllowElement(XLSheetProtectionElements.Sort);
+        xssfSheet.LockFormatColumns(false);
+        xssfSheet.LockFormatRows(false);
+        xssfSheet.LockSelectLockedCells(false);
+        xssfSheet.LockSelectUnlockedCells(false);
+        xssfSheet.LockObjects(false);
+        xssfSheet.LockSort(false);
+        xssfSheet.EnableLocking();
     }
 
     /// <summary>
@@ -34,9 +41,9 @@ public static class WorksheetProtector
     /// </summary>
     /// <param name="worksheet">The worksheet to protect.</param>
     /// <param name="password">The protection password.</param>
-    public static void ApplyCriteriaProtection(IXLWorksheet worksheet, string password)
+    public static void ApplyCriteriaProtection(ISheet worksheet, string password)
     {
-        worksheet.Protect(password);
+        worksheet.ProtectSheet(password);
     }
 
     /// <summary>
@@ -48,15 +55,27 @@ public static class WorksheetProtector
     /// <param name="extensionRows">Number of rows to unlock beyond data (default 1000).</param>
     /// <param name="extensionCols">Number of columns to unlock beyond data (default 1000).</param>
     public static void UnlockExtensionArea(
-        IXLWorksheet worksheet,
+        ISheet worksheet,
         int lastDataRow,
         int lastDataCol,
         int extensionRows = 1000,
         int extensionCols = 1000)
     {
-        var extensionRange = worksheet.Range(
+        var workbook = worksheet.Workbook;
-            1, lastDataCol + 1,
+        var unlockedStyle = workbook.CreateCellStyle();
-            lastDataRow + extensionRows, lastDataCol + extensionCols);
+        unlockedStyle.IsLocked = false;
-        extensionRange.Style.Protection.Locked = false;
+
+        // Apply unlocked default style to extension columns (NPOI uses 0-based columns).
+        var startCol = lastDataCol;
+        var endCol = lastDataCol + extensionCols - 1;
+        for (var col = startCol; col <= endCol; col++)
+        {
+            worksheet.SetDefaultColumnStyle(col, unlockedStyle);
+        }
+
+        // Touch at least one extension cell to ensure style materializes in workbook XML.
+        var row = worksheet.GetRow(0) ?? worksheet.CreateRow(0);
+        var cell = row.GetCell(startCol) ?? row.CreateCell(startCol);
+        cell.CellStyle = unlockedStyle;
     }
 }

NEW/src/JdeScoping.ExcelIO/Generators/CriteriaSheetGenerator.cs

@@ -1,8 +1,8 @@
-using ClosedXML.Excel;
 using JdeScoping.ExcelIO.Options;
 using JdeScoping.ExcelIO.Formatting;
 using JdeScoping.ExcelIO.Models.Reporting;
 using Microsoft.Extensions.Options;
+using NPOI.SS.UserModel;
 
 namespace JdeScoping.ExcelIO.Generators;
 
@@ -11,6 +11,8 @@ namespace JdeScoping.ExcelIO.Generators;
 /// </summary>
 public class CriteriaSheetGenerator
 {
+    private const int ExcelMaxColumnWidth = 255 * 256;
+
     private readonly IOptions<ExcelExportOptions> _options;
     private readonly FluentTableWriter _tableWriter;
 
@@ -32,142 +34,83 @@ public class CriteriaSheetGenerator
     /// </summary>
     /// <param name="workbook">The workbook to add the sheet to.</param>
     /// <param name="search">The search model with criteria.</param>
-    public void Generate(XLWorkbook workbook, SearchModel search)
+    public void Generate(IWorkbook workbook, SearchModel search)
     {
-        var worksheet = workbook.Worksheets.Add("Search Criteria");
+        var worksheet = workbook.CreateSheet("Search Criteria");
         var row = 1;
 
-        // Write name and user
+        HeaderFormatter.ApplyHeaderFormat(GetOrCreateCell(worksheet, row, 1), "Search Name");
-        HeaderFormatter.ApplyHeaderFormat(worksheet.Cell(row, 1), "Search Name");
+        GetOrCreateCell(worksheet, row, 2).SetCellValue(search.Name);
-        worksheet.Cell(row, 2).Value = search.Name;
 
-        HeaderFormatter.ApplyHeaderFormat(worksheet.Cell(++row, 1), "User Name");
+        HeaderFormatter.ApplyHeaderFormat(GetOrCreateCell(worksheet, ++row, 1), "User Name");
-        worksheet.Cell(row, 2).Value = search.UserName;
+        GetOrCreateCell(worksheet, row, 2).SetCellValue(search.UserName);
 
-        // Skip row
         row++;
 
-        // Write timestamps
+        HeaderFormatter.ApplyHeaderFormat(GetOrCreateCell(worksheet, ++row, 1), "Submit timestamp");
-        HeaderFormatter.ApplyHeaderFormat(worksheet.Cell(++row, 1), "Submit timestamp");
+        GetOrCreateCell(worksheet, row, 2).SetCellValue(FormatTimestamp(search.SubmitDt));
-        worksheet.Cell(row, 2).Value = FormatTimestamp(search.SubmitDt);
 
-        HeaderFormatter.ApplyHeaderFormat(worksheet.Cell(++row, 1), "Start timestamp");
+        HeaderFormatter.ApplyHeaderFormat(GetOrCreateCell(worksheet, ++row, 1), "Start timestamp");
-        worksheet.Cell(row, 2).Value = FormatTimestamp(search.StartDt);
+        GetOrCreateCell(worksheet, row, 2).SetCellValue(FormatTimestamp(search.StartDt));
 
-        HeaderFormatter.ApplyHeaderFormat(worksheet.Cell(++row, 1), "Completed timestamp");
+        HeaderFormatter.ApplyHeaderFormat(GetOrCreateCell(worksheet, ++row, 1), "Completed timestamp");
-        worksheet.Cell(row, 2).Value = FormatTimestamp(search.EndDt);
+        GetOrCreateCell(worksheet, row, 2).SetCellValue(FormatTimestamp(search.EndDt));
 
-        // Skip row
         row++;
 
-        // Write timespan filter table
         var timespanData = new List<TimespanFilter>
         {
             new() { MinimumDt = search.MinimumDt, MaximumDt = search.MaximumDt }
         };
+
         var timespanTable = _tableWriter.WriteTable(worksheet, ++row, 1, timespanData);
-        if (timespanTable != null)
+        row = GetNextTableStartRow(timespanTable, row);
-        {
-            row = timespanTable.RangeAddress.LastAddress.RowNumber + 3;
-        }
-        else
-        {
-            row += 4;
-        }
 
-        // Write work order filter table
         var workOrderTable = _tableWriter.WriteTable(worksheet, row, 1, search.WorkOrderFilter);
-        if (workOrderTable != null)
+        row = GetNextTableStartRow(workOrderTable, row);
-        {
-            row = workOrderTable.RangeAddress.LastAddress.RowNumber + 3;
-        }
-        else
-        {
-            row += 4;
-        }
 
-        // Write item number filter table
         var itemNumberTable = _tableWriter.WriteTable(worksheet, row, 1, search.ItemNumberFilter);
-        if (itemNumberTable != null)
+        row = GetNextTableStartRow(itemNumberTable, row);
-        {
-            row = itemNumberTable.RangeAddress.LastAddress.RowNumber + 3;
-        }
-        else
-        {
-            row += 4;
-        }
 
-        // Write profit center filter table
         var profitCenterTable = _tableWriter.WriteTable(worksheet, row, 1, search.ProfitCenterFilter);
-        if (profitCenterTable != null)
+        row = GetNextTableStartRow(profitCenterTable, row);
-        {
-            row = profitCenterTable.RangeAddress.LastAddress.RowNumber + 3;
-        }
-        else
-        {
-            row += 4;
-        }
 
-        // Write work center filter table
         var workCenterTable = _tableWriter.WriteTable(worksheet, row, 1, search.WorkCenterFilter);
-        if (workCenterTable != null)
+        row = GetNextTableStartRow(workCenterTable, row);
-        {
-            row = workCenterTable.RangeAddress.LastAddress.RowNumber + 3;
-        }
-        else
-        {
-            row += 4;
-        }
 
-        // Write component lot filter table
         var componentLotTable = _tableWriter.WriteTable(worksheet, row, 1, search.ComponentLotFilter);
-        if (componentLotTable != null)
+        row = GetNextTableStartRow(componentLotTable, row);
-        {
-            row = componentLotTable.RangeAddress.LastAddress.RowNumber + 3;
-        }
-        else
-        {
-            row += 4;
-        }
 
-        // Write operator filter table
         var operatorTable = _tableWriter.WriteTable(worksheet, row, 1, search.OperatorFilter);
-        if (operatorTable != null)
+        row = GetNextTableStartRow(operatorTable, row);
-        {
-            row = operatorTable.RangeAddress.LastAddress.RowNumber + 3;
-        }
-        else
-        {
-            row += 4;
-        }
 
-        // Write item/operation/MIS filter table
         var itemOpMisTable = _tableWriter.WriteTable(worksheet, row, 1, search.ItemOperationMisFilter);
-        if (itemOpMisTable != null)
+        row = GetNextTableStartRow(itemOpMisTable, row);
-        {
-            row = itemOpMisTable.RangeAddress.LastAddress.RowNumber + 3;
-        }
-        else
-        {
-            row += 4;
-        }
 
-        // Write extract MIS data option
+        HeaderFormatter.ApplyHeaderFormat(worksheet, row, 1, row, 2, "Extract MIS data?", merge: true);
-        var headerRange = worksheet.Range(row, 1, row, 2);
+        GetOrCreateCell(worksheet, ++row, 1).SetCellValue(search.ExtractMisData ? "YES" : "NO");
-        HeaderFormatter.ApplyHeaderFormat(headerRange, "Extract MIS data?", merge: true);
-        worksheet.Cell(++row, 1).Value = search.ExtractMisData ? "YES" : "NO";
 
-        // Auto-fit columns with 15% padding
         for (var column = 1; column <= 4; column++)
         {
-            worksheet.Column(column).AdjustToContents();
+            worksheet.AutoSizeColumn(column - 1);
-            worksheet.Column(column).Width *= ExcelFormats.CriteriaPaddingFactor;
+            var padded = (int)(worksheet.GetColumnWidth(column - 1) * ExcelFormats.CriteriaPaddingFactor);
+            worksheet.SetColumnWidth(column - 1, padded > ExcelMaxColumnWidth ? ExcelMaxColumnWidth : padded);
         }
 
-        // Apply protection
         WorksheetProtector.ApplyCriteriaProtection(worksheet, _options.Value.CriteriaSheetPassword);
     }
 
+    private static int GetNextTableStartRow(TableWriteResult? result, int fallbackRow)
+    {
+        return result != null ? result.LastRow + 3 : fallbackRow + 4;
+    }
+
+    private static ICell GetOrCreateCell(ISheet sheet, int rowNumber1Based, int colNumber1Based)
+    {
+        var row = sheet.GetRow(rowNumber1Based - 1) ?? sheet.CreateRow(rowNumber1Based - 1);
+        return row.GetCell(colNumber1Based - 1) ?? row.CreateCell(colNumber1Based - 1);
+    }
+
     private string FormatTimestamp(DateTime? dateTime)
     {
         if (!dateTime.HasValue)
@@ -179,12 +122,10 @@ public class CriteriaSheetGenerator
         var targetTimezone = TimeZoneInfo.FindSystemTimeZoneById(options.TimezoneId);
         var dt = dateTime.Value;
 
-        // Convert to target timezone based on the source DateTime's Kind
         var localTime = dt.Kind switch
         {
             DateTimeKind.Utc => TimeZoneInfo.ConvertTimeFromUtc(dt, targetTimezone),
             DateTimeKind.Local => TimeZoneInfo.ConvertTime(dt, TimeZoneInfo.Local, targetTimezone),
-            // Unspecified - database values are stored in target timezone, no conversion needed
             _ => dt
         };
 

NEW/src/JdeScoping.ExcelIO/Generators/DataEntryTemplateGenerator.cs

@@ -1,6 +1,7 @@
-using ClosedXML.Excel;
 using JdeScoping.ExcelIO.Formatting;
 using JdeScoping.ExcelIO.Utilities;
+using NPOI.SS.UserModel;
+using NPOI.XSSF.UserModel;
 
 namespace JdeScoping.ExcelIO.Generators;
 
@@ -18,29 +19,28 @@ public class DataEntryTemplateGenerator
     /// <returns>The Excel file as a byte array.</returns>
     public byte[] Generate<T>(IEnumerable<T>? sourceData, string headerText)
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
-        var worksheet = workbook.Worksheets.Add("Data Entry Template");
+        var worksheet = workbook.CreateSheet("Data Entry Template");
+        var style = workbook.CreateCellStyle();
+        style.DataFormat = workbook.CreateDataFormat().GetFormat(ExcelFormats.StdFormat);
+        worksheet.SetDefaultColumnStyle(0, style);
 
-        // Header
+        var headerCell = GetOrCreateCell(worksheet, 1, 1);
-        var headerCell = worksheet.Cell(1, 1);
         HeaderFormatter.ApplyHeaderFormat(headerCell, headerText);
-        worksheet.Column(1).Width = 45;
+        worksheet.SetColumnWidth(0, 45 * 256);
 
-        // Data (if provided)
         if (sourceData != null)
         {
             var row = 2;
             foreach (var item in sourceData)
             {
-                worksheet.Cell(row++, 1).Value = CellValueConverter.ConvertToXlValue(item);
+                var cell = GetOrCreateCell(worksheet, row++, 1);
+                CellValueConverter.SetCellValue(cell, item);
             }
         }
 
-        // All cells as text
-        worksheet.Column(1).Style.NumberFormat.Format = ExcelFormats.StdFormat;
-
         using var stream = new MemoryStream();
-        workbook.SaveAs(stream);
+        workbook.Write(stream, leaveOpen: true);
         return stream.ToArray();
     }
 
@@ -52,31 +52,41 @@ public class DataEntryTemplateGenerator
     /// <returns>The Excel file as a byte array.</returns>
     public byte[] Generate(object[][]? sourceData, string[] headers)
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
-        var worksheet = workbook.Worksheets.Add("Data Entry Template");
+        var worksheet = workbook.CreateSheet("Data Entry Template");
+
+        var dataFormat = workbook.CreateDataFormat();
 
-        // Headers
         for (var col = 0; col < headers.Length; col++)
         {
-            HeaderFormatter.ApplyHeaderFormat(worksheet.Cell(1, col + 1), headers[col]);
+            var style = workbook.CreateCellStyle();
-            worksheet.Column(col + 1).Width = 65;
+            style.DataFormat = dataFormat.GetFormat(ExcelFormats.StdFormat);
-            worksheet.Column(col + 1).Style.NumberFormat.Format = ExcelFormats.StdFormat;
+            worksheet.SetDefaultColumnStyle(col, style);
+
+            HeaderFormatter.ApplyHeaderFormat(GetOrCreateCell(worksheet, 1, col + 1), headers[col]);
+            worksheet.SetColumnWidth(col, 65 * 256);
         }
 
-        // Data
         if (sourceData != null)
         {
             for (var row = 0; row < sourceData.Length; row++)
             {
                 for (var col = 0; col < sourceData[row].Length; col++)
                 {
-                    worksheet.Cell(row + 2, col + 1).Value = CellValueConverter.ConvertToXlValue(sourceData[row][col]);
+                    var cell = GetOrCreateCell(worksheet, row + 2, col + 1);
+                    CellValueConverter.SetCellValue(cell, sourceData[row][col]);
                 }
             }
         }
 
         using var stream = new MemoryStream();
-        workbook.SaveAs(stream);
+        workbook.Write(stream, leaveOpen: true);
         return stream.ToArray();
     }
+
+    private static ICell GetOrCreateCell(ISheet sheet, int rowNumber1Based, int colNumber1Based)
+    {
+        var row = sheet.GetRow(rowNumber1Based - 1) ?? sheet.CreateRow(rowNumber1Based - 1);
+        return row.GetCell(colNumber1Based - 1) ?? row.CreateCell(colNumber1Based - 1);
+    }
 }

NEW/src/JdeScoping.ExcelIO/Generators/FluentTableWriter.cs

@@ -1,15 +1,32 @@
-using ClosedXML.Excel;
 using JdeScoping.ExcelIO.Formatting;
 using JdeScoping.ExcelIO.Mapping;
 using JdeScoping.ExcelIO.Utilities;
+using NPOI.SS;
+using NPOI.SS.UserModel;
+using NPOI.SS.Util;
+using NPOI.XSSF.UserModel;
 
 namespace JdeScoping.ExcelIO.Generators;
 
+/// <summary>
+/// Result metadata for a written table region.
+/// </summary>
+public sealed class TableWriteResult
+{
+    public int FirstRow { get; init; }
+    public int LastRow { get; init; }
+    public int FirstCol { get; init; }
+    public int LastCol { get; init; }
+    public XSSFTable? Table { get; init; }
+}
+
 /// <summary>
 /// Writes Excel tables using fluent mapping configuration.
 /// </summary>
 public sealed class FluentTableWriter
 {
+    private const int ExcelMaxColumnWidth = 255 * 256;
+
     private readonly ExcelMapRegistry _registry;
 
     /// <summary>
@@ -32,9 +49,9 @@ public sealed class FluentTableWriter
     /// <param name="tableNameOverride">Optional override for the table name; uses map name if null.</param>
     /// <param name="showHeader">Whether to show a merged header above the table.</param>
     /// <param name="headerText">Optional text to display in the merged header.</param>
-    /// <returns>The created Excel table, or null if no columns are configured.</returns>
+    /// <returns>The created table metadata, or null if no columns are configured.</returns>
-    public IXLTable? WriteTable<T>(
+    public TableWriteResult? WriteTable<T>(
-        IXLWorksheet worksheet,
+        ISheet worksheet,
         int startRow,
         int startCol,
         IEnumerable<T> data,
@@ -48,95 +65,184 @@ public sealed class FluentTableWriter
         var header = headerText ?? map.TabName ?? string.Empty;
 
         if (columns.Count == 0)
+        {
             return null;
+        }
 
         var dataList = data.ToList();
         var baseRow = startRow;
 
-        // Write merged header if requested
         if (showHeader && !string.IsNullOrEmpty(header))
         {
-            var mergedHeaderRange = worksheet.Range(baseRow, startCol, baseRow, startCol + columns.Count - 1);
+            HeaderFormatter.ApplyHeaderFormat(
-            HeaderFormatter.ApplyHeaderFormat(mergedHeaderRange, header, merge: true);
+                worksheet,
+                baseRow,
+                startCol,
+                baseRow,
+                startCol + columns.Count - 1,
+                header,
+                merge: true);
             baseRow++;
         }
 
-        // Write column headers
+        var dataFormat = worksheet.Workbook.CreateDataFormat();
-        var col = startCol;
+        var columnStyles = new ICellStyle[columns.Count];
-        foreach (var column in columns)
-        {
-            var cell = worksheet.Cell(baseRow, col);
-            HeaderFormatter.ApplyHeaderFormat(cell, column.HeaderText);
 
-            // Pre-set column formatting
+        // Write column headers and set column defaults.
-            worksheet.Column(col).Style.Alignment.WrapText = column.WrapText;
+        for (var i = 0; i < columns.Count; i++)
-            if (!column.AutoWidth)
+        {
+            var col = startCol + i;
+            var columnStyle = worksheet.Workbook.CreateCellStyle();
+            if (!string.IsNullOrEmpty(columns[i].Format))
             {
-                worksheet.Column(col).Width = column.Width;
+                columnStyle.DataFormat = dataFormat.GetFormat(columns[i].Format);
             }
 
-            col++;
+            columnStyle.WrapText = columns[i].WrapText;
+            columnStyles[i] = columnStyle;
+
+            var headerRow = GetOrCreateRow(worksheet, baseRow);
+            var headerCell = GetOrCreateCell(headerRow, col);
+            HeaderFormatter.ApplyHeaderFormat(headerCell, columns[i].HeaderText);
         }
 
-        // Write data rows
+        // Write data rows.
         var row = baseRow + 1;
         foreach (var item in dataList)
         {
-            col = startCol;
+            var npoiRow = GetOrCreateRow(worksheet, row);
-            foreach (var column in columns)
+
+            for (var i = 0; i < columns.Count; i++)
             {
+                var col = startCol + i;
+                var column = columns[i];
                 var value = column.ValueGetter(item!);
-                worksheet.Cell(row, col).Value = CellValueConverter.ConvertToXlValue(value);
+                var cell = GetOrCreateCell(npoiRow, col);
-                col++;
+                CellValueConverter.SetCellValue(cell, value);
+                cell.CellStyle = columnStyles[i];
             }
+
             row++;
         }
 
-        // Handle empty data case
         if (dataList.Count == 0)
         {
             row = baseRow + 1;
         }
 
-        // Create table range
+        var firstRow = baseRow;
-        var dataRange = worksheet.Range(
+        var lastRow = baseRow + dataList.Count;
-            baseRow, startCol,
+        var firstCol = startCol;
-            baseRow + dataList.Count, startCol + columns.Count - 1);
+        var lastCol = startCol + columns.Count - 1;
 
-        // Create table
+        var table = CreateTableIfSupported(worksheet, tableName, firstRow, lastRow, firstCol, lastCol);
-        var table = dataRange.CreateTable(tableName);
-        table.Theme = XLTableTheme.TableStyleLight18;
-        table.ShowTotalsRow = false;
 
-        // Apply column formatting
+        // Preserve filter behavior.
-        col = startCol;
+        worksheet.SetAutoFilter(new CellRangeAddress(firstRow - 1, lastRow - 1, firstCol - 1, lastCol - 1));
-        var tableStartRow = table.RangeAddress.FirstAddress.RowNumber;
-        var tableEndRow = table.RangeAddress.LastAddress.RowNumber;
 
-        foreach (var column in columns)
+        // Apply column widths.
+        for (var i = 0; i < columns.Count; i++)
         {
-            // Apply number format
+            var column = columns[i];
-            worksheet.Range(tableStartRow, col, tableEndRow, col)
+            var colIndex = startCol + i - 1;
-                .Style.NumberFormat.Format = column.Format;
 
-            // Apply column width
             if (column.WrapText && !column.AutoWidth)
             {
-                worksheet.Column(col).Width = column.Width;
+                worksheet.SetColumnWidth(colIndex, ToNpoiWidth(column.Width));
             }
             else if (column.AutoWidth)
             {
-                worksheet.Column(col).AdjustToContents();
+                worksheet.AutoSizeColumn(colIndex);
-                worksheet.Column(col).Width *= ExcelFormats.DataPaddingFactor;
+                var width = worksheet.GetColumnWidth(colIndex);
+                var padded = (int)(width * ExcelFormats.DataPaddingFactor);
+                worksheet.SetColumnWidth(colIndex, ClampWidth(padded));
             }
             else
             {
-                worksheet.Column(col).Width = column.Width;
+                worksheet.SetColumnWidth(colIndex, ToNpoiWidth(column.Width));
             }
-
-            col++;
         }
 
+        return new TableWriteResult
+        {
+            FirstRow = firstRow,
+            LastRow = lastRow,
+            FirstCol = firstCol,
+            LastCol = lastCol,
+            Table = table
+        };
+    }
+
+    private static IRow GetOrCreateRow(ISheet sheet, int rowNumber1Based)
+    {
+        return sheet.GetRow(rowNumber1Based - 1) ?? sheet.CreateRow(rowNumber1Based - 1);
+    }
+
+    private static ICell GetOrCreateCell(IRow row, int colNumber1Based)
+    {
+        return row.GetCell(colNumber1Based - 1) ?? row.CreateCell(colNumber1Based - 1);
+    }
+
+    private static XSSFTable? CreateTableIfSupported(
+        ISheet worksheet,
+        string tableName,
+        int firstRow,
+        int lastRow,
+        int firstCol,
+        int lastCol)
+    {
+        if (worksheet is not XSSFSheet xssfSheet)
+        {
+            return null;
+        }
+
+        var safeName = ToSafeTableName(tableName);
+        var area = new AreaReference(
+            new CellReference(firstRow - 1, firstCol - 1),
+            new CellReference(lastRow - 1, lastCol - 1),
+            SpreadsheetVersion.EXCEL2007);
+
+        var table = xssfSheet.CreateTable();
+        table.Name = safeName;
+        table.DisplayName = safeName;
+        table.StyleName = "TableStyleLight18";
+        table.CellReferences = area;
+        table.UpdateReferences();
+        table.UpdateHeaders();
+
         return table;
     }
+
+    private static string ToSafeTableName(string tableName)
+    {
+        var chars = tableName.Where(ch => char.IsLetterOrDigit(ch) || ch == '_').ToArray();
+        var value = new string(chars);
+
+        if (string.IsNullOrWhiteSpace(value))
+        {
+            return "Table1";
+        }
+
+        if (!char.IsLetter(value[0]) && value[0] != '_')
+        {
+            value = $"_{value}";
+        }
+
+        return value;
+    }
+
+    private static int ToNpoiWidth(double widthInChars)
+    {
+        return ClampWidth((int)(widthInChars * 256));
+    }
+
+    private static int ClampWidth(int width)
+    {
+        if (width < 0)
+        {
+            return 0;
+        }
+
+        return width > ExcelMaxColumnWidth ? ExcelMaxColumnWidth : width;
+    }
 }

NEW/src/JdeScoping.ExcelIO/JdeScoping.ExcelIO.csproj

@@ -7,7 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="ClosedXML" Version="0.105.0" />
+    <PackageReference Include="NPOI" Version="2.7.5" />
     <PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" Version="10.0.1" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="10.0.1" />
     <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="10.0.1" />

NEW/src/JdeScoping.ExcelIO/Parsing/ExcelParserService.cs

@@ -1,7 +1,7 @@
-using ClosedXML.Excel;
 using JdeScoping.Core.Interfaces;
 using JdeScoping.Core.ViewModels;
 using Microsoft.Extensions.Logging;
+using NPOI.SS.UserModel;
 
 namespace JdeScoping.ExcelIO.Parsing;
 
@@ -24,15 +24,16 @@ public class ExcelParserService : IExcelParserService
     /// <inheritdoc />
     public List<long> ParseWorkOrders(Stream fileStream)
     {
-        using var workbook = new XLWorkbook(fileStream);
+        using var workbook = WorkbookFactory.Create(ResetStream(fileStream));
-        var worksheet = workbook.Worksheet(1);
+        var worksheet = workbook.GetSheetAt(0);
+        var formatter = new DataFormatter();
 
         var workOrderNumbers = new List<long>();
-        var lastRow = worksheet.LastRowUsed()?.RowNumber() ?? 1;
+        var lastRow = worksheet.LastRowNum + 1;
 
         for (var row = 2; row <= lastRow; row++)
         {
-            var cellValue = worksheet.Cell(row, 1).GetString()?.Trim();
+            var cellValue = GetCellText(worksheet, row, 1, formatter);
             if (long.TryParse(cellValue, out var woNumber))
             {
                 workOrderNumbers.Add(woNumber);
@@ -45,15 +46,16 @@ public class ExcelParserService : IExcelParserService
     /// <inheritdoc />
     public List<string> ParseItems(Stream fileStream)
     {
-        using var workbook = new XLWorkbook(fileStream);
+        using var workbook = WorkbookFactory.Create(ResetStream(fileStream));
-        var worksheet = workbook.Worksheet(1);
+        var worksheet = workbook.GetSheetAt(0);
+        var formatter = new DataFormatter();
 
         var itemNumbers = new List<string>();
-        var lastRow = worksheet.LastRowUsed()?.RowNumber() ?? 1;
+        var lastRow = worksheet.LastRowNum + 1;
 
         for (var row = 2; row <= lastRow; row++)
         {
-            var cellValue = worksheet.Cell(row, 1).GetString()?.Trim();
+            var cellValue = GetCellText(worksheet, row, 1, formatter);
             if (!string.IsNullOrEmpty(cellValue))
             {
                 itemNumbers.Add(cellValue);
@@ -66,16 +68,17 @@ public class ExcelParserService : IExcelParserService
     /// <inheritdoc />
     public List<LotViewModel> ParseComponentLots(Stream fileStream)
     {
-        using var workbook = new XLWorkbook(fileStream);
+        using var workbook = WorkbookFactory.Create(ResetStream(fileStream));
-        var worksheet = workbook.Worksheet(1);
+        var worksheet = workbook.GetSheetAt(0);
+        var formatter = new DataFormatter();
 
         var lotViewModels = new List<LotViewModel>();
-        var lastRow = worksheet.LastRowUsed()?.RowNumber() ?? 1;
+        var lastRow = worksheet.LastRowNum + 1;
 
         for (var row = 2; row <= lastRow; row++)
         {
-            var lotNumber = worksheet.Cell(row, 1).GetString()?.Trim() ?? string.Empty;
+            var lotNumber = GetCellText(worksheet, row, 1, formatter);
-            var itemNumber = worksheet.Cell(row, 2).GetString()?.Trim() ?? string.Empty;
+            var itemNumber = GetCellText(worksheet, row, 2, formatter);
 
             if (!string.IsNullOrEmpty(lotNumber))
             {
@@ -93,22 +96,22 @@ public class ExcelParserService : IExcelParserService
     /// <inheritdoc />
     public List<PartOperationViewModel> ParsePartOperations(Stream fileStream)
     {
-        using var workbook = new XLWorkbook(fileStream);
+        using var workbook = WorkbookFactory.Create(ResetStream(fileStream));
-        var worksheet = workbook.Worksheet(1);
+        var worksheet = workbook.GetSheetAt(0);
+        var formatter = new DataFormatter();
 
         var partOperations = new List<PartOperationViewModel>();
-        var lastRow = worksheet.LastRowUsed()?.RowNumber() ?? 1;
+        var lastRow = worksheet.LastRowNum + 1;
 
         for (var row = 2; row <= lastRow; row++)
         {
             try
             {
-                var itemNumber = worksheet.Cell(row, 1).GetString()?.Trim() ?? string.Empty;
+                var itemNumber = GetCellText(worksheet, row, 1, formatter);
-                var operationNumber = worksheet.Cell(row, 2).GetString()?.Trim() ?? string.Empty;
+                var operationNumber = GetCellText(worksheet, row, 2, formatter);
-                var misNumber = worksheet.Cell(row, 3).GetString()?.Trim() ?? string.Empty;
+                var misNumber = GetCellText(worksheet, row, 3, formatter);
-                var misRevision = worksheet.Cell(row, 4).GetString()?.Trim() ?? string.Empty;
+                var misRevision = GetCellText(worksheet, row, 4, formatter);
 
-                // Remove decimal places from operation number
                 if (!string.IsNullOrEmpty(operationNumber) && operationNumber.Contains('.'))
                 {
                     operationNumber = operationNumber[..operationNumber.IndexOf('.')];
@@ -133,4 +136,31 @@ public class ExcelParserService : IExcelParserService
 
         return partOperations;
     }
+
+    private static string GetCellText(ISheet sheet, int rowNumber1Based, int colNumber1Based, DataFormatter formatter)
+    {
+        var row = sheet.GetRow(rowNumber1Based - 1);
+        if (row == null)
+        {
+            return string.Empty;
+        }
+
+        var cell = row.GetCell(colNumber1Based - 1);
+        if (cell == null)
+        {
+            return string.Empty;
+        }
+
+        return formatter.FormatCellValue(cell).Trim();
+    }
+
+    private static Stream ResetStream(Stream stream)
+    {
+        if (stream.CanSeek)
+        {
+            stream.Position = 0;
+        }
+
+        return stream;
+    }
 }

NEW/src/JdeScoping.ExcelIO/Templates/ExcelTemplateService.cs

@@ -1,5 +1,6 @@
-using ClosedXML.Excel;
 using JdeScoping.Core.Interfaces;
+using NPOI.SS.UserModel;
+using NPOI.XSSF.UserModel;
 
 namespace JdeScoping.ExcelIO.Templates;
 
@@ -11,43 +12,49 @@ public class ExcelTemplateService : IExcelTemplateService
     /// <inheritdoc />
     public byte[] GenerateSingleColumn<T>(IEnumerable<T> data, string headerText)
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
-        var worksheet = workbook.Worksheets.Add("Template");
+        var worksheet = workbook.CreateSheet("Template");
 
-        // Write header
+        var headerCell = GetOrCreateCell(worksheet, 1, 1);
-        worksheet.Cell(1, 1).Value = headerText;
+        headerCell.SetCellValue(headerText);
-        worksheet.Cell(1, 1).Style.Font.Bold = true;
+
+        var boldStyle = workbook.CreateCellStyle();
+        var boldFont = workbook.CreateFont();
+        boldFont.IsBold = true;
+        boldStyle.SetFont(boldFont);
+        headerCell.CellStyle = boldStyle;
 
-        // Write data
         var row = 2;
         foreach (var item in data)
         {
-            worksheet.Cell(row, 1).Value = item?.ToString() ?? string.Empty;
+            GetOrCreateCell(worksheet, row++, 1).SetCellValue(item?.ToString() ?? string.Empty);
-            row++;
         }
 
-        // Auto-fit column width
+        worksheet.AutoSizeColumn(0);
-        worksheet.Column(1).AdjustToContents();
 
         using var stream = new MemoryStream();
-        workbook.SaveAs(stream);
+        workbook.Write(stream, leaveOpen: true);
         return stream.ToArray();
     }
 
     /// <inheritdoc />
     public byte[] GenerateMultiColumn(object?[][] data, string[] headers)
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
-        var worksheet = workbook.Worksheets.Add("Template");
+        var worksheet = workbook.CreateSheet("Template");
+
+        var boldStyle = workbook.CreateCellStyle();
+        var boldFont = workbook.CreateFont();
+        boldFont.IsBold = true;
+        boldStyle.SetFont(boldFont);
 
-        // Write headers
         for (var col = 0; col < headers.Length; col++)
         {
-            worksheet.Cell(1, col + 1).Value = headers[col];
+            var headerCell = GetOrCreateCell(worksheet, 1, col + 1);
-            worksheet.Cell(1, col + 1).Style.Font.Bold = true;
+            headerCell.SetCellValue(headers[col]);
+            headerCell.CellStyle = boldStyle;
         }
 
-        // Write data
         for (var row = 0; row < data.Length; row++)
         {
             for (var col = 0; col < data[row].Length; col++)
@@ -55,16 +62,24 @@ public class ExcelTemplateService : IExcelTemplateService
                 var value = data[row][col];
                 if (value != null)
                 {
-                    worksheet.Cell(row + 2, col + 1).Value = value.ToString();
+                    GetOrCreateCell(worksheet, row + 2, col + 1).SetCellValue(value.ToString());
                 }
             }
         }
 
-        // Auto-fit column widths
+        for (var col = 0; col < headers.Length; col++)
-        worksheet.Columns().AdjustToContents();
+        {
+            worksheet.AutoSizeColumn(col);
+        }
 
         using var stream = new MemoryStream();
-        workbook.SaveAs(stream);
+        workbook.Write(stream, leaveOpen: true);
         return stream.ToArray();
     }
+
+    private static ICell GetOrCreateCell(ISheet sheet, int rowNumber1Based, int colNumber1Based)
+    {
+        var row = sheet.GetRow(rowNumber1Based - 1) ?? sheet.CreateRow(rowNumber1Based - 1);
+        return row.GetCell(colNumber1Based - 1) ?? row.CreateCell(colNumber1Based - 1);
+    }
 }

NEW/src/JdeScoping.ExcelIO/Utilities/CellValueConverter.cs

@@ -1,31 +1,51 @@
-using ClosedXML.Excel;
+using NPOI.SS.UserModel;
 
 namespace JdeScoping.ExcelIO.Utilities;
 
 /// <summary>
-/// Utility class for converting .NET objects to ClosedXML cell values.
+/// Utility class for converting .NET objects to NPOI cell values.
 /// </summary>
 public static class CellValueConverter
 {
     /// <summary>
-    /// Converts a .NET object to an XLCellValue for use in ClosedXML worksheets.
+    /// Sets an NPOI cell value from a .NET object.
     /// </summary>
-    /// <param name="value">The value to convert.</param>
+    /// <param name="cell">The target cell.</param>
-    /// <returns>An XLCellValue suitable for setting as a cell value.</returns>
+    /// <param name="value">The value to write.</param>
-    public static XLCellValue ConvertToXlValue(object? value)
+    public static void SetCellValue(ICell cell, object? value)
     {
-        return value switch
+        switch (value)
         {
-            null => Blank.Value,
+            case null:
-            string s => s,
+                cell.SetCellType(CellType.Blank);
-            int i => i,
+                break;
-            long l => l,
+            case string s:
-            decimal d => d,
+                cell.SetCellValue(s);
-            double dbl => dbl,
+                break;
-            float f => f,
+            case int i:
-            DateTime dt => dt,
+                cell.SetCellValue(i);
-            bool b => b,
+                break;
-            _ => value.ToString() ?? string.Empty
+            case long l:
-        };
+                cell.SetCellValue(l);
+                break;
+            case decimal d:
+                cell.SetCellValue((double)d);
+                break;
+            case double dbl:
+                cell.SetCellValue(dbl);
+                break;
+            case float f:
+                cell.SetCellValue(f);
+                break;
+            case DateTime dt:
+                cell.SetCellValue(dt);
+                break;
+            case bool b:
+                cell.SetCellValue(b);
+                break;
+            default:
+                cell.SetCellValue(value.ToString() ?? string.Empty);
+                break;
+        }
     }
 }

NEW/tests/JdeScoping.ExcelIO.Tests/CriteriaSheetGeneratorTests.cs

@@ -1,10 +1,11 @@
-using ClosedXML.Excel;
 using JdeScoping.ExcelIO.Options;
 using JdeScoping.ExcelIO.Generators;
 using JdeScoping.ExcelIO.Mapping;
 using JdeScoping.ExcelIO.Mapping.Maps;
 using JdeScoping.ExcelIO.Models.Reporting;
+using JdeScoping.ExcelIO.Tests.Fixtures;
 using Microsoft.Extensions.Options;
+using NPOI.XSSF.UserModel;
 using Shouldly;
 using Xunit;
 
@@ -13,18 +14,17 @@ namespace JdeScoping.ExcelIO.Tests;
 public class CriteriaSheetGeneratorTests
 {
     private readonly CriteriaSheetGenerator _generator;
-    private readonly IOptions<ExcelExportOptions> _options;
 
     public CriteriaSheetGeneratorTests()
     {
-        _options = Microsoft.Extensions.Options.Options.Create(new ExcelExportOptions
+        var options = Microsoft.Extensions.Options.Options.Create(new ExcelExportOptions
         {
             CriteriaSheetPassword = "TestPassword"
         });
 
         var registry = CreateTestRegistry();
         var tableWriter = new FluentTableWriter(registry);
-        _generator = new CriteriaSheetGenerator(_options, tableWriter);
+        _generator = new CriteriaSheetGenerator(options, tableWriter);
     }
 
     private static ExcelMapRegistry CreateTestRegistry()
@@ -44,171 +44,158 @@ public class CriteriaSheetGeneratorTests
     [Fact]
     public void Generate_CreatesSearchCriteriaSheet()
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
         var search = CreateMinimalSearchModel();
 
         _generator.Generate(workbook, search);
 
-        workbook.Worksheets.TryGetWorksheet("Search Criteria", out var worksheet).ShouldBeTrue();
+        workbook.GetSheet("Search Criteria").ShouldNotBeNull();
-        worksheet.ShouldNotBeNull();
     }
 
     [Fact]
     public void Generate_ContainsSearchName()
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
         var search = CreateMinimalSearchModel();
         search.Name = "Test Search Name";
 
         _generator.Generate(workbook, search);
 
-        var worksheet = workbook.Worksheet("Search Criteria");
+        var worksheet = workbook.GetSheet("Search Criteria");
-        worksheet.Cell(1, 1).Value.GetText().ShouldBe("Search Name");
+        ExcelTestHelpers.GetCellText(worksheet, 1, 1).ShouldBe("Search Name");
-        worksheet.Cell(1, 2).Value.GetText().ShouldBe("Test Search Name");
+        ExcelTestHelpers.GetCellText(worksheet, 1, 2).ShouldBe("Test Search Name");
     }
 
     [Fact]
     public void Generate_ContainsUserName()
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
         var search = CreateMinimalSearchModel();
         search.UserName = "testuser";
 
         _generator.Generate(workbook, search);
 
-        var worksheet = workbook.Worksheet("Search Criteria");
+        var worksheet = workbook.GetSheet("Search Criteria");
-        worksheet.Cell(2, 1).Value.GetText().ShouldBe("User Name");
+        ExcelTestHelpers.GetCellText(worksheet, 2, 1).ShouldBe("User Name");
-        worksheet.Cell(2, 2).Value.GetText().ShouldBe("testuser");
+        ExcelTestHelpers.GetCellText(worksheet, 2, 2).ShouldBe("testuser");
     }
 
     [Fact]
     public void Generate_ContainsTimestamps()
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
         var search = CreateMinimalSearchModel();
-        var submitDt = new DateTime(2024, 1, 15, 10, 30, 0);
+        search.SubmitDt = new DateTime(2024, 1, 15, 10, 30, 0);
-        var startDt = new DateTime(2024, 1, 15, 10, 31, 0);
+        search.StartDt = new DateTime(2024, 1, 15, 10, 31, 0);
-        var endDt = new DateTime(2024, 1, 15, 10, 35, 0);
+        search.EndDt = new DateTime(2024, 1, 15, 10, 35, 0);
-        search.SubmitDt = submitDt;
-        search.StartDt = startDt;
-        search.EndDt = endDt;
 
         _generator.Generate(workbook, search);
 
-        var worksheet = workbook.Worksheet("Search Criteria");
+        var worksheet = workbook.GetSheet("Search Criteria");
-        worksheet.Cell(4, 1).Value.GetText().ShouldBe("Submit timestamp");
+        ExcelTestHelpers.GetCellText(worksheet, 4, 1).ShouldBe("Submit timestamp");
-        worksheet.Cell(4, 2).Value.GetText().ShouldContain("Jan 15, 2024");
+        ExcelTestHelpers.GetCellText(worksheet, 4, 2).ShouldContain("Jan 15, 2024");
-
+        ExcelTestHelpers.GetCellText(worksheet, 5, 1).ShouldBe("Start timestamp");
-        worksheet.Cell(5, 1).Value.GetText().ShouldBe("Start timestamp");
+        ExcelTestHelpers.GetCellText(worksheet, 5, 2).ShouldContain("Jan 15, 2024");
-        worksheet.Cell(5, 2).Value.GetText().ShouldContain("Jan 15, 2024");
+        ExcelTestHelpers.GetCellText(worksheet, 6, 1).ShouldBe("Completed timestamp");
-
+        ExcelTestHelpers.GetCellText(worksheet, 6, 2).ShouldContain("Jan 15, 2024");
-        worksheet.Cell(6, 1).Value.GetText().ShouldBe("Completed timestamp");
-        worksheet.Cell(6, 2).Value.GetText().ShouldContain("Jan 15, 2024");
     }
 
     [Fact]
     public void Generate_ContainsTimespanFilterTable()
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
         var search = CreateMinimalSearchModel();
         search.MinimumDt = new DateTime(2024, 1, 1);
         search.MaximumDt = new DateTime(2024, 12, 31);
 
         _generator.Generate(workbook, search);
 
-        var worksheet = workbook.Worksheet("Search Criteria");
+        var worksheet = workbook.GetSheet("Search Criteria");
-        var tables = worksheet.Tables;
+        ExcelTestHelpers.TableExists(worksheet, "Timespan_Filter").ShouldBeTrue();
-        tables.Any(t => t.Name == "Timespan_Filter").ShouldBeTrue();
     }
 
     [Fact]
     public void Generate_ContainsWorkOrderFilterTable()
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
         var search = CreateMinimalSearchModel();
         search.WorkOrderFilter.Add(new WorkOrderFilterEntry { WorkOrderNumber = 12345, ItemNumber = "ITEM-001" });
 
         _generator.Generate(workbook, search);
 
-        var worksheet = workbook.Worksheet("Search Criteria");
+        var worksheet = workbook.GetSheet("Search Criteria");
-        var tables = worksheet.Tables;
+        ExcelTestHelpers.TableExists(worksheet, "Work_Order_Filter").ShouldBeTrue();
-        tables.Any(t => t.Name == "Work_Order_Filter").ShouldBeTrue();
     }
 
     [Fact]
     public void Generate_ContainsItemNumberFilterTable()
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
         var search = CreateMinimalSearchModel();
         search.ItemNumberFilter.Add(new ItemNumberFilterEntry { ItemNumber = "ITEM-001" });
 
         _generator.Generate(workbook, search);
 
-        var worksheet = workbook.Worksheet("Search Criteria");
+        var worksheet = workbook.GetSheet("Search Criteria");
-        var tables = worksheet.Tables;
+        ExcelTestHelpers.TableExists(worksheet, "Item_Number_Filter").ShouldBeTrue();
-        tables.Any(t => t.Name == "Item_Number_Filter").ShouldBeTrue();
     }
 
     [Fact]
     public void Generate_ContainsProfitCenterFilterTable()
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
         var search = CreateMinimalSearchModel();
         search.ProfitCenterFilter.Add(new ProfitCenterFilterEntry { Code = "PC01", Description = "Profit Center 1" });
 
         _generator.Generate(workbook, search);
 
-        var worksheet = workbook.Worksheet("Search Criteria");
+        var worksheet = workbook.GetSheet("Search Criteria");
-        var tables = worksheet.Tables;
+        ExcelTestHelpers.TableExists(worksheet, "Profit_Center_Filter").ShouldBeTrue();
-        tables.Any(t => t.Name == "Profit_Center_Filter").ShouldBeTrue();
     }
 
     [Fact]
     public void Generate_ContainsWorkCenterFilterTable()
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
         var search = CreateMinimalSearchModel();
         search.WorkCenterFilter.Add(new WorkCenterFilterEntry { Code = "WC01", Description = "Work Center 1" });
 
         _generator.Generate(workbook, search);
 
-        var worksheet = workbook.Worksheet("Search Criteria");
+        var worksheet = workbook.GetSheet("Search Criteria");
-        var tables = worksheet.Tables;
+        ExcelTestHelpers.TableExists(worksheet, "Work_Center_Filter").ShouldBeTrue();
-        tables.Any(t => t.Name == "Work_Center_Filter").ShouldBeTrue();
     }
 
     [Fact]
     public void Generate_ContainsOperatorFilterTable()
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
         var search = CreateMinimalSearchModel();
         search.OperatorFilter.Add(new OperatorFilterEntry { UserId = "OP01", FullName = "Operator 1" });
 
         _generator.Generate(workbook, search);
 
-        var worksheet = workbook.Worksheet("Search Criteria");
+        var worksheet = workbook.GetSheet("Search Criteria");
-        var tables = worksheet.Tables;
+        ExcelTestHelpers.TableExists(worksheet, "Operator_Filter").ShouldBeTrue();
-        tables.Any(t => t.Name == "Operator_Filter").ShouldBeTrue();
     }
 
     [Fact]
     public void Generate_ContainsComponentLotFilterTable()
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
         var search = CreateMinimalSearchModel();
         search.ComponentLotFilter.Add(new ComponentLotFilterEntry { LotNumber = "LOT001" });
 
         _generator.Generate(workbook, search);
 
-        var worksheet = workbook.Worksheet("Search Criteria");
+        var worksheet = workbook.GetSheet("Search Criteria");
-        var tables = worksheet.Tables;
+        ExcelTestHelpers.TableExists(worksheet, "Component_Lot_Filter").ShouldBeTrue();
-        tables.Any(t => t.Name == "Component_Lot_Filter").ShouldBeTrue();
     }
 
     [Fact]
     public void Generate_ContainsItemOperationMisFilterTable()
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
         var search = CreateMinimalSearchModel();
         search.ItemOperationMisFilter.Add(new ItemOperationMisFilterEntry
         {
@@ -219,113 +206,101 @@ public class CriteriaSheetGeneratorTests
 
         _generator.Generate(workbook, search);
 
-        var worksheet = workbook.Worksheet("Search Criteria");
+        var worksheet = workbook.GetSheet("Search Criteria");
-        var tables = worksheet.Tables;
+        ExcelTestHelpers.TableExists(worksheet, "Item_Operation_MIS_Filter").ShouldBeTrue();
-        tables.Any(t => t.Name == "Item_Operation_MIS_Filter").ShouldBeTrue();
     }
 
     [Fact]
     public void Generate_ContainsExtractMisDataIndicator_WhenTrue()
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
         var search = CreateMinimalSearchModel();
         search.ExtractMisData = true;
 
         _generator.Generate(workbook, search);
 
-        var worksheet = workbook.Worksheet("Search Criteria");
+        var worksheet = workbook.GetSheet("Search Criteria");
-        // Find the "Extract MIS data?" header and check for YES
+        var yesNo = FindYesNo(worksheet);
-        var cells = worksheet.CellsUsed();
+        yesNo.ShouldBe("YES");
-        var extractMisCell = cells.FirstOrDefault(c => c.Value.ToString() == "YES" || c.Value.ToString() == "NO");
-        extractMisCell.ShouldNotBeNull();
-        extractMisCell.Value.GetText().ShouldBe("YES");
     }
 
     [Fact]
     public void Generate_ContainsExtractMisDataIndicator_WhenFalse()
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
         var search = CreateMinimalSearchModel();
         search.ExtractMisData = false;
 
         _generator.Generate(workbook, search);
 
-        var worksheet = workbook.Worksheet("Search Criteria");
+        var worksheet = workbook.GetSheet("Search Criteria");
-        // Find the "Extract MIS data?" header and check for NO
+        var yesNo = FindYesNo(worksheet);
-        var cells = worksheet.CellsUsed();
+        yesNo.ShouldBe("NO");
-        var extractMisCell = cells.FirstOrDefault(c => c.Value.ToString() == "YES" || c.Value.ToString() == "NO");
-        extractMisCell.ShouldNotBeNull();
-        extractMisCell.Value.GetText().ShouldBe("NO");
     }
 
     [Fact]
     public void Generate_AppliesHeaderFormatting()
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
         var search = CreateMinimalSearchModel();
 
         _generator.Generate(workbook, search);
 
-        var worksheet = workbook.Worksheet("Search Criteria");
+        var worksheet = workbook.GetSheet("Search Criteria");
-        // Search Name header should be bold with Gainsboro background
+        var headerCell = ExcelTestHelpers.GetCell(worksheet, 1, 1)!;
-        var headerCell = worksheet.Cell(1, 1);
+        (headerCell.CellStyle.FontIndex >= 0 &&
-        headerCell.Style.Font.Bold.ShouldBeTrue();
+         workbook.GetFontAt(headerCell.CellStyle.FontIndex).IsBold).ShouldBeTrue();
-        headerCell.Style.Fill.BackgroundColor.ShouldBe(XLColor.Gainsboro);
+        ExcelTestHelpers.GetFillForegroundRgb(headerCell).ShouldBe([0xDC, 0xDC, 0xDC]);
     }
 
     [Fact]
     public void Generate_AppliesProtection()
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
         var search = CreateMinimalSearchModel();
 
         _generator.Generate(workbook, search);
 
-        var worksheet = workbook.Worksheet("Search Criteria");
+        var worksheet = workbook.GetSheet("Search Criteria");
-        worksheet.Protection.IsProtected.ShouldBeTrue();
+        ExcelTestHelpers.IsSheetProtected(worksheet).ShouldBeTrue();
     }
 
     [Fact]
     public void Generate_TablesHaveLight18Style()
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
         var search = CreateMinimalSearchModel();
         search.WorkOrderFilter.Add(new WorkOrderFilterEntry { WorkOrderNumber = 12345, ItemNumber = "ITEM-001" });
 
         _generator.Generate(workbook, search);
 
-        var worksheet = workbook.Worksheet("Search Criteria");
+        var worksheet = workbook.GetSheet("Search Criteria");
-        var table = worksheet.Tables.First(t => t.Name == "Work_Order_Filter");
+        var table = ExcelTestHelpers.GetTableByName(worksheet, "Work_Order_Filter");
-        table.Theme.ShouldBe(XLTableTheme.TableStyleLight18);
+        table.StyleName.ShouldBe("TableStyleLight18");
     }
 
     [Fact]
     public void Generate_FilterTables_Have2BlankRowSpacing()
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
         var search = CreateMinimalSearchModel();
         search.WorkOrderFilter.Add(new WorkOrderFilterEntry { WorkOrderNumber = 12345, ItemNumber = "ITEM-001" });
         search.ItemNumberFilter.Add(new ItemNumberFilterEntry { ItemNumber = "ITEM-001" });
 
         _generator.Generate(workbook, search);
 
-        var worksheet = workbook.Worksheet("Search Criteria");
+        var worksheet = workbook.GetSheet("Search Criteria");
-        var woTable = worksheet.Tables.First(t => t.Name == "Work_Order_Filter");
+        var woTable = ExcelTestHelpers.GetTableByName(worksheet, "Work_Order_Filter");
-        var itemTable = worksheet.Tables.First(t => t.Name == "Item_Number_Filter");
+        var itemTable = ExcelTestHelpers.GetTableByName(worksheet, "Item_Number_Filter");
 
-        // There should be 2 blank rows between tables. With the header row of the next table, that's a gap of 3
+        var gap = itemTable.StartCellReference.Row - woTable.EndCellReference.Row;
-        // Looking at CriteriaSheetGenerator: row = table.RangeAddress.LastAddress.RowNumber + 3
-        // This means the next table starts 3 rows after the last row, leaving 2 blank rows in between
-        var gap = itemTable.RangeAddress.FirstAddress.RowNumber - woTable.RangeAddress.LastAddress.RowNumber;
-        // Gap includes header row of next table, so: 2 blank rows + 1 header = gap of 3
-        // But with table header (Timespan_Filter has ShowHeader=true), add 1 more
         gap.ShouldBeGreaterThanOrEqualTo(3);
     }
 
     [Fact]
     public void Generate_NullTimestamps_ShowEmptyValue()
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
         var search = CreateMinimalSearchModel();
         search.SubmitDt = null;
         search.StartDt = null;
@@ -333,65 +308,86 @@ public class CriteriaSheetGeneratorTests
 
         _generator.Generate(workbook, search);
 
-        var worksheet = workbook.Worksheet("Search Criteria");
+        var worksheet = workbook.GetSheet("Search Criteria");
-        worksheet.Cell(4, 2).Value.ToString().ShouldBe(string.Empty);
+        ExcelTestHelpers.GetCellText(worksheet, 4, 2).ShouldBe(string.Empty);
-        worksheet.Cell(5, 2).Value.ToString().ShouldBe(string.Empty);
+        ExcelTestHelpers.GetCellText(worksheet, 5, 2).ShouldBe(string.Empty);
-        worksheet.Cell(6, 2).Value.ToString().ShouldBe(string.Empty);
+        ExcelTestHelpers.GetCellText(worksheet, 6, 2).ShouldBe(string.Empty);
     }
 
     [Fact]
     public void Generate_ColumnsAreAutoFitWithPadding()
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
         var search = CreateMinimalSearchModel();
         search.Name = "A Very Long Search Name That Needs Extra Width";
 
         _generator.Generate(workbook, search);
 
-        var worksheet = workbook.Worksheet("Search Criteria");
+        var worksheet = workbook.GetSheet("Search Criteria");
-        // Columns should have been adjusted - verify they have non-default width
+        ExcelTestHelpers.GetColumnWidthChars(worksheet, 1).ShouldBeGreaterThan(0);
-        worksheet.Column(1).Width.ShouldBeGreaterThan(0);
+        ExcelTestHelpers.GetColumnWidthChars(worksheet, 2).ShouldBeGreaterThan(0);
-        worksheet.Column(2).Width.ShouldBeGreaterThan(0);
     }
 
     [Fact]
     public void Generate_MultipleFiltersWithData_CreatesAllTables()
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
         var search = CreateFullSearchModel();
 
         _generator.Generate(workbook, search);
 
-        var worksheet = workbook.Worksheet("Search Criteria");
+        var worksheet = workbook.GetSheet("Search Criteria");
-        var tables = worksheet.Tables;
+        var tableCount = ((XSSFSheet)worksheet).GetTables().Count;
 
-        // Should have 8 filter tables
+        tableCount.ShouldBe(8);
-        tables.Count().ShouldBe(8);
+        ExcelTestHelpers.TableExists(worksheet, "Timespan_Filter").ShouldBeTrue();
-        tables.Any(t => t.Name == "Timespan_Filter").ShouldBeTrue();
+        ExcelTestHelpers.TableExists(worksheet, "Work_Order_Filter").ShouldBeTrue();
-        tables.Any(t => t.Name == "Work_Order_Filter").ShouldBeTrue();
+        ExcelTestHelpers.TableExists(worksheet, "Item_Number_Filter").ShouldBeTrue();
-        tables.Any(t => t.Name == "Item_Number_Filter").ShouldBeTrue();
+        ExcelTestHelpers.TableExists(worksheet, "Profit_Center_Filter").ShouldBeTrue();
-        tables.Any(t => t.Name == "Profit_Center_Filter").ShouldBeTrue();
+        ExcelTestHelpers.TableExists(worksheet, "Work_Center_Filter").ShouldBeTrue();
-        tables.Any(t => t.Name == "Work_Center_Filter").ShouldBeTrue();
+        ExcelTestHelpers.TableExists(worksheet, "Component_Lot_Filter").ShouldBeTrue();
-        tables.Any(t => t.Name == "Component_Lot_Filter").ShouldBeTrue();
+        ExcelTestHelpers.TableExists(worksheet, "Operator_Filter").ShouldBeTrue();
-        tables.Any(t => t.Name == "Operator_Filter").ShouldBeTrue();
+        ExcelTestHelpers.TableExists(worksheet, "Item_Operation_MIS_Filter").ShouldBeTrue();
-        tables.Any(t => t.Name == "Item_Operation_MIS_Filter").ShouldBeTrue();
     }
 
     [Fact]
     public void Generate_TimestampFormat_IncludesESTSuffix()
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
         var search = CreateMinimalSearchModel();
         search.SubmitDt = new DateTime(2024, 1, 15, 10, 30, 45);
 
         _generator.Generate(workbook, search);
 
-        var worksheet = workbook.Worksheet("Search Criteria");
+        var worksheet = workbook.GetSheet("Search Criteria");
-        var timestampValue = worksheet.Cell(4, 2).Value.GetText();
+        var timestampValue = ExcelTestHelpers.GetCellText(worksheet, 4, 2);
         timestampValue.ShouldContain("EST");
         timestampValue.ShouldContain("10:30:45");
     }
 
+    private static string FindYesNo(NPOI.SS.UserModel.ISheet worksheet)
+    {
+        for (var row = 0; row <= worksheet.LastRowNum; row++)
+        {
+            var npoiRow = worksheet.GetRow(row);
+            if (npoiRow == null)
+            {
+                continue;
+            }
+
+            for (var col = 0; col < npoiRow.LastCellNum; col++)
+            {
+                var text = ExcelTestHelpers.GetCellText(worksheet, row + 1, col + 1);
+                if (text == "YES" || text == "NO")
+                {
+                    return text;
+                }
+            }
+        }
+
+        return string.Empty;
+    }
+
     private static SearchModel CreateMinimalSearchModel()
     {
         return new SearchModel

NEW/tests/JdeScoping.ExcelIO.Tests/DataEntryTemplateGeneratorTests.cs

@@ -1,5 +1,5 @@
-using ClosedXML.Excel;
 using JdeScoping.ExcelIO.Generators;
+using JdeScoping.ExcelIO.Tests.Fixtures;
 using Shouldly;
 using Xunit;
 
@@ -17,9 +17,8 @@ public class DataEntryTemplateGeneratorTests
         result.ShouldNotBeNull();
         result.Length.ShouldBeGreaterThan(0);
 
-        using var stream = new MemoryStream(result);
+        using var workbook = ExcelTestHelpers.OpenWorkbook(result);
-        using var workbook = new XLWorkbook(stream);
+        workbook.NumberOfSheets.ShouldBe(1);
-        workbook.Worksheets.Count.ShouldBe(1);
     }
 
     [Fact]
@@ -27,11 +26,10 @@ public class DataEntryTemplateGeneratorTests
     {
         var result = _generator.Generate<string>(null, "Item Numbers");
 
-        using var stream = new MemoryStream(result);
+        using var workbook = ExcelTestHelpers.OpenWorkbook(result);
-        using var workbook = new XLWorkbook(stream);
+        var worksheet = workbook.GetSheetAt(0);
-        var worksheet = workbook.Worksheets.First();
 
-        worksheet.Cell(1, 1).Value.GetText().ShouldBe("Item Numbers");
+        ExcelTestHelpers.GetCellText(worksheet, 1, 1).ShouldBe("Item Numbers");
     }
 
     [Fact]
@@ -39,13 +37,13 @@ public class DataEntryTemplateGeneratorTests
     {
         var result = _generator.Generate<string>(null, "Test Header");
 
-        using var stream = new MemoryStream(result);
+        using var workbook = ExcelTestHelpers.OpenWorkbook(result);
-        using var workbook = new XLWorkbook(stream);
+        var worksheet = workbook.GetSheetAt(0);
-        var worksheet = workbook.Worksheets.First();
+        var headerCell = ExcelTestHelpers.GetCell(worksheet, 1, 1)!;
-        var headerCell = worksheet.Cell(1, 1);
 
-        headerCell.Style.Font.Bold.ShouldBeTrue();
+        (headerCell.CellStyle.FontIndex >= 0 &&
-        headerCell.Style.Fill.BackgroundColor.ShouldBe(XLColor.Gainsboro);
+         workbook.GetFontAt(headerCell.CellStyle.FontIndex).IsBold).ShouldBeTrue();
+        ExcelTestHelpers.GetFillForegroundRgb(headerCell).ShouldBe([0xDC, 0xDC, 0xDC]);
     }
 
     [Fact]
@@ -55,13 +53,12 @@ public class DataEntryTemplateGeneratorTests
 
         var result = _generator.Generate(data, "Items");
 
-        using var stream = new MemoryStream(result);
+        using var workbook = ExcelTestHelpers.OpenWorkbook(result);
-        using var workbook = new XLWorkbook(stream);
+        var worksheet = workbook.GetSheetAt(0);
-        var worksheet = workbook.Worksheets.First();
 
-        worksheet.Cell(2, 1).Value.GetText().ShouldBe("Item1");
+        ExcelTestHelpers.GetCellText(worksheet, 2, 1).ShouldBe("Item1");
-        worksheet.Cell(3, 1).Value.GetText().ShouldBe("Item2");
+        ExcelTestHelpers.GetCellText(worksheet, 3, 1).ShouldBe("Item2");
-        worksheet.Cell(4, 1).Value.GetText().ShouldBe("Item3");
+        ExcelTestHelpers.GetCellText(worksheet, 4, 1).ShouldBe("Item3");
     }
 
     [Fact]
@@ -69,11 +66,10 @@ public class DataEntryTemplateGeneratorTests
     {
         var result = _generator.Generate<string>(null, "Test");
 
-        using var stream = new MemoryStream(result);
+        using var workbook = ExcelTestHelpers.OpenWorkbook(result);
-        using var workbook = new XLWorkbook(stream);
+        var worksheet = workbook.GetSheetAt(0);
-        var worksheet = workbook.Worksheets.First();
 
-        worksheet.Column(1).Style.NumberFormat.Format.ShouldBe("@");
+        worksheet.GetColumnStyle(0).GetDataFormatString().ShouldBe("@");
     }
 
     [Fact]
@@ -85,13 +81,12 @@ public class DataEntryTemplateGeneratorTests
 
         result.ShouldNotBeNull();
 
-        using var stream = new MemoryStream(result);
+        using var workbook = ExcelTestHelpers.OpenWorkbook(result);
-        using var workbook = new XLWorkbook(stream);
+        var worksheet = workbook.GetSheetAt(0);
-        var worksheet = workbook.Worksheets.First();
 
-        worksheet.Cell(1, 1).Value.GetText().ShouldBe("Column A");
+        ExcelTestHelpers.GetCellText(worksheet, 1, 1).ShouldBe("Column A");
-        worksheet.Cell(1, 2).Value.GetText().ShouldBe("Column B");
+        ExcelTestHelpers.GetCellText(worksheet, 1, 2).ShouldBe("Column B");
-        worksheet.Cell(1, 3).Value.GetText().ShouldBe("Column C");
+        ExcelTestHelpers.GetCellText(worksheet, 1, 3).ShouldBe("Column C");
     }
 
     [Fact]
@@ -106,14 +101,13 @@ public class DataEntryTemplateGeneratorTests
 
         var result = _generator.Generate(data, headers);
 
-        using var stream = new MemoryStream(result);
+        using var workbook = ExcelTestHelpers.OpenWorkbook(result);
-        using var workbook = new XLWorkbook(stream);
+        var worksheet = workbook.GetSheetAt(0);
-        var worksheet = workbook.Worksheets.First();
 
-        worksheet.Cell(2, 1).Value.GetText().ShouldBe("Row1");
+        ExcelTestHelpers.GetCellText(worksheet, 2, 1).ShouldBe("Row1");
-        worksheet.Cell(2, 2).Value.GetNumber().ShouldBe(100);
+        ExcelTestHelpers.GetCellNumber(worksheet, 2, 2).ShouldBe(100);
-        worksheet.Cell(3, 1).Value.GetText().ShouldBe("Row2");
+        ExcelTestHelpers.GetCellText(worksheet, 3, 1).ShouldBe("Row2");
-        worksheet.Cell(3, 2).Value.GetNumber().ShouldBe(200);
+        ExcelTestHelpers.GetCellNumber(worksheet, 3, 2).ShouldBe(200);
     }
 
     [Fact]
@@ -123,12 +117,11 @@ public class DataEntryTemplateGeneratorTests
 
         var result = _generator.Generate(null, headers);
 
-        using var stream = new MemoryStream(result);
+        using var workbook = ExcelTestHelpers.OpenWorkbook(result);
-        using var workbook = new XLWorkbook(stream);
+        var worksheet = workbook.GetSheetAt(0);
-        var worksheet = workbook.Worksheets.First();
 
-        worksheet.Column(1).Width.ShouldBe(65);
+        ExcelTestHelpers.GetColumnWidthChars(worksheet, 1).ShouldBe(65);
-        worksheet.Column(2).Width.ShouldBe(65);
+        ExcelTestHelpers.GetColumnWidthChars(worksheet, 2).ShouldBe(65);
     }
 
     [Fact]
@@ -136,10 +129,9 @@ public class DataEntryTemplateGeneratorTests
     {
         var result = _generator.Generate<string>(null, "Test");
 
-        using var stream = new MemoryStream(result);
+        using var workbook = ExcelTestHelpers.OpenWorkbook(result);
-        using var workbook = new XLWorkbook(stream);
+        var worksheet = workbook.GetSheetAt(0);
-        var worksheet = workbook.Worksheets.First();
 
-        worksheet.Column(1).Width.ShouldBe(45);
+        ExcelTestHelpers.GetColumnWidthChars(worksheet, 1).ShouldBe(45);
     }
 }

NEW/tests/JdeScoping.ExcelIO.Tests/ExcelExportServiceTests.cs

@@ -1,9 +1,9 @@
-using ClosedXML.Excel;
 using JdeScoping.Core.Models.SearchResults;
 using JdeScoping.ExcelIO.Options;
 using JdeScoping.ExcelIO.Generators;
 using JdeScoping.ExcelIO.Mapping;
 using JdeScoping.ExcelIO.Mapping.Maps;
+using JdeScoping.ExcelIO.Tests.Fixtures;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using NSubstitute;
@@ -15,13 +15,11 @@ namespace JdeScoping.ExcelIO.Tests;
 public class ExcelExportServiceTests
 {
     private readonly ExcelExportService _service;
-    private readonly ILogger<ExcelExportService> _logger;
-    private readonly IOptions<ExcelExportOptions> _options;
 
     public ExcelExportServiceTests()
     {
-        _logger = Substitute.For<ILogger<ExcelExportService>>();
+        var logger = Substitute.For<ILogger<ExcelExportService>>();
-        _options = Microsoft.Extensions.Options.Options.Create(new ExcelExportOptions
+        var options = Microsoft.Extensions.Options.Options.Create(new ExcelExportOptions
         {
             CriteriaSheetPassword = "TestCriteriaPass",
             DataSheetPassword = "TestDataPass"
@@ -29,21 +27,19 @@ public class ExcelExportServiceTests
 
         var registry = CreateTestRegistry();
         var tableWriter = new FluentTableWriter(registry);
-        var criteriaGenerator = new CriteriaSheetGenerator(_options, tableWriter);
+        var criteriaGenerator = new CriteriaSheetGenerator(options, tableWriter);
 
-        _service = new ExcelExportService(_logger, _options, criteriaGenerator, tableWriter, registry);
+        _service = new ExcelExportService(logger, options, criteriaGenerator, tableWriter, registry);
     }
 
     private static ExcelMapRegistry CreateTestRegistry()
     {
         var registry = new ExcelMapRegistry();
 
-        // Search result maps
         registry.Register(new SearchResultMap());
         registry.Register(new MisSearchResultMap());
         registry.Register(new MisNonMatchSearchResultMap());
 
-        // Filter entry maps
         registry.Register(new TimespanFilterMap());
         registry.Register(new WorkOrderFilterEntryMap());
         registry.Register(new ItemNumberFilterEntryMap());
@@ -66,10 +62,8 @@ public class ExcelExportServiceTests
         result.ShouldNotBeNull();
         result.Length.ShouldBeGreaterThan(0);
 
-        // Verify it's a valid Excel file
+        using var workbook = ExcelTestHelpers.OpenWorkbook(result);
-        using var stream = new MemoryStream(result);
+        workbook.NumberOfSheets.ShouldBeGreaterThanOrEqualTo(2);
-        using var workbook = new XLWorkbook(stream);
-        workbook.Worksheets.Count.ShouldBeGreaterThanOrEqualTo(2);
     }
 
     [Fact]
@@ -79,11 +73,9 @@ public class ExcelExportServiceTests
 
         var result = await _service.GenerateAsync(search);
 
-        using var stream = new MemoryStream(result);
+        using var workbook = ExcelTestHelpers.OpenWorkbook(result);
-        using var workbook = new XLWorkbook(stream);
 
-        workbook.Worksheets.TryGetWorksheet("Search Criteria", out var criteriaSheet).ShouldBeTrue();
+        workbook.GetSheet("Search Criteria").ShouldNotBeNull();
-        criteriaSheet.ShouldNotBeNull();
     }
 
     [Fact]
@@ -93,11 +85,9 @@ public class ExcelExportServiceTests
 
         var result = await _service.GenerateAsync(search);
 
-        using var stream = new MemoryStream(result);
+        using var workbook = ExcelTestHelpers.OpenWorkbook(result);
-        using var workbook = new XLWorkbook(stream);
 
-        workbook.Worksheets.TryGetWorksheet("Search Results", out var resultsSheet).ShouldBeTrue();
+        workbook.GetSheet("Search Results").ShouldNotBeNull();
-        resultsSheet.ShouldNotBeNull();
     }
 
     [Fact]
@@ -107,12 +97,10 @@ public class ExcelExportServiceTests
 
         var result = await _service.GenerateAsync(search);
 
-        using var stream = new MemoryStream(result);
+        using var workbook = ExcelTestHelpers.OpenWorkbook(result);
-        using var workbook = new XLWorkbook(stream);
 
-        workbook.Worksheets.Count.ShouldBe(4); // Criteria, Results, MIS Info, Investigation
+        workbook.NumberOfSheets.ShouldBe(4);
-        workbook.Worksheets.TryGetWorksheet("MIS Info", out var misSheet).ShouldBeTrue();
+        workbook.GetSheet("MIS Info").ShouldNotBeNull();
-        misSheet.ShouldNotBeNull();
     }
 
     [Fact]
@@ -122,11 +110,9 @@ public class ExcelExportServiceTests
 
         var result = await _service.GenerateAsync(search);
 
-        using var stream = new MemoryStream(result);
+        using var workbook = ExcelTestHelpers.OpenWorkbook(result);
-        using var workbook = new XLWorkbook(stream);
 
-        workbook.Worksheets.TryGetWorksheet("Investigation", out var investigationSheet).ShouldBeTrue();
+        workbook.GetSheet("Investigation").ShouldNotBeNull();
-        investigationSheet.ShouldNotBeNull();
     }
 
     [Fact]
@@ -137,10 +123,9 @@ public class ExcelExportServiceTests
 
         var result = await _service.GenerateAsync(search);
 
-        using var stream = new MemoryStream(result);
+        using var workbook = ExcelTestHelpers.OpenWorkbook(result);
-        using var workbook = new XLWorkbook(stream);
 
-        workbook.Worksheets.Count.ShouldBe(2); // Only Criteria and Results
+        workbook.NumberOfSheets.ShouldBe(2);
     }
 
     [Fact]
@@ -162,11 +147,10 @@ public class ExcelExportServiceTests
 
         var result = await _service.GenerateAsync(search);
 
-        using var stream = new MemoryStream(result);
+        using var workbook = ExcelTestHelpers.OpenWorkbook(result);
-        using var workbook = new XLWorkbook(stream);
+        var criteriaSheet = workbook.GetSheet("Search Criteria");
-        var criteriaSheet = workbook.Worksheet("Search Criteria");
 
-        criteriaSheet.Cell(1, 2).Value.GetText().ShouldBe("Test Search Name");
+        ExcelTestHelpers.GetCellText(criteriaSheet, 1, 2).ShouldBe("Test Search Name");
     }
 
     [Fact]
@@ -177,11 +161,10 @@ public class ExcelExportServiceTests
 
         var result = await _service.GenerateAsync(search);
 
-        using var stream = new MemoryStream(result);
+        using var workbook = ExcelTestHelpers.OpenWorkbook(result);
-        using var workbook = new XLWorkbook(stream);
+        var criteriaSheet = workbook.GetSheet("Search Criteria");
-        var criteriaSheet = workbook.Worksheet("Search Criteria");
 
-        criteriaSheet.Cell(2, 2).Value.GetText().ShouldBe("testuser");
+        ExcelTestHelpers.GetCellText(criteriaSheet, 2, 2).ShouldBe("testuser");
     }
 
     [Fact]
@@ -198,15 +181,11 @@ public class ExcelExportServiceTests
 
         var result = await _service.GenerateAsync(search);
 
-        using var stream = new MemoryStream(result);
+        using var workbook = ExcelTestHelpers.OpenWorkbook(result);
-        using var workbook = new XLWorkbook(stream);
+        var resultsSheet = workbook.GetSheet("Search Results");
-        var resultsSheet = workbook.Worksheet("Search Results");
 
-        // Check header row
+        ExcelTestHelpers.GetCellText(resultsSheet, 1, 1).ShouldBe("Work Order Number");
-        resultsSheet.Cell(1, 1).Value.GetText().ShouldBe("Work Order Number");
+        ExcelTestHelpers.GetCellNumber(resultsSheet, 2, 1).ShouldBe(12345);
-
-        // Check data row
-        resultsSheet.Cell(2, 1).Value.GetNumber().ShouldBe(12345);
     }
 
     private static SearchModel CreateMinimalSearchModel()

NEW/tests/JdeScoping.ExcelIO.Tests/Fixtures/ExcelTestHelpers.cs

@@ -1,18 +1,139 @@
-using ClosedXML.Excel;
+using NPOI.SS.UserModel;
+using NPOI.SS.Util;
+using NPOI.XSSF.UserModel;
 
 namespace JdeScoping.ExcelIO.Tests.Fixtures;
 
 public static class ExcelTestHelpers
 {
-    public static List<string> GetHeadersFromSheet(IXLWorksheet sheet)
+    private static readonly DataFormatter Formatter = new();
+
+    public static List<string> GetHeadersFromSheet(ISheet sheet)
     {
         var headers = new List<string>();
-        var col = 1;
+        var headerRow = sheet.GetRow(0);
-        while (!sheet.Cell(1, col).IsEmpty())
+        if (headerRow == null)
         {
-            headers.Add(sheet.Cell(1, col).Value.GetText());
+            return headers;
+        }
+
+        var col = 0;
+        while (true)
+        {
+            var cell = headerRow.GetCell(col);
+            var text = cell == null ? string.Empty : Formatter.FormatCellValue(cell);
+            if (string.IsNullOrEmpty(text))
+            {
+                break;
+            }
+
+            headers.Add(text);
             col++;
         }
+
         return headers;
     }
+
+    public static string GetCellText(ISheet sheet, int row1Based, int col1Based)
+    {
+        var cell = GetCell(sheet, row1Based, col1Based);
+        return cell == null ? string.Empty : Formatter.FormatCellValue(cell);
+    }
+
+    public static double GetCellNumber(ISheet sheet, int row1Based, int col1Based)
+    {
+        var cell = GetCell(sheet, row1Based, col1Based);
+        if (cell == null)
+        {
+            return 0;
+        }
+
+        if (cell.CellType == CellType.Numeric)
+        {
+            return cell.NumericCellValue;
+        }
+
+        var text = Formatter.FormatCellValue(cell);
+        return double.TryParse(text, out var value) ? value : 0;
+    }
+
+    public static ICell? GetCell(ISheet sheet, int row1Based, int col1Based)
+    {
+        return sheet.GetRow(row1Based - 1)?.GetCell(col1Based - 1);
+    }
+
+    public static XSSFSheet GetXssfSheet(IWorkbook workbook, string sheetName)
+    {
+        return (XSSFSheet)workbook.GetSheet(sheetName)!;
+    }
+
+    public static XSSFWorkbook OpenWorkbook(byte[] bytes)
+    {
+        return new XSSFWorkbook(new MemoryStream(bytes));
+    }
+
+    public static double GetColumnWidthChars(ISheet sheet, int col1Based)
+    {
+        return sheet.GetColumnWidth(col1Based - 1) / 256d;
+    }
+
+    public static bool IsSheetProtected(ISheet sheet)
+    {
+        return sheet is XSSFSheet xssf && xssf.IsSheetLocked;
+    }
+
+    public static byte[]? GetFillForegroundRgb(ICell cell)
+    {
+        if (cell.CellStyle is XSSFCellStyle xssfStyle)
+        {
+            return xssfStyle.FillForegroundXSSFColor?.RGB;
+        }
+
+        return null;
+    }
+
+    public static bool IsMerged(ISheet sheet, int firstRow1Based, int lastRow1Based, int firstCol1Based, int lastCol1Based)
+    {
+        for (var i = 0; i < sheet.NumMergedRegions; i++)
+        {
+            var region = sheet.GetMergedRegion(i);
+            if (region.FirstRow == firstRow1Based - 1 &&
+                region.LastRow == lastRow1Based - 1 &&
+                region.FirstColumn == firstCol1Based - 1 &&
+                region.LastColumn == lastCol1Based - 1)
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public static XSSFTable GetFirstTable(ISheet sheet)
+    {
+        return ((XSSFSheet)sheet).GetTables().First();
+    }
+
+    public static XSSFTable GetTableByName(ISheet sheet, string name)
+    {
+        return ((XSSFSheet)sheet).GetTables().First(t => t.Name == name || t.DisplayName == name);
+    }
+
+    public static int GetTableRowCount(XSSFTable table)
+    {
+        // header row + data rows
+        return table.RowCount;
+    }
+
+    public static bool TableExists(ISheet sheet, string tableName)
+    {
+        return ((XSSFSheet)sheet).GetTables().Any(t => t.Name == tableName || t.DisplayName == tableName);
+    }
+
+    public static bool RegionIntersectsCell(CellRangeAddress region, int row1Based, int col1Based)
+    {
+        var row = row1Based - 1;
+        var col = col1Based - 1;
+        return region.IsInRange(row, col);
+    }
 }

NEW/tests/JdeScoping.ExcelIO.Tests/Fixtures/WorkbookFixtureBase.cs

@@ -1,18 +1,17 @@
-using ClosedXML.Excel;
 using JdeScoping.Core.Models.SearchResults;
 using JdeScoping.ExcelIO.Generators;
 using JdeScoping.ExcelIO.Mapping;
 using JdeScoping.ExcelIO.Mapping.Maps;
 using JdeScoping.ExcelIO.Options;
 using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
+using NPOI.XSSF.UserModel;
 using NSubstitute;
 
 namespace JdeScoping.ExcelIO.Tests.Fixtures;
 
 public abstract class WorkbookFixtureBase : IDisposable
 {
-    public XLWorkbook Workbook { get; }
+    public XSSFWorkbook Workbook { get; }
     public SearchModel SearchModel { get; }
 
     protected abstract SearchModel CreateSearchModel();
@@ -22,7 +21,7 @@ public abstract class WorkbookFixtureBase : IDisposable
         SearchModel = CreateSearchModel();
         var service = CreateExportService();
         var bytes = service.GenerateAsync(SearchModel).GetAwaiter().GetResult();
-        Workbook = new XLWorkbook(new MemoryStream(bytes));
+        Workbook = new XSSFWorkbook(new MemoryStream(bytes));
     }
 
     private static ExcelExportService CreateExportService()

NEW/tests/JdeScoping.ExcelIO.Tests/HeaderFormatterTests.cs

@@ -1,5 +1,6 @@
-using ClosedXML.Excel;
 using JdeScoping.ExcelIO.Formatting;
+using JdeScoping.ExcelIO.Tests.Fixtures;
+using NPOI.XSSF.UserModel;
 using Shouldly;
 using Xunit;
 
@@ -10,71 +11,71 @@ public class HeaderFormatterTests
     [Fact]
     public void ApplyHeaderFormat_Cell_AppliesCorrectStyling()
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
-        var worksheet = workbook.Worksheets.Add("Test");
+        var worksheet = workbook.CreateSheet("Test");
-        var cell = worksheet.Cell(1, 1);
+        var row = worksheet.CreateRow(0);
+        var cell = row.CreateCell(0);
 
         HeaderFormatter.ApplyHeaderFormat(cell, "Test Header");
 
-        cell.Value.GetText().ShouldBe("Test Header");
+        ExcelTestHelpers.GetCellText(worksheet, 1, 1).ShouldBe("Test Header");
-        cell.Style.Font.Bold.ShouldBeTrue();
+        cell.CellStyle.GetFont(workbook).IsBold.ShouldBeTrue();
-        cell.Style.Alignment.Horizontal.ShouldBe(XLAlignmentHorizontalValues.Center);
+        cell.CellStyle.Alignment.ShouldBe(NPOI.SS.UserModel.HorizontalAlignment.Center);
-        cell.Style.Fill.BackgroundColor.ShouldBe(XLColor.Gainsboro);
+        ExcelTestHelpers.GetFillForegroundRgb(cell).ShouldBe([0xDC, 0xDC, 0xDC]);
     }
 
     [Fact]
     public void ApplyHeaderFormat_Cell_WithoutText_AppliesOnlyStyling()
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
-        var worksheet = workbook.Worksheets.Add("Test");
+        var worksheet = workbook.CreateSheet("Test");
-        var cell = worksheet.Cell(1, 1);
+        var row = worksheet.CreateRow(0);
-        cell.Value = "Original";
+        var cell = row.CreateCell(0);
+        cell.SetCellValue("Original");
 
         HeaderFormatter.ApplyHeaderFormat(cell);
 
-        cell.Value.GetText().ShouldBe("Original");
+        ExcelTestHelpers.GetCellText(worksheet, 1, 1).ShouldBe("Original");
-        cell.Style.Font.Bold.ShouldBeTrue();
+        cell.CellStyle.GetFont(workbook).IsBold.ShouldBeTrue();
     }
 
     [Fact]
     public void ApplyHeaderFormat_Range_AppliesCorrectStyling()
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
-        var worksheet = workbook.Worksheets.Add("Test");
+        var worksheet = workbook.CreateSheet("Test");
-        var range = worksheet.Range(1, 1, 1, 3);
 
-        HeaderFormatter.ApplyHeaderFormat(range, "Header", merge: false);
+        HeaderFormatter.ApplyHeaderFormat(worksheet, 1, 1, 1, 3, "Header", merge: false);
 
-        range.FirstCell().Value.GetText().ShouldBe("Header");
+        ExcelTestHelpers.GetCellText(worksheet, 1, 1).ShouldBe("Header");
-        foreach (var cell in range.Cells())
+        for (var col = 1; col <= 3; col++)
         {
-            cell.Style.Font.Bold.ShouldBeTrue();
+            var cell = ExcelTestHelpers.GetCell(worksheet, 1, col)!;
-            cell.Style.Fill.BackgroundColor.ShouldBe(XLColor.Gainsboro);
+            cell.CellStyle.GetFont(workbook).IsBold.ShouldBeTrue();
+            ExcelTestHelpers.GetFillForegroundRgb(cell).ShouldBe([0xDC, 0xDC, 0xDC]);
         }
     }
 
     [Fact]
     public void ApplyHeaderFormat_Range_WithMerge_MergesCells()
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
-        var worksheet = workbook.Worksheets.Add("Test");
+        var worksheet = workbook.CreateSheet("Test");
-        var range = worksheet.Range(1, 1, 1, 3);
 
-        HeaderFormatter.ApplyHeaderFormat(range, "Merged Header", merge: true);
+        HeaderFormatter.ApplyHeaderFormat(worksheet, 1, 1, 1, 3, "Merged Header", merge: true);
 
-        range.IsMerged().ShouldBeTrue();
+        ExcelTestHelpers.IsMerged(worksheet, 1, 1, 1, 3).ShouldBeTrue();
-        range.FirstCell().Value.GetText().ShouldBe("Merged Header");
+        ExcelTestHelpers.GetCellText(worksheet, 1, 1).ShouldBe("Merged Header");
     }
 
     [Fact]
     public void ApplyHeaderFormat_Range_WithoutMerge_DoesNotMergeCells()
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
-        var worksheet = workbook.Worksheets.Add("Test");
+        var worksheet = workbook.CreateSheet("Test");
-        var range = worksheet.Range(1, 1, 1, 3);
 
-        HeaderFormatter.ApplyHeaderFormat(range, "Not Merged", merge: false);
+        HeaderFormatter.ApplyHeaderFormat(worksheet, 1, 1, 1, 3, "Not Merged", merge: false);
 
-        range.IsMerged().ShouldBeFalse();
+        ExcelTestHelpers.IsMerged(worksheet, 1, 1, 1, 3).ShouldBeFalse();
     }
 }

NEW/tests/JdeScoping.ExcelIO.Tests/Integration/InvestigationSheetTests.cs

@@ -1,5 +1,6 @@
-using ClosedXML.Excel;
 using JdeScoping.ExcelIO.Tests.Fixtures;
+using NPOI.SS.UserModel;
+using NPOI.XSSF.UserModel;
 using Shouldly;
 using Xunit;
 
@@ -7,21 +8,21 @@ namespace JdeScoping.ExcelIO.Tests.Integration;
 
 public class InvestigationSheetTests : IClassFixture<WithMisDataFixture>
 {
-    private readonly XLWorkbook _workbook;
+    private readonly XSSFWorkbook _workbook;
-    private readonly IXLWorksheet _sheet;
+    private readonly ISheet _sheet;
     private readonly List<string> _headers;
 
     public InvestigationSheetTests(WithMisDataFixture fixture)
     {
         _workbook = fixture.Workbook;
-        _sheet = _workbook.Worksheet("Investigation");
+        _sheet = _workbook.GetSheet("Investigation")!;
         _headers = ExcelTestHelpers.GetHeadersFromSheet(_sheet);
     }
 
     [Fact]
     public void InvestigationSheet_Exists()
     {
-        _workbook.Worksheets.TryGetWorksheet("Investigation", out _).ShouldBeTrue();
+        _workbook.GetSheet("Investigation").ShouldNotBeNull();
     }
 
     [Fact]
@@ -67,20 +68,20 @@ public class InvestigationSheetTests : IClassFixture<WithMisDataFixture>
     [Fact]
     public void TableStyle_IsLight18()
     {
-        var table = _sheet.Tables.First();
+        var table = ExcelTestHelpers.GetFirstTable(_sheet);
-        table.Theme.ShouldBe(XLTableTheme.TableStyleLight18);
+        table.StyleName.ShouldBe("TableStyleLight18");
     }
 
     [Fact]
     public void Protection_IsEnabled()
     {
-        _sheet.Protection.IsProtected.ShouldBeTrue();
+        ((XSSFSheet)_sheet).IsSheetLocked.ShouldBeTrue();
     }
 
     [Fact]
     public void DataRow_ContainsExpectedValues()
     {
-        _sheet.Cell(2, 2).Value.GetNumber().ShouldBe(12345);
+        ExcelTestHelpers.GetCellNumber(_sheet, 2, 2).ShouldBe(12345);
-        _sheet.Cell(2, 10).Value.GetText().ShouldBe("ITEM-001");
+        ExcelTestHelpers.GetCellText(_sheet, 2, 10).ShouldBe("ITEM-001");
     }
 }

NEW/tests/JdeScoping.ExcelIO.Tests/Integration/LargeDataSetTests.cs

@@ -1,5 +1,5 @@
-using ClosedXML.Excel;
 using JdeScoping.ExcelIO.Tests.Fixtures;
+using NPOI.XSSF.UserModel;
 using Shouldly;
 using Xunit;
 
@@ -7,7 +7,7 @@ namespace JdeScoping.ExcelIO.Tests.Integration;
 
 public class LargeDataSetTests : IClassFixture<LargeDataSetFixture>
 {
-    private readonly XLWorkbook _workbook;
+    private readonly XSSFWorkbook _workbook;
 
     public LargeDataSetTests(LargeDataSetFixture fixture)
     {
@@ -17,8 +17,8 @@ public class LargeDataSetTests : IClassFixture<LargeDataSetFixture>
     [Fact]
     public void TableRowCount_Is1001()
     {
-        var sheet = _workbook.Worksheet("Search Results");
+        var sheet = _workbook.GetSheet("Search Results")!;
-        var table = sheet.Tables.First();
+        var table = ExcelTestHelpers.GetFirstTable(sheet);
-        table.RowCount().ShouldBe(1001); // 1 header + 1000 data rows
+        ExcelTestHelpers.GetTableRowCount(table).ShouldBe(1001);
     }
 }

NEW/tests/JdeScoping.ExcelIO.Tests/Integration/MinimalSearchTests.cs

@@ -1,5 +1,5 @@
-using ClosedXML.Excel;
 using JdeScoping.ExcelIO.Tests.Fixtures;
+using NPOI.XSSF.UserModel;
 using Shouldly;
 using Xunit;
 
@@ -7,7 +7,7 @@ namespace JdeScoping.ExcelIO.Tests.Integration;
 
 public class MinimalSearchTests : IClassFixture<MinimalSearchFixture>
 {
-    private readonly XLWorkbook _workbook;
+    private readonly XSSFWorkbook _workbook;
 
     public MinimalSearchTests(MinimalSearchFixture fixture)
     {
@@ -17,32 +17,32 @@ public class MinimalSearchTests : IClassFixture<MinimalSearchFixture>
     [Fact]
     public void SheetCount_IsTwo()
     {
-        _workbook.Worksheets.Count.ShouldBe(2);
+        _workbook.NumberOfSheets.ShouldBe(2);
     }
 
     [Fact]
     public void SearchCriteriaSheet_Exists()
     {
-        _workbook.Worksheets.TryGetWorksheet("Search Criteria", out _).ShouldBeTrue();
+        _workbook.GetSheet("Search Criteria").ShouldNotBeNull();
     }
 
     [Fact]
     public void SearchResultsSheet_Exists()
     {
-        _workbook.Worksheets.TryGetWorksheet("Search Results", out _).ShouldBeTrue();
+        _workbook.GetSheet("Search Results").ShouldNotBeNull();
     }
 
     [Fact]
     public void SearchCriteriaSheet_IsProtected()
     {
-        var sheet = _workbook.Worksheet("Search Criteria");
+        var sheet = (XSSFSheet)_workbook.GetSheet("Search Criteria")!;
-        sheet.Protection.IsProtected.ShouldBeTrue();
+        sheet.IsSheetLocked.ShouldBeTrue();
     }
 
     [Fact]
     public void SearchResultsSheet_IsProtected()
     {
-        var sheet = _workbook.Worksheet("Search Results");
+        var sheet = (XSSFSheet)_workbook.GetSheet("Search Results")!;
-        sheet.Protection.IsProtected.ShouldBeTrue();
+        sheet.IsSheetLocked.ShouldBeTrue();
     }
 }

NEW/tests/JdeScoping.ExcelIO.Tests/Integration/MisInfoSheetTests.cs

@@ -1,5 +1,6 @@
-using ClosedXML.Excel;
 using JdeScoping.ExcelIO.Tests.Fixtures;
+using NPOI.SS.UserModel;
+using NPOI.XSSF.UserModel;
 using Shouldly;
 using Xunit;
 
@@ -7,27 +8,27 @@ namespace JdeScoping.ExcelIO.Tests.Integration;
 
 public class MisInfoSheetTests : IClassFixture<WithMisDataFixture>
 {
-    private readonly XLWorkbook _workbook;
+    private readonly XSSFWorkbook _workbook;
-    private readonly IXLWorksheet _sheet;
+    private readonly ISheet _sheet;
     private readonly List<string> _headers;
 
     public MisInfoSheetTests(WithMisDataFixture fixture)
     {
         _workbook = fixture.Workbook;
-        _sheet = _workbook.Worksheet("MIS Info");
+        _sheet = _workbook.GetSheet("MIS Info")!;
         _headers = ExcelTestHelpers.GetHeadersFromSheet(_sheet);
     }
 
     [Fact]
     public void SheetCount_IsFour()
     {
-        _workbook.Worksheets.Count.ShouldBe(4);
+        _workbook.NumberOfSheets.ShouldBe(4);
     }
 
     [Fact]
     public void MisInfoSheet_Exists()
     {
-        _workbook.Worksheets.TryGetWorksheet("MIS Info", out _).ShouldBeTrue();
+        _workbook.GetSheet("MIS Info").ShouldNotBeNull();
     }
 
     [Fact]
@@ -87,44 +88,44 @@ public class MisInfoSheetTests : IClassFixture<WithMisDataFixture>
     [Fact]
     public void TableStyle_IsLight18()
     {
-        var table = _sheet.Tables.First();
+        var table = ExcelTestHelpers.GetFirstTable(_sheet);
-        table.Theme.ShouldBe(XLTableTheme.TableStyleLight18);
+        table.StyleName.ShouldBe("TableStyleLight18");
     }
 
     [Fact]
     public void Protection_IsEnabled()
     {
-        _sheet.Protection.IsProtected.ShouldBeTrue();
+        ((XSSFSheet)_sheet).IsSheetLocked.ShouldBeTrue();
     }
 
     [Fact]
     public void DataRow_ContainsExpectedValues()
     {
-        _sheet.Cell(2, 1).Value.GetText().ShouldBe("ITEM-001");
+        ExcelTestHelpers.GetCellText(_sheet, 2, 1).ShouldBe("ITEM-001");
-        _sheet.Cell(2, 3).Value.GetText().ShouldBe("MIS-001");
+        ExcelTestHelpers.GetCellText(_sheet, 2, 3).ShouldBe("MIS-001");
     }
 
     [Fact]
     public void TestDescriptionColumn_IsWrapped()
     {
         var colIndex = _headers.IndexOf("Test Description") + 1;
-        _sheet.Column(colIndex).Width.ShouldBe(65);
+        ExcelTestHelpers.GetColumnWidthChars(_sheet, colIndex).ShouldBe(65);
-        _sheet.Column(colIndex).Style.Alignment.WrapText.ShouldBeTrue();
+        ExcelTestHelpers.GetCell(_sheet, 2, colIndex)!.CellStyle.WrapText.ShouldBeTrue();
     }
 
     [Fact]
     public void ToolsGaugesColumn_IsWrapped()
     {
         var colIndex = _headers.IndexOf("Tools & Gauges") + 1;
-        _sheet.Column(colIndex).Width.ShouldBe(65);
+        ExcelTestHelpers.GetColumnWidthChars(_sheet, colIndex).ShouldBe(65);
-        _sheet.Column(colIndex).Style.Alignment.WrapText.ShouldBeTrue();
+        ExcelTestHelpers.GetCell(_sheet, 2, colIndex)!.CellStyle.WrapText.ShouldBeTrue();
     }
 
     [Fact]
     public void WorkInstructionsColumn_IsWrapped()
     {
         var colIndex = _headers.IndexOf("Work Instructions") + 1;
-        _sheet.Column(colIndex).Width.ShouldBe(65);
+        ExcelTestHelpers.GetColumnWidthChars(_sheet, colIndex).ShouldBe(65);
-        _sheet.Column(colIndex).Style.Alignment.WrapText.ShouldBeTrue();
+        ExcelTestHelpers.GetCell(_sheet, 2, colIndex)!.CellStyle.WrapText.ShouldBeTrue();
     }
 }

NEW/tests/JdeScoping.ExcelIO.Tests/Integration/ProtectionAndStyleTests.cs

@@ -1,5 +1,6 @@
-using ClosedXML.Excel;
 using JdeScoping.ExcelIO.Tests.Fixtures;
+using NPOI.SS.UserModel;
+using NPOI.XSSF.UserModel;
 using Shouldly;
 using Xunit;
 
@@ -7,7 +8,7 @@ namespace JdeScoping.ExcelIO.Tests.Integration;
 
 public class ProtectionAndStyleTests : IClassFixture<WithMisDataFixture>
 {
-    private readonly XLWorkbook _workbook;
+    private readonly XSSFWorkbook _workbook;
 
     public ProtectionAndStyleTests(WithMisDataFixture fixture)
     {
@@ -17,57 +18,58 @@ public class ProtectionAndStyleTests : IClassFixture<WithMisDataFixture>
     [Fact]
     public void AllDataSheets_AreProtected()
     {
-        _workbook.Worksheet("Search Results").Protection.IsProtected.ShouldBeTrue();
+        ((XSSFSheet)_workbook.GetSheet("Search Results")!).IsSheetLocked.ShouldBeTrue();
-        _workbook.Worksheet("MIS Info").Protection.IsProtected.ShouldBeTrue();
+        ((XSSFSheet)_workbook.GetSheet("MIS Info")!).IsSheetLocked.ShouldBeTrue();
-        _workbook.Worksheet("Investigation").Protection.IsProtected.ShouldBeTrue();
+        ((XSSFSheet)_workbook.GetSheet("Investigation")!).IsSheetLocked.ShouldBeTrue();
     }
 
     [Fact]
     public void Protection_AllowsFiltering()
     {
-        var sheet = _workbook.Worksheet("Search Results");
+        var sheet = (XSSFSheet)_workbook.GetSheet("Search Results")!;
-        sheet.Protection.AllowedElements.HasFlag(XLSheetProtectionElements.AutoFilter).ShouldBeTrue();
+        sheet.IsAutoFilterLocked.ShouldBeFalse();
     }
 
     [Fact]
     public void Protection_AllowsSorting()
     {
-        var sheet = _workbook.Worksheet("Search Results");
+        var sheet = (XSSFSheet)_workbook.GetSheet("Search Results")!;
-        sheet.Protection.AllowedElements.HasFlag(XLSheetProtectionElements.Sort).ShouldBeTrue();
+        sheet.IsSortLocked.ShouldBeFalse();
     }
 
     [Fact]
     public void Protection_AllowsFormatting()
     {
-        var sheet = _workbook.Worksheet("Search Results");
+        var sheet = (XSSFSheet)_workbook.GetSheet("Search Results")!;
-        sheet.Protection.AllowedElements.HasFlag(XLSheetProtectionElements.FormatCells).ShouldBeTrue();
+        sheet.IsFormatCellsLocked.ShouldBeFalse();
-        sheet.Protection.AllowedElements.HasFlag(XLSheetProtectionElements.FormatColumns).ShouldBeTrue();
+        sheet.IsFormatColumnsLocked.ShouldBeFalse();
-        sheet.Protection.AllowedElements.HasFlag(XLSheetProtectionElements.FormatRows).ShouldBeTrue();
+        sheet.IsFormatRowsLocked.ShouldBeFalse();
     }
 
     [Fact]
     public void AllTables_UseLight18Style()
     {
-        _workbook.Worksheet("Search Results").Tables.First().Theme.ShouldBe(XLTableTheme.TableStyleLight18);
+        ExcelTestHelpers.GetFirstTable(_workbook.GetSheet("Search Results")!).StyleName.ShouldBe("TableStyleLight18");
-        _workbook.Worksheet("MIS Info").Tables.First().Theme.ShouldBe(XLTableTheme.TableStyleLight18);
+        ExcelTestHelpers.GetFirstTable(_workbook.GetSheet("MIS Info")!).StyleName.ShouldBe("TableStyleLight18");
-        _workbook.Worksheet("Investigation").Tables.First().Theme.ShouldBe(XLTableTheme.TableStyleLight18);
+        ExcelTestHelpers.GetFirstTable(_workbook.GetSheet("Investigation")!).StyleName.ShouldBe("TableStyleLight18");
     }
 
     [Fact]
     public void HeaderCells_HaveCorrectFormatting()
     {
-        var sheet = _workbook.Worksheet("Search Criteria");
+        var sheet = _workbook.GetSheet("Search Criteria")!;
-        var headerCell = sheet.Cell(1, 1);
+        var headerCell = ExcelTestHelpers.GetCell(sheet, 1, 1)!;
-        headerCell.Style.Font.Bold.ShouldBeTrue();
+        (headerCell.CellStyle.FontIndex >= 0 &&
-        headerCell.Style.Fill.BackgroundColor.ShouldBe(XLColor.Gainsboro);
+         _workbook.GetFontAt(headerCell.CellStyle.FontIndex).IsBold).ShouldBeTrue();
-        headerCell.Style.Alignment.Horizontal.ShouldBe(XLAlignmentHorizontalValues.Center);
+        ExcelTestHelpers.GetFillForegroundRgb(headerCell).ShouldBe([0xDC, 0xDC, 0xDC]);
+        headerCell.CellStyle.Alignment.ShouldBe(HorizontalAlignment.Center);
     }
 
     [Fact]
     public void CriteriaTimestamp_MatchesLegacyFormat()
     {
-        var sheet = _workbook.Worksheet("Search Criteria");
+        var sheet = _workbook.GetSheet("Search Criteria")!;
-        var timestamp = sheet.Cell(4, 2).Value.GetText();
+        var timestamp = ExcelTestHelpers.GetCellText(sheet, 4, 2);
         timestamp.ShouldContain("Jan 15, 2024");
         timestamp.ShouldContain("02:30:45");
         timestamp.ShouldContain("EST");

NEW/tests/JdeScoping.ExcelIO.Tests/Integration/SearchResultsSheetTests.cs

@@ -1,5 +1,6 @@
-using ClosedXML.Excel;
 using JdeScoping.ExcelIO.Tests.Fixtures;
+using NPOI.SS.UserModel;
+using NPOI.XSSF.UserModel;
 using Shouldly;
 using Xunit;
 
@@ -7,14 +8,14 @@ namespace JdeScoping.ExcelIO.Tests.Integration;
 
 public class SearchResultsSheetTests : IClassFixture<WithResultsFixture>
 {
-    private readonly XLWorkbook _workbook;
+    private readonly XSSFWorkbook _workbook;
-    private readonly IXLWorksheet _sheet;
+    private readonly ISheet _sheet;
     private readonly List<string> _headers;
 
     public SearchResultsSheetTests(WithResultsFixture fixture)
     {
         _workbook = fixture.Workbook;
-        _sheet = _workbook.Worksheet("Search Results");
+        _sheet = _workbook.GetSheet("Search Results")!;
         _headers = ExcelTestHelpers.GetHeadersFromSheet(_sheet);
     }
 
@@ -75,15 +76,15 @@ public class SearchResultsSheetTests : IClassFixture<WithResultsFixture>
     [Fact]
     public void TableStyle_IsLight18()
     {
-        var table = _sheet.Tables.First();
+        var table = ExcelTestHelpers.GetFirstTable(_sheet);
-        table.Theme.ShouldBe(XLTableTheme.TableStyleLight18);
+        table.StyleName.ShouldBe("TableStyleLight18");
     }
 
     [Fact]
     public void DataRow_ContainsExpectedValues()
     {
-        _sheet.Cell(2, 1).Value.GetNumber().ShouldBe(12345);
+        ExcelTestHelpers.GetCellNumber(_sheet, 2, 1).ShouldBe(12345);
-        _sheet.Cell(2, 3).Value.GetText().ShouldBe("LOT-001");
+        ExcelTestHelpers.GetCellText(_sheet, 2, 3).ShouldBe("LOT-001");
-        _sheet.Cell(2, 4).Value.GetText().ShouldBe("ITEM-001");
+        ExcelTestHelpers.GetCellText(_sheet, 2, 4).ShouldBe("ITEM-001");
     }
 }

NEW/tests/JdeScoping.ExcelIO.Tests/JdeScoping.ExcelIO.Tests.csproj

@@ -11,6 +11,7 @@
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
     <PackageReference Include="xunit" Version="2.9.3" />
+    <PackageReference Include="NPOI" Version="2.7.5" />
     <PackageReference Include="xunit.runner.visualstudio" Version="3.0.2">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>

NEW/tests/JdeScoping.ExcelIO.Tests/Parsing/ExcelParserServiceTests.cs

@@ -1,6 +1,6 @@
-using ClosedXML.Excel;
 using JdeScoping.ExcelIO.Parsing;
 using Microsoft.Extensions.Logging.Abstractions;
+using NPOI.XSSF.UserModel;
 using Shouldly;
 using Xunit;
 
@@ -13,14 +13,11 @@ public class ExcelParserServiceTests
     [Fact]
     public void ParseWorkOrders_ReturnsWorkOrderNumbers()
     {
-        // Arrange
         var excelData = CreateWorkOrderExcel([12345, 67890, 11111]);
 
-        // Act
         using var stream = new MemoryStream(excelData);
         var result = _service.ParseWorkOrders(stream);
 
-        // Assert
         result.Count.ShouldBe(3);
         result.ShouldContain(12345);
         result.ShouldContain(67890);
@@ -30,36 +27,30 @@ public class ExcelParserServiceTests
     [Fact]
     public void ParseWorkOrders_SkipsInvalidNumbers()
     {
-        // Arrange
+        using var workbook = new XSSFWorkbook();
-        using var workbook = new XLWorkbook();
+        var worksheet = workbook.CreateSheet("Sheet1");
-        var worksheet = workbook.Worksheets.Add("Sheet1");
+        worksheet.CreateRow(0).CreateCell(0).SetCellValue("Work Order");
-        worksheet.Cell(1, 1).Value = "Work Order";
+        worksheet.CreateRow(1).CreateCell(0).SetCellValue("12345");
-        worksheet.Cell(2, 1).Value = "12345";
+        worksheet.CreateRow(2).CreateCell(0).SetCellValue("not-a-number");
-        worksheet.Cell(3, 1).Value = "not-a-number";
+        worksheet.CreateRow(3).CreateCell(0).SetCellValue("67890");
-        worksheet.Cell(4, 1).Value = "67890";
 
         using var ms = new MemoryStream();
-        workbook.SaveAs(ms);
+        workbook.Write(ms, leaveOpen: true);
         ms.Position = 0;
 
-        // Act
         var result = _service.ParseWorkOrders(ms);
 
-        // Assert
         result.Count.ShouldBe(2);
     }
 
     [Fact]
     public void ParseItems_ReturnsItemNumbers()
     {
-        // Arrange
         var excelData = CreateItemExcel(["ITEM-001", "ITEM-002"]);
 
-        // Act
         using var stream = new MemoryStream(excelData);
         var result = _service.ParseItems(stream);
 
-        // Assert
         result.Count.ShouldBe(2);
         result.ShouldContain("ITEM-001");
         result.ShouldContain("ITEM-002");
@@ -68,14 +59,11 @@ public class ExcelParserServiceTests
     [Fact]
     public void ParseComponentLots_ReturnsLotViewModels()
     {
-        // Arrange
         var excelData = CreateComponentLotExcel([("LOT001", "ITEM-001"), ("LOT002", "ITEM-002")]);
 
-        // Act
         using var stream = new MemoryStream(excelData);
         var result = _service.ParseComponentLots(stream);
 
-        // Assert
         result.Count.ShouldBe(2);
         result[0].LotNumber.ShouldBe("LOT001");
         result[0].ItemNumber.ShouldBe("ITEM-001");
@@ -84,14 +72,11 @@ public class ExcelParserServiceTests
     [Fact]
     public void ParsePartOperations_ReturnsPartOperations()
     {
-        // Arrange
         var excelData = CreatePartOperationExcel([("ITEM-001", "100", "MIS001", "A")]);
 
-        // Act
         using var stream = new MemoryStream(excelData);
         var result = _service.ParsePartOperations(stream);
 
-        // Assert
         result.Count.ShouldBe(1);
         result[0].ItemNumber.ShouldBe("ITEM-001");
         result[0].OperationNumber.ShouldBe("100");
@@ -102,78 +87,85 @@ public class ExcelParserServiceTests
     [Fact]
     public void ParsePartOperations_TruncatesDecimalOperationNumbers()
     {
-        // Arrange
         var excelData = CreatePartOperationExcel([("ITEM-001", "100.5", "MIS001", "A")]);
 
-        // Act
         using var stream = new MemoryStream(excelData);
         var result = _service.ParsePartOperations(stream);
 
-        // Assert
         result[0].OperationNumber.ShouldBe("100");
     }
 
     private static byte[] CreateWorkOrderExcel(long[] workOrderNumbers)
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
-        var worksheet = workbook.Worksheets.Add("Sheet1");
+        var worksheet = workbook.CreateSheet("Sheet1");
-        worksheet.Cell(1, 1).Value = "Work Order Number";
+        worksheet.CreateRow(0).CreateCell(0).SetCellValue("Work Order Number");
         for (var i = 0; i < workOrderNumbers.Length; i++)
         {
-            worksheet.Cell(i + 2, 1).Value = workOrderNumbers[i];
+            worksheet.CreateRow(i + 1).CreateCell(0).SetCellValue(workOrderNumbers[i]);
         }
+
         using var stream = new MemoryStream();
-        workbook.SaveAs(stream);
+        workbook.Write(stream, leaveOpen: true);
         return stream.ToArray();
     }
 
     private static byte[] CreateItemExcel(string[] itemNumbers)
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
-        var worksheet = workbook.Worksheets.Add("Sheet1");
+        var worksheet = workbook.CreateSheet("Sheet1");
-        worksheet.Cell(1, 1).Value = "Item Number";
+        worksheet.CreateRow(0).CreateCell(0).SetCellValue("Item Number");
         for (var i = 0; i < itemNumbers.Length; i++)
         {
-            worksheet.Cell(i + 2, 1).Value = itemNumbers[i];
+            worksheet.CreateRow(i + 1).CreateCell(0).SetCellValue(itemNumbers[i]);
         }
+
         using var stream = new MemoryStream();
-        workbook.SaveAs(stream);
+        workbook.Write(stream, leaveOpen: true);
         return stream.ToArray();
     }
 
     private static byte[] CreateComponentLotExcel((string LotNumber, string ItemNumber)[] lots)
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
-        var worksheet = workbook.Worksheets.Add("Sheet1");
+        var worksheet = workbook.CreateSheet("Sheet1");
-        worksheet.Cell(1, 1).Value = "Lot Number";
+        var header = worksheet.CreateRow(0);
-        worksheet.Cell(1, 2).Value = "Item Number";
+        header.CreateCell(0).SetCellValue("Lot Number");
+        header.CreateCell(1).SetCellValue("Item Number");
+
         for (var i = 0; i < lots.Length; i++)
         {
-            worksheet.Cell(i + 2, 1).Value = lots[i].LotNumber;
+            var row = worksheet.CreateRow(i + 1);
-            worksheet.Cell(i + 2, 2).Value = lots[i].ItemNumber;
+            row.CreateCell(0).SetCellValue(lots[i].LotNumber);
+            row.CreateCell(1).SetCellValue(lots[i].ItemNumber);
         }
+
         using var stream = new MemoryStream();
-        workbook.SaveAs(stream);
+        workbook.Write(stream, leaveOpen: true);
         return stream.ToArray();
     }
 
     private static byte[] CreatePartOperationExcel((string ItemNumber, string OpNumber, string MisNumber, string MisRevision)[] operations)
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
-        var worksheet = workbook.Worksheets.Add("Sheet1");
+        var worksheet = workbook.CreateSheet("Sheet1");
-        worksheet.Cell(1, 1).Value = "Item Number";
+        var header = worksheet.CreateRow(0);
-        worksheet.Cell(1, 2).Value = "Operation Number";
+        header.CreateCell(0).SetCellValue("Item Number");
-        worksheet.Cell(1, 3).Value = "MIS Number";
+        header.CreateCell(1).SetCellValue("Operation Number");
-        worksheet.Cell(1, 4).Value = "MIS Revision";
+        header.CreateCell(2).SetCellValue("MIS Number");
+        header.CreateCell(3).SetCellValue("MIS Revision");
+
         for (var i = 0; i < operations.Length; i++)
         {
-            worksheet.Cell(i + 2, 1).Value = operations[i].ItemNumber;
+            var row = worksheet.CreateRow(i + 1);
-            worksheet.Cell(i + 2, 2).Value = operations[i].OpNumber;
+            row.CreateCell(0).SetCellValue(operations[i].ItemNumber);
-            worksheet.Cell(i + 2, 3).Value = operations[i].MisNumber;
+            row.CreateCell(1).SetCellValue(operations[i].OpNumber);
-            worksheet.Cell(i + 2, 4).Value = operations[i].MisRevision;
+            row.CreateCell(2).SetCellValue(operations[i].MisNumber);
+            row.CreateCell(3).SetCellValue(operations[i].MisRevision);
         }
+
         using var stream = new MemoryStream();
-        workbook.SaveAs(stream);
+        workbook.Write(stream, leaveOpen: true);
         return stream.ToArray();
     }
 }

NEW/tests/JdeScoping.ExcelIO.Tests/Templates/ExcelTemplateServiceTests.cs

@@ -1,5 +1,5 @@
-using ClosedXML.Excel;
 using JdeScoping.ExcelIO.Templates;
+using JdeScoping.ExcelIO.Tests.Fixtures;
 using Shouldly;
 using Xunit;
 
@@ -12,30 +12,24 @@ public class ExcelTemplateServiceTests
     [Fact]
     public void GenerateSingleColumn_CreatesValidExcel()
     {
-        // Arrange
         var data = new[] { 12345L, 67890L };
 
-        // Act
         var result = _service.GenerateSingleColumn(data, "Work Order Number");
 
-        // Assert
         result.ShouldNotBeNull();
         result.Length.ShouldBeGreaterThan(0);
 
-        // Verify content
+        using var workbook = ExcelTestHelpers.OpenWorkbook(result);
-        using var stream = new MemoryStream(result);
+        var worksheet = workbook.GetSheetAt(0);
-        using var workbook = new XLWorkbook(stream);
-        var worksheet = workbook.Worksheet(1);
 
-        worksheet.Cell(1, 1).GetString().ShouldBe("Work Order Number");
+        ExcelTestHelpers.GetCellText(worksheet, 1, 1).ShouldBe("Work Order Number");
-        worksheet.Cell(2, 1).GetString().ShouldBe("12345");
+        ExcelTestHelpers.GetCellText(worksheet, 2, 1).ShouldBe("12345");
-        worksheet.Cell(3, 1).GetString().ShouldBe("67890");
+        ExcelTestHelpers.GetCellText(worksheet, 3, 1).ShouldBe("67890");
     }
 
     [Fact]
     public void GenerateMultiColumn_CreatesValidExcel()
     {
-        // Arrange
         var data = new[]
         {
             new object?[] { "ITEM-001", "Description 1" },
@@ -43,31 +37,25 @@ public class ExcelTemplateServiceTests
         };
         var headers = new[] { "Item Number", "Description" };
 
-        // Act
         var result = _service.GenerateMultiColumn(data, headers);
 
-        // Assert
         result.ShouldNotBeNull();
         result.Length.ShouldBeGreaterThan(0);
 
-        // Verify content
+        using var workbook = ExcelTestHelpers.OpenWorkbook(result);
-        using var stream = new MemoryStream(result);
+        var worksheet = workbook.GetSheetAt(0);
-        using var workbook = new XLWorkbook(stream);
-        var worksheet = workbook.Worksheet(1);
 
-        worksheet.Cell(1, 1).GetString().ShouldBe("Item Number");
+        ExcelTestHelpers.GetCellText(worksheet, 1, 1).ShouldBe("Item Number");
-        worksheet.Cell(1, 2).GetString().ShouldBe("Description");
+        ExcelTestHelpers.GetCellText(worksheet, 1, 2).ShouldBe("Description");
-        worksheet.Cell(2, 1).GetString().ShouldBe("ITEM-001");
+        ExcelTestHelpers.GetCellText(worksheet, 2, 1).ShouldBe("ITEM-001");
-        worksheet.Cell(2, 2).GetString().ShouldBe("Description 1");
+        ExcelTestHelpers.GetCellText(worksheet, 2, 2).ShouldBe("Description 1");
     }
 
     [Fact]
     public void GenerateSingleColumn_HandlesEmptyData()
     {
-        // Act
         var result = _service.GenerateSingleColumn(Array.Empty<string>(), "Header");
 
-        // Assert
         result.ShouldNotBeNull();
         result.Length.ShouldBeGreaterThan(0);
     }
@@ -75,22 +63,18 @@ public class ExcelTemplateServiceTests
     [Fact]
     public void GenerateMultiColumn_HandlesNullValues()
     {
-        // Arrange
         var data = new[]
         {
             new object?[] { "ITEM-001", null }
         };
         var headers = new[] { "Item", "Value" };
 
-        // Act
         var result = _service.GenerateMultiColumn(data, headers);
 
-        // Assert
         result.ShouldNotBeNull();
-        using var stream = new MemoryStream(result);
+        using var workbook = ExcelTestHelpers.OpenWorkbook(result);
-        using var workbook = new XLWorkbook(stream);
+        var worksheet = workbook.GetSheetAt(0);
-        var worksheet = workbook.Worksheet(1);
 
-        worksheet.Cell(2, 2).GetString().ShouldBe(string.Empty);
+        ExcelTestHelpers.GetCellText(worksheet, 2, 2).ShouldBe(string.Empty);
     }
 }

NEW/tests/JdeScoping.ExcelIO.Tests/WorksheetProtectorTests.cs

@@ -1,5 +1,6 @@
-using ClosedXML.Excel;
 using JdeScoping.ExcelIO.Formatting;
+using JdeScoping.ExcelIO.Tests.Fixtures;
+using NPOI.XSSF.UserModel;
 using Shouldly;
 using Xunit;
 
@@ -10,71 +11,68 @@ public class WorksheetProtectorTests
     [Fact]
     public void ApplyProtection_ProtectsWorksheet()
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
-        var worksheet = workbook.Worksheets.Add("Test");
+        var worksheet = (XSSFSheet)workbook.CreateSheet("Test");
 
         WorksheetProtector.ApplyProtection(worksheet, "TestPassword");
 
-        worksheet.Protection.IsProtected.ShouldBeTrue();
+        worksheet.IsSheetLocked.ShouldBeTrue();
     }
 
     [Fact]
     public void ApplyProtection_AllowsSpecifiedOperations()
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
-        var worksheet = workbook.Worksheets.Add("Test");
+        var worksheet = (XSSFSheet)workbook.CreateSheet("Test");
 
         WorksheetProtector.ApplyProtection(worksheet, "TestPassword");
 
-        // Check that specified operations are allowed
+        worksheet.IsDeleteColumnsLocked.ShouldBeFalse();
-        worksheet.Protection.AllowedElements.HasFlag(XLSheetProtectionElements.DeleteColumns).ShouldBeTrue();
+        worksheet.IsDeleteRowsLocked.ShouldBeFalse();
-        worksheet.Protection.AllowedElements.HasFlag(XLSheetProtectionElements.DeleteRows).ShouldBeTrue();
+        worksheet.IsAutoFilterLocked.ShouldBeFalse();
-        worksheet.Protection.AllowedElements.HasFlag(XLSheetProtectionElements.AutoFilter).ShouldBeTrue();
+        worksheet.IsFormatCellsLocked.ShouldBeFalse();
-        worksheet.Protection.AllowedElements.HasFlag(XLSheetProtectionElements.FormatCells).ShouldBeTrue();
+        worksheet.IsFormatColumnsLocked.ShouldBeFalse();
-        worksheet.Protection.AllowedElements.HasFlag(XLSheetProtectionElements.FormatColumns).ShouldBeTrue();
+        worksheet.IsFormatRowsLocked.ShouldBeFalse();
-        worksheet.Protection.AllowedElements.HasFlag(XLSheetProtectionElements.FormatRows).ShouldBeTrue();
+        worksheet.IsSelectLockedCellsLocked.ShouldBeFalse();
-        worksheet.Protection.AllowedElements.HasFlag(XLSheetProtectionElements.SelectLockedCells).ShouldBeTrue();
+        worksheet.IsSelectUnlockedCellsLocked.ShouldBeFalse();
-        worksheet.Protection.AllowedElements.HasFlag(XLSheetProtectionElements.SelectUnlockedCells).ShouldBeTrue();
+        worksheet.IsObjectsLocked.ShouldBeFalse();
-        worksheet.Protection.AllowedElements.HasFlag(XLSheetProtectionElements.EditObjects).ShouldBeTrue();
+        worksheet.IsSortLocked.ShouldBeFalse();
-        worksheet.Protection.AllowedElements.HasFlag(XLSheetProtectionElements.Sort).ShouldBeTrue();
     }
 
     [Fact]
     public void ApplyProtection_AllowsDeleteRows()
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
-        var worksheet = workbook.Worksheets.Add("Test");
+        var worksheet = (XSSFSheet)workbook.CreateSheet("Test");
 
         WorksheetProtector.ApplyProtection(worksheet, "TestPassword");
 
-        // DeleteRows should be allowed
+        worksheet.IsDeleteRowsLocked.ShouldBeFalse();
-        worksheet.Protection.AllowedElements.HasFlag(XLSheetProtectionElements.DeleteRows).ShouldBeTrue();
     }
 
     [Fact]
     public void ApplyCriteriaProtection_ProtectsWorksheet()
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
-        var worksheet = workbook.Worksheets.Add("Test");
+        var worksheet = (XSSFSheet)workbook.CreateSheet("Test");
 
         WorksheetProtector.ApplyCriteriaProtection(worksheet, "CriteriaPassword");
 
-        worksheet.Protection.IsProtected.ShouldBeTrue();
+        worksheet.IsSheetLocked.ShouldBeTrue();
     }
 
     [Fact]
     public void UnlockExtensionArea_UnlocksSpecifiedRange()
     {
-        using var workbook = new XLWorkbook();
+        using var workbook = new XSSFWorkbook();
-        var worksheet = workbook.Worksheets.Add("Test");
+        var worksheet = (XSSFSheet)workbook.CreateSheet("Test");
-
-        // First, set some cells to locked (default)
-        worksheet.Range(1, 1, 10, 5).Style.Protection.Locked = true;
 
         WorksheetProtector.UnlockExtensionArea(worksheet, 10, 5, 100, 100);
 
-        // Extension area should be unlocked
+        var extensionStyle = worksheet.GetColumnStyle(5);
-        var extensionCell = worksheet.Cell(1, 6);
+        extensionStyle.IsLocked.ShouldBeFalse();
-        extensionCell.Style.Protection.Locked.ShouldBeFalse();
+
+        var extensionCell = ExcelTestHelpers.GetCell(worksheet, 1, 6)!;
+        extensionCell.CellStyle.IsLocked.ShouldBeFalse();
     }
 }