@affino/datagrid-vue 0.3.32 → 0.3.34

package/dist/app/useDataGridAppInteractionController.js

@@ -3,6 +3,17 @@ import { invokeDataGridCellInteraction, resolveDataGridCellKeyboardAction, toggl
 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";
+const SERVER_FILL_SERIES_UNSUPPORTED_WARNING = "Series fill is not supported by the server datasource yet; using copy fill.";
+function resolveServerFillCommitBehavior(behavior) {
+    return behavior === "series"
+        ? { behavior: "copy", downgraded: true }
+        : { behavior, downgraded: false };
+}
+function normalizeServerFillOperationId(value) {
+    return typeof value === "string" && value.trim().length > 0
+        ? value
+        : null;
+}
 function getFillRangeStart(range) {
     const candidate = range;
     return Number.isFinite(candidate.startRow)
@@ -213,6 +224,37 @@ export function useDataGridAppInteractionController(options) {
     const rangeMoveBaseRange = ref(null);
     const rangeMoveOrigin = ref(null);
     const rangeMovePreviewRange = ref(null);
+    const serverFillBoundaryConsistencyMetadata = ref(null);
+    let fillPreviewCancelVersion = 0;
+    let lastServerFillMaterializationWarning = null;
+    const hasActiveFillPreviewState = () => {
+        return isFillDragging.value || fillBaseRange.value != null || fillPreviewRange.value != null;
+    };
+    const clearFillPreviewState = (expectedBaseRange, expectedPreviewRange) => {
+        if (expectedBaseRange !== undefined
+            && !options.rangesEqual(fillBaseRange.value, expectedBaseRange)) {
+            return false;
+        }
+        if (expectedPreviewRange !== undefined
+            && !options.rangesEqual(fillPreviewRange.value, expectedPreviewRange)) {
+            return false;
+        }
+        isFillDragging.value = false;
+        fillDragStartPointer.value = null;
+        fillPointer.value = null;
+        fillBaseRange.value = null;
+        fillPreviewRange.value = null;
+        fillOriginFocusCoord.value = null;
+        serverFillBoundaryConsistencyMetadata.value = null;
+        return true;
+    };
+    const cancelFillPreviewState = () => {
+        if (!hasActiveFillPreviewState()) {
+            return false;
+        }
+        fillPreviewCancelVersion += 1;
+        return clearFillPreviewState();
+    };
     const focusViewport = () => {
         options.bodyViewportRef.value?.focus({ preventScroll: true });
     };
@@ -434,6 +476,97 @@ export function useDataGridAppInteractionController(options) {
         }
         return options.captureRowsSnapshotForRowIds?.(rowIds) ?? options.captureRowsSnapshot();
     };
+    const isRowMaterializedForOperation = (rowIndex) => {
+        const row = getBodyRowAtIndex(rowIndex);
+        return options.isRowMaterializedAtIndex
+            ? options.isRowMaterializedAtIndex(rowIndex)
+            : !!row && row.__placeholder !== true;
+    };
+    const isRangeFullyMaterialized = (range) => {
+        const normalizedRange = range ? options.normalizeClipboardRange(range) : null;
+        if (!normalizedRange) {
+            return false;
+        }
+        for (let rowIndex = normalizedRange.startRow; rowIndex <= normalizedRange.endRow; rowIndex += 1) {
+            if (!isRowMaterializedForOperation(rowIndex)) {
+                return false;
+            }
+        }
+        return true;
+    };
+    const applyServerBackedRangeMove = async (baseRange, targetRange) => {
+        if (!isRangeFullyMaterialized(baseRange) || !isRangeFullyMaterialized(targetRange)) {
+            options.reportFillWarning?.("Range move includes unloaded rows. Load the full source and target ranges before moving.");
+            return false;
+        }
+        const editsByRowId = new Map();
+        let appliedCells = 0;
+        let blockedCells = 0;
+        for (let rowOffset = 0; rowOffset <= baseRange.endRow - baseRange.startRow; rowOffset += 1) {
+            const sourceRowIndex = baseRange.startRow + rowOffset;
+            const targetRowIndex = targetRange.startRow + rowOffset;
+            const sourceRow = getBodyRowAtIndex(sourceRowIndex);
+            const targetRow = getBodyRowAtIndex(targetRowIndex);
+            if (!sourceRow
+                || !targetRow
+                || sourceRow.kind === "group"
+                || targetRow.kind === "group"
+                || sourceRow.rowId == null
+                || targetRow.rowId == null) {
+                blockedCells += Math.max(0, baseRange.endColumn - baseRange.startColumn + 1);
+                continue;
+            }
+            for (let columnOffset = 0; columnOffset <= baseRange.endColumn - baseRange.startColumn; columnOffset += 1) {
+                const sourceColumnIndex = baseRange.startColumn + columnOffset;
+                const targetColumnIndex = targetRange.startColumn + columnOffset;
+                const sourceColumnKey = options.visibleColumns.value[sourceColumnIndex]?.key;
+                const targetColumnKey = options.visibleColumns.value[targetColumnIndex]?.key;
+                if (!sourceColumnKey
+                    || !targetColumnKey
+                    || sourceColumnKey === ROW_SELECTION_COLUMN_KEY
+                    || targetColumnKey === ROW_SELECTION_COLUMN_KEY
+                    || !options.isCellEditable(sourceRow, sourceRowIndex, sourceColumnKey, sourceColumnIndex)
+                    || !options.isCellEditable(targetRow, targetRowIndex, targetColumnKey, targetColumnIndex)) {
+                    blockedCells += 1;
+                    continue;
+                }
+                const sourceValue = options.readCell(sourceRow, sourceColumnKey);
+                const sourcePatch = editsByRowId.get(sourceRow.rowId) ?? {};
+                sourcePatch[sourceColumnKey] = "";
+                editsByRowId.set(sourceRow.rowId, sourcePatch);
+                const targetPatch = editsByRowId.get(targetRow.rowId) ?? {};
+                targetPatch[targetColumnKey] = sourceValue;
+                editsByRowId.set(targetRow.rowId, targetPatch);
+                appliedCells += 1;
+            }
+        }
+        if (appliedCells === 0) {
+            return false;
+        }
+        const updates = Array.from(editsByRowId.entries(), ([rowId, data]) => ({
+            rowId,
+            data: data,
+        }));
+        const beforeSnapshot = captureRowsSnapshotForRanges([baseRange, targetRange]);
+        try {
+            await Promise.resolve(options.runtime.api.rows.applyEdits(updates));
+        }
+        catch (error) {
+            options.reportFillWarning?.(error instanceof Error ? error.message : "range move commit failed");
+            return false;
+        }
+        const afterSnapshot = captureRowsSnapshotForRanges([baseRange, targetRange]);
+        void options.recordIntentTransaction({
+            intent: "move",
+            label: blockedCells > 0
+                ? `Move ${appliedCells} cells (blocked ${blockedCells})`
+                : `Move ${appliedCells} cells`,
+            affectedRange: targetRange,
+        }, beforeSnapshot, afterSnapshot);
+        options.applySelectionRange(targetRange);
+        options.syncViewport();
+        return true;
+    };
     const rangeMutationEngine = useDataGridRangeMutationEngine({
         resolveRangeMoveBaseRange: () => rangeMoveBaseRange.value,
         resolveRangeMovePreviewRange: () => rangeMovePreviewRange.value,
@@ -507,41 +640,45 @@ export function useDataGridAppInteractionController(options) {
         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_runtimeRowModel_dataSource_exists", controllerRowModel?.dataSource != null);
+            options.reportFillPlumbingState?.("controller_runtimeRowModel_dataSource_keys", Object.keys(controllerRowModel?.dataSource ?? {}).length > 0);
+            options.reportFillPlumbingDetail?.("controller_runtimeRowModel_dataSource_keys", Object.keys(controllerRowModel?.dataSource ?? {}).join(","));
+            options.reportFillPlumbingState?.("controller_runtimeRowModel_commit_type", typeof controllerRowModel?.dataSource?.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;
+            const dataSource = resolveServerFillDataSource();
             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;
+            return serverFillBoundaryConsistencyMetadata.value != null || !isRangeFullyMaterialized(previewRange);
         },
         commitServerFill: async ({ baseRange, previewRange, behavior }) => {
-            const runtimeRowModelDataSource = options.runtimeRowModel?.dataSource;
-            const runtimeRowModelFallback = options.runtime.rowModel?.dataSource;
-            const dataSource = runtimeRowModelDataSource ?? runtimeRowModelFallback;
+            lastServerFillMaterializationWarning = null;
+            const serverFillBehavior = resolveServerFillCommitBehavior(behavior);
+            if (serverFillBehavior.downgraded) {
+                options.reportFillWarning?.(SERVER_FILL_SERIES_UNSUPPORTED_WARNING);
+                options.reportFillPlumbingState?.("server_fill_series_downgraded_to_copy", true);
+            }
+            const clearCurrentFillPreview = () => {
+                clearFillPreviewState(baseRange, previewRange);
+            };
+            const dataSource = resolveServerFillDataSource();
             if (!dataSource?.commitFillOperation) {
                 options.reportFillWarning?.("server fill execution not implemented yet");
+                clearCurrentFillPreview();
                 return null;
             }
             const snapshot = options.runtime.api.rows.getSnapshot();
             const operationId = `fill-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            const boundaryConsistencyMetadata = serverFillBoundaryConsistencyMetadata.value;
             const sourceMatrix = options.buildFillMatrixFromRange(baseRange);
             const fillMatrix = buildDataGridFillMatrix({
                 baseRange,
                 previewRange,
                 sourceMatrix,
-                behavior,
+                behavior: serverFillBehavior.behavior,
             });
             const materializedTargetRowIds = [];
             const optimisticUpdatesByRowId = new Map();
@@ -571,6 +708,31 @@ export function useDataGridAppInteractionController(options) {
                     }
                 }
             }
+            const sourceResolution = resolveProjectedFillRowIds(baseRange);
+            reportProjectedFillRowIdResolution("source", sourceResolution);
+            if (!sourceResolution.fullyMaterialized) {
+                options.reportFillWarning?.(`server fill source row ids are not fully materialized (${sourceResolution.missingCount} source rows missing)`);
+                clearCurrentFillPreview();
+                return null;
+            }
+            const sourceRowIds = sourceResolution.rowIds;
+            let targetResolution = resolveProjectedFillRowIds(previewRange);
+            reportProjectedFillRowIdResolution("target", targetResolution);
+            if (!targetResolution.fullyMaterialized) {
+                const materialized = await materializeProjectedFillRows(previewRange);
+                if (materialized) {
+                    targetResolution = resolveProjectedFillRowIds(previewRange);
+                    reportProjectedFillRowIdResolution("target", targetResolution);
+                }
+            }
+            const missingTargetRows = targetResolution.missingCount;
+            if (!targetResolution.fullyMaterialized || targetResolution.rowIds.length <= sourceRowIds.length) {
+                options.reportFillWarning?.(`server fill target row ids are not fully materialized (${missingTargetRows} target rows missing)`);
+                clearCurrentFillPreview();
+                return null;
+            }
+            const commitTargetRange = previewRange;
+            const targetRowIds = targetResolution.rowIds;
             let optimisticRollbackUpdates = null;
             if (optimisticFillCandidate && materializedTargetRowIds.length > 0 && optimisticUpdatesByRowId.size > 0) {
                 const baselineSnapshot = options.captureRowsSnapshotForRowIds?.(materializedTargetRowIds);
@@ -621,14 +783,25 @@ export function useDataGridAppInteractionController(options) {
                         },
                     },
                     sourceRange: baseRange,
-                    targetRange: previewRange,
+                    targetRange: commitTargetRange,
+                    sourceRowIds,
+                    targetRowIds,
                     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,
+                    mode: serverFillBehavior.behavior,
+                    ...(boundaryConsistencyMetadata?.revision !== undefined
+                        ? { baseRevision: boundaryConsistencyMetadata.revision }
+                        : {}),
+                    ...(boundaryConsistencyMetadata?.projectionHash !== undefined
+                        ? { projectionHash: boundaryConsistencyMetadata.projectionHash }
+                        : {}),
+                    ...(boundaryConsistencyMetadata?.boundaryToken !== undefined
+                        ? { boundaryToken: boundaryConsistencyMetadata.boundaryToken }
+                        : {}),
                     metadata: { origin: "double-click-fill", behaviorSource: "default" },
                 });
                 options.reportFillPlumbingState?.("commitFillOperation_called", true);
@@ -641,6 +814,9 @@ export function useDataGridAppInteractionController(options) {
                 options.reportFillWarning?.("server fill commit failed");
                 return null;
             }
+            finally {
+                clearCurrentFillPreview();
+            }
             if (!result) {
                 if (optimisticRollbackUpdates && optimisticRollbackUpdates.length > 0) {
                     await Promise.resolve(options.runtime.api.rows.applyEdits(optimisticRollbackUpdates));
@@ -648,33 +824,92 @@ export function useDataGridAppInteractionController(options) {
                 options.reportFillWarning?.("server fill commit failed");
                 return null;
             }
-            const invalidationRange = result.invalidation?.kind === "range" ? result.invalidation.range : previewRange;
+            const affectedRowCount = result.affectedRowCount ?? 0;
+            const affectedCellCount = result.affectedCellCount ?? affectedRowCount;
+            const warnings = result.warnings ?? [];
+            if (affectedCellCount <= 0) {
+                if (optimisticRollbackUpdates && optimisticRollbackUpdates.length > 0) {
+                    await Promise.resolve(options.runtime.api.rows.applyEdits(optimisticRollbackUpdates));
+                }
+                if (warnings.length > 0) {
+                    for (const warning of warnings) {
+                        options.reportFillWarning?.(warning);
+                    }
+                }
+                else {
+                    options.reportFillWarning?.("server fill no-op");
+                }
+                options.reportFillPlumbingState?.("server_fill_affectedRowCount", false);
+                return null;
+            }
+            const committedOperationId = normalizeServerFillOperationId(result.operationId);
+            const invalidationRange = result.invalidation?.kind === "range" ? result.invalidation.range : commitTargetRange;
+            const serverFillRefreshPayload = result.invalidation ?? invalidationRange;
+            const hasRowInvalidation = result.invalidation?.kind === "rows";
             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);
+            const runtimeRowModel = options.runtimeRowModel;
+            const runtimeRowModelFallback = options.runtime.rowModel;
+            const rowsApi = options.runtime.api.rows;
+            const invalidateRangeTarget = runtimeRowModel?.invalidateRange ?? runtimeRowModelFallback?.invalidateRange;
+            const invalidateRowsTarget = runtimeRowModel?.invalidateRows ?? runtimeRowModelFallback?.invalidateRows;
+            const applyServerFillInvalidation = async () => {
+                if (result.invalidation?.kind === "rows") {
+                    if (typeof invalidateRowsTarget === "function") {
+                        invalidateRowsTarget(result.invalidation.rowIds);
+                        options.reportFillPlumbingState?.("server_fill_invalidation_applied", true);
+                        return;
+                    }
+                    await Promise.resolve(rowsApi.refresh?.());
+                    return;
+                }
+                if (normalizedInvalidationRange && typeof invalidateRangeTarget === "function") {
+                    invalidateRangeTarget(normalizedInvalidationRange);
                     options.reportFillPlumbingState?.("server_fill_invalidation_applied", true);
+                    return;
                 }
                 await Promise.resolve(rowsApi.refresh?.());
+            };
+            promoteCommittedFillSelection(previewRange);
+            if (!committedOperationId) {
+                options.reportFillWarning?.("server fill committed without operation id; undo/redo disabled");
+                options.reportFillPlumbingState?.("server_fill_operationId", false);
+                if (hasRowInvalidation) {
+                    await applyServerFillInvalidation();
+                }
+                else if (options.refreshServerFillViewport) {
+                    await Promise.resolve(options.refreshServerFillViewport(serverFillRefreshPayload));
+                }
+                else {
+                    await applyServerFillInvalidation();
+                }
+                return null;
+            }
+            if (warnings.length > 0) {
+                for (const warning of warnings) {
+                    options.reportFillWarning?.(warning);
+                }
+            }
+            else {
+                options.reportFillWarning?.("server fill committed");
+            }
+            options.reportFillPlumbingState?.("server_fill_affectedRowCount", true);
+            options.reportFillPlumbingState?.("server-fill-committed", true);
+            if (hasRowInvalidation || !options.refreshServerFillViewport) {
+                await applyServerFillInvalidation();
+            }
+            else {
+                await Promise.resolve(options.refreshServerFillViewport(serverFillRefreshPayload));
             }
             return {
-                operationId: result.operationId,
+                operationId: committedOperationId,
                 revision: result.revision,
                 affectedRange: invalidationRange,
                 invalidation: result.invalidation ?? null,
                 affectedRowCount,
-                affectedCellCount: result.affectedCellCount ?? affectedRowCount,
+                affectedCellCount,
                 warnings,
             };
         },
@@ -704,6 +939,9 @@ export function useDataGridAppInteractionController(options) {
                 mode: session.behavior,
             });
         },
+        applyCommittedFillSelection: (range) => {
+            applySelectionRangeWithActivePosition(range, "start");
+        },
         syncServerFillViewport: options.refreshServerFillViewport,
         syncViewport: options.syncViewport,
     });
@@ -785,6 +1023,7 @@ export function useDataGridAppInteractionController(options) {
                         sourceMatrix,
                         behavior: resolvedBehavior,
                     }), { recordHistory: false });
+                    promoteCommittedFillSelection(previewRange);
                     lastAppliedFill.value = {
                         baseRange: { ...baseRange },
                         previewRange: { ...previewRange },
@@ -1193,6 +1432,9 @@ export function useDataGridAppInteractionController(options) {
         options.selectionSnapshot.value = nextSnapshot;
         options.runtime.api.selection.setSnapshot(nextSnapshot);
     };
+    const promoteCommittedFillSelection = (range) => {
+        applySelectionRangeWithActivePosition(range, "start");
+    };
     const resolveFillOriginFocusCoord = () => {
         const anchorCoord = resolveSelectionAnchorCoord();
         if (anchorCoord) {
@@ -1232,6 +1474,9 @@ export function useDataGridAppInteractionController(options) {
             if (options.applyRangeMove && baseRange && targetRange) {
                 return options.applyRangeMove(baseRange, targetRange);
             }
+            if (baseRange && targetRange && isServerBackedRowModel()) {
+                return applyServerBackedRangeMove(baseRange, targetRange);
+            }
             return rangeMutationEngine.applyRangeMove();
         },
         setRangeMoving: value => {
@@ -1486,6 +1731,7 @@ export function useDataGridAppInteractionController(options) {
         const originCoord = resolveFillOriginFocusCoord();
         const restartSession = resolveRestartableFillSession(baseRange);
         if (fillHandleStart.onSelectionHandleMouseDown(event)) {
+            fillPreviewCancelVersion += 1;
             activeRestartFillSession.value = restartSession;
             fillOriginFocusCoord.value = originCoord;
         }
@@ -1520,6 +1766,100 @@ export function useDataGridAppInteractionController(options) {
             },
         };
     };
+    const resolveServerFillDataSource = () => {
+        const controllerDataSource = options.runtimeRowModel?.dataSource;
+        const runtimeDataSource = options.runtime.rowModel?.dataSource;
+        if (typeof controllerDataSource?.commitFillOperation === "function") {
+            return controllerDataSource;
+        }
+        if (typeof runtimeDataSource?.commitFillOperation === "function") {
+            return runtimeDataSource;
+        }
+        if (typeof controllerDataSource?.resolveFillBoundary === "function") {
+            return controllerDataSource;
+        }
+        if (typeof runtimeDataSource?.resolveFillBoundary === "function") {
+            return runtimeDataSource;
+        }
+        return controllerDataSource ?? runtimeDataSource;
+    };
+    const resolveProjectedFillRowIds = (range) => {
+        const rowIds = [];
+        const requestedRowCount = Math.max(0, range.endRow - range.startRow + 1);
+        let firstMissingRowIndex = null;
+        let lastResolvedRowIndex = null;
+        for (let rowIndex = range.startRow; rowIndex <= range.endRow; rowIndex += 1) {
+            const row = getBodyRowAtIndex(rowIndex);
+            const isMaterialized = options.isRowMaterializedAtIndex
+                ? options.isRowMaterializedAtIndex(rowIndex)
+                : !!row && row.__placeholder !== true;
+            if (!isMaterialized || !row || row.kind === "group" || row.rowId == null || row.__placeholder === true) {
+                firstMissingRowIndex = rowIndex;
+                break;
+            }
+            rowIds.push(row.rowId);
+            lastResolvedRowIndex = rowIndex;
+        }
+        const missingCount = firstMissingRowIndex == null
+            ? 0
+            : Math.max(0, range.endRow - firstMissingRowIndex + 1);
+        return {
+            rowIds,
+            requestedRowCount,
+            missingCount,
+            firstMissingRowIndex,
+            lastResolvedRowIndex,
+            fullyMaterialized: missingCount === 0,
+        };
+    };
+    const reportProjectedFillRowIdResolution = (label, resolution) => {
+        options.reportFillPlumbingDetail?.(`server_fill_${label}_rows_requested`, String(resolution.requestedRowCount));
+        options.reportFillPlumbingDetail?.(`server_fill_${label}_row_ids_resolved`, String(resolution.rowIds.length));
+        options.reportFillPlumbingDetail?.(`server_fill_${label}_row_ids_missing`, String(resolution.missingCount));
+        options.reportFillPlumbingDetail?.(`server_fill_${label}_first_missing_row_index`, resolution.firstMissingRowIndex == null ? "none" : String(resolution.firstMissingRowIndex));
+    };
+    const materializeProjectedFillRows = async (range) => {
+        const normalizedRange = {
+            start: Math.max(0, Math.trunc(range.startRow)),
+            end: Math.max(Math.max(0, Math.trunc(range.startRow)), Math.trunc(range.endRow)),
+        };
+        const runtimeWithViewport = options.runtime;
+        const rowModel = (options.runtimeRowModel ?? options.runtime.rowModel);
+        const rowsApi = options.runtime.api.rows;
+        let attempted = false;
+        try {
+            if (typeof runtimeWithViewport.setViewportRange === "function") {
+                runtimeWithViewport.setViewportRange(normalizedRange);
+                attempted = true;
+            }
+            else if (typeof rowModel?.setViewportRange === "function") {
+                rowModel.setViewportRange(normalizedRange);
+                attempted = true;
+            }
+            if (typeof rowModel?.refresh === "function") {
+                attempted = true;
+                await Promise.resolve(rowModel.refresh("fill-materialize"));
+            }
+            else if (typeof rowsApi.refresh === "function") {
+                attempted = true;
+                await Promise.resolve(rowsApi.refresh());
+            }
+            if (typeof runtimeWithViewport.syncBodyRowsInRange === "function") {
+                runtimeWithViewport.syncBodyRowsInRange(normalizedRange);
+                attempted = true;
+            }
+        }
+        catch (caught) {
+            options.reportFillPlumbingDetail?.("server_fill_materialize_error", caught instanceof Error ? caught.message : String(caught));
+            return false;
+        }
+        options.reportFillPlumbingState?.("server_fill_materialize_attempted", attempted);
+        options.reportFillPlumbingDetail?.("server_fill_materialize_range", `${normalizedRange.start}..${normalizedRange.end}`);
+        return attempted;
+    };
+    const isAcceptedServerFillBoundaryKind = (boundaryKind) => {
+        return boundaryKind === "data-end" || boundaryKind === "gap" || boundaryKind === "cache-boundary";
+    };
     const resolveReferenceColumnExtentEndRow = (baseRange, columnIndex) => {
         const columnKey = options.visibleColumns.value[columnIndex]?.key;
         if (!columnKey) {
@@ -1571,6 +1911,7 @@ export function useDataGridAppInteractionController(options) {
         return evaluateDirection(baseRange.endColumn + 1, 1);
     };
     const resolveServerAwareFillBoundary = async (baseRange) => {
+        serverFillBoundaryConsistencyMetadata.value = null;
         if (!options.resolveFillBoundary) {
             options.reportFillPlumbingState?.("interaction_controller_option", false);
             return null;
@@ -1624,15 +1965,25 @@ export function useDataGridAppInteractionController(options) {
         };
         const left = await resolve(leftReferenceColumns, "left");
         options.reportFillPlumbingState?.("double_click_left_result", left != null);
-        if (left && left.boundaryKind !== "unresolved" && left.endRowIndex != null) {
+        if (left && isAcceptedServerFillBoundaryKind(left.boundaryKind) && left.endRowIndex != null) {
             options.reportFillPlumbingState?.("double_click_left_selected", true);
-            return { endRow: left.endRowIndex, boundaryKind: left.boundaryKind, resolvedByServer: true };
+            serverFillBoundaryConsistencyMetadata.value = {
+                revision: left.revision,
+                projectionHash: left.projectionHash,
+                boundaryToken: left.boundaryToken,
+            };
+            return { endRow: left.endRowIndex, boundaryKind: left.boundaryKind, resolvedByServer: true, truncated: left.truncated === true };
         }
         const right = await resolve(rightReferenceColumns, "right");
         options.reportFillPlumbingState?.("double_click_right_result", right != null);
-        if (right && right.boundaryKind !== "unresolved" && right.endRowIndex != null) {
+        if (right && isAcceptedServerFillBoundaryKind(right.boundaryKind) && right.endRowIndex != null) {
             options.reportFillPlumbingState?.("double_click_right_selected", true);
-            return { endRow: right.endRowIndex, boundaryKind: right.boundaryKind, resolvedByServer: true };
+            serverFillBoundaryConsistencyMetadata.value = {
+                revision: right.revision,
+                projectionHash: right.projectionHash,
+                boundaryToken: right.boundaryToken,
+            };
+            return { endRow: right.endRowIndex, boundaryKind: right.boundaryKind, resolvedByServer: true, truncated: right.truncated === true };
         }
         if (left?.boundaryKind === "unresolved" || right?.boundaryKind === "unresolved") {
             options.reportFillWarning?.("server fill boundary unresolved; using loaded-cache fallback");
@@ -1676,6 +2027,10 @@ export function useDataGridAppInteractionController(options) {
                 })
                 : null;
             if (!previewRange || options.rangesEqual(baseRange, previewRange)) {
+                serverFillBoundaryConsistencyMetadata.value = null;
+                if (resolved?.resolvedByServer && resolved.truncated) {
+                    options.reportFillWarning?.("Fill truncated at cache boundary");
+                }
                 return;
             }
             const sourceMatrix = options.buildFillMatrixFromRange(baseRange);
@@ -1686,23 +2041,26 @@ export function useDataGridAppInteractionController(options) {
             });
             if (resolved?.resolvedByServer) {
                 options.reportFillPlumbingState?.("double_click_server_branch_entered", true);
-                const resolvedRowCount = previewRange.endRow - previewRange.startRow + 1;
-                const threshold = 500;
+                const normalizedFillBaseRange = options.normalizeClipboardRange(baseRange);
+                if (!options.rangesEqual(options.resolveSelectionRange(), baseRange)) {
+                    serverFillBoundaryConsistencyMetadata.value = null;
+                    return;
+                }
+                if (normalizedFillBaseRange) {
+                    fillBaseRange.value = normalizedFillBaseRange;
+                    fillPreviewRange.value = previewRange;
+                }
+                const fillPreviewCancelVersionAtCommitStart = fillPreviewCancelVersion;
                 const rowModel = options.runtimeRowModel;
-                const dataSource = rowModel?.dataSource ?? options.runtime.rowModel?.dataSource;
+                const runtimeRowModel = options.runtime.rowModel;
+                const dataSource = resolveServerFillDataSource();
                 options.reportFillPlumbingState?.("controller_runtimeRowModel_exists", rowModel != null);
-                options.reportFillPlumbingState?.("controller_runtimeRowModel_dataSource_exists", dataSource != null);
+                options.reportFillPlumbingState?.("controller_runtimeRowModel_dataSource_exists", rowModel?.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");
+                options.reportFillPlumbingState?.("controller_runtime_rowModel_commit_type", typeof runtimeRowModel?.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;
-                    }
-                }
+                const serverFillBehavior = resolveServerFillCommitBehavior(behavior);
                 let allLoaded = true;
                 for (let rowIndex = previewRange.startRow; rowIndex <= previewRange.endRow; rowIndex += 1) {
                     const isMaterialized = options.isRowMaterializedAtIndex
@@ -1716,25 +2074,54 @@ export function useDataGridAppInteractionController(options) {
                 if (!allLoaded && !canCommitServerFill) {
                     options.reportFillPlumbingState?.("double_click_blocked_unloaded", true);
                     options.reportFillWarning?.("server fill execution not implemented yet");
+                    clearFillPreviewState(normalizedFillBaseRange, previewRange);
                     return;
                 }
                 if (canCommitServerFill) {
-                    options.reportFillPlumbingState?.("server-fill-committed", true);
-                    void Promise.resolve(applyFillRange(baseRange, previewRange, behavior)).then((applied) => {
+                    if (serverFillBehavior.downgraded) {
+                        options.reportFillWarning?.(SERVER_FILL_SERIES_UNSUPPORTED_WARNING);
+                        options.reportFillPlumbingState?.("server_fill_series_downgraded_to_copy", true);
+                    }
+                    void Promise.resolve(applyFillRange(baseRange, previewRange, serverFillBehavior.behavior))
+                        .then((applied) => {
                         if (!applied) {
                             return;
                         }
-                        activeFillBehavior.value = behavior;
+                        if (fillPreviewCancelVersion !== fillPreviewCancelVersionAtCommitStart) {
+                            return;
+                        }
+                        applySelectionRangeWithActivePosition(previewRange, "start");
+                        if (normalizedFillBaseRange
+                            && options.rangesEqual(fillBaseRange.value, normalizedFillBaseRange)
+                            && options.rangesEqual(fillPreviewRange.value, previewRange)) {
+                            fillBaseRange.value = null;
+                            fillPreviewRange.value = null;
+                        }
+                        activeFillBehavior.value = serverFillBehavior.behavior;
+                        if (resolved.truncated && !lastServerFillMaterializationWarning) {
+                            options.reportFillWarning?.("Fill truncated at cache boundary");
+                        }
                         const restoredCoord = preferredFocusCoord
                             ? restoreSelectionActiveCellToCoord(preferredFocusCoord)
                             : null;
                         restoreActiveCellFocus(restoredCoord ?? preferredFocusCoord);
+                    })
+                        .catch((caught) => {
+                        options.reportFillWarning?.(`server fill commit failed: ${caught instanceof Error ? caught.message : String(caught)}`);
+                    })
+                        .finally(() => {
+                        clearFillPreviewState(normalizedFillBaseRange, previewRange);
                     });
                     return;
                 }
+                options.reportFillPlumbingState?.("double_click_blocked_unloaded", true);
+                options.reportFillWarning?.("server fill execution not implemented yet");
+                clearFillPreviewState(normalizedFillBaseRange, previewRange);
+                return;
             }
             options.reportFillPlumbingState?.("double_click_batch_commit_path", true);
-            void applyCommittedFillRange(baseRange, previewRange, behavior).then(applied => {
+            void applyCommittedFillRange(baseRange, previewRange, behavior)
+                .then(applied => {
                 if (!applied) {
                     return;
                 }
@@ -1743,7 +2130,12 @@ export function useDataGridAppInteractionController(options) {
                     ? restoreSelectionActiveCellToCoord(preferredFocusCoord)
                     : null;
                 restoreActiveCellFocus(restoredCoord ?? preferredFocusCoord);
+            })
+                .catch((caught) => {
+                options.reportFillWarning?.(`fill commit failed: ${caught instanceof Error ? caught.message : String(caught)}`);
             });
+        }).catch((caught) => {
+            options.reportFillWarning?.(`server fill boundary failed: ${caught instanceof Error ? caught.message : String(caught)}`);
         });
     };
     const applyLastFillBehavior = async (behavior) => {
@@ -1777,6 +2169,15 @@ export function useDataGridAppInteractionController(options) {
             columnIndex,
             rowId: row.rowId ?? null,
         });
+        if (hasActiveFillPreviewState()) {
+            cancelFillPreviewState();
+            if (event.button === 0 && coord) {
+                event.preventDefault();
+                options.setCellSelection(row, rowOffset, columnIndex, false, false);
+                target?.focus({ preventScroll: true });
+            }
+            return;
+        }
         const currentRange = options.resolveSelectionRange();
         if (options.mode.value === "base"
             && isRangeMoveEnabled.value
@@ -1819,9 +2220,9 @@ export function useDataGridAppInteractionController(options) {
     };
     const handleCellKeydown = (event, row, rowOffset, columnIndex) => {
         const rowIndex = resolveRowIndex(row, rowOffset);
-        if (isFillDragging.value && event.key === "Escape") {
+        if (hasActiveFillPreviewState() && event.key === "Escape") {
             event.preventDefault();
-            stopFillSelection(false);
+            cancelFillPreviewState();
             return;
         }
         if (!supportsCellSelectionMode()) {