@affino/datagrid-vue 0.3.30 → 0.3.32

package/dist/app/useDataGridAppInteractionController.js

@@ -2,6 +2,52 @@ import { computed, nextTick, ref } from "vue";
 import { invokeDataGridCellInteraction, resolveDataGridCellKeyboardAction, toggleDataGridCellValue, } from "@affino/datagrid-core";
 import { buildDataGridFillMatrix, canToggleDataGridFillBehavior, resolveDataGridDefaultFillBehavior, } from "../composables/dataGridFillBehavior";
 import { useDataGridAxisAutoScrollDelta, useDataGridCellNavigation, useDataGridCellPointerDownRouter, useDataGridDragPointerSelection, useDataGridFillHandleStart, useDataGridFillSelectionLifecycle, useDataGridHistoryActionRunner, useDataGridKeyboardCommandRouter, useDataGridPointerCellCoordResolver, useDataGridPointerAutoScroll, useDataGridPointerPreviewRouter, useDataGridRangeMoveLifecycle, useDataGridRangeMoveStart, useDataGridRangeMutationEngine, } from "../advanced";
+import { resolveMissingRowIndexInRange } from "./useDataGridAppClipboard";
+function getFillRangeStart(range) {
+    const candidate = range;
+    return Number.isFinite(candidate.startRow)
+        ? Math.max(0, Math.trunc(Number(candidate.startRow)))
+        : Math.max(0, Math.trunc(Number(candidate.start ?? 0)));
+}
+function getFillRangeEnd(range) {
+    const candidate = range;
+    return Number.isFinite(candidate.endRow)
+        ? Math.max(0, Math.trunc(Number(candidate.endRow)))
+        : Math.max(0, Math.trunc(Number(candidate.end ?? getFillRangeStart(range))));
+}
+function formatServerFillAffectedRange(range, fallbackColumns) {
+    const start = getFillRangeStart(range);
+    const end = getFillRangeEnd(range);
+    const startColumn = Number.isFinite(range.startColumn)
+        ? range.startColumn
+        : fallbackColumns.startColumn;
+    const endColumn = Number.isFinite(range.endColumn)
+        ? range.endColumn
+        : fallbackColumns.endColumn;
+    return `${start}..${end} x ${startColumn}..${endColumn}`;
+}
+function normalizeServerFillInvalidationRange(range) {
+    if (!range) {
+        return null;
+    }
+    const candidate = range;
+    const rawStart = Number.isFinite(candidate.startRow)
+        ? candidate.startRow
+        : candidate.start;
+    const rawEnd = Number.isFinite(candidate.endRow)
+        ? candidate.endRow
+        : candidate.end;
+    const start = Number(rawStart);
+    const end = Number(rawEnd ?? rawStart);
+    if (!Number.isFinite(start) || !Number.isFinite(end)) {
+        return null;
+    }
+    return {
+        start: Math.max(0, Math.trunc(start)),
+        end: Math.max(Math.max(0, Math.trunc(start)), Math.trunc(end)),
+    };
+}
+const ROW_SELECTION_COLUMN_KEY = "__datagrid_row_selection__";
 import { useDataGridAppFill, } from "./useDataGridAppFill";
 import { restoreDataGridFocus } from "./dataGridFocusRestore";
 const DRAG_SELECTION_POINTER_THRESHOLD_PX = 4;
@@ -30,10 +76,53 @@ export function useDataGridAppInteractionController(options) {
         }
         return options.readCell(row, columnKey).trim().length > 0;
     };
