fix(grid): purge deleted rows and sanitize kNullSentinel after Save in staging buffer (Closes #884)

After a successful Save the new baseline was built from effectiveRows, which
kept rows marked for deletion and leaked the raw NULL sentinel into cells.

Add DataGridStagingBuffer.committedRows (deleted baseline rows dropped, staged
NULLs mapped to 'NULL') and use it as the post-save baseline in the
Postgres/MySQL/SQLite table views and SQL workspaces. effectiveRows keeps row
indices aligned with the grid for struck-through rendering but now also maps
the sentinel to 'NULL'.

Author: ZhuchkaTriplesix

lib/features/mysql/mysql_sql_workspace.dart

@@ -538,7 +538,7 @@ class _MysqlSqlWorkspaceState extends material.State<MysqlSqlWorkspace> {
       await _refreshTxStatus();
 
       if (!mounted) return;
-      final newRows = session.stagingBuffer!.effectiveRows;
+      final newRows = session.stagingBuffer!.committedRows;
       session.stagingBuffer?.dispose();
       setState(() {
         session.rows = newRows;

lib/features/mysql/mysql_table_view.dart

@@ -575,7 +575,7 @@ class _MysqlTableViewState extends material.State<MysqlTableView> {
     );
     if (!mounted) return;
     if (outcome.isApplied) {
-      final newRows = buffer.effectiveRows;
+      final newRows = buffer.committedRows;
       buffer.dispose();
       setState(() {
         _rows = newRows;

lib/features/postgresql/postgres_sql_workspace.dart

@@ -666,7 +666,7 @@ class _PostgresSqlWorkspaceState extends material.State<PostgresSqlWorkspace> {
       );
 
       if (!mounted) return;
-      final newRows = session.stagingBuffer!.effectiveRows;
+      final newRows = session.stagingBuffer!.committedRows;
       session.stagingBuffer?.dispose();
       setState(() {
         session.rows = newRows;

lib/features/postgresql/postgres_table_view.dart

@@ -596,7 +596,7 @@ class _PostgresTableViewState extends material.State<PostgresTableView> {
     );
     if (!mounted) return;
     if (outcome.isApplied) {
-      final newRows = buffer.effectiveRows;
+      final newRows = buffer.committedRows;
       buffer.dispose();
       setState(() {
         _rows = newRows;

lib/features/sqlite/sqlite_sql_workspace.dart

@@ -504,7 +504,7 @@ class _SqliteSqlWorkspaceState extends material.State<SqliteSqlWorkspace> {
       await _refreshTxStatus();
 
       if (!mounted) return;
-      final newRows = session.stagingBuffer!.effectiveRows;
+      final newRows = session.stagingBuffer!.committedRows;
       session.stagingBuffer?.dispose();
       setState(() {
         session.rows = newRows;

lib/features/sqlite/sqlite_table_view.dart

@@ -398,7 +398,7 @@ class _SqliteTableViewState extends material.State<SqliteTableView> {
     );
     if (!mounted) return;
     if (outcome.isApplied) {
-      final newRows = buffer.effectiveRows;
+      final newRows = buffer.committedRows;
       buffer.dispose();
       setState(() {
         _rows = newRows;

lib/features/workspace/data_grid_staging_buffer.dart

@@ -98,7 +98,8 @@ class DataGridStagingBuffer extends ChangeNotifier {
       return '';
     }
     final insertIdx = row - _originalRows.length;
-    if (insertIdx < _insertedRows.length && col < _insertedRows[insertIdx].length) {
+    if (insertIdx < _insertedRows.length &&
+        col < _insertedRows[insertIdx].length) {
       final ins = _insertedRows[insertIdx][col];
       return ins == TableMutationEngine.kNullSentinel ? 'NULL' : ins;
     }
@@ -118,7 +119,8 @@ class DataGridStagingBuffer extends ChangeNotifier {
       return false;
     }
     final insertIdx = row - _originalRows.length;
-    if (insertIdx < _insertedRows.length && col < _insertedRows[insertIdx].length) {
+    if (insertIdx < _insertedRows.length &&
+        col < _insertedRows[insertIdx].length) {
       final ins = _insertedRows[insertIdx][col];
       return ins == 'NULL' || ins == TableMutationEngine.kNullSentinel;
     }
@@ -127,7 +129,10 @@ class DataGridStagingBuffer extends ChangeNotifier {
 
   /// Returns original baseline cell value, or null if row is inserted.
   String? getOriginalCellValue(int row, int col) {
-    if (row >= 0 && row < _originalRows.length && col >= 0 && col < _originalRows[row].length) {
+    if (row >= 0 &&
+        row < _originalRows.length &&
+        col >= 0 &&
+        col < _originalRows[row].length) {
       return _originalRows[row][col];
     }
     return null;
@@ -169,7 +174,8 @@ class DataGridStagingBuffer extends ChangeNotifier {
     if (row < 0 || col < 0) return;
 
     if (row < _originalRows.length) {
-      final orig = col < _originalRows[row].length ? _originalRows[row][col] : '';
+      final orig =
+          col < _originalRows[row].length ? _originalRows[row][col] : '';
       if (value == orig) {
         if (_modifiedCells.containsKey(row)) {
           _modifiedCells[row]!.remove(col);
@@ -281,7 +287,8 @@ class DataGridStagingBuffer extends ChangeNotifier {
   /// Read-only snapshot of modified cells mapping.
   Map<int, Map<int, String>> get modifiedCells =>
       Map<int, Map<int, String>>.unmodifiable(
-        _modifiedCells.map((k, v) => MapEntry(k, Map<int, String>.unmodifiable(v))),
+        _modifiedCells
+            .map((k, v) => MapEntry(k, Map<int, String>.unmodifiable(v))),
       );
 
   /// Read-only list of newly inserted rows.
@@ -317,6 +324,10 @@ class DataGridStagingBuffer extends ChangeNotifier {
 
   /// Returns the full list of effective rows (original with modifications applied + inserted rows).
   ///
+  /// Row indices stay aligned with the grid (rows marked for deletion are still
+  /// present so they can render struck through); use [committedRows] for the
+  /// baseline after a successful save. Staged NULLs are shown as `'NULL'`.
+  ///
   /// Optimized for zero allocations when [isDirty] is false, and caches
   /// the effective row list to prevent breaking widget memoization.
   List<List<String>> get effectiveRows {
@@ -326,14 +337,27 @@ class DataGridStagingBuffer extends ChangeNotifier {
     if (_cachedEffectiveRows != null) {
       return _cachedEffectiveRows!;
     }
+    _cachedEffectiveRows = List.unmodifiable(_buildRows(includeDeleted: true));
+    return _cachedEffectiveRows!;
+  }
+
+  /// Rows as they exist in the database once the staged changes are applied:
+  /// deleted baseline rows are dropped and staged NULLs become `'NULL'`.
+  ///
+  /// Use this as the new baseline after a successful save.
+  List<List<String>> get committedRows =>
+      List.unmodifiable(_buildRows(includeDeleted: false));
+
+  List<List<String>> _buildRows({required bool includeDeleted}) {
     final result = <List<String>>[];
     for (var r = 0; r < _originalRows.length; r++) {
+      if (!includeDeleted && _deletedRowIndices.contains(r)) continue;
       final mods = _modifiedCells[r];
       if (mods != null) {
         final row = List<String>.from(_originalRows[r]);
         for (final entry in mods.entries) {
           if (entry.key < row.length) {
-            row[entry.key] = entry.value;
+            row[entry.key] = _sanitizeNull(entry.value);
           }
         }
         result.add(row);
@@ -342,12 +366,18 @@ class DataGridStagingBuffer extends ChangeNotifier {
       }
     }
     for (final ins in _insertedRows) {
-      result.add(ins);
+      result.add(
+        ins.any((v) => v == TableMutationEngine.kNullSentinel)
+            ? ins.map(_sanitizeNull).toList()
+            : ins,
+      );
     }
-    _cachedEffectiveRows = List.unmodifiable(result);
-    return _cachedEffectiveRows!;
+    return result;
   }
 
+  static String _sanitizeNull(String value) =>
+      value == TableMutationEngine.kNullSentinel ? 'NULL' : value;
+
   @override
   void dispose() {
     UnsavedWorkRegistry.instance.unregister(this);
@@ -358,4 +388,3 @@ class DataGridStagingBuffer extends ChangeNotifier {
     super.dispose();
   }
 }
-

test/features/workspace/data_grid_staging_buffer_test.dart

@@ -121,7 +121,45 @@ void main() {
       expect(eff[3], ['4', 'David', 'david@test.com']);
     });
 
-    test('effectiveRows returns identical reference when clean and caches unmodifiable list when dirty', () {
+    test(
+        'effectiveRows keeps deleted rows aligned and maps staged NULL to NULL',
+        () {
+      buffer.toggleDeleteRow(1);
+      buffer.setCellNull(0, 2);
+      buffer.addRow(['4', TableMutationEngine.kNullSentinel, 'd@test.com']);
+
+      final eff = buffer.effectiveRows;
+      expect(eff.length, 4);
+      expect(eff[0], ['1', 'Alice', 'NULL']);
+      expect(eff[1], ['2', 'Bob', 'bob@test.com']);
+      expect(eff[3], ['4', 'NULL', 'd@test.com']);
+      expect(
+        eff.expand((r) => r).any((v) => v.contains('\u0000')),
+        isFalse,
+      );
+    });
+
+    test('committedRows drops deleted rows and sanitizes NULL sentinels', () {
+      buffer.toggleDeleteRow(1);
+      buffer.setCell(1, 1, 'ignored'); // edit on a row that is also deleted
+      buffer.setCellNull(0, 2);
+      buffer.addRow(['4', TableMutationEngine.kNullSentinel, 'd@test.com']);
+
+      final committed = buffer.committedRows;
+      expect(committed, [
+        ['1', 'Alice', 'NULL'],
+        ['3', 'Charlie', 'charlie@test.com'],
+        ['4', 'NULL', 'd@test.com'],
+      ]);
+    });
+
+    test('committedRows equals baseline when clean', () {
+      expect(buffer.committedRows, buffer.originalRows);
+    });
+
+    test(
+        'effectiveRows returns identical reference when clean and caches unmodifiable list when dirty',
+        () {
       // When clean, effectiveRows returns the exact baseline instance (zero allocation)
       final cleanRows1 = buffer.effectiveRows;
       final cleanRows2 = buffer.effectiveRows;
@@ -160,7 +198,9 @@ void main() {
       expect(buffer.getCellValue(0, 1), 'NULL');
     });
 
-    test('generateMutationPlan builds correct DML statements from staged modifications', () {
+    test(
+        'generateMutationPlan builds correct DML statements from staged modifications',
+        () {
       buffer.setCell(0, 1, 'Alice Updated');
       buffer.addRow(['4', 'Diana', 'diana@test.com']);
       buffer.toggleDeleteRow(2);
@@ -174,14 +214,19 @@ void main() {
 
       expect(plan.statementCount, 3);
       expect(plan.statements[0].type, MutationType.update);
-      expect(plan.statements[0].sql, 'UPDATE "public"."users" SET "name" = \'Alice Updated\' WHERE "id" = 1');
+      expect(plan.statements[0].sql,
+          'UPDATE "public"."users" SET "name" = \'Alice Updated\' WHERE "id" = 1');
       expect(plan.statements[1].type, MutationType.insert);
-      expect(plan.statements[1].sql, 'INSERT INTO "public"."users" ("id", "name", "email") VALUES (4, \'Diana\', \'diana@test.com\')');
+      expect(plan.statements[1].sql,
+          'INSERT INTO "public"."users" ("id", "name", "email") VALUES (4, \'Diana\', \'diana@test.com\')');
       expect(plan.statements[2].type, MutationType.delete);
-      expect(plan.statements[2].sql, 'DELETE FROM "public"."users" WHERE "id" = 3');
+      expect(plan.statements[2].sql,
+          'DELETE FROM "public"."users" WHERE "id" = 3');
     });
 
-    test('dispose clears internal collections and prevents further listener notifications', () {
+    test(
+        'dispose clears internal collections and prevents further listener notifications',
+        () {
       buffer.setCell(0, 1, 'Alice Modified');
       buffer.addRow(['4', 'Diana', 'diana@test.com']);
       buffer.toggleDeleteRow(2);

test/features/workspace/table_view_staging_test.dart

@@ -347,6 +347,46 @@ void main() {
       expect(executed, isFalse);
     });
 
+    testWidgets(
+        'applied save yields a baseline without deleted rows or NULL sentinels',
+        (tester) async {
+      await tester.pumpWidget(
+        ShadcnApp(
+          theme: AppTheme.dark,
+          home: const material.Scaffold(body: material.SizedBox()),
+        ),
+      );
+      final ctx = tester.element(find.byType(material.Scaffold));
+      final buffer = DataGridStagingBuffer(
+        columns: ['id', 'name'],
+        rows: [
+          ['1', 'Ada'],
+          ['2', 'Grace'],
+        ],
+      );
+      buffer.toggleDeleteRow(1);
+      buffer.setCellNull(0, 1);
+      addTearDown(buffer.dispose);
+
+      final future = applyTableViewStagedChanges(
+        context: ctx,
+        buffer: buffer,
+        dialect: SqlDialect.postgres,
+        tableName: 'users',
+        schema: 'public',
+        primaryKeys: ['id'],
+        execute: (_) async {},
+      );
+      await tester.pumpAndSettle();
+      await tester.tap(find.text('Apply Changes'));
+      final outcome = await future;
+
+      expect(outcome.isApplied, isTrue);
+      expect(buffer.committedRows, [
+        ['1', 'NULL'],
+      ]);
+    });
+
     testWidgets('0-row DML is failed and the staging buffer stays dirty',
         (tester) async {
       await tester.pumpWidget(