@sqlrooms/kepler 0.29.0-rc.1 → 0.29.0-rc.11

package/dist/KeplerSlice.js

@@ -1,4 +1,4 @@
-import { addDataToMap, addLayer as addLayerAction, deleteEntry, ActionTypes as KeplerActionTypes, registerEntry, removeDataset, requestMapStyles, wrapTo, } from '@kepler.gl/actions';
+import { addDataToMap, addFilter as addFilterAction, addLayer as addLayerAction, deleteEntry, interactionConfigChange, ActionTypes as KeplerActionTypes, registerEntry, removeDataset, requestMapStyles, setFilter as setFilterAction, setFilterAnimationTime as setFilterAnimationTimeAction, setFilterAnimationWindow as setFilterAnimationWindowAction, setFilterView as setFilterViewAction, toggleLayerForMap as toggleLayerForMapAction, toggleSplitMap as toggleSplitMapAction, wrapTo, } from '@kepler.gl/actions';
 import { ALL_FIELD_TYPES } from '@kepler.gl/constants';
 import { castDuckDBTypesForKepler, getDuckDBColumnTypes, getDuckDBColumnTypesMap, restoreGeoarrowMetadata, setGeoArrowWKBExtension, } from '@kepler.gl/duckdb';
 import { arrowSchemaToFields } from '@kepler.gl/processors';
@@ -7,11 +7,15 @@ import { KeplerGLSchemaClass } from '@kepler.gl/schemas';
 import { KeplerTable } from '@kepler.gl/table';
 import { initApplicationConfig, } from '@kepler.gl/utils';
 import { createId } from '@paralleldrive/cuid2';
+import { KeplerSliceConfig } from '@sqlrooms/kepler-config';
 import { createSlice, useBaseRoomShellStore, } from '@sqlrooms/room-shell';
+import { getTheme } from '@sqlrooms/ui';
 import { produce, setAutoFreeze } from 'immer';
 import { taskMiddleware } from 'react-palm/tasks';
 import { compose } from 'redux';
 import { createLogger } from 'redux-logger';
+import { getTableIdentity, getUnqualifiedSqlIdentifier, } from '@sqlrooms/duckdb-core';
+import { findKeplerTableForDatasetId, getKeplerDatasetIdForTable, getKeplerTableLabel, } from './keplerTableSelection';
 setAutoFreeze(false); // Kepler attempts to mutate redux state, so we need to disable immer's auto freeze to avoid errors
 const KeplerGLSchemaManager = new KeplerGLSchemaClass();
 class DesktopKeplerTable extends KeplerTable {
@@ -20,9 +24,40 @@ class DesktopKeplerTable extends KeplerTable {
         return (d) => d;
     };
 }
