@yogiswara/honcho-editor-ui 2.7.13 → 2.7.14

package/dist/hooks/useAdjustmentHistoryBatch.js

@@ -1,1189 +0,0 @@
-import { useState, useCallback, useMemo, useRef, useEffect } from 'react';
-import { mapAdjustmentStateToColorAdjustment, mapColorAdjustmentToAdjustmentState } from '../utils/adjustment';
-/**
- * Create default adjustment state
- */
-const createDefaultAdjustmentState = (overrides) => ({
-    tempScore: 0,
-    tintScore: 0,
-    vibranceScore: 0,
-    saturationScore: 0,
-    exposureScore: 0,
-    highlightsScore: 0,
-    shadowsScore: 0,
-    whitesScore: 0,
-    blacksScore: 0,
-    contrastScore: 0,
-    clarityScore: 0,
-    sharpnessScore: 0,
-    ...overrides
-});
-/**
- * Compare two BatchAdjustmentState objects for equality
- */
-const compareBatchStates = (a, b) => {
-    try {
-        return JSON.stringify(a) === JSON.stringify(b);
-    }
-    catch (error) {
-        console.warn('Failed to compare batch states with JSON.stringify:', error);
-        return false;
-    }
-};
-/**
- * Create empty batch state
- */
-const createEmptyBatchState = () => ({
-    currentSelection: {},
-    allImages: {},
-    initialStates: {}
-});
-/**
- * Generate unique ID for history entries using UUID format
- */
-const generateEntryId = () => {
-    // Simple UUID v4 implementation
-    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
-        const r = Math.random() * 16 | 0;
-        const v = c === 'x' ? r : (r & 0x3 | 0x8);
-        return v.toString(16);
-    });
-};
-/**
- * Generate unique task ID for backend operations (same as entry ID)
- */
-const generateTaskId = () => {
-    return generateEntryId();
-};
-/**
- * Advanced hook for managing batch AdjustmentState history with selective undo/redo functionality.
- *
- * **Pure State Management Design:**
- * - Starts empty, no image loading functionality
- * - Focus on state management and history tracking only
- * - Selection-based operations with persistent state
- * - Manual selection via `actions.setSelection()`
- *
- * **Key Features:**
- * - **Current Selection**: Images actively being adjusted
- * - **All Images**: Persistent state for every image touched
- * - **Selective Operations**: Undo/redo only affects selected images
- * - **Automatic State Persistence**: Images remain in allImages even when deselected
- *
- * **Typical Usage Flow:**
- * ```typescript
- * const { actions, currentBatch, selectedIds } = useAdjustmentHistoryBatch();
- *
- * // Select images (new images get default state automatically)
- * actions.setSelection(['img1', 'img2', 'img3']);
- *
- * // Apply adjustments to selected images
- * actions.adjustSelected({ exposureScore: 10 });
- *
- * // Change selection (img1, img2 state persists in allImages)
- * actions.setSelection(['img3']);
- *
- * // Adjust only img3
- * actions.adjustSelected({ contrastScore: 5 });
- *
- * // Undo affects only currently selected (img3)
- * actions.undo();
- * ```
- *
- * **State Structure:**
- * - `currentBatch.currentSelection`: Currently selected images and their states
- * - `currentBatch.allImages`: All images that have been selected/adjusted (persistent)
- * - `selectedIds`: Array of currently selected image IDs
- *
- * @param options - Configuration options for history behavior
- * @returns Object with current batch, selection, history info, actions, and config
- */
-export function useAdjustmentHistoryBatch(options = {}) {
-    // Internal stabilization
-    const internalOptions = useMemo(() => ({
-        maxSize: options.maxSize ?? 'unlimited',
-        devWarnings: options.devWarnings ?? false,
-        defaultAdjustmentState: options.defaultAdjustmentState ?? {},
-        controller: options.controller,
-        firebaseUid: options.firebaseUid,
-        eventId: options.eventId
-    }), [
-        options.maxSize,
-        options.devWarnings,
-        options.defaultAdjustmentState,
-        options.controller,
-        options.firebaseUid,
-        options.eventId
-    ]);
-    // Core state management - using per-image history instead of batch history
-    const [allImageIds, setAllImageIds] = useState([]);
-    const [selectedIds, setSelectedIds] = useState([]);
-    const [imageHistories, setImageHistories] = useState([]);
-    const [currentBatch, setCurrentBatch] = useState(createEmptyBatchState());
-    const [lastUpdateTimestamp, setLastUpdateTimestamp] = useState(Date.now());
-    // Configuration refs
-    const maxSizeRef = useRef(internalOptions.maxSize);
-    const devWarningsRef = useRef(internalOptions.devWarnings);
-    // Helper function to rebuild currentBatch from imageHistories
-    const rebuildCurrentBatch = useCallback(() => {
-        console.log('[useAdjustmentHistoryBatch] 🔧 rebuildCurrentBatch called with imageHistories:', imageHistories.map(h => ({
-            imageId: h.imageId,
-            currentHistoryEntryId: h.currentHistoryEntryId,
-            historyLength: h.history.length,
-            historyIds: h.history.map(entry => entry.id)
-        })));
-        const newBatch = createEmptyBatchState();
-        imageHistories.forEach(imageHistory => {
-            // Find current adjustment using currentHistoryEntryId
-            const currentEntry = imageHistory.history.find(entry => entry.id === imageHistory.currentHistoryEntryId);
-            console.log(`[useAdjustmentHistoryBatch] 🔍 rebuildCurrentBatch for image ${imageHistory.imageId}:`, {
-                currentHistoryEntryId: imageHistory.currentHistoryEntryId,
-                foundCurrentEntry: !!currentEntry,
-                historyLength: imageHistory.history.length,
-                historyIds: imageHistory.history.map(entry => entry.id)
-            });
-            if (currentEntry) {
-                newBatch.allImages[imageHistory.imageId] = currentEntry.adjustment;
-                if (selectedIds.includes(imageHistory.imageId)) {
-                    newBatch.currentSelection[imageHistory.imageId] = currentEntry.adjustment;
-                }
-                console.log(`[useAdjustmentHistoryBatch] ✅ Successfully rebuilt batch for image ${imageHistory.imageId}`);
-            }
-            else {
-                console.error(`[useAdjustmentHistoryBatch] ❌ CRITICAL: Current entry not found for image ${imageHistory.imageId}!`, {
-                    searchingFor: imageHistory.currentHistoryEntryId,
-                    availableIds: imageHistory.history.map(entry => entry.id),
-                    historyLength: imageHistory.history.length
-                });
-            }
-        });
-        console.log('[useAdjustmentHistoryBatch] 🔧 rebuildCurrentBatch result:', {
-            allImagesCount: Object.keys(newBatch.allImages).length,
-            currentSelectionCount: Object.keys(newBatch.currentSelection).length,
-            allImagesIds: Object.keys(newBatch.allImages),
-            currentSelectionIds: Object.keys(newBatch.currentSelection)
-        });
-        return newBatch;
-    }, [imageHistories, selectedIds]);
-    // Sync currentBatch with imageHistories
-    useEffect(() => {
-        setCurrentBatch(rebuildCurrentBatch());
-    }, [rebuildCurrentBatch]);
-    // Memory usage calculation
-    const getMemoryUsage = useCallback(() => {
-        try {
-            const historiesString = JSON.stringify(imageHistories);
-            return historiesString.length * 2; // Rough estimate: 2 bytes per character
-        }
-        catch (error) {
-            console.warn('Failed to estimate memory usage:', error);
-            return imageHistories.length * 100 * 1000; // Fallback estimate
-        }
-    }, [imageHistories]);
-    // Trim individual image histories to specified size
-    const trimImageHistoriesToSize = useCallback((size) => {
-        if (size <= 0)
-            return;
-        setImageHistories(prevHistories => prevHistories.map(imageHistory => ({
-            ...imageHistory,
-            history: imageHistory.history.length <= size
-                ? imageHistory.history
-                : imageHistory.history.slice(-size) // Keep last 'size' entries
-        })));
-    }, []);
-    // Apply max size limit
-    const enforceMaxSize = useCallback(() => {
-        if (maxSizeRef.current === 'unlimited')
-            return;
-        const maxSize = maxSizeRef.current;
-        if (typeof maxSize === 'number' && imageHistories.length > 0) {
-            const totalHistorySize = imageHistories.reduce((sum, h) => sum + h.history.length, 0);
-            if (totalHistorySize > maxSize * imageHistories.length) {
-                trimImageHistoriesToSize(maxSize);
-            }
-        }
-    }, [imageHistories, trimImageHistoriesToSize]);
-    // Apply adjustment deltas to selected images - with entry-based history and backend sync
-    const adjustSelected = useCallback(async (delta) => {
-        if (selectedIds.length === 0) {
-            if (devWarningsRef.current) {
-                console.warn('[useAdjustmentHistoryBatch] adjustSelected called with no selection');
-            }
-            return;
-        }
-        // Prepare backend operations BEFORE state update (outside setImageHistories)
-        const backendOperations = [];
-        // Process each image to prepare operations
-        const operationsToApply = [];
-        imageHistories.forEach(imageHistory => {
-            if (!selectedIds.includes(imageHistory.imageId)) {
-                return; // Skip images not being adjusted
-            }
-            // Get current adjustment from current entry
-            const currentEntry = imageHistory.history.find(entry => entry.id === imageHistory.currentHistoryEntryId);
-            const currentAdjustment = currentEntry?.adjustment || createDefaultAdjustmentState(internalOptions.defaultAdjustmentState);
-            // Apply deltas with clamping
-            const newAdjustment = { ...currentAdjustment };
-            Object.keys(delta).forEach(key => {
-                const deltaValue = delta[key];
-                if (typeof deltaValue === 'number') {
-                    const currentValue = newAdjustment[key];
-                    newAdjustment[key] = Math.max(-100, Math.min(100, currentValue + deltaValue));
-                }
-            });
-            // Check if user is in the middle of history (not at latest state)
-            const currentEntryIndex = imageHistory.history.findIndex(entry => entry.id === imageHistory.currentHistoryEntryId);
-            const isInMiddleOfHistory = currentEntryIndex < imageHistory.history.length - 1;
-            let replaceFromTaskId;
-            console.log(`[useAdjustmentHistoryBatch] 🎯 Delta replace logic for image ${imageHistory.imageId}:`, {
-                currentEntryIndex,
-                historyLength: imageHistory.history.length,
-                isInMiddleOfHistory,
-                currentEntryId: currentEntry?.id
-            });
-            if (isInMiddleOfHistory) {
-                // If user is in middle of history, get the task ID of current position
-                replaceFromTaskId = currentEntry?.id;
-                console.log(`[useAdjustmentHistoryBatch] 🔄 DELTA will REPLACE current position. replaceFromTaskId=${replaceFromTaskId}`);
-            }
-            else {
-                console.log(`[useAdjustmentHistoryBatch] ➕ DELTA will ADD new entry (at end of history)`);
-            }
-            // Generate new task ID for backend (same as entry ID)
-            const taskId = generateTaskId();
-            // Create new entry with task ID
-            const newEntryId = taskId; // Use the same ID for both entry and task
-            const newEntry = {
-                id: newEntryId,
-                adjustment: newAdjustment
-            };
-            // Build new history
-            let newHistory;
-            if (isInMiddleOfHistory) {
-                // If in middle of history, truncate from current position and add new entry
-                newHistory = [...imageHistory.history.slice(0, currentEntryIndex + 1), newEntry];
-            }
-            else {
-                // If at end of history, just add new entry
-                newHistory = [...imageHistory.history, newEntry];
-            }
-            // Trim if needed
-            const maxSize = maxSizeRef.current;
-            const trimmedHistory = typeof maxSize === 'number' && newHistory.length > maxSize
-                ? newHistory.slice(-maxSize)
-                : newHistory;
-            // Store operation for state update
-            operationsToApply.push({
-                imageId: imageHistory.imageId,
-                newEntryId,
-                newHistory: trimmedHistory
-            });
-            // Prepare backend operation (OUTSIDE state setter)
-            if (internalOptions.controller && internalOptions.firebaseUid) {
-                backendOperations.push({
-                    imageId: imageHistory.imageId,
-                    taskId,
-                    adjustment: newAdjustment,
-                    replaceFromTaskId
-                });
-            }
-        });
-        // Now update state with prepared operations (no backend preparation inside)
-        setImageHistories(prevHistories => {
-            return prevHistories.map(imageHistory => {
-                // Find operation for this image
-                const operation = operationsToApply.find(op => op.imageId === imageHistory.imageId);
-                if (!operation) {
-                    return imageHistory; // No change for images not being adjusted
-                }
-                console.log(`[useAdjustmentHistoryBatch] 📝 Applying state update for delta on image ${imageHistory.imageId}`);
-                return {
-                    ...imageHistory,
-                    history: operation.newHistory,
-                    currentHistoryEntryId: operation.newEntryId // Update current pointer
-                };
-            });
-        });
-        // Perform backend operations asynchronously (already prepared)
-        if (backendOperations.length > 0 && internalOptions.controller && internalOptions.firebaseUid) {
-            try {
-                console.log(`[useAdjustmentHistoryBatch] 📤 Syncing ${backendOperations.length} adjustments to backend (createEditorConfig for each image)`);
-                const promises = backendOperations.map(async (operation) => {
-                    console.log(`[useAdjustmentHistoryBatch] 🔄 Calling createEditorConfig for image ${operation.imageId} with taskId ${operation.taskId}`);
-                    await internalOptions.controller.createEditorConfig(internalOptions.firebaseUid, {
-                        gallery_id: operation.imageId,
-                        task_id: operation.taskId,
-                        color_adjustment: mapAdjustmentStateToColorAdjustment(operation.adjustment),
-                        replace_from: operation.replaceFromTaskId
-                    });
-                });
-                await Promise.all(promises);
-                if (devWarningsRef.current) {
-                    console.log(`[useAdjustmentHistoryBatch] ✅ Successfully synced ${backendOperations.length} adjustments to backend`);
-                }
-            }
-            catch (error) {
-                console.error('[useAdjustmentHistoryBatch] ❌ Failed to sync adjustments to backend:', error);
-            }
-        }
-    }, [selectedIds, internalOptions, imageHistories]);
-    // Shared function for applying adjustments (used by both reset and preset)
-    const applyAdjustmentToSelected = useCallback(async (adjustment, operationType, targetImageIds) => {
-        const idsToProcess = targetImageIds || selectedIds;
-        if (idsToProcess.length === 0) {
-            if (devWarningsRef.current) {
-                console.warn(`[useAdjustmentHistoryBatch] ❌ ${operationType} called with no images to process`);
-            }
-            return;
-        }
-        console.log(`[useAdjustmentHistoryBatch] 🔄 ${operationType.toUpperCase()} called for images:`, idsToProcess);
-        // Prepare backend operations BEFORE state update (outside setImageHistories)
-        const backendOperations = [];
-        // Process each image to prepare operations
-        const operationsToApply = [];
-        imageHistories.forEach(imageHistory => {
-            if (!idsToProcess.includes(imageHistory.imageId)) {
-                return; // Skip images not being processed
-            }
-            console.log(`[useAdjustmentHistoryBatch] 🔄 Processing ${operationType} for image ${imageHistory.imageId}`);
-            // Get current entry for replace_from logic
-            const currentEntry = imageHistory.history.find(entry => entry.id === imageHistory.currentHistoryEntryId);
-            const currentEntryIndex = imageHistory.history.findIndex(entry => entry.id === imageHistory.currentHistoryEntryId);
-            const isInMiddleOfHistory = currentEntryIndex < imageHistory.history.length - 1;
-            let replaceFromTaskId;
-            console.log(`[useAdjustmentHistoryBatch] 🎯 ${operationType.toUpperCase()} replace logic for image ${imageHistory.imageId}:`, {
-                currentEntryIndex,
-                historyLength: imageHistory.history.length,
-                isInMiddleOfHistory,
-                currentEntryId: currentEntry?.id
-            });
-            if (isInMiddleOfHistory && currentEntry?.id) {
-                // Only use replace_from when truly in middle of history (not at latest)
-                replaceFromTaskId = currentEntry.id;
-                console.log(`[useAdjustmentHistoryBatch] 🔄 ${operationType.toUpperCase()} will REPLACE current position. replaceFromTaskId=${replaceFromTaskId}`);
-            }
-            else {
-                console.log(`[useAdjustmentHistoryBatch] ➕ ${operationType.toUpperCase()} will ADD new entry (at end of history)`);
-            }
-            // Create new entry with adjustment
-            const newEntryId = generateEntryId();
-            const newEntry = {
-                id: newEntryId,
-                adjustment
-            };
-            // Build new history
-            let newHistory;
-            if (isInMiddleOfHistory) {
-                // If in middle of history, truncate from current position and add new entry
-                newHistory = [...imageHistory.history.slice(0, currentEntryIndex + 1), newEntry];
-            }
-            else {
-                // If at end of history, just add new entry
-                newHistory = [...imageHistory.history, newEntry];
-            }
-            // Trim if needed
-            const maxSize = maxSizeRef.current;
-            const trimmedHistory = typeof maxSize === 'number' && newHistory.length > maxSize
-                ? newHistory.slice(-maxSize)
-                : newHistory;
-            // Store operation for state update
-            operationsToApply.push({
-                imageId: imageHistory.imageId,
-                newEntryId,
-                newHistory: trimmedHistory
-            });
-            // Prepare backend operation (OUTSIDE state setter)
-            if (internalOptions.controller && internalOptions.firebaseUid) {
-                console.log(`[useAdjustmentHistoryBatch] ✅ Adding ${operationType.toUpperCase()} backend operation for image ${imageHistory.imageId} with taskId ${newEntryId}`, {
-                    replaceFromTaskId,
-                    willReplace: !!replaceFromTaskId
-                });
-                backendOperations.push({
-                    imageId: imageHistory.imageId,
-                    taskId: newEntryId,
-                    adjustment,
-                    replaceFromTaskId
-                });
-            }
-        });
-        // Now update state with prepared operations (no backend preparation inside)
-        setImageHistories(prevHistories => {
-            return prevHistories.map(imageHistory => {
-                // Find operation for this image
-                const operation = operationsToApply.find(op => op.imageId === imageHistory.imageId);
-                if (!operation) {
-                    return imageHistory; // No change for images not being processed
-                }
-                console.log(`[useAdjustmentHistoryBatch] 📝 Applying state update for ${operationType} on image ${imageHistory.imageId}`);
-                return {
-                    ...imageHistory,
-                    history: operation.newHistory,
-                    currentHistoryEntryId: operation.newEntryId // Update current pointer
-                };
-            });
-        });
-        // Perform backend operations asynchronously (already prepared)
-        if (backendOperations.length > 0 && internalOptions.controller && internalOptions.firebaseUid) {
-            try {
-                console.log(`[useAdjustmentHistoryBatch] 📤 Syncing ${backendOperations.length} ${operationType} operations to backend (createEditorConfig for each image)`);
-                const promises = backendOperations.map(async (operation) => {
-                    console.log(`[useAdjustmentHistoryBatch] 🔄 Calling createEditorConfig for ${operationType} on image ${operation.imageId} with taskId ${operation.taskId}`, {
-                        replaceFrom: operation.replaceFromTaskId,
-                        hasReplaceFrom: !!operation.replaceFromTaskId
-                    });
-                    await internalOptions.controller.createEditorConfig(internalOptions.firebaseUid, {
-                        gallery_id: operation.imageId,
-                        task_id: operation.taskId,
-                        color_adjustment: mapAdjustmentStateToColorAdjustment(operation.adjustment),
-                        replace_from: operation.replaceFromTaskId
-                    });
-                });
-                await Promise.all(promises);
-                if (devWarningsRef.current) {
-                    console.log(`[useAdjustmentHistoryBatch] ✅ Successfully synced ${backendOperations.length} ${operationType} operations to backend`);
-                }
-            }
-            catch (error) {
-                console.error(`[useAdjustmentHistoryBatch] ❌ Failed to sync ${operationType} to backend:`, error);
-            }
-        }
-        console.log(`[useAdjustmentHistoryBatch] 📊 ${operationType.toUpperCase()} backend operations prepared: ${backendOperations.length}`);
-    }, [selectedIds, internalOptions, imageHistories]);
-    // Apply preset values directly to selected images - now uses shared logic
-    const adjustSelectedWithPreset = useCallback(async (presetAdjustments) => {
-        console.log('[useAdjustmentHistoryBatch] 🎨 adjustSelectedWithPreset called with:', {
-            selectedIds,
-            selectedCount: selectedIds.length,
-            presetAdjustments,
-            hasController: !!internalOptions.controller,
-            hasFirebaseUid: !!internalOptions.firebaseUid,
-            imageHistoriesCount: imageHistories.length,
-            imageHistoriesIds: imageHistories.map(h => h.imageId)
-        });
-        console.log('[useAdjustmentHistoryBatch] 🔍 PRESET: Current imageHistories state at start:', imageHistories.map(h => ({
-            imageId: h.imageId,
-            currentHistoryEntryId: h.currentHistoryEntryId,
-            historyLength: h.history.length,
-            historyIds: h.history.map(entry => entry.id)
-        })));
-        if (selectedIds.length === 0) {
-            if (devWarningsRef.current) {
-                console.warn('[useAdjustmentHistoryBatch] ❌ adjustSelectedWithPreset called with no selection');
-            }
-            return;
-        }
-        // Apply preset values with clamping
-        const clampedPreset = { ...presetAdjustments };
-        Object.keys(clampedPreset).forEach(key => {
-            const presetValue = clampedPreset[key];
-            clampedPreset[key] = Math.max(-100, Math.min(100, presetValue));
-        });
-        console.log('[useAdjustmentHistoryBatch] 🎨 Using SHARED logic for preset (same as reset)');
-        // Use the same logic as reset, just with preset values instead of default values
-        await applyAdjustmentToSelected(clampedPreset, 'preset');
-    }, [selectedIds, internalOptions, imageHistories, applyAdjustmentToSelected]);
-    // Set specific adjustment states for specified images (removed since not needed)
-    // Undo last changes to selected images - entry-based history version with backend sync
-    const undo = useCallback(async () => {
-        if (selectedIds.length === 0) {
-            if (devWarningsRef.current) {
-                console.warn('[useAdjustmentHistoryBatch] Cannot undo - no images selected');
-            }
-            return;
-        }
-        console.log('[useAdjustmentHistoryBatch] 🔍 UNDO: Before undo, current imageHistories state:', imageHistories.map(h => ({
-            imageId: h.imageId,
-            currentHistoryEntryId: h.currentHistoryEntryId,
-            historyLength: h.history.length,
-            historyIds: h.history.map(entry => entry.id)
-        })));
-        // Prepare backend operations BEFORE state update (outside setImageHistories)
-        let anyChanges = false;
-        const backendOperations = [];
-        // Process each image to prepare operations
-        const operationsToApply = [];
-        imageHistories.forEach(imageHistory => {
-            if (!selectedIds.includes(imageHistory.imageId)) {
-                return; // Skip images not selected
-            }
-            console.log(`[useAdjustmentHistoryBatch] 🔍 UNDO: Processing image ${imageHistory.imageId} with history:`, {
-                currentHistoryEntryId: imageHistory.currentHistoryEntryId,
-                historyLength: imageHistory.history.length,
-                historyIds: imageHistory.history.map(entry => entry.id)
-            });
-            // Find current entry index
-            const currentEntryIndex = imageHistory.history.findIndex(entry => entry.id === imageHistory.currentHistoryEntryId);
-            if (currentEntryIndex <= 0) {
-                console.log(`[useAdjustmentHistoryBatch] 🔍 UNDO: Cannot undo image ${imageHistory.imageId} - at first entry or not found`);
-                return; // Cannot undo if at first entry or entry not found
-            }
-            // Move to previous entry
-            const previousEntry = imageHistory.history[currentEntryIndex - 1];
-            anyChanges = true;
-            console.log(`[useAdjustmentHistoryBatch] 🔍 UNDO: Moving image ${imageHistory.imageId} from index ${currentEntryIndex} to ${currentEntryIndex - 1}`, {
-                fromId: imageHistory.currentHistoryEntryId,
-                toId: previousEntry.id,
-                preservedHistoryLength: imageHistory.history.length
-            });
-            // Store operation for state update
-            operationsToApply.push({
-                imageId: imageHistory.imageId,
-                newCurrentHistoryEntryId: previousEntry.id
-            });
-            // Prepare backend sync operation (OUTSIDE state setter)
-            if (previousEntry.id && internalOptions.controller && internalOptions.firebaseUid) {
-                backendOperations.push({
-                    imageId: imageHistory.imageId,
-                    taskId: previousEntry.id
-                });
-            }
-        });
-        // Now update state with prepared operations (no backend preparation inside)
-        setImageHistories(prevHistories => {
-            const result = prevHistories.map(imageHistory => {
-                // Find operation for this image
-                const operation = operationsToApply.find(op => op.imageId === imageHistory.imageId);
-                if (!operation) {
-                    return imageHistory; // No change for images not selected
-                }
-                console.log(`[useAdjustmentHistoryBatch] 📝 Applying state update for undo on image ${imageHistory.imageId}`);
-                const updatedHistory = {
-                    ...imageHistory,
-                    currentHistoryEntryId: operation.newCurrentHistoryEntryId
-                };
-                console.log(`[useAdjustmentHistoryBatch] 🔍 UNDO: Updated image ${imageHistory.imageId} history:`, {
-                    currentHistoryEntryId: updatedHistory.currentHistoryEntryId,
-                    historyLength: updatedHistory.history.length,
-                    historyIds: updatedHistory.history.map(entry => entry.id)
-                });
-                return updatedHistory;
-            });
-            console.log('[useAdjustmentHistoryBatch] 🔍 UNDO: After undo, final imageHistories state:', result.map(h => ({
-                imageId: h.imageId,
-                currentHistoryEntryId: h.currentHistoryEntryId,
-                historyLength: h.history.length,
-                historyIds: h.history.map(entry => entry.id)
-            })));
-            return result;
-        });
-        // Sync with backend (already prepared)
-        if (backendOperations.length > 0 && internalOptions.controller && internalOptions.firebaseUid) {
-            try {
-                console.log(`[useAdjustmentHistoryBatch] ⏪ Syncing ${backendOperations.length} undo operations to backend (setHistoryIndex for each image)`);
-                const promises = backendOperations.map(async (operation) => {
-                    console.log(`[useAdjustmentHistoryBatch] 🔄 Calling setHistoryIndex for undo on image ${operation.imageId} to taskId ${operation.taskId}`);
-                    await internalOptions.controller.setHistoryIndex(internalOptions.firebaseUid, operation.imageId, operation.taskId);
-                });
-                await Promise.all(promises);
-                if (devWarningsRef.current) {
-                    console.log(`[useAdjustmentHistoryBatch] ✅ Successfully synced ${backendOperations.length} undo operations to backend`);
-                }
-            }
-            catch (error) {
-                console.error('[useAdjustmentHistoryBatch] ❌ Failed to sync undo to backend:', error);
-            }
-        }
-        if (!anyChanges && devWarningsRef.current) {
-            console.warn('[useAdjustmentHistoryBatch] Undo skipped - no changes to undo for selected images');
-        }
-    }, [selectedIds, internalOptions, imageHistories]);
-    // Redo next changes to selected images - entry-based history version with backend sync
-    const redo = useCallback(async () => {
-        if (selectedIds.length === 0) {
-            if (devWarningsRef.current) {
-                console.warn('[useAdjustmentHistoryBatch] Cannot redo - no images selected');
-            }
-            return;
-        }
-        // Step 1: Prepare redo operations from current state
-        let anyChanges = false;
-        const operationsToApply = [];
-        const backendOperations = [];
-        imageHistories.forEach(imageHistory => {
-            if (!selectedIds.includes(imageHistory.imageId)) {
-                return; // Skip unselected images
-            }
-            // Find current entry index
-            const currentEntryIndex = imageHistory.history.findIndex(entry => entry.id === imageHistory.currentHistoryEntryId);
-            if (currentEntryIndex >= imageHistory.history.length - 1 || currentEntryIndex === -1) {
-                return; // Cannot redo if at last entry or entry not found
-            }
-            // Move to next entry
-            const nextEntry = imageHistory.history[currentEntryIndex + 1];
-            anyChanges = true;
-            operationsToApply.push({
-                imageId: imageHistory.imageId,
-                nextEntryId: nextEntry.id
-            });
-            // Prepare backend sync operation
-            if (nextEntry.id && internalOptions.controller && internalOptions.firebaseUid) {
-                backendOperations.push({
-                    imageId: imageHistory.imageId,
-                    taskId: nextEntry.id
-                });
-            }
-        });
-        // Step 2: Apply state updates cleanly
-        if (operationsToApply.length > 0) {
-            setImageHistories(prevHistories => {
-                return prevHistories.map(imageHistory => {
-                    const operation = operationsToApply.find(op => op.imageId === imageHistory.imageId);
-                    if (!operation) {
-                        return imageHistory; // No change for this image
-                    }
-                    return {
-                        ...imageHistory,
-                        currentHistoryEntryId: operation.nextEntryId
-                    };
-                });
-            });
-        }
-        // Step 3: Sync with backend
-        if (backendOperations.length > 0 && internalOptions.controller && internalOptions.firebaseUid) {
-            try {
-                console.log(`[useAdjustmentHistoryBatch] ⏩ Syncing ${backendOperations.length} redo operations to backend (setHistoryIndex for each image)`);
-                const promises = backendOperations.map(async (operation) => {
-                    console.log(`[useAdjustmentHistoryBatch] 🔄 Calling setHistoryIndex for redo on image ${operation.imageId} to taskId ${operation.taskId}`);
-                    await internalOptions.controller.setHistoryIndex(internalOptions.firebaseUid, operation.imageId, operation.taskId);
-                });
-                await Promise.all(promises);
-                if (devWarningsRef.current) {
-                    console.log(`[useAdjustmentHistoryBatch] ✅ Successfully synced ${backendOperations.length} redo operations to backend`);
-                }
-            }
-            catch (error) {
-                console.error('[useAdjustmentHistoryBatch] ❌ Failed to sync redo to backend:', error);
-            }
-        }
-        if (!anyChanges && devWarningsRef.current) {
-            console.warn('[useAdjustmentHistoryBatch] Redo skipped - no changes to redo for selected images');
-        }
-    }, [selectedIds, internalOptions, imageHistories]);
-    // Check if any selected image can be undone
-    const canUndoSelected = useCallback(() => {
-        return selectedIds.some(imageId => {
-            const imageHistory = imageHistories.find(h => h.imageId === imageId);
-            if (!imageHistory)
-                return false;
-            const currentEntryIndex = imageHistory.history.findIndex(entry => entry.id === imageHistory.currentHistoryEntryId);
-            return currentEntryIndex > 0;
-        });
-    }, [selectedIds, imageHistories]);
-    // Check if any selected image can be redone
-    const canRedoSelected = useCallback(() => {
-        return selectedIds.some(imageId => {
-            const imageHistory = imageHistories.find(h => h.imageId === imageId);
-            if (!imageHistory)
-                return false;
-            const currentEntryIndex = imageHistory.history.findIndex(entry => entry.id === imageHistory.currentHistoryEntryId);
-            return currentEntryIndex >= 0 && currentEntryIndex < imageHistory.history.length - 1;
-        });
-    }, [selectedIds, imageHistories]);
-    // Reset selected images to default state - now uses shared logic
-    const reset = useCallback(async (imageIds) => {
-        const idsToReset = imageIds || selectedIds;
-        console.log('[useAdjustmentHistoryBatch] 🔄 reset called for images:', idsToReset);
-        // Create default state
-        const defaultState = createDefaultAdjustmentState(internalOptions.defaultAdjustmentState);
-        console.log('[useAdjustmentHistoryBatch] 🔄 Using SHARED logic for reset (same as preset)');
-        // Use the same logic as preset, just with default values instead of preset values
-        await applyAdjustmentToSelected(defaultState, 'reset', idsToReset);
-    }, [selectedIds, internalOptions.defaultAdjustmentState, applyAdjustmentToSelected]);
-    // Selection management with initial adjustments - single state update
-    const setSelection = useCallback((configs) => {
-        const imageIds = configs.map(config => config.imageId);
-        // Update selectedIds state
-        setSelectedIds(imageIds);
-        // Build new batch state with initial adjustments
-        const newBatch = {
-            currentSelection: {},
-            allImages: { ...currentBatch.allImages },
-            initialStates: { ...currentBatch.initialStates }
-        };
-        // Process each image config
-        for (const config of configs) {
-            const { imageId, adjustment } = config;
-            // If image exists in allImages, use its state
-            if (currentBatch.allImages[imageId]) {
-                newBatch.currentSelection[imageId] = { ...currentBatch.allImages[imageId] };
-            }
-            else {
-                // New image - determine initial state
-                let initialState;
-                if (adjustment) {
-                    // Use provided adjustment as initial state
-                    initialState = {
-                        ...createDefaultAdjustmentState(internalOptions.defaultAdjustmentState),
-                        ...adjustment
-                    };
-                }
-                else {
-                    // Use default state
-                    initialState = createDefaultAdjustmentState(internalOptions.defaultAdjustmentState);
-                }
-                // Set initial state for new image
-                newBatch.currentSelection[imageId] = { ...initialState };
-                newBatch.allImages[imageId] = { ...initialState };
-                newBatch.initialStates[imageId] = { ...initialState };
-            }
-        }
-        // Update allImageIds to include any new images
-        const newAllImageIds = Array.from(new Set([...allImageIds, ...imageIds]));
-        setAllImageIds(newAllImageIds);
-        // Single state update to prevent multiple re-renders
-        setCurrentBatch(newBatch);
-        if (internalOptions.devWarnings) {
-            console.log('useAdjustmentHistoryBatch: Selection updated with initial adjustments', {
-                selected: imageIds,
-                totalImages: newAllImageIds.length,
-                newImages: imageIds.filter(id => !allImageIds.includes(id)),
-                withInitialAdjustments: configs.filter(c => c.adjustment).length
-            });
-        }
-    }, [allImageIds, currentBatch, internalOptions.defaultAdjustmentState, internalOptions.devWarnings]);
-    // Sync adjustments for specific images - loads full history from backend
-    const syncAdjustment = useCallback(async (configs) => {
-        if (configs.length === 0)
-            return;
-        // If controller is available, load full history from backend
-        if (internalOptions.controller && internalOptions.firebaseUid) {
-            try {
-                const historyPromises = configs.map(async (config) => {
-                    try {
-                        const historyResponse = await internalOptions.controller.getEditorHistory(internalOptions.firebaseUid, config.imageId);
-                        return {
-                            imageId: config.imageId,
-                            backendHistory: historyResponse.history || [],
-                            fallbackAdjustment: config.adjustment
-                        };
-                    }
-                    catch (error) {
-                        console.warn(`[useAdjustmentHistoryBatch] Failed to load history for image ${config.imageId}:`, error);
-                        return {
-                            imageId: config.imageId,
-                            backendHistory: [],
-                            fallbackAdjustment: config.adjustment
-                        };
-                    }
-                });
-                const historyResults = await Promise.all(historyPromises);
-                setImageHistories(prevHistories => {
-                    const updatedHistories = [...prevHistories];
-                    for (const result of historyResults) {
-                        const { imageId, backendHistory, fallbackAdjustment } = result;
-                        const existingIndex = updatedHistories.findIndex(h => h.imageId === imageId);
-                        if (backendHistory.length > 0) {
-                            // Convert backend history to local history entries
-                            const historyEntries = backendHistory.map((entry, index) => ({
-                                id: entry.task_id, // Use backend task_id as our entry id
-                                adjustment: mapColorAdjustmentToAdjustmentState ?
-                                    mapColorAdjustmentToAdjustmentState(entry.editor_config.color_adjustment) :
-                                    createDefaultAdjustmentState(internalOptions.defaultAdjustmentState)
-                            }));
-                            const newImageHistory = {
-                                imageId,
-                                currentHistoryEntryId: historyEntries[historyEntries.length - 1].id, // Point to latest entry
-                                history: historyEntries
-                            };
-                            if (existingIndex >= 0) {
-                                updatedHistories[existingIndex] = newImageHistory;
-                            }
-                            else {
-                                updatedHistories.push(newImageHistory);
-                            }
-                        }
-                        else {
-                            // No backend history, use fallback adjustment or default
-                            const adjustment = fallbackAdjustment ? {
-                                ...createDefaultAdjustmentState(internalOptions.defaultAdjustmentState),
-                                ...fallbackAdjustment
-                            } : createDefaultAdjustmentState(internalOptions.defaultAdjustmentState);
-                            const entryId = generateEntryId();
-                            const entry = {
-                                id: entryId,
-                                adjustment
-                            };
-                            const newImageHistory = {
-                                imageId,
-                                currentHistoryEntryId: entryId,
-                                history: [entry]
-                            };
-                            if (existingIndex >= 0) {
-                                updatedHistories[existingIndex] = newImageHistory;
-                            }
-                            else {
-                                updatedHistories.push(newImageHistory);
-                            }
-                        }
-                    }
-                    return updatedHistories;
-                });
-                if (internalOptions.devWarnings) {
-                    const syncedImageIds = configs.map(c => c.imageId);
-                    const totalHistoryEntries = historyResults.reduce((sum, result) => sum + result.backendHistory.length, 0);
-                    console.log('[useAdjustmentHistoryBatch] Synced adjustments with backend history', {
-                        syncedImages: syncedImageIds,
-                        totalHistoryEntries,
-                        historyLoaded: true
-                    });
-                }
-            }
-            catch (error) {
-                console.error('[useAdjustmentHistoryBatch] Failed to sync with backend, falling back to local only:', error);
-                // Fall back to local-only sync
-                syncAdjustmentLocal(configs);
-            }
-        }
-        else {
-            // No controller available, use local-only sync
-            syncAdjustmentLocal(configs);
-        }
-        // Update allImageIds to include any new images
-        const newImageIds = configs.map(c => c.imageId);
-        setAllImageIds(prev => {
-            const combined = Array.from(new Set([...prev, ...newImageIds]));
-            return combined;
-        });
-    }, [internalOptions]);
-    // Local-only sync for fallback
-    const syncAdjustmentLocal = useCallback((configs) => {
-        setImageHistories(prevHistories => {
-            const updatedHistories = [...prevHistories];
-            for (const config of configs) {
-                const { imageId, adjustment } = config;
-                const existingIndex = updatedHistories.findIndex(h => h.imageId === imageId);
-                if (adjustment) {
-                    const fullAdjustment = {
-                        ...createDefaultAdjustmentState(internalOptions.defaultAdjustmentState),
-                        ...adjustment
-                    };
-                    const entryId = generateEntryId();
-                    const entry = {
-                        id: entryId,
-                        adjustment: fullAdjustment
-                    };
-                    if (existingIndex >= 0) {
-                        // Update existing image history, replace with new adjustment as initial state
-                        updatedHistories[existingIndex] = {
-                            imageId,
-                            currentHistoryEntryId: entryId,
-                            history: [entry] // Reset history with synced state
-                        };
-                    }
-                    else {
-                        // Add new image history
-                        updatedHistories.push({
-                            imageId,
-                            currentHistoryEntryId: entryId,
-                            history: [entry]
-                        });
-                    }
-                }
-                else if (existingIndex < 0) {
-                    // Add new image with default state
-                    const defaultState = createDefaultAdjustmentState(internalOptions.defaultAdjustmentState);
-                    const entryId = generateEntryId();
-                    const entry = {
-                        id: entryId,
-                        adjustment: defaultState
-                    };
-                    updatedHistories.push({
-                        imageId,
-                        currentHistoryEntryId: entryId,
-                        history: [entry]
-                    });
-                }
-            }
-            return updatedHistories;
-        });
-    }, [internalOptions]);
-    const toggleSelection = useCallback((imageId) => {
-        setSelectedIds(prev => {
-            const isCurrentlySelected = prev.includes(imageId);
-            const newSelectedIds = isCurrentlySelected
-                ? prev.filter(id => id !== imageId)
-                : [...prev, imageId];
-            // Update currentSelection in batch state
-            const newBatch = {
-                currentSelection: { ...currentBatch.currentSelection },
-                allImages: { ...currentBatch.allImages },
-                initialStates: { ...currentBatch.initialStates }
-            };
-            if (isCurrentlySelected) {
-                // Remove from currentSelection
-                delete newBatch.currentSelection[imageId];
-            }
-            else {
-                // Add to currentSelection - use existing state from allImages or create default
-                if (currentBatch.allImages[imageId]) {
-                    newBatch.currentSelection[imageId] = { ...currentBatch.allImages[imageId] };
-                }
-                else {
-                    // New image - create default state
-                    const defaultState = createDefaultAdjustmentState(internalOptions.defaultAdjustmentState);
-                    newBatch.currentSelection[imageId] = { ...defaultState };
-                    newBatch.allImages[imageId] = { ...defaultState };
-                    newBatch.initialStates[imageId] = { ...defaultState };
-                }
-            }
-            setCurrentBatch(newBatch);
-            return newSelectedIds;
-        });
-    }, [currentBatch, internalOptions.defaultAdjustmentState]);
-    const selectAll = useCallback(() => {
-        setSelectedIds([...allImageIds]);
-        // Update currentSelection to include all images
-        const newBatch = {
-            currentSelection: {},
-            allImages: { ...currentBatch.allImages },
-            initialStates: { ...currentBatch.initialStates }
-        };
-        for (const imageId of allImageIds) {
-            if (currentBatch.allImages[imageId]) {
-                newBatch.currentSelection[imageId] = { ...currentBatch.allImages[imageId] };
-            }
-            else {
-                // New image - create default state
-                const defaultState = createDefaultAdjustmentState(internalOptions.defaultAdjustmentState);
-                newBatch.currentSelection[imageId] = { ...defaultState };
-                newBatch.allImages[imageId] = { ...defaultState };
-                newBatch.initialStates[imageId] = { ...defaultState };
-            }
-        }
-        setCurrentBatch(newBatch);
-    }, [allImageIds, currentBatch, internalOptions.defaultAdjustmentState]);
-    const clearSelection = useCallback(() => {
-        setSelectedIds([]);
-        // Clear currentSelection but keep allImages and initialStates
-        const newBatch = {
-            currentSelection: {},
-            allImages: { ...currentBatch.allImages },
-            initialStates: { ...currentBatch.initialStates }
-        };
-        setCurrentBatch(newBatch);
-    }, [currentBatch]);
-    // Jump to specific index - not applicable in per-image history
-    const jumpToIndex = useCallback((index) => {
-        if (devWarningsRef.current) {
-            console.warn('[useAdjustmentHistoryBatch] jumpToIndex not supported in per-image history mode');
-        }
-    }, []);
-    // Clear all history and start fresh
-    const clearHistory = useCallback(() => {
-        setImageHistories([]);
-        setCurrentBatch(createEmptyBatchState());
-        setAllImageIds([]);
-        setSelectedIds([]);
-    }, []);
-    const getCurrentBatch = useCallback(() => {
-        return {
-            currentSelection: { ...currentBatch.currentSelection },
-            allImages: { ...currentBatch.allImages },
-            initialStates: { ...currentBatch.initialStates }
-        };
-    }, [currentBatch]);
-    // Sync entire batch state - adapted for entry-based history
-    const syncBatch = useCallback((newBatch, targetIndex) => {
-        // Validate input
-        if (!newBatch || typeof newBatch !== 'object' || !newBatch.currentSelection || !newBatch.allImages || !newBatch.initialStates) {
-            console.warn('syncBatch: newBatch must be a valid BatchAdjustmentState object with currentSelection, allImages, and initialStates');
-            return;
-        }
-        // Convert batch state to entry-based histories
-        const newImageHistories = [];
-        Object.entries(newBatch.allImages).forEach(([imageId, adjustment]) => {
-            const entryId = generateEntryId();
-            const entry = {
-                id: entryId,
-                adjustment
-            };
-            newImageHistories.push({
-                imageId,
-                currentHistoryEntryId: entryId,
-                history: [entry] // Start with current state as single history entry
-            });
-        });
-        // Update state
-        setImageHistories(newImageHistories);
-        setCurrentBatch({
-            currentSelection: { ...newBatch.currentSelection },
-            allImages: { ...newBatch.allImages },
-            initialStates: { ...newBatch.initialStates }
-        });
-        // Update tracking
-        const allImageIds = Object.keys(newBatch.allImages);
-        const selectedImageIds = Object.keys(newBatch.currentSelection);
-        setAllImageIds(allImageIds);
-        setSelectedIds(selectedImageIds);
-        if (devWarningsRef.current) {
-            console.log('[useAdjustmentHistoryBatch] Synchronized batch state to entry-based history', {
-                totalImages: allImageIds.length,
-                selectedImages: selectedImageIds.length
-            });
-        }
-    }, []);
-    // Sync gallery updates - check for updated galleries and refresh their history
-    const syncGalleryUpdates = useCallback(async () => {
-        if (!internalOptions.controller || !internalOptions.firebaseUid || !internalOptions.eventId) {
-            if (devWarningsRef.current) {
-                console.warn('[useAdjustmentHistoryBatch] syncGalleryUpdates: Missing required options (controller, firebaseUid, or eventId)');
-            }
-            return;
-        }
-        try {
-            // Step 1: Check for gallery updates since last timestamp
-            console.log(`[useAdjustmentHistoryBatch] 🔄 Checking for gallery updates since timestamp: ${lastUpdateTimestamp}`);
-            const updateResponse = await internalOptions.controller.getGalleryUpdateTimestamp(internalOptions.firebaseUid, internalOptions.eventId, lastUpdateTimestamp);
-            if (!updateResponse.gallery || updateResponse.gallery.length === 0) {
-                if (devWarningsRef.current) {
-                    console.log('[useAdjustmentHistoryBatch] ✅ No gallery updates found');
-                }
-                return;
-            }
-            console.log(`[useAdjustmentHistoryBatch] 📥 Found ${updateResponse.gallery.length} updated galleries:`, updateResponse.gallery);
-            // Step 2: Fetch history for each updated gallery
-            const historyPromises = updateResponse.gallery.map(async (galleryId) => {
-                try {
-                    console.log(`[useAdjustmentHistoryBatch] 🔄 Fetching history for gallery: ${galleryId}`);
-                    const historyResponse = await internalOptions.controller.getEditorHistory(internalOptions.firebaseUid, galleryId);
-                    return {
-                        imageId: galleryId,
-                        currentTaskId: historyResponse.current_task_id,
-                        backendHistory: historyResponse.history || [],
-                        success: true
-                    };
-                }
-                catch (error) {
-                    console.error(`[useAdjustmentHistoryBatch] ❌ Failed to fetch history for gallery ${galleryId}:`, error);
-                    return {
-                        imageId: galleryId,
-                        currentTaskId: '',
-                        backendHistory: [],
-                        success: false
-                    };
-                }
-            });
-            const historyResults = await Promise.all(historyPromises);
-            const successfulUpdates = historyResults.filter(result => result.success && result.backendHistory.length > 0);
-            if (successfulUpdates.length === 0) {
-                if (devWarningsRef.current) {
-                    console.log('[useAdjustmentHistoryBatch] ℹ️ No valid history updates to apply');
-                }
-                // Update timestamp even if no valid updates
-                setLastUpdateTimestamp(Date.now());
-                return;
-            }
-            // Step 3: Prepare history updates from backend data
-            const historyUpdates = [];
-            successfulUpdates.forEach(result => {
-                const { imageId, currentTaskId, backendHistory } = result;
-                if (backendHistory.length > 0) {
-                    // Convert backend history to local history entries
-                    const historyEntries = backendHistory.map((entry) => ({
-                        id: entry.task_id, // Use backend task_id as our entry id
-                        adjustment: mapColorAdjustmentToAdjustmentState ?
-                            mapColorAdjustmentToAdjustmentState(entry.editor_config.color_adjustment) :
-                            createDefaultAdjustmentState(internalOptions.defaultAdjustmentState)
-                    }));
-                    historyUpdates.push({
-                        imageId,
-                        newHistory: historyEntries,
-                        newCurrentEntryId: currentTaskId // Use current_task_id as current history entry
-                    });
-                    console.log(`[useAdjustmentHistoryBatch] 📝 Prepared history update for gallery ${imageId}:`, {
-                        historyEntries: historyEntries.length,
-                        currentEntryId: currentTaskId
-                    });
-                }
-            });
-            // Step 4: Apply history updates cleanly to state
-            if (historyUpdates.length > 0) {
-                setImageHistories(prevHistories => {
-                    return prevHistories.map(imageHistory => {
-                        const update = historyUpdates.find(u => u.imageId === imageHistory.imageId);
-                        if (!update) {
-                            return imageHistory; // No update for this image
-                        }
-                        // Replace entire history with updated backend data
-                        return {
-                            ...imageHistory,
-                            history: update.newHistory,
-                            currentHistoryEntryId: update.newCurrentEntryId
-                        };
-                    });
-                });
-                console.log(`[useAdjustmentHistoryBatch] ✅ Successfully updated history for ${historyUpdates.length} galleries`);
-            }
-            // Step 5: Update timestamp to mark successful sync
-            setLastUpdateTimestamp(Date.now());
-            if (devWarningsRef.current) {
-                console.log('[useAdjustmentHistoryBatch] 🔄 Gallery sync completed', {
-                    totalChecked: updateResponse.gallery.length,
-                    successfulUpdates: successfulUpdates.length,
-                    appliedUpdates: historyUpdates.length,
-                    newTimestamp: Date.now()
-                });
-            }
-        }
-        catch (error) {
-            console.error('[useAdjustmentHistoryBatch] ❌ Failed to sync gallery updates:', error);
-            // Don't update timestamp on error, so we can retry
-        }
-    }, [internalOptions, lastUpdateTimestamp, mapColorAdjustmentToAdjustmentState]);
-    // Configuration actions
-    const setMaxSize = useCallback((size) => {
-        maxSizeRef.current = size;
-        if (size !== 'unlimited') {
-            enforceMaxSize();
-        }
-    }, [enforceMaxSize]);
-    // History info object - updated for per-image history
-    const historyInfo = useMemo(() => ({
-        canUndo: canUndoSelected(),
-        canRedo: canRedoSelected(),
-        currentIndex: 0, // Not applicable in per-image history
-        totalStates: imageHistories.reduce((sum, h) => sum + h.history.length, 0),
-        selectedCount: selectedIds.length,
-        totalImages: allImageIds.length,
-        historySize: getMemoryUsage()
-    }), [canUndoSelected, canRedoSelected, imageHistories, selectedIds.length, allImageIds.length, getMemoryUsage]);
-    // Actions object - stabilized with useMemo
-    const actions = useMemo(() => ({
-        adjustSelected,
-        adjustSelectedWithPreset,
-        undo,
-        redo,
-        reset,
-        setSelection,
-        syncAdjustment,
-        syncGalleryUpdates,
-        toggleSelection,
-        selectAll,
-        clearSelection,
-        jumpToIndex,
-        clearHistory,
-        getCurrentBatch,
-        syncBatch
-    }), [
-        adjustSelected, adjustSelectedWithPreset, undo, redo, reset,
-        setSelection, syncAdjustment, syncGalleryUpdates, toggleSelection, selectAll, clearSelection,
-        jumpToIndex, clearHistory, getCurrentBatch, syncBatch
-    ]);
-    // Config object - stabilized with useMemo
-    const config = useMemo(() => ({
-        setMaxSize,
-        getMemoryUsage
-    }), [setMaxSize, getMemoryUsage]);
-    // Apply max size enforcement when history changes
-    useEffect(() => {
-        enforceMaxSize();
-    }, [enforceMaxSize]);
-    return {
-        currentBatch,
-        selectedIds,
-        allImageIds,
-        historyInfo,
-        actions,
-        config
-    };
-}