+    const isServerBackedRowModel = () => {
+        const controllerRowModel = options.runtimeRowModel;
+        const runtimeRowModel = options.runtime.rowModel;
+        return controllerRowModel?.dataSource != null || runtimeRowModel?.dataSource != null;
+    };
+    const resolveSelectableColumnIndexes = () => {
+        return options.visibleColumns.value
+            .map((column, columnIndex) => ({ column, columnIndex }))
+            .filter(({ column }) => column.key !== ROW_SELECTION_COLUMN_KEY)
+            .map(({ columnIndex }) => columnIndex);
+    };
     const resolveDirectionalSemanticJumpTarget = (current, direction, event) => {
         if (!(event.ctrlKey || event.metaKey) || event.altKey) {
             return undefined;
         }
+        if (event.shiftKey && isServerBackedRowModel()) {
+            const lastRowIndex = Math.max(0, options.totalRows.value - 1);
+            const selectableColumnIndexes = resolveSelectableColumnIndexes();
+            const firstSelectableColumnIndex = selectableColumnIndexes[0] ?? 0;
+            const lastSelectableColumnIndex = selectableColumnIndexes[selectableColumnIndexes.length - 1] ?? Math.max(0, options.visibleColumns.value.length - 1);
+            switch (direction) {
+                case "down":
+                    return options.normalizeCellCoord({
+                        ...current,
+                        rowIndex: lastRowIndex,
+                        rowId: getBodyRowAtIndex(lastRowIndex)?.rowId ?? null,
+                    }) ?? current;
+                case "up":
+                    return options.normalizeCellCoord({
+                        ...current,
+                        rowIndex: 0,
+                        rowId: getBodyRowAtIndex(0)?.rowId ?? null,
+                    }) ?? current;
+                case "right":
+                    return options.normalizeCellCoord({
+                        ...current,
+                        columnIndex: lastSelectableColumnIndex,
+                        rowId: getBodyRowAtIndex(current.rowIndex)?.rowId ?? null,
+                    }) ?? current;
+                case "left":
+                    return options.normalizeCellCoord({
+                        ...current,
+                        columnIndex: firstSelectableColumnIndex,
+                        rowId: getBodyRowAtIndex(current.rowIndex)?.rowId ?? null,
+                    }) ?? current;
+            }
+        }
         const currentCellIsNonEmpty = isSemanticNavigationCellNonEmpty(current.rowIndex, current.columnIndex);
         if (currentCellIsNonEmpty == null) {
             return undefined;
@@ -174,7 +263,7 @@ export function useDataGridAppInteractionController(options) {
         }
         return event.key.length === 1;
     };
-    const applyDirectCellEdit = (row, rowIndex, columnIndex, columnKey, nextValue, label) => {
+    const applyDirectCellEdit = async (row, rowIndex, columnIndex, columnKey, nextValue, label) => {
         if (row.kind === "group" || row.rowId == null) {
             return false;
         }
@@ -183,7 +272,7 @@ export function useDataGridAppInteractionController(options) {
         if (resolvedRow.kind === "group" || resolvedRow.rowId == null) {
             return false;
         }
-        options.runtime.api.rows.applyEdits([
+        await options.runtime.api.rows.applyEdits([
             {
                 rowId: resolvedRow.rowId,
                 data: {
@@ -397,12 +486,12 @@ export function useDataGridAppInteractionController(options) {
         setSelectionFromRange: (range, activePosition) => {
             applySelectionRangeWithActivePosition(range, activePosition);
         },
-        recordIntent: (descriptor, beforeSnapshot) => {
+        recordIntent: (descriptor, beforeSnapshot, afterSnapshotOverride) => {
             void options.recordIntentTransaction({
                 intent: descriptor.intent,
                 label: descriptor.label,
                 affectedRange: descriptor.affectedRange ?? null,
-            }, beforeSnapshot);
+            }, beforeSnapshot, afterSnapshotOverride);
         },
         setLastAction: () => undefined,
     });
@@ -416,6 +505,179 @@ export function useDataGridAppInteractionController(options) {
         resolveSelectionRange: options.resolveSelectionRange,
         rangesEqual: options.rangesEqual,
         buildFillMatrixFromRange: options.buildFillMatrixFromRange,
+        shouldUseServerFill: (_baseRange, previewRange) => {
+            const controllerRowModel = options.runtimeRowModel;
+            const runtimeRowModelDataSource = controllerRowModel?.dataSource;
+            const runtimeRowModelFromRuntime = options.runtime.rowModel?.dataSource;
+            options.reportFillPlumbingState?.("controller_runtimeRowModel_exists", controllerRowModel != null);
+            options.reportFillPlumbingState?.("controller_runtimeRowModel_dataSource_exists", runtimeRowModelDataSource != null);
+            options.reportFillPlumbingState?.("controller_runtimeRowModel_dataSource_keys", Object.keys(runtimeRowModelDataSource ?? {}).length > 0);
+            options.reportFillPlumbingDetail?.("controller_runtimeRowModel_dataSource_keys", Object.keys(runtimeRowModelDataSource ?? {}).join(","));
+            options.reportFillPlumbingState?.("controller_runtimeRowModel_commit_type", typeof runtimeRowModelDataSource?.commitFillOperation === "function");
+            options.reportFillPlumbingState?.("controller_runtime_rowModel_keys", Object.keys(runtimeRowModelFromRuntime ?? {}).length > 0);
+            options.reportFillPlumbingDetail?.("controller_runtime_rowModel_keys", Object.keys(runtimeRowModelFromRuntime ?? {}).join(","));
+            options.reportFillPlumbingState?.("controller_runtime_rowModel_commit_type", typeof runtimeRowModelFromRuntime?.commitFillOperation === "function");
+            const dataSource = runtimeRowModelDataSource ?? runtimeRowModelFromRuntime;
+            options.reportFillPlumbingState?.("commitFillOperation_available", typeof dataSource?.commitFillOperation === "function");
+            options.reportFillPlumbingState?.("server_fill_dispatch_attempted", true);
+            if (typeof dataSource?.commitFillOperation !== "function") {
+                return false;
+            }
+            const rowCount = Math.max(0, previewRange.endRow - previewRange.startRow + 1);
+            return rowCount >= 256;
+        },
+        commitServerFill: async ({ baseRange, previewRange, behavior }) => {
+            const runtimeRowModelDataSource = options.runtimeRowModel?.dataSource;
+            const runtimeRowModelFallback = options.runtime.rowModel?.dataSource;
+            const dataSource = runtimeRowModelDataSource ?? runtimeRowModelFallback;
+            if (!dataSource?.commitFillOperation) {
+                options.reportFillWarning?.("server fill execution not implemented yet");
+                return null;
+            }
+            const snapshot = options.runtime.api.rows.getSnapshot();
+            const operationId = `fill-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            const sourceMatrix = options.buildFillMatrixFromRange(baseRange);
+            const fillMatrix = buildDataGridFillMatrix({
+                baseRange,
+                previewRange,
+                sourceMatrix,
+                behavior,
+            });
+            const materializedTargetRowIds = [];
+            const optimisticUpdatesByRowId = new Map();
+            let optimisticFillCandidate = options.captureRowsSnapshotForRowIds != null;
+            if (optimisticFillCandidate) {
+                for (let rowIndex = previewRange.startRow; rowIndex <= previewRange.endRow; rowIndex += 1) {
+                    const targetRow = getBodyRowAtIndex(rowIndex);
+                    const isMaterialized = options.isRowMaterializedAtIndex
+                        ? options.isRowMaterializedAtIndex(rowIndex)
+                        : !!targetRow && targetRow.__placeholder !== true;
+                    if (!isMaterialized || !targetRow || targetRow.kind === "group" || targetRow.rowId == null || targetRow.__placeholder === true) {
+                        optimisticFillCandidate = false;
+                        break;
+                    }
+                    materializedTargetRowIds.push(targetRow.rowId);
+                    for (let columnIndex = previewRange.startColumn; columnIndex <= previewRange.endColumn; columnIndex += 1) {
+                        const columnKey = options.visibleColumns.value[columnIndex]?.key;
+                        if (!columnKey || columnKey === ROW_SELECTION_COLUMN_KEY) {
+                            continue;
+                        }
+                        const rowOffset = rowIndex - previewRange.startRow;
+                        const columnOffset = columnIndex - previewRange.startColumn;
+                        const nextValue = fillMatrix[rowOffset]?.[columnOffset] ?? "";
+                        const current = optimisticUpdatesByRowId.get(targetRow.rowId) ?? {};
+                        current[columnKey] = nextValue;
+                        optimisticUpdatesByRowId.set(targetRow.rowId, current);
+                    }
+                }
+            }
+            let optimisticRollbackUpdates = null;
+            if (optimisticFillCandidate && materializedTargetRowIds.length > 0 && optimisticUpdatesByRowId.size > 0) {
+                const baselineSnapshot = options.captureRowsSnapshotForRowIds?.(materializedTargetRowIds);
+                const baselineRows = baselineSnapshot?.rows ?? [];
+                if (baselineRows.length === materializedTargetRowIds.length) {
+                    const baselineByRowId = new Map();
+                    for (const entry of baselineRows) {
+                        baselineByRowId.set(entry.rowId, entry.row);
+                    }
+                    optimisticRollbackUpdates = materializedTargetRowIds.flatMap(rowId => {
+                        const row = baselineByRowId.get(rowId);
+                        return row ? [{ rowId, data: row }] : [];
+                    });
+                    if (optimisticRollbackUpdates.length > 0) {
+                        options.reportFillPlumbingState?.("server_fill_optimistic_applied", true);
+                        await Promise.resolve(options.runtime.api.rows.applyEdits(Array.from(optimisticUpdatesByRowId.entries()).map(([rowId, data]) => ({
+                            rowId,
+                            data: data,
+                        }))));
+                    }
+                    else {
+                        optimisticRollbackUpdates = null;
+                    }
+                }
+                else {
+                    optimisticFillCandidate = false;
+                }
+            }
+            let result = null;
+            try {
+                result = await dataSource.commitFillOperation({
+                    operationId,
+                    projection: {
+                        sortModel: snapshot.sortModel ?? [],
+                        filterModel: snapshot.filterModel ?? null,
+                        groupBy: snapshot.groupBy ?? null,
+                        groupExpansion: snapshot.groupExpansion ?? { expandedByDefault: false, toggledGroupKeys: [] },
+                        treeData: null,
+                        pivot: null,
+                        pagination: snapshot.pagination ?? {
+                            enabled: false,
+                            pageSize: 0,
+                            currentPage: 0,
+                            pageCount: 0,
+                            totalRowCount: 0,
+                            startIndex: 0,
+                            endIndex: 0,
+                        },
+                    },
+                    sourceRange: baseRange,
+                    targetRange: previewRange,
+                    fillColumns: options.visibleColumns.value
+                        .slice(previewRange.startColumn, previewRange.endColumn + 1)
+                        .map(column => String(column.key)),
+                    referenceColumns: options.visibleColumns.value
+                        .slice(baseRange.startColumn, baseRange.endColumn + 1)
+                        .map(column => String(column.key)),
+                    mode: behavior,
+                    metadata: { origin: "double-click-fill", behaviorSource: "default" },
+                });
+                options.reportFillPlumbingState?.("commitFillOperation_called", true);
+                options.reportFillPlumbingState?.("server_fill_operationId", true);
+            }
+            catch {
+                if (optimisticRollbackUpdates && optimisticRollbackUpdates.length > 0) {
+                    await Promise.resolve(options.runtime.api.rows.applyEdits(optimisticRollbackUpdates));
+                }
+                options.reportFillWarning?.("server fill commit failed");
+                return null;
+            }
+            if (!result) {
+                if (optimisticRollbackUpdates && optimisticRollbackUpdates.length > 0) {
+                    await Promise.resolve(options.runtime.api.rows.applyEdits(optimisticRollbackUpdates));
+                }
+                options.reportFillWarning?.("server fill commit failed");
+                return null;
+            }
+            const invalidationRange = result.invalidation?.kind === "range" ? result.invalidation.range : previewRange;
+            const normalizedInvalidationRange = normalizeServerFillInvalidationRange(invalidationRange);
+            options.reportFillPlumbingDetail?.("server_fill_raw_invalidation", JSON.stringify(invalidationRange ?? null));
+            options.reportFillPlumbingDetail?.("server_fill_normalized_invalidation", normalizedInvalidationRange ? `${normalizedInvalidationRange.start}..${normalizedInvalidationRange.end}` : "none");
+            options.reportFillPlumbingDetail?.("server_fill_affected_range", formatServerFillAffectedRange(normalizedInvalidationRange ?? invalidationRange, previewRange));
+            const affectedRowCount = result.affectedRowCount ?? 0;
+            const warnings = result.warnings ?? [];
+            options.reportFillWarning?.(warnings[0] ?? (affectedRowCount > 0 ? "server fill committed" : "server fill no-op"));
+            options.reportFillPlumbingState?.("server_fill_affectedRowCount", true);
+            if (!options.refreshServerFillViewport) {
+                const runtimeRowModel = options.runtimeRowModel;
+                const runtimeRowModelFallback = options.runtime.rowModel;
+                const rowsApi = options.runtime.api.rows;
+                const invalidateTarget = runtimeRowModel?.invalidateRange ?? runtimeRowModelFallback?.invalidateRange;
+                if (normalizedInvalidationRange && typeof invalidateTarget === "function") {
+                    invalidateTarget(normalizedInvalidationRange);
+                    options.reportFillPlumbingState?.("server_fill_invalidation_applied", true);
+                }
+                await Promise.resolve(rowsApi.refresh?.());
+            }
+            return {
+                operationId: result.operationId,
+                revision: result.revision,
+                affectedRange: invalidationRange,
+                invalidation: result.invalidation ?? null,
+                affectedRowCount,
+                affectedCellCount: result.affectedCellCount ?? affectedRowCount,
+                warnings,
+            };
+        },
         applyClipboardEdits: options.applyClipboardEdits,
         isCellEditableAt: (rowIndex, columnIndex) => {
             const row = getBodyRowAtIndex(rowIndex);
@@ -429,9 +691,23 @@ export function useDataGridAppInteractionController(options) {
             lastAppliedFill.value = session;
             activeFillBehavior.value = session?.behavior ?? activeFillBehavior.value;
         },
+        setLastServerFillSession: session => {
+            if (!session) {
+                return;
+            }
+            options.recordServerFillTransaction?.({
+                intent: "fill",
+                label: "Server fill",
+                affectedRange: session.affectedRange ?? null,
+                operationId: session.operationId,
+                revision: session.revision,
+                mode: session.behavior,
+            });
+        },
+        syncServerFillViewport: options.refreshServerFillViewport,
         syncViewport: options.syncViewport,
     });
-    const applyCommittedFillRange = (baseRange, previewRange, behavior) => {
+    const applyCommittedFillRange = async (baseRange, previewRange, behavior) => {
         const resolveRemovedFillRange = (previousRange, nextRange) => {
             if (options.rangesEqual(previousRange, nextRange)) {
                 return null;
@@ -497,13 +773,13 @@ export function useDataGridAppInteractionController(options) {
                         previewRange,
                         sourceMatrix,
                     });
-                options.applyClipboardEdits(removedRange, [[""]], { recordHistory: false });
+                await options.applyClipboardEdits(removedRange, [[""]], { recordHistory: false });
                 if (options.rangesEqual(baseRange, previewRange)) {
                     options.applySelectionRange(baseRange);
                     lastAppliedFill.value = null;
                 }
                 else {
-                    options.applyClipboardEdits(previewRange, buildDataGridFillMatrix({
+                    await options.applyClipboardEdits(previewRange, buildDataGridFillMatrix({
                         baseRange,
                         previewRange,
                         sourceMatrix,
@@ -520,19 +796,20 @@ export function useDataGridAppInteractionController(options) {
                         }),
                     };
                 }
+                const afterSnapshot = captureRowsSnapshotForRanges([removedRange, previewRange]);
                 options.syncViewport();
                 void options.recordIntentTransaction({
                     intent: "fill",
-                    label: "Fill cells",
+                    label: "Fill edit",
                     affectedRange: previewRange,
-                }, beforeSnapshot);
+                }, beforeSnapshot, afterSnapshot);
                 if (behavior) {
                     activeFillBehavior.value = behavior;
                 }
                 return true;
             }
         }
-        const applied = applyFillRange(baseRange, previewRange, behavior);
+        const applied = await applyFillRange(baseRange, previewRange, behavior);
         if (applied && behavior) {
             activeFillBehavior.value = behavior;
         }
@@ -806,7 +1083,7 @@ export function useDataGridAppInteractionController(options) {
             if (!baseRange || !previewRange) {
                 return;
             }
-            applyCommittedFillRange(baseRange, previewRange);
+            void applyCommittedFillRange(baseRange, previewRange);
         },
         setFillDragging: value => {
             isFillDragging.value = value;
@@ -1065,9 +1342,14 @@ export function useDataGridAppInteractionController(options) {
         if (!range) {
             return false;
         }
+        const missingRowIndex = resolveMissingRowIndexInRange(getBodyRowAtIndex, range);
+        if (missingRowIndex != null) {
+            options.reportFillWarning?.("Selected range includes unloaded rows. Load rows or use server operation.");
+            return false;
+        }
         const beforeSnapshot = captureRowsSnapshotForRanges([range]);
         options.clearPendingClipboardOperation(false);
-        const applied = options.applyClipboardEdits(range, [[""]], { recordHistory: false });
+        const applied = await options.applyClipboardEdits(range, [[""]], { recordHistory: false });
         if (applied <= 0) {
             return false;
         }
@@ -1211,6 +1493,33 @@ export function useDataGridAppInteractionController(options) {
     const isNonEmptyFillReferenceValue = (row, columnKey) => {
         return options.readCell(row, columnKey).trim().length > 0;
     };
+    const buildFillProjectionContext = () => {
+        const getSnapshot = options.runtime.api.rows.getSnapshot;
+        if (typeof getSnapshot !== "function") {
+            return null;
+        }
+        const snapshot = getSnapshot();
+        if (!snapshot) {
+            return null;
+        }
+        return {
+            sortModel: snapshot.sortModel ?? [],
+            filterModel: snapshot.filterModel ?? null,
+            groupBy: snapshot.groupBy ?? null,
+            groupExpansion: snapshot.groupExpansion ?? { expandedByDefault: false, toggledGroupKeys: [] },
+            treeData: null,
+            pivot: null,
+            pagination: snapshot.pagination ?? {
+                enabled: false,
+                pageSize: 0,
+                currentPage: 0,
+                pageCount: 0,
+                totalRowCount: 0,
+                startIndex: 0,
+                endIndex: 0,
+            },
+        };
+    };
     const resolveReferenceColumnExtentEndRow = (baseRange, columnIndex) => {
         const columnKey = options.visibleColumns.value[columnIndex]?.key;
         if (!columnKey) {
@@ -1261,52 +1570,183 @@ export function useDataGridAppInteractionController(options) {
         }
         return evaluateDirection(baseRange.endColumn + 1, 1);
     };
+    const resolveServerAwareFillBoundary = async (baseRange) => {
+        if (!options.resolveFillBoundary) {
+            options.reportFillPlumbingState?.("interaction_controller_option", false);
+            return null;
+        }
+        options.reportFillPlumbingState?.("interaction_controller_option", true);
+        const fillColumns = [];
+        for (let columnIndex = baseRange.startColumn; columnIndex <= baseRange.endColumn; columnIndex += 1) {
+            const columnKey = options.visibleColumns.value[columnIndex]?.key;
+            if (columnKey) {
+                fillColumns.push(columnKey);
+            }
+        }
+        const leftReferenceColumns = [];
+        for (let columnIndex = baseRange.startColumn - 1; columnIndex >= 0; columnIndex -= 1) {
+            const columnKey = options.visibleColumns.value[columnIndex]?.key;
+            if (columnKey) {
+                leftReferenceColumns.push(columnKey);
+            }
+        }
+        const rightReferenceColumns = [];
+        for (let columnIndex = baseRange.endColumn + 1; columnIndex < options.visibleColumns.value.length; columnIndex += 1) {
+            const columnKey = options.visibleColumns.value[columnIndex]?.key;
+            if (columnKey) {
+                rightReferenceColumns.push(columnKey);
+            }
+        }
+        const projection = buildFillProjectionContext();
+        options.reportFillPlumbingState?.("double_click_fill_columns", fillColumns.length > 0);
+        options.reportFillPlumbingState?.("double_click_left_refs", leftReferenceColumns.length > 0);
+        options.reportFillPlumbingState?.("double_click_right_refs", rightReferenceColumns.length > 0);
+        options.reportFillPlumbingState?.("double_click_projection", projection != null);
+        if (!projection) {
+            return null;
+        }
+        const resolve = async (referenceColumns, direction) => {
+            if (referenceColumns.length === 0) {
+                options.reportFillPlumbingState?.(`double_click_resolve_${direction}_skipped_no_refs`, true);
+                return null;
+            }
+            options.reportFillPlumbingState?.(`double_click_resolve_${direction}_called`, true);
+            return options.resolveFillBoundary({
+                direction,
+                baseRange,
+                fillColumns,
+                referenceColumns,
+                projection,
+                startRowIndex: baseRange.startRow,
+                startColumnIndex: direction === "left" ? baseRange.startColumn - 1 : baseRange.endColumn + 1,
+                limit: 500,
+            });
+        };
+        const left = await resolve(leftReferenceColumns, "left");
+        options.reportFillPlumbingState?.("double_click_left_result", left != null);
+        if (left && left.boundaryKind !== "unresolved" && left.endRowIndex != null) {
+            options.reportFillPlumbingState?.("double_click_left_selected", true);
+            return { endRow: left.endRowIndex, boundaryKind: left.boundaryKind, resolvedByServer: true };
+        }
+        const right = await resolve(rightReferenceColumns, "right");
+        options.reportFillPlumbingState?.("double_click_right_result", right != null);
+        if (right && right.boundaryKind !== "unresolved" && right.endRowIndex != null) {
+            options.reportFillPlumbingState?.("double_click_right_selected", true);
+            return { endRow: right.endRowIndex, boundaryKind: right.boundaryKind, resolvedByServer: true };
+        }
+        if (left?.boundaryKind === "unresolved" || right?.boundaryKind === "unresolved") {
+            options.reportFillWarning?.("server fill boundary unresolved; using loaded-cache fallback");
+        }
+        return null;
+    };
     const startFillHandleDoubleClick = (event) => {
+        options.reportFillPlumbingState?.("double_click_handler", true);
         if (options.mode.value !== "base" || !isFillHandleEnabled.value) {
+            options.reportFillPlumbingState?.("double_click_handler_skipped", true);
             return;
         }
         const baseRange = options.resolveSelectionRange();
         if (!baseRange) {
+            options.reportFillPlumbingState?.("double_click_handler_skipped_no_range", true);
             return;
         }
         const anchorRow = getBodyRowAtIndex(baseRange.endRow);
         const anchorColumnKey = options.visibleColumns.value[baseRange.endColumn]?.key;
         if (!anchorRow || !anchorColumnKey) {
+            options.reportFillPlumbingState?.("double_click_handler_skipped_no_anchor", true);
             return;
         }
         if (!options.isCellEditable(anchorRow, baseRange.endRow, anchorColumnKey, baseRange.endColumn)) {
+            options.reportFillPlumbingState?.("double_click_handler_skipped_not_editable", true);
             return;
         }
-        const targetEndRow = resolveBestNeighborFillEndRow(baseRange);
-        const previewRange = targetEndRow > baseRange.endRow
-            ? options.normalizeClipboardRange({
-                startRow: baseRange.startRow,
-                endRow: targetEndRow,
-                startColumn: baseRange.startColumn,
-                endColumn: baseRange.endColumn,
-            })
-            : null;
-        if (!previewRange || options.rangesEqual(baseRange, previewRange)) {
-            return;
-        }
-        const sourceMatrix = options.buildFillMatrixFromRange(baseRange);
-        const behavior = activeFillBehavior.value ?? resolveDataGridDefaultFillBehavior({
-            baseRange,
-            previewRange,
-            sourceMatrix,
-        });
         const preferredFocusCoord = resolveFillOriginFocusCoord();
         event.preventDefault();
         event.stopPropagation();
-        if (applyCommittedFillRange(baseRange, previewRange, behavior)) {
-            activeFillBehavior.value = behavior;
-            const restoredCoord = preferredFocusCoord
-                ? restoreSelectionActiveCellToCoord(preferredFocusCoord)
+        void resolveServerAwareFillBoundary(baseRange).then(resolved => {
+            options.reportFillPlumbingState?.("double_click_resolved_server_branch", !!resolved?.resolvedByServer);
+            options.reportFillPlumbingState?.("double_click_resolved_endrow", typeof resolved?.endRow === "number");
+            const targetEndRow = resolved?.endRow ?? resolveBestNeighborFillEndRow(baseRange);
+            const previewRange = targetEndRow > baseRange.endRow
+                ? options.normalizeClipboardRange({
+                    startRow: baseRange.startRow,
+                    endRow: targetEndRow,
+                    startColumn: baseRange.startColumn,
+                    endColumn: baseRange.endColumn,
+                })
                 : null;
-            restoreActiveCellFocus(restoredCoord ?? preferredFocusCoord);
-        }
+            if (!previewRange || options.rangesEqual(baseRange, previewRange)) {
+                return;
+            }
+            const sourceMatrix = options.buildFillMatrixFromRange(baseRange);
+            const behavior = activeFillBehavior.value ?? resolveDataGridDefaultFillBehavior({
+                baseRange,
+                previewRange,
+                sourceMatrix,
+            });
+            if (resolved?.resolvedByServer) {
+                options.reportFillPlumbingState?.("double_click_server_branch_entered", true);
+                const resolvedRowCount = previewRange.endRow - previewRange.startRow + 1;
+                const threshold = 500;
+                const rowModel = options.runtimeRowModel;
+                const dataSource = rowModel?.dataSource ?? options.runtime.rowModel?.dataSource;
+                options.reportFillPlumbingState?.("controller_runtimeRowModel_exists", rowModel != null);
+                options.reportFillPlumbingState?.("controller_runtimeRowModel_dataSource_exists", dataSource != null);
+                options.reportFillPlumbingState?.("controller_runtimeRowModel_commit_type", typeof rowModel?.dataSource?.commitFillOperation === "function");
+                options.reportFillPlumbingState?.("controller_runtime_rowModel_commit_type", typeof options.runtime.rowModel?.dataSource?.commitFillOperation === "function");
+                const canCommitServerFill = typeof dataSource?.commitFillOperation === "function";
+                options.reportFillPlumbingState?.("commitFillOperation_available", canCommitServerFill);
+                if (resolvedRowCount > threshold) {
+                    if (!canCommitServerFill) {
+                        options.reportFillPlumbingState?.("double_click_blocked_large", true);
+                        options.reportFillWarning?.("server fill execution not implemented yet");
+                        return;
+                    }
+                }
+                let allLoaded = true;
+                for (let rowIndex = previewRange.startRow; rowIndex <= previewRange.endRow; rowIndex += 1) {
+                    const isMaterialized = options.isRowMaterializedAtIndex
+                        ? options.isRowMaterializedAtIndex(rowIndex)
+                        : !!getBodyRowAtIndex(rowIndex) && getBodyRowAtIndex(rowIndex).__placeholder !== true;
+                    if (!isMaterialized) {
+                        allLoaded = false;
+                        break;
+                    }
+                }
+                if (!allLoaded && !canCommitServerFill) {
+                    options.reportFillPlumbingState?.("double_click_blocked_unloaded", true);
+                    options.reportFillWarning?.("server fill execution not implemented yet");
+                    return;
+                }
+                if (canCommitServerFill) {
+                    options.reportFillPlumbingState?.("server-fill-committed", true);
+                    void Promise.resolve(applyFillRange(baseRange, previewRange, behavior)).then((applied) => {
+                        if (!applied) {
+                            return;
+                        }
+                        activeFillBehavior.value = behavior;
+                        const restoredCoord = preferredFocusCoord
+                            ? restoreSelectionActiveCellToCoord(preferredFocusCoord)
+                            : null;
+                        restoreActiveCellFocus(restoredCoord ?? preferredFocusCoord);
+                    });
+                    return;
+                }
+            }
+            options.reportFillPlumbingState?.("double_click_batch_commit_path", true);
+            void applyCommittedFillRange(baseRange, previewRange, behavior).then(applied => {
+                if (!applied) {
+                    return;
+                }
+                activeFillBehavior.value = behavior;
+                const restoredCoord = preferredFocusCoord
+                    ? restoreSelectionActiveCellToCoord(preferredFocusCoord)
+                    : null;
+                restoreActiveCellFocus(restoredCoord ?? preferredFocusCoord);
+            });
+        });
     };
-    const applyLastFillBehavior = (behavior) => {
+    const applyLastFillBehavior = async (behavior) => {
         if (!isFillHandleEnabled.value) {
             return false;
         }
@@ -1315,7 +1755,7 @@ export function useDataGridAppInteractionController(options) {
             return false;
         }
         const preferredFocusCoord = resolveFillOriginFocusCoord();
-        const applied = applyCommittedFillRange(session.baseRange, session.previewRange, behavior);
+        const applied = await applyCommittedFillRange(session.baseRange, session.previewRange, behavior);
         if (applied) {
             activeFillBehavior.value = behavior;
             const restoredCoord = preferredFocusCoord
@@ -1459,7 +1899,7 @@ export function useDataGridAppInteractionController(options) {
         if (keyboardAction === "toggle" && columnSnapshot && columnKey) {
             event.preventDefault();
             options.setCellSelection(row, rowOffset, columnIndex, event.shiftKey);
-            applyDirectCellEdit(row, rowIndex, columnIndex, columnKey, toggleDataGridCellValue({
+            void applyDirectCellEdit(row, rowIndex, columnIndex, columnKey, toggleDataGridCellValue({
                 column: columnSnapshot.column,
                 row: row.kind !== "group" ? row.data : undefined,
             }), `Toggle ${columnKey}`);