+function createDefaultMapKeplerState(resolvedTheme) {
+    return {
+        mapStyle: {
+            styleType: resolvedTheme === 'dark' ? 'dark-matter' : 'positron',
+        },
+        uiState: {
+            ...INITIAL_UI_STATE,
+            activeSidePanel: null,
+            currentModal: null,
+            mapControls: {
+                visibleLayers: INITIAL_UI_STATE.mapControls.visibleLayers,
+                splitMap: {
+                    show: true,
+                    active: false,
+                },
+                mapLegend: {
+                    show: true,
+                    active: false,
+                },
+                toggle3d: {
+                    show: true,
+                    active: false,
+                },
+                mapDraw: {
+                    show: true,
+                    active: false,
+                },
+            },
+        },
+    };
+}
 export function createDefaultKeplerConfig(props) {
     const mapId = createId();
-    return {
+    const config = {
         maps: [
             {
                 id: mapId,
@@ -31,10 +66,9 @@ export function createDefaultKeplerConfig(props) {
                 lastOpenedAt: Date.now(),
             },
         ],
-        currentMapId: mapId,
-        openTabs: [mapId],
         ...props,
     };
+    return KeplerSliceConfig.parse(config);
 }
 export function hasMapId(action) {
     return (typeof action.payload === 'object' &&
@@ -44,6 +78,25 @@ export function hasMapId(action) {
         action.payload.meta !== null &&
         '_id_' in action.payload.meta);
 }
+function normalizeAddTableToMapParams(paramsOrMapId, tableName, options = {}, config = {}, loadOptions = {}) {
+    if (typeof paramsOrMapId === 'object') {
+        return {
+            options: {},
+            config: {},
+            ...paramsOrMapId,
+        };
+    }
+    if (!tableName) {
+        throw new Error('addTableToMap requires a tableName.');
+    }
+    return {
+        mapId: paramsOrMapId,
+        tableName,
+        options,
+        config,
+        datasetId: loadOptions.datasetId,
+    };
+}
 // Auto save will be triggered in middleware on every kepler action
 // skip these actions to avoid unnecessary save
 const SKIP_AUTO_SAVE_ACTIONS = [
@@ -51,37 +104,60 @@ const SKIP_AUTO_SAVE_ACTIONS = [
     KeplerActionTypes.UPDATE_MAP,
     KeplerActionTypes.MOUSE_MOVE,
 ];
-export function createKeplerSlice({ basicKeplerProps = {}, config: initialConfigProps, initialKeplerState = {
-    mapStyle: { styleType: 'positron' },
-    uiState: {
-        ...INITIAL_UI_STATE,
-        currentModal: null,
-        mapControls: {
-            visibleLayers: INITIAL_UI_STATE.mapControls.visibleLayers,
-            mapLegend: {
-                show: true,
-                active: false,
-            },
-            toggle3d: {
-                show: true,
-                active: false,
-            },
-        },
-    },
-}, actionLogging = false, middlewares: additionalMiddlewares = [], applicationConfig, onAction, } = {}) {
+export function createKeplerSlice({ basicKeplerProps = {}, keplerTheme, modalPortalTarget = 'container', config: initialConfigProps, createInitialMapKeplerState, actionLogging = false, middlewares: additionalMiddlewares = [], applicationConfig, tableSelection = {}, onAction, } = {}) {
     const initialConfig = createDefaultKeplerConfig(initialConfigProps);
     initApplicationConfig({
         table: DesktopKeplerTable,
         ...applicationConfig,
     });
+    let syncKeplerPromise = null;
+    let configRestoreDepth = 0;
+    const configRestorePromises = new Set();
+    // When a caller arrives while a sync is already in-flight, the in-flight run
+    // may have captured a stale snapshot of db.tables/kepler.map (missing maps or
+    // tables added by createMap, duplicateMap, etc.). Setting this flag tells the
+    // active run to loop once more with a fresh snapshot after it finishes, so
+    // late mutations are never silently dropped.
+    let pendingKeplerSync = false;
     const updateMapLastOpenedAt = (maps, mapId, now = Date.now()) => {
         const map = maps.find((item) => item.id === mapId);
         if (map) {
             map.lastOpenedAt = now;
         }
     };
-    return createSlice((set, get) => {
-        const keplerReducer = keplerGlReducer.initialState(initialKeplerState);
+    return createSlice((set, get, _store) => {
+        function getDefaultDbSchema() {
+            const currentDatabase = get().db.currentDatabase;
+            const currentSchema = get().db.currentSchema;
+            if (!currentDatabase || !currentSchema) {
+                return undefined;
+            }
+            return {
+                database: currentDatabase,
+                schema: currentSchema,
+            };
+        }
+        const resolvedTableSelection = {
+            ...tableSelection,
+        };
+        if (!resolvedTableSelection.defaultDbSchema) {
+            resolvedTableSelection.defaultDbSchema = getDefaultDbSchema;
+        }
+        function resolveInitialMapKeplerState(context) {
+            const resolvedTheme = getTheme();
+            const defaultInitialMapKeplerState = createDefaultMapKeplerState(resolvedTheme);
+            return (createInitialMapKeplerState?.({
+                ...context,
+                defaultInitialMapKeplerState,
+            }) ?? defaultInitialMapKeplerState);
+        }
+        function createKeplerReducer(context) {
+            return keplerGlReducer.initialState(resolveInitialMapKeplerState(context));
+        }
+        function registerMapEntry(id) {
+            return registerEntry({ id, ...basicKeplerProps });
+        }
+        const keplerReducer = createKeplerReducer({ reason: 'initialize' });
         const middlewares = [
             taskMiddleware,
             saveKeplerConfigMiddleware,
@@ -111,23 +187,37 @@ export function createKeplerSlice({ basicKeplerProps = {}, config: initialConfig
             kepler: {
                 config: initialConfig,
                 basicKeplerProps,
+                keplerTheme,
+                modalPortalTarget,
+                tableSelection: resolvedTableSelection,
                 map: {},
+                isRestoringConfig: false,
                 dispatchAction: () => { },
                 __reduxProviderStore: undefined,
                 forwardDispatch: {},
                 setConfig: (config) => {
-                    set((state) => produce(state, (draft) => {
-                        draft.kepler.config = config;
-                    }));
-                    updateMapReduxStates();
-                    updateForwardDispatch();
-                    updateMapConfigs();
-                    get().kepler.syncKeplerDatasets();
+                    void get()
+                        .kepler.withConfigPersistencePaused(async () => {
+                        const nextConfig = KeplerSliceConfig.parse(config);
+                        set((state) => produce(state, (draft) => {
+                            draft.kepler.config = nextConfig;
+                        }));
+                        updateMapReduxStates();
+                        updateForwardDispatch();
+                        updateMapConfigs();
+                        await get().kepler.syncKeplerDatasets();
+                    })
+                        .catch((error) => {
+                        console.error('setConfig: failed to restore Kepler config', error);
+                    });
                 },
                 async initialize() {
                     const config = get().kepler.config;
-                    const currentMapId = config.currentMapId;
-                    const keplerInitialState = keplerReducer(undefined, registerEntry({ id: currentMapId }));
+                    const keplerInitialState = config.maps.reduce((mapState, map) => createKeplerReducer({
+                        reason: 'initialize',
+                        mapId: map.id,
+                        name: map.name,
+                    })(mapState, registerMapEntry(map.id)), {});
                     set({
                         kepler: {
                             ...get().kepler,
@@ -150,24 +240,101 @@ export function createKeplerSlice({ basicKeplerProps = {}, config: initialConfig
                                 // @ts-expect-error - Symbol.observable is not defined in the Redux type definitions
                                 [Symbol.observable]: () => { },
                             },
+                            isRestoringConfig: get().kepler.isRestoringConfig,
                         },
                     });
                     updateForwardDispatch();
-                    updateMapConfigs();
                     await get().kepler.syncKeplerDatasets();
-                    requestMapStyle(config.currentMapId);
+                    updateMapConfigs();
+                    for (const mapId of Object.keys(get().kepler.map)) {
+                        requestMapStyle(mapId);
+                    }
+                },
+                async destroy() {
+                    // no-op
                 },
                 addLayer: (mapId, layer, datasetId) => {
                     get().kepler.registerKeplerMapIfNotExists(mapId);
                     get().kepler.dispatchAction(mapId, addLayerAction(layer, datasetId));
                 },
-                addTableToMap: async (mapId, tableName, options = {}) => {
+                addFilter: (mapId, datasetId) => {
+                    get().kepler.registerKeplerMapIfNotExists(mapId);
+                    get().kepler.dispatchAction(mapId, addFilterAction(datasetId));
+                },
+                setFilter: (mapId, filterIdx, prop, value, valueIndex) => {
+                    get().kepler.registerKeplerMapIfNotExists(mapId);
+                    get().kepler.dispatchAction(mapId, setFilterAction(filterIdx, prop, value, valueIndex));
+                },
+                setFilterAnimationTime: (mapId, filterIdx, prop, value) => {
+                    get().kepler.registerKeplerMapIfNotExists(mapId);
+                    get().kepler.dispatchAction(mapId, setFilterAnimationTimeAction(filterIdx, prop, value));
+                },
+                setFilterAnimationWindow: (mapId, filterId, animationWindow) => {
+                    get().kepler.registerKeplerMapIfNotExists(mapId);
+                    get().kepler.dispatchAction(mapId, setFilterAnimationWindowAction({ id: filterId, animationWindow }));
+                },
+                setFilterView: (mapId, filterIdx, view) => {
+                    get().kepler.registerKeplerMapIfNotExists(mapId);
+                    get().kepler.dispatchAction(mapId, setFilterViewAction(filterIdx, view));
+                },
+                updateTooltipFields: (mapId, datasetId, fieldNames) => {
+                    get().kepler.registerKeplerMapIfNotExists(mapId);
+                    const mapState = get().kepler.map[mapId];
+                    const tooltipConfig = mapState?.visState?.interactionConfig?.tooltip;
+                    if (!tooltipConfig)
+                        return;
+                    const currentFieldsToShow = tooltipConfig.config?.fieldsToShow || {};
+                    const existingFields = currentFieldsToShow[datasetId] || [];
+                    const existingByName = new Map(existingFields.map((field) => [
+                        field.name,
+                        field,
+                    ]));
+                    const nextFields = Array.from(new Set(fieldNames)).map((name) => existingByName.get(name) ?? { name, format: null });
+                    if (nextFields.length === existingFields.length &&
+                        nextFields.every((field, index) => field.name === existingFields[index]?.name &&
+                            field.format === existingFields[index]?.format)) {
+                        return;
+                    }
+                    get().kepler.dispatchAction(mapId, interactionConfigChange({
+                        ...tooltipConfig,
+                        config: {
+                            ...tooltipConfig.config,
+                            fieldsToShow: {
+                                ...currentFieldsToShow,
+                                [datasetId]: nextFields,
+                            },
+                        },
+                    }));
+                },
+                toggleSplitMap: (mapId, index) => {
+                    get().kepler.registerKeplerMapIfNotExists(mapId);
+                    get().kepler.dispatchAction(mapId, toggleSplitMapAction(index));
+                },
+                toggleLayerForMap: (mapId, mapIndex, layerId) => {
+                    get().kepler.registerKeplerMapIfNotExists(mapId);
+                    get().kepler.dispatchAction(mapId, toggleLayerForMapAction(mapIndex, layerId));
+                },
+                addTableToMap: (async (paramsOrMapId, legacyTableName, legacyOptions, legacyConfig, legacyLoadOptions) => {
+                    const { mapId, tableName, options, config, datasetId: explicitDatasetId, } = normalizeAddTableToMapParams(paramsOrMapId, legacyTableName, legacyOptions, legacyConfig, legacyLoadOptions);
+                    const tableSelection = get().kepler.tableSelection;
+                    const table = findKeplerTableForDatasetId(get().db.tables, tableName, tableSelection);
+                    const sqlTableName = table
+                        ? getTableIdentity(table.table)
+                        : tableName;
+                    let datasetId = explicitDatasetId;
+                    if (!datasetId && table) {
+                        datasetId = getKeplerDatasetIdForTable(table, tableSelection);
+                    }
+                    if (!datasetId) {
+                        datasetId =
+                            getUnqualifiedSqlIdentifier(String(sqlTableName)) ?? tableName;
+                    }
                     const connector = await get().db.getConnector();
                     const duckDbColumns = await getDuckDBColumnTypes({
                         query: (query) => connector.query(query).result,
-                    }, tableName);
+                    }, sqlTableName);
                     const tableDuckDBTypes = getDuckDBColumnTypesMap(duckDbColumns);
-                    const adjustedQuery = castDuckDBTypesForKepler(tableName, duckDbColumns);
+                    const adjustedQuery = castDuckDBTypesForKepler(sqlTableName, duckDbColumns);
                     const arrowResult = await connector.query(adjustedQuery).result;
                     setGeoArrowWKBExtension(arrowResult, duckDbColumns);
                     // TODO remove once DuckDB doesn't drop geoarrow metadata
@@ -175,98 +342,169 @@ export function createKeplerSlice({ basicKeplerProps = {}, config: initialConfig
                     const fields = arrowSchemaToFields(arrowResult, tableDuckDBTypes);
                     const cols = Array.from({ length: arrowResult.numCols }, (_, i) => arrowResult.getChildAt(i)).filter((col) => col);
                     if (fields && cols) {
+                        let label = tableName;
+                        if (table) {
+                            label = getKeplerTableLabel(table, tableSelection);
+                        }
+                        else {
+                            label =
+                                getUnqualifiedSqlIdentifier(String(sqlTableName)) ?? tableName;
+                        }
                         const datasets = {
                             data: { fields, cols, rows: [], arrowTable: arrowResult },
-                            info: { label: tableName, id: tableName },
-                            metadata: { tableName },
+                            info: { label, id: datasetId },
+                            metadata: { tableName: sqlTableName },
                         };
-                        get().kepler.dispatchAction(mapId, addDataToMap({ datasets, options }));
+                        get().kepler.dispatchAction(mapId, addDataToMap({ datasets, options, config }));
                     }
-                },
-                getCurrentMap: () => {
-                    return get().kepler.config.maps.find((map) => map.id === get().kepler.config.currentMapId);
-                },
-                setCurrentMapId: (mapId) => {
-                    return set((state) => produce(state, (draft) => {
-                        const now = Date.now();
-                        draft.kepler.config.currentMapId = mapId;
-                        updateMapLastOpenedAt(draft.kepler.config.maps, mapId, now);
-                    }));
-                },
-                createMap: (name) => {
-                    const mapId = createId();
+                }),
+                ensureMap: (mapId, name) => {
                     const now = Date.now();
                     set((state) => produce(state, (draft) => {
+                        const existing = draft.kepler.config.maps.find((map) => map.id === mapId);
+                        if (existing) {
+                            if (name && existing.name !== name) {
+                                existing.name = name;
+                            }
+                            return;
+                        }
                         draft.kepler.config.maps.push({
                             id: mapId,
                             name: name ?? 'Untitled Map',
                             lastOpenedAt: now,
                         });
-                        draft.kepler.config.openTabs.push(mapId);
-                        draft.kepler.map = keplerReducer(draft.kepler.map, registerEntry({ id: mapId }));
+                        draft.kepler.map = createKeplerReducer({
+                            reason: 'create-map',
+                            mapId,
+                            name,
+                        })(draft.kepler.map, registerMapEntry(mapId));
                         draft.kepler.forwardDispatch[mapId] = getForwardDispatch(mapId);
                     }));
+                    if (!get().kepler.map[mapId]) {
+                        get().kepler.registerKeplerMapIfNotExists(mapId);
+                    }
                     requestMapStyle(mapId);
                     get().kepler.syncKeplerDatasets();
+                },
+                createMap: (name, options) => {
+                    const mapId = options?.id ?? createId();
+                    get().kepler.ensureMap(mapId, name);
                     return mapId;
                 },
                 async syncKeplerDatasets() {
-                    for (const mapId of Object.keys(get().kepler.map)) {
-                        const keplerDatasets = get().kepler.map[mapId]?.visState.datasets;
-                        for (const { table } of get().db.tables) {
-                            // TODO: remove this once getDuckDBColumnTypesMap can handle qualified table names
-                            // const qualifiedTable = table.toString();
-                            if (
-                            // !table.schema?.startsWith('__') && // skip internal schemas
-                            // !keplerDatasets?.[qualifiedTable]
-                            table.schema === 'main' &&
-                                !keplerDatasets?.[table.table]) {
-                                await get().kepler.addTableToMap(mapId, table.table, {
-                                    autoCreateLayers: false,
-                                    centerMap: false,
-                                });
+                    if (syncKeplerPromise) {
+                        pendingKeplerSync = true;
+                        return syncKeplerPromise;
+                    }
+                    syncKeplerPromise = (async () => {
+                        // Loop until no new sync was requested during the current pass.
+                        // Each iteration reads a fresh snapshot of db.tables and kepler.map,
+                        // so tables/maps added concurrently are picked up on the next pass.
+                        do {
+                            pendingKeplerSync = false;
+                            for (const mapId of Object.keys(get().kepler.map)) {
+                                const mapState = get().kepler.map[mapId];
+                                if (!mapState)
+                                    continue;
+                                const keplerDatasets = mapState.visState.datasets;
+                                // Only sync tables that are referenced by existing layers or filters
+                                const referencedDataIds = new Set();
+                                for (const layer of mapState.visState.layers ?? []) {
+                                    if (layer.config.dataId) {
+                                        referencedDataIds.add(layer.config.dataId);
+                                    }
+                                }
+                                for (const filter of mapState.visState.filters ?? []) {
+                                    for (const dataId of filter.dataId ?? []) {
+                                        referencedDataIds.add(dataId);
+                                    }
+                                }
+                                const availableTables = get().db.tables;
+                                for (const dataId of referencedDataIds) {
+                                    if (keplerDatasets?.[dataId]) {
+                                        continue;
+                                    }
+                                    const table = findKeplerTableForDatasetId(availableTables, dataId, get().kepler.tableSelection);
+                                    if (!table) {
+                                        continue;
+                                    }
+                                    try {
+                                        await get().kepler.addTableToMap({
+                                            mapId,
+                                            tableName: dataId,
+                                            options: {
+                                                autoCreateLayers: false,
+                                                centerMap: false,
+                                            },
+                                            datasetId: dataId,
+                                        });
+                                    }
+                                    catch (e) {
+                                        console.error('syncKeplerDatasets: addTableToMap failed', {
+                                            dataId,
+                                            e,
+                                        });
+                                    }
+                                }
                             }
-                        }
+                        } while (pendingKeplerSync);
+                    })();
+                    try {
+                        await syncKeplerPromise;
+                    }
+                    finally {
+                        syncKeplerPromise = null;
                     }
                 },
                 deleteMap: (mapId) => {
                     set((state) => produce(state, (draft) => {
-                        const openTabs = draft.kepler.config.openTabs;
                         const maps = draft.kepler.config.maps;
-                        const wasCurrentMap = draft.kepler.config.currentMapId === mapId;
-                        const deletingIndex = openTabs.indexOf(mapId);
-                        // Remove from maps and openTabs
                         draft.kepler.config.maps = maps.filter((map) => map.id !== mapId);
-                        draft.kepler.config.openTabs = openTabs.filter((id) => id !== mapId);
-                        // If we deleted the current map, select another one
-                        if (wasCurrentMap) {
-                            const newOpenTabs = draft.kepler.config.openTabs;
-                            const remainingMaps = draft.kepler.config.maps;
-                            if (newOpenTabs.length > 0) {
-                                // Select from remaining open tabs
-                                const newIndex = deletingIndex === 0
-                                    ? 0
-                                    : Math.min(deletingIndex - 1, newOpenTabs.length - 1);
-                                const newSelectedId = newOpenTabs[newIndex];
-                                if (newSelectedId) {
-                                    draft.kepler.config.currentMapId = newSelectedId;
-                                    updateMapLastOpenedAt(draft.kepler.config.maps, newSelectedId, Date.now());
-                                }
-                            }
-                            else if (remainingMaps.length > 0) {
-                                // No open tabs left, open a closed map
-                                const mapToOpen = remainingMaps[0];
-                                if (mapToOpen) {
-                                    draft.kepler.config.openTabs.push(mapToOpen.id);
-                                    draft.kepler.config.currentMapId = mapToOpen.id;
-                                    updateMapLastOpenedAt(draft.kepler.config.maps, mapToOpen.id, Date.now());
-                                }
-                            }
-                        }
                         draft.kepler.map = keplerReducer(draft.kepler.map, deleteEntry(mapId));
                         delete draft.kepler.forwardDispatch[mapId];
                     }));
                 },
+                duplicateMap: async (mapId) => {
+                    // Ensure the map's redux state is registered, consistent with other kepler actions
+                    get().kepler.registerKeplerMapIfNotExists(mapId);
+                    const sourceMap = get().kepler.config.maps.find((m) => m.id === mapId);
+                    const sourceMapState = get().kepler.map[mapId];
+                    if (!sourceMap || !sourceMapState) {
+                        return {
+                            success: false,
+                            message: 'Unable to duplicate map: source map or state not found',
+                            code: 'source-map-not-found',
+                        };
+                    }
+                    const newMapId = createId();
+                    const now = Date.now();
+                    // Save the source map state using Kepler's schema manager
+                    const savedConfig = KeplerGLSchemaManager.getConfigToSave(sourceMapState);
+                    set((state) => produce(state, (draft) => {
+                        draft.kepler.config.maps.push({
+                            id: newMapId,
+                            name: `Copy of ${sourceMap.name}`,
+                            config: savedConfig,
+                            lastOpenedAt: now,
+                        });
+                        // Register the new map with empty state, then load the config
+                        draft.kepler.map = createKeplerReducer({
+                            reason: 'duplicate-map',
+                            mapId: newMapId,
+                            name: `Copy of ${sourceMap.name}`,
+                        })(draft.kepler.map, registerMapEntry(newMapId));
+                        draft.kepler.forwardDispatch[newMapId] =
+                            getForwardDispatch(newMapId);
+                    }));
+                    // Load the saved config into the new map
+                    get().kepler.addConfigToMap(newMapId, savedConfig);
+                    requestMapStyle(newMapId);
+                    get().kepler.syncKeplerDatasets();
+                    return {
+                        success: true,
+                        message: 'Map duplicated successfully',
+                    };
+                },
                 renameMap: (mapId, name) => {
                     set((state) => produce(state, (draft) => {
                         const map = draft.kepler.config.maps.find((map) => map.id === mapId);
@@ -275,21 +513,6 @@ export function createKeplerSlice({ basicKeplerProps = {}, config: initialConfig
                         }
                     }));
                 },
-                closeMap: (mapId) => {
-                    set((state) => produce(state, (draft) => {
-                        const openTabs = draft.kepler.config.openTabs;
-                        // Don't close if it's the last open tab (defensive check, TabStrip also prevents this)
-                        if (openTabs.length <= 1)
-                            return;
-                        // Just remove from openTabs - TabStrip handles selection via onSelect before calling onClose
-                        draft.kepler.config.openTabs = openTabs.filter((id) => id !== mapId);
-                    }));
-                },
-                setOpenTabs: (tabIds) => {
-                    set((state) => produce(state, (draft) => {
-                        draft.kepler.config.openTabs = tabIds;
-                    }));
-                },
                 addDataToMap: (mapId, data) => {
                     get().kepler.registerKeplerMapIfNotExists(mapId);
                     get().kepler.dispatchAction(mapId, addDataToMap(data));
@@ -338,12 +561,53 @@ export function createKeplerSlice({ basicKeplerProps = {}, config: initialConfig
                     }
                     get().kepler.dispatchAction(mapId, addDataToMap({ config: parsedConfig, datasets: [] }));
                 },
+                withConfigPersistencePaused: async (fn) => {
+                    configRestoreDepth += 1;
+                    if (configRestoreDepth === 1) {
+                        set((state) => produce(state, (draft) => {
+                            draft.kepler.isRestoringConfig = true;
+                        }));
+                    }
+                    const restorePromise = (async () => {
+                        try {
+                            return await fn();
+                        }
+                        finally {
+                            // Kepler restore actions can enqueue follow-up work through
+                            // react-palm; let those actions settle before persisted config
+                            // writes are allowed again.
+                            await new Promise((resolve) => setTimeout(resolve, 0));
+                            await new Promise((resolve) => setTimeout(resolve, 0));
+                            configRestoreDepth -= 1;
+                            if (configRestoreDepth === 0) {
+                                set((state) => produce(state, (draft) => {
+                                    draft.kepler.isRestoringConfig = false;
+                                }));
+                            }
+                        }
+                    })();
+                    configRestorePromises.add(restorePromise);
+                    try {
+                        return await restorePromise;
+                    }
+                    finally {
+                        configRestorePromises.delete(restorePromise);
+                    }
+                },
+                waitForConfigRestore: async () => {
+                    while (configRestorePromises.size > 0) {
+                        await Promise.allSettled(Array.from(configRestorePromises));
+                    }
+                },
                 registerKeplerMapIfNotExists(mapId) {
                     if (!get().kepler.map[mapId]) {
                         set({
                             kepler: {
                                 ...get().kepler,
-                                map: keplerReducer(get().kepler.map, registerEntry({ id: mapId })),
+                                map: createKeplerReducer({
+                                    reason: 'register-map',
+                                    mapId,
+                                })(get().kepler.map, registerMapEntry(mapId)),
                                 forwardDispatch: {
                                     ...get().kepler.forwardDispatch,
                                     [mapId]: getForwardDispatch(mapId),
@@ -377,7 +641,10 @@ export function createKeplerSlice({ basicKeplerProps = {}, config: initialConfig
                 if (!mapId)
                     throw new Error('Map ID not found in action payload');
                 const result = next(action);
-                if (!SKIP_AUTO_SAVE_ACTIONS.includes(action.type) && mapId) {
+                if (configRestoreDepth === 0 &&
+                    !get().kepler.isRestoringConfig &&
+                    !SKIP_AUTO_SAVE_ACTIONS.includes(action.type) &&
+                    mapId) {
                     // save kepler config to store
                     set((state) => produce(state, (draft) => {
                         const mapToSave = draft.kepler.config.maps.find((map) => map.id === mapId);
@@ -410,7 +677,11 @@ export function createKeplerSlice({ basicKeplerProps = {}, config: initialConfig
                 // Register redux state of maps that are not in the config
                 for (const map of draft.kepler.config.maps) {
                     if (!draft.kepler.map[map.id]) {
-                        draft.kepler.map = keplerReducer(draft.kepler.map, registerEntry({ id: map.id }));
+                        draft.kepler.map = createKeplerReducer({
+                            reason: 'sync-config',
+                            mapId: map.id,
+                            name: map.name,
+                        })(draft.kepler.map, registerMapEntry(map.id));
                         draft.kepler.forwardDispatch[map.id] = getForwardDispatch(map.id);
                     }
                 }
@@ -418,10 +689,7 @@ export function createKeplerSlice({ basicKeplerProps = {}, config: initialConfig
         }
         function updateForwardDispatch() {
             const config = get().kepler.config;
-            const currentMapId = config.currentMapId;
-            const forwardDispatch = {
-                [currentMapId]: getForwardDispatch(currentMapId),
-            };
+            const forwardDispatch = {};
             if (config) {
                 for (const { id } of config.maps) {
                     forwardDispatch[id] = getForwardDispatch(id);