diff --git a/web/client/components/widgets/builder/wizard/FilterWizard.jsx b/web/client/components/widgets/builder/wizard/FilterWizard.jsx
index 2a14013a0f9..62d5138e4f2 100644
--- a/web/client/components/widgets/builder/wizard/FilterWizard.jsx
+++ b/web/client/components/widgets/builder/wizard/FilterWizard.jsx
@@ -95,8 +95,8 @@ const FilterWizard = ({
     }, [editorData, setValid]);
 
     const tabContents = {
-        data: <FilterDataTab data={filterData} onChange={onChange} onOpenLayerSelector={onOpenLayerSelector} openFilterEditor={openFilterEditor} onEditorChange={onEditorChange} dashBoardEditing={dashBoardEditing} selections={selections} />,
-        layout: <FilterLayoutTab data={filterData} onChange={onChange} selections={selections} onEditorChange={onEditorChange} selectableItems={selectableItems}  />,
+        data: <FilterDataTab data={filterData} onChange={onChange} onOpenLayerSelector={onOpenLayerSelector} openFilterEditor={openFilterEditor} onEditorChange={onEditorChange} dashBoardEditing={dashBoardEditing} selections={selections} interactions={editorData?.interactions || []} />,
+        layout: <FilterLayoutTab data={filterData} onChange={onChange} selections={selections} onEditorChange={onEditorChange} selectableItems={selectableItems} interactions={editorData?.interactions || []}  />,
         actions: <FilterActionsTab data={filterData} onChange={onChange} onEditorChange={onEditorChange}  />
     };
 
diff --git a/web/client/components/widgets/builder/wizard/common/interactions/InteractionButtons.jsx b/web/client/components/widgets/builder/wizard/common/interactions/InteractionButtons.jsx
index b5a45ff285c..eff3789b82c 100644
--- a/web/client/components/widgets/builder/wizard/common/interactions/InteractionButtons.jsx
+++ b/web/client/components/widgets/builder/wizard/common/interactions/InteractionButtons.jsx
@@ -24,38 +24,27 @@ const TButton = tooltip(Button);
  * @param {function} setShowConfiguration toggles the UI for configuration
  * @param {boolean} isPluggable tells if the interaction can be plugged or not
  * @param {boolean} isConfigurable tells if the interaction can be configured or not
+ * @param {object} plugConstraints describes whether plugging is disabled and why
  * @returns {React.ReactElement}
  */
-const InteractionButtons = ({ plugged, setPlugged, showConfiguration, setShowConfiguration = () => {}, isPluggable, isConfigurable, notConnectableForSpecialCase, notConnectableForSpecialCaseMsg}) => {
-
-    if (notConnectableForSpecialCase) {
-        return (
-            <FlexBox gap="xs" className="ms-interaction-buttons">
-                <TButton
-                    disabled
-                    borderTransparent
-                    tooltip={<Message msgId={notConnectableForSpecialCaseMsg} />}
-                    className="square-button"
-                >
-                    <Glyphicon glyph="ban-circle" />
-                </TButton>
-            </FlexBox>
-        );
-    }
+const InteractionButtons = ({ plugged, setPlugged, showConfiguration, setShowConfiguration = () => {}, isPluggable, isConfigurable, plugConstraints = {} }) => {
+    const { disabled: isPlugConstrained = false, reason: plugConstraintReason = null } = plugConstraints;
     return (
-        <FlexBox gap="xs" className="ms-interaction-buttons">
+        <FlexBox gap="xs" className={`ms-interaction-buttons${isPlugConstrained ? ' is-disabled' : ''}`}>
             {isConfigurable && <TButton
                 visible={isConfigurable}
+                disabled={isPlugConstrained}
                 onClick={() => setShowConfiguration(!showConfiguration)}
                 borderTransparent
-                tooltip={<Message msgId="widgets.filterWidget.targetAutomaticallyNotConnectableTooltip" />}
+                tooltip={plugConstraintReason || <Message msgId="widgets.filterWidget.targetAutomaticallyNotConnectableTooltip" />}
                 variant={showConfiguration ? "primary" : undefined}
 
             >
                 <Glyphicon glyph="cog" />
             </TButton>}
             <TButton
-                disabled={!isPluggable}
+                disabled={!isPluggable || isPlugConstrained}
+                tooltip={plugConstraintReason || undefined}
                 onClick={() => setPlugged(!plugged)}
                 borderTransparent
                 variant={plugged ? "success" : undefined}
@@ -67,4 +56,3 @@ const InteractionButtons = ({ plugged, setPlugged, showConfiguration, setShowCon
 };
 
 export default InteractionButtons;
-
diff --git a/web/client/components/widgets/builder/wizard/common/interactions/InteractionEventsSelector.jsx b/web/client/components/widgets/builder/wizard/common/interactions/InteractionEventsSelector.jsx
index 437b4f975fb..642558bf649 100644
--- a/web/client/components/widgets/builder/wizard/common/interactions/InteractionEventsSelector.jsx
+++ b/web/client/components/widgets/builder/wizard/common/interactions/InteractionEventsSelector.jsx
@@ -14,25 +14,27 @@ import { Glyphicon } from 'react-bootstrap';
 import { getWidgetInteractionTreeGenerated, getEditingWidget, getAllInteractionsWhileEditingSelector } from '../../../../../../selectors/widgets';
 import InteractionTargetsList from './InteractionTargetsList';
 import './interaction-wizard.less';
-import { detachSingleChildCollections, filterTreeWithTarget } from '../../../../../../utils/InteractionUtils';
+import { detachSingleChildCollections, filterTreeWithTarget, filterDimensionTreeByValueAttributeType } from '../../../../../../utils/InteractionUtils';
 import Message from '../../../../../I18N/Message';
+import tooltip from '../../../../../misc/enhancers/tooltip';
 
-const targetTitleTranslationMap = {
-    "Apply filter": "widgets.filterWidget.applyFilter",
-    "Apply style": "widgets.filterWidget.applyStyle"
-};
-
+const TButton = tooltip(Button);
 
-const InteractionEventsSelector = ({target, expanded, toggleExpanded = () => {}, interactionTree, interactions, sourceWidgetId, currentSourceId, onEditorChange, alreadyExistingInteractions}) => {
+export const InteractionEventsSelector = ({target, expanded, toggleExpanded = () => {}, interactionTree, interactions, sourceWidgetId, currentSourceId, onEditorChange, alreadyExistingInteractions, valueAttributeType, sourceSelectionMode, targetTitleMsgIds = {}, removable = false, onRemove = () => {}}) => {
 
     const filteredInteractionTree = useMemo(() => {
-        const filteredTree = filterTreeWithTarget(interactionTree, target) || [];
-        return detachSingleChildCollections(filteredTree, ['widgets', 'traces', "layers"]);
-    }, [interactionTree]);
+        const filteredTree = filterTreeWithTarget(interactionTree, target) || { children: [] };
+        const dimensionFilteredTree = target?.targetType === 'applyDimension'
+            ? filterDimensionTreeByValueAttributeType(filteredTree, valueAttributeType)
+            : filteredTree;
+        return detachSingleChildCollections(dimensionFilteredTree, ['widgets', 'traces', "map", "layers"]) || { children: [] };
+    }, [interactionTree, target, valueAttributeType]);
+    const hasConnectableNodes = (filteredInteractionTree?.children || []).length > 0;
+    const targetTitleMsgId = targetTitleMsgIds[target.targetType];
 
     return (<FlexBox className="ms-interactions-container" component="ul" column gap="sm">
         <FlexBox component="li" gap="xs" column>
-            <FlexBox className="ms-interactions-event"gap="sm" centerChildrenVertically >
+            <FlexBox className="ms-interactions-event" gap="sm" centerChildrenVertically >
                 <Button
                     onClick={() => toggleExpanded()}
                     borderTransparent
@@ -42,21 +44,37 @@ const InteractionEventsSelector = ({target, expanded, toggleExpanded = () => {},
                     }
                 </Button>
                 <Glyphicon glyph={target?.glyph} />
-                <Text className="ms-flex-fill"><Message msgId={targetTitleTranslationMap[target.title] || ""} /></Text>
-
-
+                <Text className="ms-flex-fill">
+                    {targetTitleMsgId ? <Message msgId={targetTitleMsgId} /> : target.title}
+                </Text>
+                {removable && (
+                    <TButton
+                        onClick={onRemove}
+                        borderTransparent
+                        tooltip={<Message msgId="widgets.filterWidget.delete" />}
+                        style={{ padding: 0, background: 'transparent' }}>
+                        <Glyphicon glyph="trash" />
+                    </TButton>
+                )}
             </FlexBox>
             {expanded && <FlexBox className="ms-interactions-targets" component="ul" column gap="sm" >
-                <InteractionTargetsList
-                    target={target}
-                    interactionTree={interactionTree}
-                    interactions={interactions}
-                    sourceWidgetId={sourceWidgetId}
-                    currentSourceId={currentSourceId}
-                    onEditorChange={onEditorChange}
-                    filteredInteractionTree={filteredInteractionTree}
-                    alreadyExistingInteractions={alreadyExistingInteractions}
-                />
+                {hasConnectableNodes ? (
+                    <InteractionTargetsList
+                        target={target}
+                        interactionTree={interactionTree}
+                        interactions={interactions}
+                        sourceWidgetId={sourceWidgetId}
+                        currentSourceId={currentSourceId}
+                        onEditorChange={onEditorChange}
+                        filteredInteractionTree={filteredInteractionTree}
+                        alreadyExistingInteractions={alreadyExistingInteractions}
+                        sourceSelectionMode={sourceSelectionMode}
+                    />
+                ) : (
+                    <FlexBox component="li" className="ms-interactions-empty-state">
+                        <Text><Message msgId="widgets.filterWidget.noConnectableNodesAvailable" /></Text>
+                    </FlexBox>
+                )}
             </FlexBox>}
         </FlexBox>
     </FlexBox>);
diff --git a/web/client/components/widgets/builder/wizard/common/interactions/InteractionTargetsList.jsx b/web/client/components/widgets/builder/wizard/common/interactions/InteractionTargetsList.jsx
index 2ee57d4689e..220a51b42b1 100644
--- a/web/client/components/widgets/builder/wizard/common/interactions/InteractionTargetsList.jsx
+++ b/web/client/components/widgets/builder/wizard/common/interactions/InteractionTargetsList.jsx
@@ -10,7 +10,7 @@ import FlexBox from '../../../../../layout/FlexBox';
 // import { filterTreeWithTarget } from '../../../../../../utils/InteractionUtils';
 import InteractionsRow from './InteractionsRow';
 
-const InteractionTargetsList = ({target, interactionTree, interactions, sourceWidgetId, currentSourceId, onEditorChange, filteredInteractionTree, alreadyExistingInteractions}) => {
+const InteractionTargetsList = ({target, interactionTree, interactions, sourceWidgetId, currentSourceId, onEditorChange, filteredInteractionTree, alreadyExistingInteractions, sourceSelectionMode}) => {
 
 
     const renderContainer = (children) => (
@@ -26,6 +26,7 @@ const InteractionTargetsList = ({target, interactionTree, interactions, sourceWi
                     currentSourceId={currentSourceId}
                     onEditorChange={onEditorChange}
                     alreadyExistingInteractions={alreadyExistingInteractions}
+                    sourceSelectionMode={sourceSelectionMode}
                 />
             ))}
         </FlexBox>
@@ -39,4 +40,3 @@ const InteractionTargetsList = ({target, interactionTree, interactions, sourceWi
 };
 
 export default InteractionTargetsList;
-
diff --git a/web/client/components/widgets/builder/wizard/common/interactions/InteractionsEditor.jsx b/web/client/components/widgets/builder/wizard/common/interactions/InteractionsEditor.jsx
index 2f104d6954d..cc3cce91684 100644
--- a/web/client/components/widgets/builder/wizard/common/interactions/InteractionsEditor.jsx
+++ b/web/client/components/widgets/builder/wizard/common/interactions/InteractionsEditor.jsx
@@ -1,9 +1,21 @@
 import React, { useEffect, useState } from 'react';
 import InteractionEventsSelector from "./InteractionEventsSelector";
 import { TARGET_TYPES } from '../../../../../../utils/InteractionUtils';
+import FlexBox from '../../../../../layout/FlexBox';
 
 // currentSourceId is the source that will be source of the target, in filter widget 'filterId' is expected
-const InteractionEditor = ({targets = [], sourceWidgetId, currentSourceId, onEditorChange = () => {}, isStyleOnly = false}) => {
+const InteractionEditor = ({
+    targets = [],
+    sourceWidgetId,
+    currentSourceId,
+    onEditorChange = () => {},
+    isStyleOnly = false,
+    valueAttributeType,
+    sourceSelectionMode,
+    targetTitleMsgIds = {},
+    removableTargetTypes = [],
+    onRemoveTarget = () => {}
+}) => {
     const initialExpandedItems = targets.length > 0 ? [targets[0].targetType] : [];
     const [expandedItems, setExpandedItems] = useState(initialExpandedItems);
     const toggleExpanded = (name) => {
@@ -21,7 +33,17 @@ const InteractionEditor = ({targets = [], sourceWidgetId, currentSourceId, onEdi
         }
     }, [isStyleOnly]);
 
-    return <>
+    useEffect(() => {
+        if (targets.some(target => target.targetType === TARGET_TYPES.APPLY_DIMENSION)) {
+            setExpandedItems(items =>
+                items.includes(TARGET_TYPES.APPLY_DIMENSION)
+                    ? items
+                    : [...items, TARGET_TYPES.APPLY_DIMENSION]
+            );
+        }
+    }, [targets]);
+
+    return (<FlexBox column gap="xs" className="ms-interactions-editor">
         {targets.map(e => {
             const expanded = expandedItems.includes(e.targetType);
             return (<InteractionEventsSelector
@@ -32,9 +54,14 @@ const InteractionEditor = ({targets = [], sourceWidgetId, currentSourceId, onEdi
                 sourceWidgetId={sourceWidgetId}
                 currentSourceId={currentSourceId}
                 onEditorChange={onEditorChange}
+                valueAttributeType={valueAttributeType}
+                sourceSelectionMode={sourceSelectionMode}
+                targetTitleMsgIds={targetTitleMsgIds}
+                removable={removableTargetTypes.includes(e.targetType)}
+                onRemove={() => onRemoveTarget(e.targetType)}
             />);
         })}
-    </>;
+    </FlexBox>);
 };
 
 export default InteractionEditor;
diff --git a/web/client/components/widgets/builder/wizard/common/interactions/InteractionsRow.jsx b/web/client/components/widgets/builder/wizard/common/interactions/InteractionsRow.jsx
index 0225f08eaed..64e8d5a6258 100644
--- a/web/client/components/widgets/builder/wizard/common/interactions/InteractionsRow.jsx
+++ b/web/client/components/widgets/builder/wizard/common/interactions/InteractionsRow.jsx
@@ -13,6 +13,7 @@ import { Glyphicon } from 'react-bootstrap';
 import {
     findNodeById,
     getItemPluggableStatus,
+    isLayerDimensionTarget,
     TARGET_TYPES
 } from '../../../../../../utils/InteractionUtils';
 import InteractionButtons from './InteractionButtons';
@@ -20,6 +21,7 @@ import InteractionConfiguration from './InteractionConfiguration';
 import { buildInteractionObject, matchesInteraction } from './interactionHelpers';
 import { DEFAULT_CONFIGURATION } from './interactionConstants';
 import Message from '../../../../../I18N/Message';
+import tooltip from '../../../../../misc/enhancers/tooltip';
 
 import LocalizedString from '../../../../../I18N/LocalizedString';
 
@@ -28,8 +30,11 @@ const itemTitleTranslationMap = {
     "Map": "widgets.filterWidget.map"
 };
 
+const isMapTimeTargetNodePath = (nodePath) => nodePath === 'map.time' || /(?:^|\.)maps\[[^\]]+\]\.time$/.test(nodePath);
+const TFlexBox = tooltip(FlexBox);
 
-const InteractionsRow = ({item, target, interactions, sourceWidgetId, interactionTree, currentSourceId, onEditorChange, alreadyExistingInteractions}) => {
+
+const InteractionsRow = ({item, target, interactions, sourceWidgetId, interactionTree, currentSourceId, onEditorChange, alreadyExistingInteractions, sourceSelectionMode}) => {
     // from interactions we can derive if the target is plugged or not, and its configuration
 
     const hasChildren = item?.children?.length > 0;
@@ -57,6 +62,14 @@ const InteractionsRow = ({item, target, interactions, sourceWidgetId, interactio
     // Get configuration directly from existing interaction or use default
     const configuration = existingInteraction?.configuration || DEFAULT_CONFIGURATION;
     const plugged = existingInteraction?.plugged || false;
+    const sourcePluggedConnections = alreadyExistingInteractions.filter(i =>
+        i?.plugged === true
+        && i?.source?.nodePath === sourceNodePath
+    );
+    const hasMapTimeConnection = sourcePluggedConnections.some(i => isMapTimeTargetNodePath(i?.target?.nodePath));
+    const hasNonMapTimeConnection = sourcePluggedConnections.some(i => !isMapTimeTargetNodePath(i?.target?.nodePath));
+    const currentItemIsMapTime = isMapTimeTargetNodePath(targetNodePath);
+    const mapTimeLockConflict = (hasMapTimeConnection && !currentItemIsMapTime) || (hasNonMapTimeConnection && currentItemIsMapTime);
 
 
     const { directlyPluggable, configuredToForcePlug } = getItemPluggableStatus(item, target, configuration);
@@ -110,9 +123,73 @@ const InteractionsRow = ({item, target, interactions, sourceWidgetId, interactio
         return alreadyExistingInteractions.filter(i => i.source.nodePath !== sourceNodePath).some(i => (i.targetType === TARGET_TYPES.APPLY_STYLE && target.targetType === TARGET_TYPES.APPLY_STYLE) && i.target.nodePath === targetNodePath && i.plugged);
     }, [alreadyExistingInteractions, targetNodePath, sourceNodePath]);
 
+    const layerDimensionAlreadyConnected = useMemo(() => {
+        if (target.targetType !== TARGET_TYPES.APPLY_DIMENSION || !isLayerDimensionTarget(targetNodePath)) {
+            return false;
+        }
+        return alreadyExistingInteractions
+            .filter(i => i.source.nodePath !== sourceNodePath)
+            .some(i =>
+                i.targetType === TARGET_TYPES.APPLY_DIMENSION
+                && i.target.nodePath === targetNodePath
+                && i.plugged
+            );
+    }, [alreadyExistingInteractions, target.targetType, targetNodePath, sourceNodePath]);
+
+    const dimensionMultipleSelectionDisabled = target.targetType === TARGET_TYPES.APPLY_DIMENSION
+        && sourceSelectionMode === 'multiple'
+        && !plugged;
+
+    const plugConstraints = useMemo(() => {
+        if (styleAlreadyConnected) {
+            return {
+                disabled: true,
+                reason: <Message msgId="widgets.filterWidget.targetAlreadyConnectedToAnotherFilterTooltip" />
+            };
+        }
+
+        if (layerDimensionAlreadyConnected) {
+            return {
+                disabled: true,
+                reason: <Message msgId="widgets.filterWidget.targetAlreadyConnectedToAnotherFilterTooltip" />
+            };
+        }
+
+        if (dimensionMultipleSelectionDisabled) {
+            return {
+                disabled: true,
+                reason: <Message msgId="widgets.filterWidget.applyDimensionMultipleSelectionDisabledTooltip" />
+            };
+        }
+
+        if (mapTimeLockConflict) {
+            return {
+                disabled: true,
+                reason: <Message msgId="widgets.filterWidget.targetAlreadyConnectedToTimeTooltip" />
+            };
+        }
+
+        return {
+            disabled: false,
+            reason: null
+        };
+    }, [styleAlreadyConnected, layerDimensionAlreadyConnected, dimensionMultipleSelectionDisabled, mapTimeLockConflict]);
+    const rowPlugConstraints = item.type === 'element'
+        ? plugConstraints
+        : {
+            disabled: false,
+            reason: null
+        };
+
     return (
         <FlexBox key={item.id} component="li" gap="xs" column>
-            <FlexBox gap="xs" className="ms-connection-row"  centerChildrenVertically>
+            <TFlexBox
+                gap="xs"
+                className={`ms-connection-row${rowPlugConstraints.disabled ? ' is-disabled' : ''}`}
+                centerChildrenVertically
+                tooltip={rowPlugConstraints.disabled ? rowPlugConstraints.reason : null}
+                tooltipPosition="top"
+            >
                 {hasChildren && (
                     <Button
                         onClick={() => setExpanded(!expanded)}
@@ -133,11 +210,10 @@ const InteractionsRow = ({item, target, interactions, sourceWidgetId, interactio
                         setPlugged={handlePlugToggle}
                         showConfiguration={showConfiguration}
                         setShowConfiguration={setShowConfiguration}
-                        notConnectableForSpecialCase={styleAlreadyConnected}
-                        notConnectableForSpecialCaseMsg="widgets.filterWidget.targetAlreadyConnectedToStyleTooltip"
+                        plugConstraints={plugConstraints}
                     />
                 )}
-            </FlexBox>
+            </TFlexBox>
             <InteractionConfiguration item={item} show={showConfiguration} configuration={configuration} setConfiguration={handleConfigurationChange} setPlugged={handlePlugToggle} target={target} />
             {hasChildren && expanded && (
                 <FlexBox component="ul" column gap="xs">
@@ -152,6 +228,7 @@ const InteractionsRow = ({item, target, interactions, sourceWidgetId, interactio
                             currentSourceId={currentSourceId}
                             onEditorChange={onEditorChange}
                             alreadyExistingInteractions={alreadyExistingInteractions}
+                            sourceSelectionMode={sourceSelectionMode}
                         />
                     ))}
                 </FlexBox>
@@ -161,4 +238,3 @@ const InteractionsRow = ({item, target, interactions, sourceWidgetId, interactio
 };
 
 export default InteractionsRow;
-
diff --git a/web/client/components/widgets/builder/wizard/common/interactions/__tests__/InteractionsRow-test.jsx b/web/client/components/widgets/builder/wizard/common/interactions/__tests__/InteractionsRow-test.jsx
new file mode 100644
index 00000000000..5092d8a5501
--- /dev/null
+++ b/web/client/components/widgets/builder/wizard/common/interactions/__tests__/InteractionsRow-test.jsx
@@ -0,0 +1,208 @@
+/*
+ * Copyright 2026, GeoSolutions Sas.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import expect from 'expect';
+import React from 'react';
+import ReactDOM from 'react-dom';
+
+import InteractionsRow from '../InteractionsRow';
+
+const renderInteractionsRow = ({
+    item,
+    target,
+    interactions = [],
+    sourceNodePath = 'widgets[filter-widget].filters[filter-1]',
+    alreadyExistingInteractions = [],
+    sourceSelectionMode
+}) => {
+    const container = document.getElementById('container');
+    const interactionTree = {
+        id: 'root',
+        children: [{
+            id: 'filter-1',
+            nodePath: sourceNodePath
+        }]
+    };
+
+    ReactDOM.render(
+        <InteractionsRow
+            item={item}
+            target={target}
+            interactions={interactions}
+            sourceWidgetId="filter-widget"
+            interactionTree={interactionTree}
+            currentSourceId="filter-1"
+            onEditorChange={() => {}}
+            alreadyExistingInteractions={alreadyExistingInteractions}
+            sourceSelectionMode={sourceSelectionMode}
+        />,
+        container
+    );
+
+    return container;
+};
+
+const createLayerDimensionItem = (dimension) => ({
+    id: `params.${dimension}`,
+    title: dimension === 'time' ? 'Time' : 'Elevation',
+    icon: dimension === 'time' ? 'time' : 'arrow-up',
+    type: 'element',
+    nodePath: `map.layers[layer-1].params.${dimension}`,
+    interactionMetadata: {
+        targets: [{
+            targetType: 'applyDimension',
+            expectedDataType: 'LAYER_DIMENSION',
+            constraints: {}
+        }]
+    }
+});
+
+describe('InteractionsRow component', () => {
+    beforeEach((done) => {
+        document.body.innerHTML = '<div id="container"></div>';
+        setTimeout(done);
+    });
+
+    afterEach((done) => {
+        ReactDOM.unmountComponentAtNode(document.getElementById('container'));
+        document.body.innerHTML = '';
+        setTimeout(done);
+    });
+
+    it('should only disable element rows when map time is already connected', () => {
+        const sourceNodePath = 'widgets[filter-widget].filters[filter-1]';
+        const target = {
+            targetType: 'applyDimension',
+            expectedDataType: 'LAYER_DIMENSION',
+            constraints: {}
+        };
+        const item = {
+            id: 'map',
+            title: 'Map',
+            icon: '1-map',
+            type: 'collection',
+            nodePath: 'map',
+            children: [{
+                id: 'params.elevation',
+                title: 'Elevation',
+                icon: 'arrow-up',
+                type: 'element',
+                nodePath: 'map.layers[layer-1].params.elevation',
+                interactionMetadata: {
+                    targets: [{
+                        targetType: 'applyDimension',
+                        expectedDataType: 'LAYER_DIMENSION',
+                        constraints: {}
+                    }]
+                }
+            }]
+        };
+        const container = renderInteractionsRow({
+            item,
+            target,
+            sourceNodePath,
+            alreadyExistingInteractions: [{
+                id: 'map-time-interaction',
+                plugged: true,
+                targetType: 'applyDimension',
+                source: {
+                    nodePath: sourceNodePath
+                },
+                target: {
+                    nodePath: 'map.time'
+                }
+            }]
+        });
+
+        const rows = container.querySelectorAll('.ms-connection-row');
+        expect(rows.length).toBe(2);
+        expect(rows[0].classList.contains('is-disabled')).toBe(false);
+        expect(rows[1].classList.contains('is-disabled')).toBe(true);
+        expect(rows[1].querySelector('button').disabled).toBe(true);
+    });
+
+    it('should disable elevation when the same layer elevation is connected from another filter', () => {
+        const sourceNodePath = 'widgets[filter-widget].filters[filter-1]';
+        const target = {
+            targetType: 'applyDimension',
+            expectedDataType: 'LAYER_DIMENSION',
+            constraints: {}
+        };
+        const item = createLayerDimensionItem('elevation');
+
+        const container = renderInteractionsRow({
+            item,
+            target,
+            sourceNodePath,
+            alreadyExistingInteractions: [{
+                id: 'elevation-interaction',
+                plugged: true,
+                targetType: 'applyDimension',
+                source: {
+                    nodePath: 'widgets[filter-widget].filters[filter-2]'
+                },
+                target: {
+                    nodePath: 'map.layers[layer-1].params.elevation'
+                }
+            }]
+        });
+
+        const row = container.querySelector('.ms-connection-row');
+        expect(row.classList.contains('is-disabled')).toBe(true);
+        expect(row.querySelector('button').disabled).toBe(true);
+    });
+
+    it('should disable layer time when the same layer time is connected from another filter', () => {
+        const sourceNodePath = 'widgets[filter-widget].filters[filter-1]';
+        const target = {
+            targetType: 'applyDimension',
+            expectedDataType: 'LAYER_DIMENSION',
+            constraints: {}
+        };
+        const item = createLayerDimensionItem('time');
+
+        const container = renderInteractionsRow({
+            item,
+            target,
+            sourceNodePath,
+            alreadyExistingInteractions: [{
+                id: 'layer-time-interaction',
+                plugged: true,
+                targetType: 'applyDimension',
+                source: {
+                    nodePath: 'widgets[filter-widget].filters[filter-2]'
+                },
+                target: {
+                    nodePath: 'map.layers[layer-1].params.time'
+                }
+            }]
+        });
+
+        const row = container.querySelector('.ms-connection-row');
+        expect(row.classList.contains('is-disabled')).toBe(true);
+        expect(row.querySelector('button').disabled).toBe(true);
+    });
+
+    it('should disable apply dimension nodes when selection mode is multiple', () => {
+        const target = {
+            targetType: 'applyDimension',
+            expectedDataType: 'LAYER_DIMENSION',
+            constraints: {}
+        };
+        const item = createLayerDimensionItem('elevation');
+
+        const container = renderInteractionsRow({
+            item,
+            target,
+            sourceSelectionMode: 'multiple'
+        });
+
+        const row = container.querySelector('.ms-connection-row');
+        expect(row.classList.contains('is-disabled')).toBe(true);
+        expect(row.querySelector('button').disabled).toBe(true);
+    });
+});
diff --git a/web/client/components/widgets/builder/wizard/common/interactions/interaction-wizard.less b/web/client/components/widgets/builder/wizard/common/interactions/interaction-wizard.less
index 501abdc89a6..c893148597c 100644
--- a/web/client/components/widgets/builder/wizard/common/interactions/interaction-wizard.less
+++ b/web/client/components/widgets/builder/wizard/common/interactions/interaction-wizard.less
@@ -38,6 +38,19 @@
     .ms-interactions-event {
         background-color: var(--ms-main-variant-bg);
     }
+    .ms-connection-row.is-disabled,
+    .ms-interaction-buttons.is-disabled {
+        opacity: 0.28;
+        filter: grayscale(1);
+        cursor: not-allowed;
+    }
+    .ms-connection-row.is-disabled .btn,
+    .ms-interaction-buttons.is-disabled .btn {
+        cursor: not-allowed;
+    }
+    .ms-interactions-empty-state {
+        margin-left: 17px;
+    }
     .ms-interaction-target {
         border: 1px solid var(--ms-main-border-color);
         padding: 0 2px;
@@ -59,4 +72,3 @@
     }
 
 }
-
diff --git a/web/client/components/widgets/builder/wizard/common/interactions/interactionHelpers.js b/web/client/components/widgets/builder/wizard/common/interactions/interactionHelpers.js
index 03e218e9972..ee8ebae8b96 100644
--- a/web/client/components/widgets/builder/wizard/common/interactions/interactionHelpers.js
+++ b/web/client/components/widgets/builder/wizard/common/interactions/interactionHelpers.js
@@ -6,11 +6,6 @@
  * LICENSE file in the root directory of this source tree.
  */
 import uuid from 'uuid/v1';
-import {
-    getDirectlyPluggableTargets,
-    getConfiguredTargets,
-    getItemPluggableStatus
-} from '../../../../../../utils/InteractionUtils';
 import { DEFAULT_CONFIGURATION } from './interactionConstants';
 
 
@@ -52,41 +47,3 @@ export function matchesInteraction(interaction, sourceNodePath, targetNodePath,
     return interaction.source.nodePath === sourceNodePath &&
         interaction.target.nodePath === targetNodePath && targetType === interaction.targetType;
 }
-
-/**
- * Helper: Recursively find all pluggable items in the tree
- * @param {object} node - The tree node to traverse
- * @param {object} event - The event object
- * @param {array} items - Accumulator array for pluggable items
- * @returns {array} Array of pluggable items with their metadata
- */
-export function findPluggableItems(node, event, items = []) {
-    if (!node) return items;
-
-    // Check if this node is an element with interaction metadata
-    if (node.type === 'element' && node.interactionMetadata) {
-        const { directlyPluggable, configuredToForcePlug } = getItemPluggableStatus(node, event, DEFAULT_CONFIGURATION);
-        const isPluggable = directlyPluggable || configuredToForcePlug;
-
-        if (isPluggable) {
-            const directlyPluggableTargets = getDirectlyPluggableTargets(node, event);
-            const configuredTargets = getConfiguredTargets(node, event, DEFAULT_CONFIGURATION);
-            const targetMetadata = directlyPluggableTargets[0] || configuredTargets[0];
-            items.push({
-                item: node,
-                targetMetadata,
-                configuration: DEFAULT_CONFIGURATION
-            });
-        }
-    }
-
-    // Recursively process children
-    if (node.children && Array.isArray(node.children)) {
-        node.children.forEach(child => {
-            findPluggableItems(child, event, items);
-        });
-    }
-
-    return items;
-}
-
diff --git a/web/client/components/widgets/builder/wizard/filter/FilterActionsTab.jsx b/web/client/components/widgets/builder/wizard/filter/FilterActionsTab.jsx
index 8f495a43bde..04af0a8e6f8 100644
--- a/web/client/components/widgets/builder/wizard/filter/FilterActionsTab.jsx
+++ b/web/client/components/widgets/builder/wizard/filter/FilterActionsTab.jsx
@@ -1,44 +1,238 @@
 import React, { useState, useMemo, useEffect } from 'react';
 import {connect} from 'react-redux';
-import { getPossibleTargetsEditingWidget, TARGET_TYPES } from '../../../../../utils/InteractionUtils';
+import {
+    getPossibleTargetsEditingWidget,
+    TARGET_TYPES,
+    TARGET_TYPE_LABELS,
+    FILTER_WIDGET_OPTIONAL_TARGET_TYPES,
+    findNodeById
+} from '../../../../../utils/InteractionUtils';
 import InteractionEditor from '../common/interactions/InteractionsEditor';
 import FlexBox from '../../../../layout/FlexBox';
-import { getEditingWidget, getWidgetInteractionTreeGenerated } from '../../../../../selectors/widgets';
+import ConfirmDialog from '../../../../layout/ConfirmDialog';
+import { DropdownButton, Glyphicon, MenuItem } from 'react-bootstrap';
+import { getEditingWidget, getWidgetInteractionTreeGenerated, getAllInteractionsWhileEditingSelector } from '../../../../../selectors/widgets';
 import Message from '../../../../I18N/Message';
+import tooltip from '../../../../misc/enhancers/tooltip';
 
+/** msgIds for target-type labels (accordion headers + optional-target "+" menu). */
+const FILTER_INTERACTION_TARGET_MSG_IDS = {
+    [TARGET_TYPES.APPLY_FILTER]: 'widgets.filterWidget.applyFilter',
+    [TARGET_TYPES.APPLY_STYLE]: 'widgets.filterWidget.applyStyle',
+    [TARGET_TYPES.APPLY_DIMENSION]: 'widgets.filterWidget.applyDimension'
+};
+const EMPTY_ARRAY = [];
+const TDropdownButton = tooltip(DropdownButton);
+
+const isCurrentFilterInteraction = (interaction, filterId, currentSourceNodePath) => {
+    if (!filterId) {
+        return false;
+    }
+    return interaction?.source?.nodePath === currentSourceNodePath
+        || interaction?.source?.nodePath?.includes(filterId);
+};
+
+/** Keep first occurrence per targetType */
+function dedupeTargetsByType(targets) {
+    return targets.filter((target, index, arr) =>
+        arr.findIndex(t => t.targetType === target.targetType) === index
+    );
+}
+
+/**
+ * Mandatory target descriptors plus optional ones (when visible in UI or persisted for this source).
+ */
+function mergeFilterActionTargets({
+    defaultTargets,
+    allDescriptors,
+    optionalTargetTypes,
+    persistedOptionalTargetTypes,
+    addedOptionalTargets
+}) {
+    const descriptorByType = new Map(allDescriptors.map(d => [d.targetType, d]));
+    const persisted = new Set(persistedOptionalTargetTypes);
+    const added = new Set(addedOptionalTargets);
+
+    const optionalTargets = optionalTargetTypes
+        .map(type => {
+            const descriptor = descriptorByType.get(type);
+            if (!descriptor) {
+                return null;
+            }
+            const keep = added.has(type) || persisted.has(type);
+            return keep ? descriptor : null;
+        })
+        .filter(Boolean);
+
+    return dedupeTargetsByType([...optionalTargets, ...defaultTargets]);
+}
 
 const FilterActionsTab = ({
     data = {},
     sourceWidgetId,
-    onEditorChange = () => {}
+    onChange = () => {},
+    onEditorChange = () => {},
+    widgetInteractionTree,
+    interactions = [],
+    allInteractionsWhileEditing = []
 }) => {
+    // Style-list widgets only expose "apply style"; otherwise default is "apply filter".
+    const isStyle = data?.data?.dataSource === "userDefined" && data?.data?.userDefinedType === "styleList";
+    const valueAttributeType = data?.data?.valueAttributeType;
+    const [targetTypeToRemove, setTargetTypeToRemove] = useState(null);
+
+    const allTargetDescriptors = useMemo(
+        () => getPossibleTargetsEditingWidget("filter", data?.data?.layer),
+        [data?.data?.layer]
+    );
+    const defaultTargets = useMemo(
+        () =>
+            isStyle
+                ? allTargetDescriptors.filter(t => t.targetType === TARGET_TYPES.APPLY_STYLE)
+                : allTargetDescriptors.filter(t => t.targetType === TARGET_TYPES.APPLY_FILTER),
+        [allTargetDescriptors, isStyle]
+    );
 
+    // Style mode: no user-added targets
+    const optionalTargetTypes = useMemo(
+        () => (isStyle ? [] : FILTER_WIDGET_OPTIONAL_TARGET_TYPES),
+        [isStyle]
+    );
+    const addedOptionalTargets = data?.addedOptionalTargets || EMPTY_ARRAY;
 
-    const memoizedTargets = useMemo(() => {
-        return getPossibleTargetsEditingWidget("filter", data?.data?.layer);
-    }, [data?.data?.layer]);
+    const currentSourceNodePath = useMemo(
+        () => findNodeById(widgetInteractionTree, data?.id)?.nodePath,
+        [widgetInteractionTree, data?.id]
+    );
 
+    const optionalTargetTypeSet = useMemo(() => new Set(optionalTargetTypes), [optionalTargetTypes]);
+    const persistedOptionalTargetTypes = useMemo(() => {
+        if (!currentSourceNodePath) {
+            return [];
+        }
+        const matched = new Set();
+        for (const interaction of allInteractionsWhileEditing) {
+            const type = interaction?.targetType;
+            if (
+                type &&
+                optionalTargetTypeSet.has(type) &&
+                interaction?.source?.nodePath === currentSourceNodePath
+            ) {
+                matched.add(type);
+            }
+        }
+        return [...matched].sort();
+    }, [allInteractionsWhileEditing, currentSourceNodePath, optionalTargetTypeSet]);
 
-    const [targets, setTargets] = useState(memoizedTargets);
+    const [targets, setTargets] = useState(defaultTargets);
 
+    // Re-sync when descriptors/mode change; keep optional rows if user added them or draft already references them.
     useEffect(() => {
-        const isStyle = data?.data?.dataSource === "userDefined" && data.data.userDefinedType === "styleList";
-        setTargets(isStyle ? memoizedTargets.filter(t => t.targetType === TARGET_TYPES.APPLY_STYLE) : memoizedTargets.filter(t => t.targetType === TARGET_TYPES.APPLY_FILTER));
-    }, [memoizedTargets, data]);
+        setTargets(mergeFilterActionTargets({
+            defaultTargets,
+            allDescriptors: allTargetDescriptors,
+            optionalTargetTypes,
+            persistedOptionalTargetTypes,
+            addedOptionalTargets
+        }));
+    }, [
+        defaultTargets,
+        allTargetDescriptors,
+        optionalTargetTypes,
+        persistedOptionalTargetTypes,
+        addedOptionalTargets
+    ]);
+
+    const handleAddOptionalTarget = targetType => {
+        if (!optionalTargetTypes.includes(targetType) || addedOptionalTargets.includes(targetType)) {
+            return;
+        }
+        onChange('addedOptionalTargets', [...addedOptionalTargets, targetType]);
+    };
+
+    const removeOptionalTarget = targetType => {
+        if (!optionalTargetTypes.includes(targetType)) {
+            return;
+        }
+        if (addedOptionalTargets.includes(targetType)) {
+            onChange(
+                'addedOptionalTargets',
+                addedOptionalTargets.filter(type => type !== targetType)
+            );
+        }
+        const nextInteractions = interactions.filter(interaction => !(
+            interaction?.targetType === targetType
+            && isCurrentFilterInteraction(interaction, data?.id, currentSourceNodePath)
+        ));
+        if (nextInteractions.length !== interactions.length) {
+            onEditorChange('interactions', nextInteractions);
+        }
+    };
+    const handleRemoveOptionalTarget = targetType => setTargetTypeToRemove(targetType);
+    const handleCancelRemoveOptionalTarget = () => setTargetTypeToRemove(null);
+    const handleConfirmRemoveOptionalTarget = () => {
+        removeOptionalTarget(targetTypeToRemove);
+        setTargetTypeToRemove(null);
+    };
+
+    const addableOptionalTargetTypes = optionalTargetTypes.filter(
+        type => !targets.some(t => t.targetType === type)
+    );
 
     return (
         <div className="ms-filter-wizard-actions-tab">
             <FlexBox
                 inline
-                wrap
-                style={{width: "100%", marginBottom: "10px"}}
+                gap="sm"
                 centerChildrenVertically
+                style={{width: "100%", marginBottom: "10px"}}
             >
-                <div style={{flex: 1}}>
+                <div style={{flex: 1, minWidth: 0}}>
                     <Message msgId="widgets.filterWidget.onSelectionChange" />
                 </div>
+                {addableOptionalTargetTypes.length > 0 && (
+                    <TDropdownButton
+                        id="ms-interaction-add-target"
+                        noCaret
+                        pullRight
+                        title={<Glyphicon glyph="plus" />}
+                        className="square-button ms-interaction-add-target"
+                        tooltipId="widgets.filterWidget.addOptionalTargetTooltip"
+                    >
+                        {addableOptionalTargetTypes.map(type => (
+                            <MenuItem key={type} onClick={() => handleAddOptionalTarget(type)}>
+                                {FILTER_INTERACTION_TARGET_MSG_IDS[type] ? (
+                                    <Message msgId={FILTER_INTERACTION_TARGET_MSG_IDS[type]} />
+                                ) : (
+                                    TARGET_TYPE_LABELS[type] ?? type
+                                )}
+                            </MenuItem>
+                        ))}
+                    </TDropdownButton>
+                )}
             </FlexBox>
-            <InteractionEditor targets={targets} sourceWidgetId={sourceWidgetId} currentSourceId={data?.id} onEditorChange={onEditorChange} isStyleOnly={data?.data?.dataSource === "userDefined" && data.data.userDefinedType === "styleList"} />
+            <InteractionEditor
+                targets={targets}
+                sourceWidgetId={sourceWidgetId}
+                currentSourceId={data?.id}
+                onEditorChange={onEditorChange}
+                isStyleOnly={isStyle}
+                valueAttributeType={valueAttributeType}
+                sourceSelectionMode={data?.layout?.selectionMode}
+                targetTitleMsgIds={FILTER_INTERACTION_TARGET_MSG_IDS}
+                removableTargetTypes={optionalTargetTypes}
+                onRemoveTarget={handleRemoveOptionalTarget}
+            />
+            <ConfirmDialog
+                show={!!targetTypeToRemove}
+                titleId="widgets.filterWidget.removeOptionalTargetConfirmTitle"
+                descriptionId="widgets.filterWidget.removeOptionalTargetConfirmContent"
+                cancelId="cancel"
+                confirmId="widgets.filterWidget.delete"
+                variant="danger"
+                onCancel={handleCancelRemoveOptionalTarget}
+                onConfirm={handleConfirmRemoveOptionalTarget}
+            />
         </div>
     );
 };
@@ -47,8 +241,8 @@ export default connect((state) => {
     const editingWidget = getEditingWidget(state);
     return {
         widgetInteractionTree: getWidgetInteractionTreeGenerated(state),
-        sourceWidgetId: editingWidget?.id
+        sourceWidgetId: editingWidget?.id,
+        interactions: editingWidget?.interactions || [],
+        allInteractionsWhileEditing: getAllInteractionsWhileEditingSelector(state)
     };
 }, null)(FilterActionsTab);
-
-
diff --git a/web/client/components/widgets/builder/wizard/filter/FilterDataTab/hooks/__tests__/useAttributeSync-test.jsx b/web/client/components/widgets/builder/wizard/filter/FilterDataTab/hooks/__tests__/useAttributeSync-test.jsx
new file mode 100644
index 00000000000..cd94d461556
--- /dev/null
+++ b/web/client/components/widgets/builder/wizard/filter/FilterDataTab/hooks/__tests__/useAttributeSync-test.jsx
@@ -0,0 +1,95 @@
+/*
+ * Copyright 2026, GeoSolutions Sas.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import expect from 'expect';
+import React, { useEffect } from 'react';
+import ReactDOM from 'react-dom';
+import { useAttributeSync } from '../useAttributeSync';
+
+const TestComponent = ({ filterData, onChangeProp, onEditorChange, selections, interactions, onReady }) => {
+    const onChange = useAttributeSync(filterData, onChangeProp, onEditorChange, selections, interactions);
+
+    useEffect(() => {
+        onReady(onChange);
+    }, [onChange, onReady]);
+
+    return null;
+};
+
+describe('useAttributeSync hook', () => {
+    beforeEach((done) => {
+        document.body.innerHTML = '<div id="container"></div>';
+        setTimeout(done);
+    });
+
+    afterEach((done) => {
+        ReactDOM.unmountComponentAtNode(document.getElementById("container"));
+        document.body.innerHTML = '';
+        setTimeout(done);
+    });
+
+    it('should clear applyDimension interactions when the value attribute changes', (done) => {
+        const container = document.getElementById('container');
+        let onChange;
+        const onChangeProp = expect.createSpy();
+        const onEditorChange = expect.createSpy();
+
+        ReactDOM.render(
+            <TestComponent
+                filterData={{
+                    id: 'filter-1',
+                    data: {
+                        valueAttribute: 'name',
+                        valueAttributeType: 'string'
+                    }
+                }}
+                onChangeProp={onChangeProp}
+                onEditorChange={onEditorChange}
+                selections={{}}
+                interactions={[
+                    {
+                        id: 'i-1',
+                        targetType: 'applyFilter',
+                        source: { nodePath: 'widgets[widget-1].filters[filter-1]' }
+                    },
+                    {
+                        id: 'i-2',
+                        targetType: 'applyDimension',
+                        plugged: true,
+                        source: { nodePath: 'widgets[widget-1].filters[filter-1]' }
+                    }
+                ]}
+                onReady={(handler) => {
+                    onChange = handler;
+                }}
+            />,
+            container
+        );
+
+        setTimeout(() => {
+            onChange('data.valueAttribute', 'population');
+
+            expect(onChangeProp.calls[0].arguments).toEqual(['data.valueAttribute', 'population']);
+            expect(onEditorChange.calls[0].arguments[0]).toBe('interactions');
+            expect(onEditorChange.calls[0].arguments[1]).toEqual([
+                {
+                    id: 'i-1',
+                    targetType: 'applyFilter',
+                    source: { nodePath: 'widgets[widget-1].filters[filter-1]' }
+                },
+                {
+                    id: 'i-2',
+                    targetType: 'applyDimension',
+                    plugged: false,
+                    source: { nodePath: 'widgets[widget-1].filters[filter-1]' }
+                }
+            ]);
+            expect(onEditorChange.calls[1].arguments[0]).toBe('selections');
+            done();
+        }, 0);
+    });
+});
diff --git a/web/client/components/widgets/builder/wizard/filter/FilterDataTab/hooks/useAttributeSync.js b/web/client/components/widgets/builder/wizard/filter/FilterDataTab/hooks/useAttributeSync.js
index e39c62402e2..86002327090 100644
--- a/web/client/components/widgets/builder/wizard/filter/FilterDataTab/hooks/useAttributeSync.js
+++ b/web/client/components/widgets/builder/wizard/filter/FilterDataTab/hooks/useAttributeSync.js
@@ -11,12 +11,13 @@ import { useCallback } from 'react';
  * Custom hook that provides an onChange handler with automatic attribute synchronization.
  * When valueAttribute changes, it automatically sets labelAttribute and sortByAttribute
  * to the same value if they are not already set.
+ * It also disconnects apply-dimension interactions because they depend on valueAttributeType.
  *
  * @param {object} filterData - Current filter data object
  * @param {function} onChangeProp - Original onChange callback
  * @returns {function} Enhanced onChange handler with auto-sync
  */
-export const useAttributeSync = (filterData, onChangeProp, onEditorChange, selections) => {
+export const useAttributeSync = (filterData, onChangeProp, onEditorChange, selections, interactions = []) => {
     return useCallback((key, value) => {
         // Call the original onChange
         onChangeProp(key, value);
@@ -36,6 +37,34 @@ export const useAttributeSync = (filterData, onChangeProp, onEditorChange, selec
                 onChangeProp('data.sortByAttribute', value);
             }
         }
+
+        if (key === 'data.valueAttribute' || key === 'data.valueAttributeType') {
+            const filterId = filterData?.id;
+            let disconnectedDimensionInteraction = false;
+            const updatedInteractions = interactions.map(interaction => {
+                const isCurrentFilterInteraction = filterId
+                    ? interaction?.source?.nodePath?.includes(filterId)
+                    : true;
+                const shouldDisconnect = isCurrentFilterInteraction
+                    && interaction?.targetType === 'applyDimension'
+                    && interaction?.plugged === true;
+
+                if (shouldDisconnect) {
+                    disconnectedDimensionInteraction = true;
+                    return {
+                        ...interaction,
+                        plugged: false
+                    };
+                }
+                return interaction;
+            });
+
+            if (disconnectedDimensionInteraction) {
+                // Apply Dimension depends on valueAttributeType, so disconnect it when the value attribute or its type changes.
+                onEditorChange('interactions', updatedInteractions);
+            }
+        }
+
         if (["data.dataSource", "data.valuesFrom", "data.layer", "data.valueAttribute", "data.labelAttribute", "data.sortByAttribute", "data.maxFeatures", "data.sortOrder"].includes(key)) {
             onEditorChange('selections', {
                 ...selections,
@@ -44,4 +73,3 @@ export const useAttributeSync = (filterData, onChangeProp, onEditorChange, selec
         }
     }, [onChangeProp, filterData, selections, onEditorChange]);
 };
-
diff --git a/web/client/components/widgets/builder/wizard/filter/FilterDataTab/index.jsx b/web/client/components/widgets/builder/wizard/filter/FilterDataTab/index.jsx
index 89f73158b35..fd7e95861cd 100644
--- a/web/client/components/widgets/builder/wizard/filter/FilterDataTab/index.jsx
+++ b/web/client/components/widgets/builder/wizard/filter/FilterDataTab/index.jsx
@@ -29,7 +29,8 @@ const FilterDataTab = ({
     openFilterEditor,
     onEditorChange = () => {},
     dashBoardEditing,
-    selections = {}
+    selections = {},
+    interactions = []
 }) => {
     // Normalize and derive filter data
     const filterDataState = useFilterData(data);
@@ -45,7 +46,7 @@ const FilterDataTab = ({
     );
 
     // Enhanced onChange handler with auto-sync
-    const onChange = useAttributeSync(data, onChangeProp, onEditorChange, selections);
+    const onChange = useAttributeSync(data, onChangeProp, onEditorChange, selections, interactions);
 
     // Generic handler factory for simple onChange handlers
     const createChangeHandler = (key) => (value) => {
@@ -212,7 +213,8 @@ FilterDataTab.propTypes = {
     onOpenLayerSelector: PropTypes.func,
     openFilterEditor: PropTypes.func,
     onEditorChange: PropTypes.func,
-    dashBoardEditing: PropTypes.bool
+    dashBoardEditing: PropTypes.bool,
+    interactions: PropTypes.array
 };
 
 export default FilterDataTab;
diff --git a/web/client/components/widgets/builder/wizard/filter/FilterLayoutTab.jsx b/web/client/components/widgets/builder/wizard/filter/FilterLayoutTab.jsx
index 3a30f32dd36..6fb9084c31d 100644
--- a/web/client/components/widgets/builder/wizard/filter/FilterLayoutTab.jsx
+++ b/web/client/components/widgets/builder/wizard/filter/FilterLayoutTab.jsx
@@ -17,6 +17,7 @@ import { useLocalizedOptions } from './hooks/useLocalizedOptions';
 import localizedProps from '../../../../misc/enhancers/localizedProps';
 import InfoPopover from '../../../widget/InfoPopover';
 import { USER_DEFINED_TYPES } from './FilterDataTab/constants';
+import { TARGET_TYPES } from '../../../../../utils/InteractionUtils';
 
 const LocalizedFormControl = localizedProps('placeholder')(FormControl);
 const TICK_INPUT_DEBOUNCE_TIME = 300;
@@ -129,12 +130,20 @@ const DIRECTION_OPTIONS = [
     { value: 'vertical', label: 'Vertical', labelKey: 'widgets.filterWidget.directionVertical' }
 ];
 
+const isInteractionFromFilter = (interaction, filterId) => {
+    if (!filterId) {
+        return false;
+    }
+    return interaction?.source?.nodePath?.includes(filterId);
+};
+
 const FilterLayoutTab = ({
     data = {},
     onChange = () => {},
     onEditorChange = () => {},
     selections = {},
-    selectableItems = []
+    selectableItems = [],
+    interactions = []
 }) => {
     const layout = data?.layout || {};
     const filterItems = Array.isArray(selectableItems) ? selectableItems : [];
@@ -156,6 +165,11 @@ const FilterLayoutTab = ({
         selectedDirection
     );
     const isSliderVariant = layout.variant === 'slider';
+    const hasConnectedApplyDimensionInteraction = interactions.some(interaction =>
+        interaction?.plugged
+        && interaction?.targetType === TARGET_TYPES.APPLY_DIMENSION
+        && isInteractionFromFilter(interaction, data?.id)
+    );
     const showTicks = layout.showTicks !== false;
     const tickAngle = normalizeTickAngle(layout.tickAngle);
     const variantOptions = [
@@ -166,11 +180,31 @@ const FilterLayoutTab = ({
         ...(layout.selectionMode === 'single' ? [{ value: 'slider', label: 'Slider' }] : [])
     ];
     const localizedSelectionModeOptionsWithDisabledMultiple = localizedSelectionModeOptions.map(opt => (
-        opt.value === 'multiple' && isSliderVariant
-            ? { ...opt, disabled: true }
+        opt.value === 'multiple' && (isSliderVariant || hasConnectedApplyDimensionInteraction)
+            ? {
+                ...opt,
+                disabled: true,
+                disabledMsgId: hasConnectedApplyDimensionInteraction
+                    ? 'widgets.filterWidget.applyDimensionSelectionModeDisabledTooltip'
+                    : undefined
+            }
             : opt
     ));
 
+    const renderSelectionModeOption = option => {
+        if (!option.disabledMsgId) {
+            return option.label;
+        }
+        return (
+            <OverlayTrigger
+                placement="top"
+                overlay={<Tooltip id={`ms-filter-selection-mode-${option.value}-tooltip`}><Message msgId={option.disabledMsgId} /></Tooltip>}
+            >
+                <span>{option.label}</span>
+            </OverlayTrigger>
+        );
+    };
+
     const handlePanelToggle = (panelName) => {
         setExpandedPanel(expandedPanel === panelName ? null : panelName);
     };
@@ -352,6 +386,7 @@ const FilterLayoutTab = ({
                                         options={localizedSelectionModeOptionsWithDisabledMultiple}
                                         placeholder="Select selection mode..."
                                         disabled={isStyleList}
+                                        optionRenderer={renderSelectionModeOption}
                                         onChange={handleSelectionModeChange}
                                     />
                                 </InputGroup>
diff --git a/web/client/components/widgets/enhancers/filterWidget.js b/web/client/components/widgets/enhancers/filterWidget.js
index 17d1250c3eb..81c5e45e70e 100644
--- a/web/client/components/widgets/enhancers/filterWidget.js
+++ b/web/client/components/widgets/enhancers/filterWidget.js
@@ -7,6 +7,7 @@
  */
 import { compose, withState, withHandlers, withProps, lifecycle } from 'recompose';
 import debounce from 'lodash/debounce';
+import moment from 'moment';
 import { getLayerJSONFeature } from '../../../observables/wfs';
 import axios from '../../../libs/ajax';
 import { getWpsUrl } from '../../../utils/LayersUtils';
@@ -17,6 +18,18 @@ import { isFilterValid, composeAttributeFilters } from '../../../utils/FilterUti
 const CancelToken = axios.CancelToken;
 const DEBOUNCE_TIME = 100; // 1 second
 
+const normalizeSelectableItemValue = (value, valueAttributeType) => {
+    const stringValue = String(value !== undefined && value !== null ? value : '');
+    if (!stringValue) {
+        return '';
+    }
+    if (valueAttributeType === 'date' || valueAttributeType === 'date-time') {
+        const normalized = moment.utc(stringValue);
+        return normalized.isValid() ? normalized.toISOString() : stringValue;
+    }
+    return stringValue;
+};
+
 /**
  * Fetches filter items from WPS service using distinct values operation
  * @param {object} filterData - The filter.data object containing layer, valueAttribute, etc.
@@ -24,7 +37,7 @@ const DEBOUNCE_TIME = 100; // 1 second
  * @returns {Promise} Promise that resolves to filter items array
  */
 const fetchWPSFilterData = (filterData, options = {}) => {
-    const { layer, valueAttribute, maxFeatures = 20, sortByAttribute, sortOrder = 'ASC' } = filterData || {};
+    const { layer, valueAttribute, valueAttributeType, maxFeatures = 20, sortByAttribute, sortOrder = 'ASC' } = filterData || {};
 
     if (!layer || !valueAttribute) {
         return Promise.resolve([]);
@@ -71,7 +84,8 @@ const fetchWPSFilterData = (filterData, options = {}) => {
             // For grouped values, the value itself is used as both id and label
             const items = values
                 .map((value) => ({
-                    id: String(value !== undefined && value !== null ? value : ''),
+                    id: normalizeSelectableItemValue(value, valueAttributeType),
+                    value: normalizeSelectableItemValue(value, valueAttributeType),
                     label: String(value !== undefined && value !== null ? value : '')
                 }))
                 .filter((item) => item.id !== '');
@@ -95,7 +109,7 @@ const fetchWPSFilterData = (filterData, options = {}) => {
  * @returns {Promise} Promise that resolves to filter items array
  */
 const fetchWFSFilterData = (filterData, options = {}) => {
-    const { layer, valueAttribute, labelAttribute, maxFeatures = 20, sortByAttribute, sortOrder = 'ASC' } = filterData || {};
+    const { layer, valueAttribute, valueAttributeType, labelAttribute, maxFeatures = 20, sortByAttribute, sortOrder = 'ASC' } = filterData || {};
 
     if (!layer || !valueAttribute) {
         return Promise.resolve([]);
@@ -155,9 +169,11 @@ const fetchWFSFilterData = (filterData, options = {}) => {
                     const label = labelAttribute
                         ? feature.properties?.[labelAttribute]
                         : value;
+                    const normalizedValue = normalizeSelectableItemValue(value, valueAttributeType);
 
                     return {
-                        id: String(value !== undefined && value !== null ? value : ''),
+                        id: normalizedValue,
+                        value: normalizedValue,
                         label: String(label !== undefined && label !== null ? label : value || '')
                     };
                 })
diff --git a/web/client/components/widgets/widget/FilterWidget.jsx b/web/client/components/widgets/widget/FilterWidget.jsx
index 1f9f0946e6f..71fae35f646 100644
--- a/web/client/components/widgets/widget/FilterWidget.jsx
+++ b/web/client/components/widgets/widget/FilterWidget.jsx
@@ -15,6 +15,8 @@ import FilterView from '../../../plugins/widgetbuilder/FilterView';
 import { applyFilterWidgetInteractions } from '../../../actions/interactions';
 import './filter-widget.less';
 import { interactionTargetVisibilitySelector, interactionTargetsFilterDisabledSelector, getApplyStyleOutOfSyncForFilterWidget } from '../../../selectors/widgets';
+import { currentTimeSelector, offsetEnabledSelector } from '../../../selectors/dimension';
+import { isMapTimeTarget } from '../../../utils/InteractionUtils';
 
 /**
  * FilterWidget component for rendering filter widgets in dashboard view
@@ -29,6 +31,8 @@ const FilterWidget = ({
     targetsWithDisabledFilter = {},
     applyStyleOutOfSyncForWidget = {},
     selections = {},
+    currentTime,
+    timelineRangeEnabled,
     updateProperty = () => {},
     toggleDeleteConfirm = () => {},
     icons,
@@ -82,7 +86,11 @@ const FilterWidget = ({
                     </div>
                 ) : (
                     filters.map((filter, index) => {
-                        const filterInteractions = interactions.filter(i => i.source.nodePath.includes(filter.id));
+                        const filterInteractions = (interactions || []).filter(i => i?.source?.nodePath?.includes(filter.id));
+                        const syncCurrentTime = filterInteractions.some(interaction =>
+                            interaction?.plugged === true
+                            && isMapTimeTarget(interaction?.target?.nodePath)
+                        );
                         return (<div
                             key={filter.id}
                             className="ms-filter-widget-item"
@@ -97,6 +105,9 @@ const FilterWidget = ({
                                 applyStyleOutOfSync={applyStyleOutOfSyncForWidget[filter.id] || {}}
                                 filterData={filter}
                                 selections={selections[filter.id] || []}
+                                currentTime={currentTime}
+                                syncCurrentTime={syncCurrentTime}
+                                timelineRangeEnabled={timelineRangeEnabled}
                                 onSelectionChange={handleSelectionChange(filter.id)}
                             />
                         </div>);
@@ -135,11 +146,14 @@ FilterWidget.propTypes = {
     confirmDelete: PropTypes.bool,
     onDelete: PropTypes.func,
     dispatch: PropTypes.func,
+    timelineRangeEnabled: PropTypes.bool,
     target: PropTypes.string
 };
 
 export default connect(createStructuredSelector({
     activeTargets: interactionTargetVisibilitySelector,
     targetsWithDisabledFilter: interactionTargetsFilterDisabledSelector,
-    applyStyleOutOfSyncForWidget: (state, ownProps) => getApplyStyleOutOfSyncForFilterWidget(state, ownProps?.id)
+    applyStyleOutOfSyncForWidget: (state, ownProps) => getApplyStyleOutOfSyncForFilterWidget(state, ownProps?.id),
+    currentTime: currentTimeSelector,
+    timelineRangeEnabled: offsetEnabledSelector
 }))(FilterWidget);
diff --git a/web/client/components/widgets/widget/filter-widget.less b/web/client/components/widgets/widget/filter-widget.less
index 419fee3600a..439ebeb07b9 100644
--- a/web/client/components/widgets/widget/filter-widget.less
+++ b/web/client/components/widgets/widget/filter-widget.less
@@ -13,3 +13,22 @@
         padding: 5px 0; // to fit with select all / clear checkbox alignment
     }
 }
+
+.ms-filter-view-map-time-range-disabled {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    text-align: center;
+    color: #999;
+
+    .ms-filter-view-map-time-range-disabled-icon {
+        font-size: 32px;
+        margin-bottom: 10px;
+    }
+
+    .ms-filter-view-map-time-range-disabled-message {
+        font-size: 14px;
+        max-width: 360px;
+    }
+}
diff --git a/web/client/epics/__tests__/interactions-test.js b/web/client/epics/__tests__/interactions-test.js
index cb83e58c8e5..2f3ea96b1cb 100644
--- a/web/client/epics/__tests__/interactions-test.js
+++ b/web/client/epics/__tests__/interactions-test.js
@@ -11,12 +11,15 @@ import { testEpic } from './epicTestUtils';
 import { applyFilterWidgetInteractionsEpic, cleanupAndReapplyFilterWidgetInteractionsEpic } from '../interactions';
 import { applyFilterWidgetInteractions } from '../../actions/interactions';
 import { UPDATE_PROPERTY, DELETE } from '../../actions/widgets';
-import { CHANGE_LAYER_PROPERTIES, removeNode } from '../../actions/layers';
+import { CHANGE_LAYER_PARAMS, CHANGE_LAYER_PROPERTIES, removeNode } from '../../actions/layers';
 
 const FILTER_ID = 'filter-1';
 const FILTER_WIDGET_ID = 'filter-widget-1';
 const CHART_WIDGET_ID = 'chart-widget-1';
 const TABLE_WIDGET_ID = 'table-widget-1';
+const MAP_WIDGET_ID = 'map-widget-1';
+const MAP_ID = 'map-1';
+const MAP_LAYER_ID = 'layer-1';
 const TRACE_ID = 'trace-1';
 const CHART_ID = 'chart-1';
 
@@ -68,6 +71,23 @@ const makeTableWidget = (overrides = {}) => ({
     ...overrides
 });
 
+const makeMapWidget = (overrides = {}) => ({
+    id: MAP_WIDGET_ID,
+    widgetType: 'map',
+    title: 'Map Widget',
+    maps: [{
+        mapId: MAP_ID,
+        name: 'Map 1',
+        layers: [{
+            id: MAP_LAYER_ID,
+            name: 'test:layer',
+            type: 'wms',
+            group: 'overlay'
+        }]
+    }],
+    ...overrides
+});
+
 const makeState = (widgets, layersState = null) => {
     const state = {
         widgets: {
@@ -183,6 +203,110 @@ describe('interactions epics', () => {
                 done
             );
         });
+
+        it('dispatches updateWidgetProperty with maps for dimension target on map layer', (done) => {
+            const filterWidget = makeFilterWidget({
+                selections: { [FILTER_ID]: ['2020-01-01T00:00:00Z'] },
+                interactions: [{
+                    id: 'int-dim',
+                    plugged: true,
+                    targetType: 'applyDimension',
+                    source: { nodePath: `widgets[${FILTER_WIDGET_ID}].filters[${FILTER_ID}]` },
+                    target: {
+                        nodePath: `widgets[${MAP_WIDGET_ID}].maps[${MAP_ID}].layers[${MAP_LAYER_ID}].params.time`,
+                        metaData: {
+                            dimension: 'time'
+                        }
+                    }
+                }]
+            });
+            const mapWidget = makeMapWidget();
+            const state = makeState([filterWidget, mapWidget]);
+
+            testEpic(
+                applyFilterWidgetInteractionsEpic,
+                1,
+                [applyFilterWidgetInteractions(FILTER_WIDGET_ID, 'floating', FILTER_ID)],
+                (actions) => {
+                    expect(actions.length).toBe(1);
+                    expect(actions[0].type).toBe(UPDATE_PROPERTY);
+                    expect(actions[0].id).toBe(MAP_WIDGET_ID);
+                    expect(actions[0].key).toBe('maps[0].layers[0].params.time');
+                    expect(actions[0].value).toBe('2020-01-01T00:00:00Z');
+                },
+                state,
+                done
+            );
+        });
+
+        it('dispatches updateWidgetProperty with maps for elevation dimension target on map layer', (done) => {
+            const filterWidget = makeFilterWidget({
+                selections: { [FILTER_ID]: [200] },
+                interactions: [{
+                    id: 'int-elev',
+                    plugged: true,
+                    targetType: 'applyDimension',
+                    source: { nodePath: `widgets[${FILTER_WIDGET_ID}].filters[${FILTER_ID}]` },
+                    target: {
+                        nodePath: `widgets[${MAP_WIDGET_ID}].maps[${MAP_ID}].layers[${MAP_LAYER_ID}].params.elevation`,
+                        metaData: {
+                            dimension: 'elevation'
+                        }
+                    }
+                }]
+            });
+            const mapWidget = makeMapWidget();
+            const state = makeState([filterWidget, mapWidget]);
+
+            testEpic(
+                applyFilterWidgetInteractionsEpic,
+                1,
+                [applyFilterWidgetInteractions(FILTER_WIDGET_ID, 'floating', FILTER_ID)],
+                (actions) => {
+                    expect(actions.length).toBe(1);
+                    expect(actions[0].type).toBe(UPDATE_PROPERTY);
+                    expect(actions[0].id).toBe(MAP_WIDGET_ID);
+                    expect(actions[0].key).toBe('maps[0].layers[0].params.elevation');
+                    expect(actions[0].value).toBe(200);
+                },
+                state,
+                done
+            );
+        });
+
+        it('dispatches changeLayerParams for elevation dimension target on main map layer', (done) => {
+            const LAYER_ID = 'mapstore:elevation_test__094852c0-0585-11f1-bc35-ed1a4c87fb4e';
+            const filterWidget = makeFilterWidget({
+                selections: { [FILTER_ID]: [200] },
+                interactions: [{
+                    id: 'int-main-map-elev',
+                    plugged: true,
+                    targetType: 'applyDimension',
+                    source: { nodePath: `widgets[${FILTER_WIDGET_ID}].filters[${FILTER_ID}]` },
+                    target: {
+                        nodePath: `map.layers[${LAYER_ID}].params.elevation`,
+                        metaData: {
+                            dimension: 'elevation'
+                        }
+                    }
+                }]
+            });
+            const state = makeState([filterWidget]);
+
+            testEpic(
+                applyFilterWidgetInteractionsEpic,
+                1,
+                [applyFilterWidgetInteractions(FILTER_WIDGET_ID, 'floating', FILTER_ID)],
+                (actions) => {
+                    expect(actions.length).toBe(1);
+                    expect(actions[0].type).toBe(CHANGE_LAYER_PARAMS);
+                    expect(actions[0].layer).toBe(LAYER_ID);
+                    expect(actions[0].params).toEqual({ elevation: 200 });
+                },
+                state,
+                done
+            );
+        });
     });
 
     describe('cleanupAndReapplyFilterWidgetInteractionsEpic', () => {
diff --git a/web/client/epics/interactions.js b/web/client/epics/interactions.js
index 122087ea282..4c3d73e693b 100644
--- a/web/client/epics/interactions.js
+++ b/web/client/epics/interactions.js
@@ -9,14 +9,23 @@
 import Rx from 'rxjs';
 import { get } from 'lodash';
 
-import { extractTraceFromWidgetByNodePath, extractLayerIdFromNodePath, isMapLayerPath, TARGET_TYPES } from '../utils/InteractionUtils';
+import {
+    extractTraceFromWidgetByNodePath,
+    extractLayerIdFromNodePath,
+    isLayerDimensionTarget,
+    isMapLayerPath,
+    isMapTimeTarget,
+    TARGET_TYPES
+} from '../utils/InteractionUtils';
 import { updateWidgetProperty, INSERT, UPDATE, DELETE } from '../actions/widgets';
 import { getLayerFromId, layersSelector } from '../selectors/layers';
-import { changeLayerProperties, REMOVE_NODE } from '../actions/layers';
+import { changeLayerProperties, changeLayerParams, REMOVE_NODE } from '../actions/layers';
+import { setCurrentTime } from '../actions/dimension';
 import { defaultLayerFilter } from '../utils/FilterUtils';
 import { processFilterToCQL, buildExcludeCQLFilter, buildDefaultCQLFilter } from '../utils/FilterEventUtils';
 import { FILTER_SELECTION_MODES } from '../components/widgets/builder/wizard/filter/FilterDataTab/constants';
 import { APPLY_FILTER_WIDGET_INTERACTIONS, applyFilterWidgetInteractions } from '../actions/interactions';
+import { getMapDependencyPath } from '../utils/WidgetsUtils';
 
 // ============================================================================
 // Node Path Utilities
@@ -288,6 +297,93 @@ function updateMapWidgetWithStyle(widget, interaction, widgetId) {
     return updateWidgetProperty(widgetId, 'maps', updatedWidget.maps);
 }
 
+function getSelectedDimensionValue(filterWidget, filterId) {
+    const selectedValue = filterWidget?.selections?.[filterId]?.[0];
+    return selectedValue?.value ?? selectedValue ?? null;
+}
+
+function getDimensionTargetInfo(interaction) {
+    return {
+        dimension: interaction?.target?.metaData?.dimension || null
+    };
+}
+
+function getMapWidgetDimensionPath(widgetId, nodePath, widgetMaps) {
+    if (!nodePath || !Array.isArray(widgetMaps)) {
+        return null;
+    }
+
+    const nodePathMatch = nodePath.match(/(?:^|\.)widgets\[[^\]]+\]\.(maps\[.*)$/);
+    if (!nodePathMatch) {
+        return null;
+    }
+
+    const resolvedPath = getMapDependencyPath(nodePathMatch[1], widgetId, widgetMaps);
+    return resolvedPath && resolvedPath !== nodePathMatch[1]
+        ? resolvedPath
+        : null;
+}
+
+function updateMapWidgetWithDimension(widget, interaction, widgetId) {
+    if (!interaction?.target?.nodePath) {
+        return null;
+    }
+
+    const nodePath = interaction.target.nodePath;
+    const path = getMapWidgetDimensionPath(widgetId, nodePath, [widget]);
+    return path
+        ? updateWidgetProperty(widgetId, path, interaction.appliedData)
+        : null;
+}
+
+function updateMapLayerWithDimension(interaction) {
+    const layerId = extractLayerIdFromNodePath(interaction?.target?.nodePath);
+    const { dimension } = getDimensionTargetInfo(interaction);
+
+    return layerId && dimension
+        ? changeLayerParams(layerId, { [dimension]: interaction.appliedData })
+        : null;
+}
+
+function applyInteractionEffectForApplyDimension(interaction, state, targetContainer = 'floating') {
+    if (!interaction?.target?.nodePath) {
+        return null;
+    }
+
+    const { dimension } = getDimensionTargetInfo(interaction);
+    if (!dimension) {
+        return null;
+    }
+
+    if (isMapTimeTarget(interaction?.target?.nodePath)) {
+        return dimension === 'time'
+            ? setCurrentTime(interaction.appliedData)
+            : null;
+    }
+
+    if (!isLayerDimensionTarget(interaction?.target?.nodePath)) {
+        return null;
+    }
+
+    if (isMapLayerPath(interaction.target.nodePath)) {
+        return updateMapLayerWithDimension(interaction);
+    }
+
+    const nodePath = interaction.target.nodePath;
+    const widgetId = extractWidgetIdFromNodePath(nodePath);
+    if (!widgetId) {
+        return null;
+    }
+
+    const widgets = get(state, `widgets.containers[${targetContainer}].widgets`) || [];
+    const targetWidget = widgets.find(w => w.id === widgetId);
+    if (targetWidget?.widgetType === 'map') {
+        return updateMapWidgetWithDimension(targetWidget, interaction, widgetId);
+    }
+
+    return null;
+}
+
 // ============================================================================
 // Widget Updates
 // ============================================================================
@@ -829,6 +925,18 @@ export const applyFilterWidgetInteractionsEpic = (action$, store) => {
                             ? Rx.Observable.of(action)
                             : Rx.Observable.empty();
                     }
+
+                    if (interaction.targetType === TARGET_TYPES.APPLY_DIMENSION) {
+                        const updatedInteraction = {
+                            ...interaction,
+                            appliedData: getSelectedDimensionValue(filterWidget, filterId)
+                        };
+                        const action = applyInteractionEffectForApplyDimension(updatedInteraction, currentState, target);
+                        return action
+                            ? Rx.Observable.of(action)
+                            : Rx.Observable.empty();
+                    }
+
                     // Find the specific filter and process it to CQL
                     const filterSelections = selections[filterId];
                     const matchingFilter = filter ? processFilterToCQL(filter, filterSelections) : null;
@@ -858,7 +966,6 @@ export const applyFilterWidgetInteractionsEpic = (action$, store) => {
                 });
         });
 };
-
 /**
  * Epic to cleanup and reapply filter widget interactions
  * For DELETE: only cleanup filters
diff --git a/web/client/plugins/widgetbuilder/FilterView.jsx b/web/client/plugins/widgetbuilder/FilterView.jsx
index 6bc3c5d8e88..b6c8a760422 100644
--- a/web/client/plugins/widgetbuilder/FilterView.jsx
+++ b/web/client/plugins/widgetbuilder/FilterView.jsx
@@ -5,10 +5,11 @@
  * This source code is licensed under the BSD-style license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import React, { useMemo, useState, useEffect, useRef } from 'react';
+import React, { useMemo, useState, useEffect, useRef, useCallback } from 'react';
 import PropTypes from 'prop-types';
 import { compose } from 'recompose';
 import { connect } from 'react-redux';
+import moment from 'moment';
 import { Button, Glyphicon, OverlayTrigger, Tooltip } from 'react-bootstrap';
 import { applyFilterWidgetInteractions } from '../../actions/interactions';
 import filterWidgetEnhancer from '../../components/widgets/enhancers/filterWidget';
@@ -26,6 +27,15 @@ import FilterNoSelectableItems from '../../components/widgets/builder/wizard/fil
 import { isFilterSelectionValid } from './utils/filterBuilder';
 import InfoPopover from '../../components/widgets/widget/InfoPopover';
 import { cleanPaths } from '../../utils/WidgetsUtils';
+import { isMapTimeTarget } from '../../utils/InteractionUtils';
+
+const toIsoTime = (value) => {
+    if (value === undefined || value === null || value === '') {
+        return '';
+    }
+    const normalized = moment.utc(value);
+    return normalized.isValid() ? normalized.toISOString() : String(value);
+};
 
 const NoTargetInfo = ({ interactions = [], activeTargets = {} }) => {
     const connectedActiveTargets = useMemo(() => {
@@ -35,7 +45,7 @@ const NoTargetInfo = ({ interactions = [], activeTargets = {} }) => {
         return interactionTargetPaths
             .filter(path =>
                 Object.entries(activeTargets).some(([activePath, visibility]) => {
-                    return visibility && path === cleanPaths(activePath);
+                    return (visibility && path === cleanPaths(activePath)) || isMapTimeTarget(path);
                 })
             );
     }, [activeTargets, interactions]);
@@ -113,6 +123,15 @@ const UnsupportedVariantInfo = ({ variant }) => (
     </div>
 );
 
+const MapTimeRangeDisabledInfo = () => (
+    <div className="ms-filter-view-map-time-range-disabled">
+        <Glyphicon glyph="warning-sign" className="ms-filter-view-map-time-range-disabled-icon" />
+        <div className="ms-filter-view-map-time-range-disabled-message">
+            <Message msgId="widgets.filterWidget.mapTimeRangeDisabledMessage" />
+        </div>
+    </div>
+);
+
 const ApplyStyleOutOfSyncInfo = connect()(
     ({ applyStyleOutOfSync = {}, dispatch }) => {
         const [debouncedState, setDebouncedState] = useState(applyStyleOutOfSync);
@@ -188,6 +207,9 @@ const FilterView = ({
     className,
     filterData,
     selections = [],
+    currentTime,
+    syncCurrentTime = false,
+    timelineRangeEnabled = false,
     interactions = [],
     activeTargets = {},
     targetsWithDisabledFilter = {},
@@ -200,16 +222,20 @@ const FilterView = ({
     onSelectableItemsChange = () => {},
     fetchError = false
 }) => {
-    if (!filterData) {
-        return null;
-    }
-
-    const { layout = {} } = filterData;
+    const layout = filterData?.layout ?? {};
     const Component = componentMap[layout.variant ?? 'checkbox'];
     const showUnsupportedVariantWarning = !Component;
     const forceSelection = layout.forceSelection === true;
+    const hasMapTimeApplyDimension = syncCurrentTime && (interactions || []).some(interaction =>
+        interaction?.plugged === true
+        && interaction?.targetType === 'applyDimension'
+        && isMapTimeTarget(interaction?.target?.nodePath)
+    );
+    const disableMapTimeSelection = hasMapTimeApplyDimension && timelineRangeEnabled;
     const showForceSelectionError = !isFilterSelectionValid(filterData, selections || []);
     const showSliderSingleItemError = layout.variant === 'slider' && selectableItems?.length === 1;
+    const selectionSyncTimeoutRef = useRef(null);
+    const currentSelection = Array.isArray(selections) ? selections : [];
 
     useEffect(() => {
         if (typeof onSelectableItemsChange === 'function') {
@@ -217,6 +243,65 @@ const FilterView = ({
         }
     }, [onSelectableItemsChange, selectableItems]);
 
+    // Reverse sync: when the map timeline changes, drive the filter widget selection from `currentTime`. For now only on APPLY_DIMENSION's targetPath map.time
+    useEffect(() => {
+        if (selectionSyncTimeoutRef.current) {
+            clearTimeout(selectionSyncTimeoutRef.current);
+            selectionSyncTimeoutRef.current = null;
+        }
+
+        if (!hasMapTimeApplyDimension || disableMapTimeSelection || !currentTime || loading) {
+            return () => {
+                if (selectionSyncTimeoutRef.current) {
+                    clearTimeout(selectionSyncTimeoutRef.current);
+                    selectionSyncTimeoutRef.current = null;
+                }
+            };
+        }
+
+        // Debounce: avoid fighting rapid timeline updates while matching selectable items to the same instant.
+        selectionSyncTimeoutRef.current = setTimeout(() => {
+            const currentTimeIso = toIsoTime(currentTime);
+            const matchedItem = (selectableItems || []).find(item =>
+                toIsoTime(item?.id ?? item?.value) === currentTimeIso
+            );
+            const nextSelection = matchedItem ? [matchedItem.id] : [];
+            const currentSelectionString = currentSelection.length > 0 ? String(currentSelection[0]) : '';
+            const nextSelectionString = nextSelection.length > 0 ? String(nextSelection[0]) : '';
+
+            if (matchedItem) {
+                if (currentSelection.length !== 1 || currentSelectionString !== nextSelectionString) {
+                    onSelectionChange(nextSelection);
+                }
+            } else if (currentSelection.length > 0) {
+                // No dimension value matches map.time anymore — clear selection.
+                onSelectionChange([]);
+            }
+        }, 250);
+
+        return () => {
+            if (selectionSyncTimeoutRef.current) {
+                clearTimeout(selectionSyncTimeoutRef.current);
+                selectionSyncTimeoutRef.current = null;
+            }
+        };
+    }, [hasMapTimeApplyDimension, disableMapTimeSelection, currentTime, selectableItems, currentSelection, loading, onSelectionChange]);
+
+    const onChangeSelections = useCallback((selectedValues) => {
+        if (disableMapTimeSelection) {
+            return;
+        }
+        // when force Selection is on, one item must be selected
+        if (selectedValues?.length === 0 && layout.forceSelection) {
+            return;
+        }
+        onSelectionChange(selectedValues);
+    }, [disableMapTimeSelection, layout.forceSelection, onSelectionChange]);
+
+    if (!filterData) {
+        return null;
+    }
+
     // Show message when required parameters are missing
     if (missingParameters) {
         return (
@@ -314,14 +399,6 @@ const FilterView = ({
         ...(layout.backgroundColor && { padding: '12px', borderRadius: '4px' })
     };
 
-    const onChangeSelections = (selectedValues) =>{
-        // when force Selection is on, one item must be selected
-        if (selectedValues?.length === 0 && layout.forceSelection) {
-            return;
-        }
-        onSelectionChange(selectedValues);
-    };
-
     const showNoTargetsInfoTool = showNoTargetsInfo ?? layout.showNoTargetsInfo ?? true;
     return (
         <div className={['ms-filter-builder-mock-previews', className].filter(Boolean).join(' ')} style={containerStyle}>
@@ -399,7 +476,7 @@ const FilterView = ({
                         : null
                 }
 
-                {showSelectAll && !showUnsupportedVariantWarning && (<FilterSelectAllOptions
+                {showSelectAll && !showUnsupportedVariantWarning && !disableMapTimeSelection && (<FilterSelectAllOptions
                     key={filterData.id + '-select-all'}
                     items={selectableItems}
                     selectedValues={selections || []}
@@ -409,7 +486,9 @@ const FilterView = ({
                 />)
                 }
             </div>
-            {showUnsupportedVariantWarning ? (
+            {disableMapTimeSelection ? (
+                <MapTimeRangeDisabledInfo />
+            ) : showUnsupportedVariantWarning ? (
                 <UnsupportedVariantInfo variant={layout.variant} />
             ) : selectableItems?.length > 0 ? (
                 showSliderSingleItemError ? (
@@ -467,7 +546,10 @@ FilterView.propTypes = {
     missingParameters: PropTypes.bool,
     selectableItems: PropTypes.array,
     onSelectableItemsChange: PropTypes.func,
-    fetchError: PropTypes.bool
+    fetchError: PropTypes.bool,
+    syncCurrentTime: PropTypes.bool,
+    timelineRangeEnabled: PropTypes.bool,
+    currentTime: PropTypes.string
 };
 FilterView.defaultProps = {};
 
diff --git a/web/client/plugins/widgetbuilder/__tests__/FilterView-test.jsx b/web/client/plugins/widgetbuilder/__tests__/FilterView-test.jsx
index c69cb6a5684..9c0a0742471 100644
--- a/web/client/plugins/widgetbuilder/__tests__/FilterView-test.jsx
+++ b/web/client/plugins/widgetbuilder/__tests__/FilterView-test.jsx
@@ -358,6 +358,36 @@ describe('FilterView component', () => {
         expect(container.textContent).toContain('widgets.filterWidget.fetchError');
     });
 
+    it('disables map.time apply dimension selection when timeline range is enabled', () => {
+        const container = document.getElementById("container");
+        const onSelectionChangeSpy = expect.createSpy();
+        const filterData = createMockFilterData('button');
+
+        renderWithProvider(
+            <FilterView
+                filterData={filterData}
+                selectableItems={[
+                    { id: '2024-01-01T00:00:00.000Z', label: '2024-01-01' }
+                ]}
+                currentTime="2024-01-01T00:00:00.000Z"
+                syncCurrentTime
+                timelineRangeEnabled
+                interactions={[{
+                    plugged: true,
+                    targetType: 'applyDimension',
+                    target: { nodePath: 'map.time' }
+                }]}
+                onSelectionChange={onSelectionChangeSpy}
+            />,
+            container
+        );
+
+        expect(container.querySelector('.ms-filter-view-map-time-range-disabled')).toExist();
+        expect(container.textContent).toContain('widgets.filterWidget.mapTimeRangeDisabledMessage');
+        expect(container.querySelector('.ms-filter-button-list-item')).toNotExist();
+
+    });
+
     it('does not call onSelectionChange when forceSelection is true and user clicks checkbox with value 1 to deselect', () => {
         const container = document.getElementById("container");
         const onSelectionChangeSpy = expect.createSpy();
diff --git a/web/client/plugins/widgetbuilder/utils/filterBuilder.js b/web/client/plugins/widgetbuilder/utils/filterBuilder.js
index c3d920cd77d..981949d1566 100644
--- a/web/client/plugins/widgetbuilder/utils/filterBuilder.js
+++ b/web/client/plugins/widgetbuilder/utils/filterBuilder.js
@@ -52,6 +52,7 @@ export const createNewFilter = (filtersCount = 0) => {
             forceSelection: false
         },
         items: [],
+        addedOptionalTargets: [],
         data: createEmptyFilterData()
     };
 };
diff --git a/web/client/selectors/__tests__/widgets-test.js b/web/client/selectors/__tests__/widgets-test.js
index 6793b54c953..c5cc2bdd5a0 100644
--- a/web/client/selectors/__tests__/widgets-test.js
+++ b/web/client/selectors/__tests__/widgets-test.js
@@ -792,6 +792,16 @@ describe('widgets selectors', () => {
                 name: "check layer visibility with group visibility set to false",
                 path: 'map.layers[test:states_training__51824df0-fac9-11f0-b714-1b62e8a515ce]',
                 expected: false
+            }, {
+                state: set('layers.flat[0].dimensions', [{ name: 'elevation' }], STATE_INTERACTION_MAP_1),
+                name: "check main map layer dimension visibility from parent layer",
+                path: 'map.layers[test:states_training__51824df0-fac9-11f0-b714-1b62e8a515ce].params.elevation',
+                expected: true
+            }, {
+                state: set('layers.flat[0].visibility', false, set('layers.flat[0].dimensions', [{ name: 'elevation' }], STATE_INTERACTION_MAP_1)),
+                name: "check main map layer dimension visibility false when parent layer is hidden",
+                path: 'map.layers[test:states_training__51824df0-fac9-11f0-b714-1b62e8a515ce].params.elevation',
+                expected: false
             }, {
                 state: set('widgets.containers.floating.collapsed["746e1fb0-fac9-11f0-b714-1b62e8a515ce"]', {
                     "layout": {
@@ -836,6 +846,18 @@ describe('widgets selectors', () => {
                 path: 'widgets[5640f860-fad2-11f0-9e1f-7900d8be1f6f].maps[5917e620-fad2-11f0-9e1f-7900d8be1f6f].layers[test:states_training__5e262640-fad2-11f0-9e1f-7900d8be1f6f]',
                 name: "dashboard visibility of map layers in map layers when GROUP has visibility false",
                 expected: false
+            },
+            {
+                state: set('widgets.containers.floating.widgets[1].maps[0].layers[0].dimensions', [{ name: 'elevation' }], STATE_INTERACTION_DASH_1),
+                path: 'widgets[5640f860-fad2-11f0-9e1f-7900d8be1f6f].maps[5917e620-fad2-11f0-9e1f-7900d8be1f6f].layers[test:states_training__5e262640-fad2-11f0-9e1f-7900d8be1f6f].params.elevation',
+                name: "dashboard visibility of map layer dimension from parent layer",
+                expected: true
+            },
+            {
+                state: set('widgets.containers.floating.widgets[1].maps[0].layers[0].visibility', false, set('widgets.containers.floating.widgets[1].maps[0].layers[0].dimensions', [{ name: 'elevation' }], STATE_INTERACTION_DASH_1)),
+                path: 'widgets[5640f860-fad2-11f0-9e1f-7900d8be1f6f].maps[5917e620-fad2-11f0-9e1f-7900d8be1f6f].layers[test:states_training__5e262640-fad2-11f0-9e1f-7900d8be1f6f].params.elevation',
+                name: "dashboard visibility of map layer dimension false when parent layer is hidden",
+                expected: false
             }
         ];
         tests.forEach(({state, name, path, expected}) => {
diff --git a/web/client/selectors/widgets.js b/web/client/selectors/widgets.js
index 5d56e2e1962..4adb65df882 100644
--- a/web/client/selectors/widgets.js
+++ b/web/client/selectors/widgets.js
@@ -10,7 +10,7 @@ import { find, get, castArray, flatten } from 'lodash';
 
 import { mapSelector } from './map';
 import { getEffectivelyVisibleLayers, getSelectedLayer, layersSelector } from './layers';
-import { generateRootTree, TARGET_TYPES, isAnyLayerPath } from '../utils/InteractionUtils';
+import { generateRootTree, TARGET_TYPES, isAnyLayerPath, isLayerDimensionTarget } from '../utils/InteractionUtils';
 import { pathnameSelector } from './router';
 import { DEFAULT_TARGET, DEPENDENCY_SELECTOR_KEY, LAYERS_REGEX, WIDGETS_REGEX } from '../actions/widgets';
 import { cleanPaths, getWidgetsGroups, getWidgetDependency, getSelectedWidgetData, extractTraceData, canTableWidgetBeDependency } from '../utils/WidgetsUtils';
@@ -98,7 +98,9 @@ export const getWidgetInteractionTreeGenerated = createSelector(
 
         // Don't pass mapLayers if dashboard editing is true
         const layersToUse = dashboardEditing ? undefined : mapLayers;
-        return generateRootTree(combinedWidgets, layersToUse);
+        return generateRootTree(combinedWidgets, layersToUse, {
+            timelineEnabled: !dashboardEditing
+        });
     }
 );
 
@@ -413,6 +415,10 @@ export const interactionsNodePathsSelector = createSelector(
     }
 );
 
+const getLayerVisibilityPath = (path) => isLayerDimensionTarget(path)
+    ? path.replace(/\.params\.(?:time|elevation)$/, '')
+    : path;
+
 /**
  * Get interaction data from the node paths available in the interaction tree.
  * @param {object} state the state
@@ -434,6 +440,11 @@ export const interactionsNodesSelector = (state) => {
         const object = createPathSelector(path)(state);
         if (object) {
             map.set(path, object);
+        } else if (isLayerDimensionTarget(path)) {
+            const layerObject = createPathSelector(getLayerVisibilityPath(path))(state);
+            if (layerObject) {
+                map.set(path, layerObject);
+            }
         }
     });
     return map;
@@ -448,8 +459,12 @@ export const interactionTargetVisibilitySelector = createSelector(
     // getCollapsedState, // collapsed widgets
     (targetsData, visibleLayers, visibleWidgets) => {
         return targetsData.entries().reduce((acc, [path, value]) => {
-            if (path.startsWith("map.layers[")) {
-                acc[path] = visibleLayers.some(l => l.id === value.id);
+            const layerVisibilityPath = getLayerVisibilityPath(path);
+            const layerVisibilityValue = layerVisibilityPath === path
+                ? value
+                : targetsData.get(layerVisibilityPath) || value;
+            if (layerVisibilityPath.startsWith("map.layers[")) {
+                acc[path] = visibleLayers.some(l => l.id === layerVisibilityValue?.id);
             }
             if (path.startsWith("widgets[")) {
                 // need to check visibility, and if contains layer, also effective visibility for the map
@@ -458,20 +473,17 @@ export const interactionTargetVisibilitySelector = createSelector(
                     const match = pp.match(/widgets\[(.*?)\]/);
                     return match ? match[1] : null;
                 };
-                if (visibleWidgets.some(w => w.id === getWidgetIdFromPath(path))) {
-                    acc[path] = true;
-                } else {
-                    acc[path] = false;
-                }
-                if (path.includes(".layers[")) {
+                const widgetVisible = visibleWidgets.some(w => w.id === getWidgetIdFromPath(path));
+                acc[path] = widgetVisible;
+                if (layerVisibilityPath.includes(".layers[")) {
                     // for the moment we only support there is no path nesting beyond layers
-                    const layerId = value.id;
+                    const layerId = layerVisibilityValue?.id;
                     // get map of the layer from the path and the targetsData
-                    const mapPath = path.substring(0, path.indexOf(".layers["));
+                    const mapPath = layerVisibilityPath.substring(0, layerVisibilityPath.indexOf(".layers["));
                     const mapObject = targetsData.get(mapPath);
-                    getDerivedLayersVisibility(mapObject.layers, mapObject.groups).forEach(l => {
+                    getDerivedLayersVisibility(mapObject?.layers, mapObject?.groups).forEach(l => {
                         if (l.id === layerId) {
-                            acc[path] = l.visibility === true;
+                            acc[path] = widgetVisible && l.visibility === true;
                         }
                     });
                 }
diff --git a/web/client/translations/data.da-DK.json b/web/client/translations/data.da-DK.json
index f3319a78aab..43cb22786bd 100644
--- a/web/client/translations/data.da-DK.json
+++ b/web/client/translations/data.da-DK.json
@@ -2468,7 +2468,8 @@
         "editFilterTitleTooltip": "Klik for at redigere filtertitel",
         "addNewFilterTooltip": "Klik for at tilføje nyt filter",
         "applyStyle": "Anvend stil",
-        "targetAlreadyConnectedToStyleTooltip": "Målet er allerede forbundet til en stil. Kan ikke forbinde til flere stile samtidigt"
+        "targetAlreadyConnectedToStyleTooltip": "Målet er allerede forbundet til en stil. Kan ikke forbinde til flere stile samtidigt",
+        "targetAlreadyConnectedToAnotherFilterTooltip": "Dette mål er allerede forbundet fra en anden kilde. Det kan ikke forbindes fra flere kilder samtidigt"
       }
     },
     "dashboard": {
diff --git a/web/client/translations/data.de-DE.json b/web/client/translations/data.de-DE.json
index 03a96cbcdf8..f491a12fdd4 100644
--- a/web/client/translations/data.de-DE.json
+++ b/web/client/translations/data.de-DE.json
@@ -2573,6 +2573,8 @@
         "interactionsTabLabel": "Interaktionen",
         "onSelectionChange": "Bei Auswahländerung",
         "applyFilter": "Filter anwenden",
+        "applyDimension": "Dimension anwenden",
+        "noConnectableNodesAvailable": "Keine verbindbaren Knoten verfügbar",
 
         "selectAll": "Alle auswählen",
         "clear": "Löschen",
@@ -2622,6 +2624,7 @@
         "missingParametersMessage": "Bitte wählen Sie die erforderlichen Felder aus, um die Filterliste zu generieren",
         "fetchError": "Fehler beim Abrufen der Daten",
         "unsupportedVariantMessage": "Nicht unterstützte Filtervariante: {variant}.",
+        "mapTimeRangeDisabledMessage": "Kann nicht verwendet werden, wenn der Bereich aktiviert ist.",
         "sliderSingleItemError": "Der Schieberegler-Filter benötigt mindestens zwei auswählbare Werte.",
         "noSelectableItems": "Keine auswählbaren Filterelemente.",
         "filters": "Filter",
@@ -2638,8 +2641,15 @@
         "filterTitlePlaceholder": "Filtertitel...",
         "editFilterTitleTooltip": "Klicken Sie, um den Filtertitel zu bearbeiten",
         "addNewFilterTooltip": "Klicken Sie, um neuen Filter hinzuzufügen",
+        "addOptionalTargetTooltip": "Optionales Ziel hinzufügen",
+        "removeOptionalTargetConfirmTitle": "Ziel löschen?",
+        "removeOptionalTargetConfirmContent": "Alle verbundenen Interaktionen von diesem Ziel werden gelöscht.",
         "applyStyle": "Stil anwenden",
-        "targetAlreadyConnectedToStyleTooltip": "Das Ziel ist bereits mit einem Stil verbunden. Es kann nicht gleichzeitig mit mehreren Stilen verbunden werden"
+        "targetAlreadyConnectedToStyleTooltip": "Das Ziel ist bereits mit einem Stil verbunden. Es kann nicht gleichzeitig mit mehreren Stilen verbunden werden",
+        "targetAlreadyConnectedToAnotherFilterTooltip": "Dieses Ziel ist bereits von einer anderen Quelle verbunden. Es kann nicht gleichzeitig von mehreren Quellen verbunden werden",
+        "applyDimensionSelectionModeDisabledTooltip": "Die Mehrfachauswahl ist deaktiviert, weil dieser Filter mit „Dimension anwenden“ verbunden ist. Trennen Sie „Dimension anwenden“, um den Mehrfachauswahlmodus zu verwenden.",
+        "applyDimensionMultipleSelectionDisabledTooltip": "„Dimension anwenden“ kann nur verbunden werden, wenn der Auswahlmodus des Filters „Einzel“ ist. Stellen Sie den Layout-Auswahlmodus auf „Einzel“, um dieses Ziel zu verbinden.",
+        "targetAlreadyConnectedToTimeTooltip": "Die Kartenzeit aus „Dimension anwenden“ kann nur allein verbunden werden. Sie kann nicht gleichzeitig mit anderen Dimensionszielen verbunden werden."
       },
       "tray": {
         "title": "Widgets",
diff --git a/web/client/translations/data.en-US.json b/web/client/translations/data.en-US.json
index f3351fc0031..676408c577f 100644
--- a/web/client/translations/data.en-US.json
+++ b/web/client/translations/data.en-US.json
@@ -2557,6 +2557,8 @@
         "onSelectionChange": "On Selection Change",
 
         "applyFilter": "Apply Filter",
+        "applyDimension": "Apply Dimension",
+        "noConnectableNodesAvailable": "No connectable nodes available",
 
         "selectAll": "Select All",
         "clear": "Clear",
@@ -2604,6 +2606,7 @@
         "missingParametersMessage": "Please select required fields to generate the filter list",
         "fetchError": "Failed to fetch data",
         "unsupportedVariantMessage": "Unsupported filter variant: {variant}.",
+        "mapTimeRangeDisabledMessage": "Cannot be used when range is enabled.",
         "sliderSingleItemError": "Slider filter requires at least two selectable values.",
         "noSelectableItems": "No selectable filter items.",
         "filters": "Filters",
@@ -2621,8 +2624,15 @@
         "filterTitlePlaceholder": "Filter title...",
         "editFilterTitleTooltip": "Click to edit filter title",
         "addNewFilterTooltip": "Click to add new filter",
+        "addOptionalTargetTooltip": "Add optional target",
+        "removeOptionalTargetConfirmTitle": "Delete target?",
+        "removeOptionalTargetConfirmContent": "All connected interactions from this target will be deleted.",
         "applyStyle": "Apply Style",
-        "targetAlreadyConnectedToStyleTooltip": "The target is already connected to a style. Can not connect to multiple styles selector at the same time"
+        "targetAlreadyConnectedToStyleTooltip": "The target is already connected to a style. Can not connect to multiple styles selector at the same time",
+        "targetAlreadyConnectedToAnotherFilterTooltip": "This target is already connected from another source. It can not be connected from multiple sources at the same time",
+        "applyDimensionSelectionModeDisabledTooltip": "Multiple selection is disabled because this filter is connected to Apply Dimension. Disconnect Apply Dimension to use Multiple selection mode.",
+        "applyDimensionMultipleSelectionDisabledTooltip": "Apply Dimension can only be connected when the filter selection mode is Single. Switch the layout selection mode to Single to connect this target.",
+        "targetAlreadyConnectedToTimeTooltip": "Map time from Apply Dimension can only be connected alone. It can not be connected with other dimension targets at the same time"
       }
     },
     "dashboard": {
diff --git a/web/client/translations/data.es-ES.json b/web/client/translations/data.es-ES.json
index f377b0c1705..2c970b485a4 100644
--- a/web/client/translations/data.es-ES.json
+++ b/web/client/translations/data.es-ES.json
@@ -2531,6 +2531,8 @@
         "interactionsTabLabel": "Interacciones",
         "onSelectionChange": "Al cambiar la selección",
         "applyFilter": "Aplicar filtro",
+        "applyDimension": "Aplicar dimensión",
+        "noConnectableNodesAvailable": "No hay nodos conectables disponibles",
         "selectAll": "Seleccionar todo",
         "clear": "Limpiar",
         "showSelectAllClear": "Mostrar 'Seleccionar todo' y 'Limpiar'",
@@ -2579,6 +2581,7 @@
         "missingParametersMessage": "Por favor seleccione los campos requeridos para generar la lista de filtros",
         "fetchError": "Error al obtener los datos",
         "unsupportedVariantMessage": "Variante de filtro no admitida: {variant}.",
+        "mapTimeRangeDisabledMessage": "No se puede usar cuando el rango está habilitado.",
         "sliderSingleItemError": "El filtro de deslizador requiere al menos dos valores seleccionables.",
         "noSelectableItems": "No hay elementos de filtro seleccionables.",
         "filters": "Filtros",
@@ -2595,8 +2598,15 @@
         "filterTitlePlaceholder": "Título del filtro...",
         "editFilterTitleTooltip": "Haga clic para editar el título del filtro",
         "addNewFilterTooltip": "Haga clic para agregar nuevo filtro",
+        "addOptionalTargetTooltip": "Añadir objetivo opcional",
+        "removeOptionalTargetConfirmTitle": "¿Eliminar objetivo?",
+        "removeOptionalTargetConfirmContent": "Se eliminarán todas las interacciones conectadas desde este objetivo.",
         "applyStyle": "Aplicar estilo",
-        "targetAlreadyConnectedToStyleTooltip": "El objetivo ya está conectado a un estilo. No se puede conectar a múltiples estilos al mismo tiempo"
+        "targetAlreadyConnectedToStyleTooltip": "El objetivo ya está conectado a un estilo. No se puede conectar a múltiples estilos al mismo tiempo",
+        "targetAlreadyConnectedToAnotherFilterTooltip": "Este objetivo ya está conectado desde otra fuente. No se puede conectar desde varias fuentes al mismo tiempo",
+        "applyDimensionSelectionModeDisabledTooltip": "La selección múltiple está deshabilitada porque este filtro está conectado a «Aplicar dimensión». Desconecte «Aplicar dimensión» para usar el modo de selección múltiple.",
+        "applyDimensionMultipleSelectionDisabledTooltip": "«Aplicar dimensión» solo puede conectarse cuando el modo de selección del filtro es «Única». Cambie el modo de selección del diseño a «Única» para conectar este objetivo.",
+        "targetAlreadyConnectedToTimeTooltip": "La hora del mapa de «Aplicar dimensión» solo puede conectarse sola. No puede conectarse con otros objetivos de dimensión al mismo tiempo."
       },
       "tray": {
         "title": "Widgets",
diff --git a/web/client/translations/data.fr-FR.json b/web/client/translations/data.fr-FR.json
index 389fb42e6fc..5f54646926f 100644
--- a/web/client/translations/data.fr-FR.json
+++ b/web/client/translations/data.fr-FR.json
@@ -2534,6 +2534,8 @@
         "interactionsTabLabel": "Interactions",
         "onSelectionChange": "Lors du changement de sélection",
         "applyFilter": "Appliquer le filtre",
+        "applyDimension": "Appliquer la dimension",
+        "noConnectableNodesAvailable": "Aucun nœud connectable disponible",
 
         "selectAll": "Tout sélectionner",
         "clear": "Effacer",
@@ -2583,6 +2585,7 @@
         "missingParametersMessage": "Veuillez sélectionner les champs requis pour générer la liste des filtres",
         "fetchError": "Échec de la récupération des données",
         "unsupportedVariantMessage": "Variante de filtre non prise en charge : {variant}.",
+        "mapTimeRangeDisabledMessage": "Impossible à utiliser lorsque la plage est activée.",
         "sliderSingleItemError": "Le filtre avec curseur nécessite au moins deux valeurs sélectionnables.",
         "noSelectableItems": "Aucun élément de filtre sélectionnable.",
         "filters": "Filtres",
@@ -2599,8 +2602,15 @@
         "filterTitlePlaceholder": "Titre du filtre...",
         "editFilterTitleTooltip": "Cliquez pour modifier le titre du filtre",
         "addNewFilterTooltip": "Cliquez pour ajouter un nouveau filtre",
+        "addOptionalTargetTooltip": "Ajouter une cible optionnelle",
+        "removeOptionalTargetConfirmTitle": "Supprimer la cible ?",
+        "removeOptionalTargetConfirmContent": "Toutes les interactions connectées à cette cible seront supprimées.",
         "applyStyle": "Appliquer le style",
-        "targetAlreadyConnectedToStyleTooltip": "La cible est déjà connectée à un style. Impossible de se connecter à plusieurs styles en même temps"
+        "targetAlreadyConnectedToStyleTooltip": "La cible est déjà connectée à un style. Impossible de se connecter à plusieurs styles en même temps",
+        "targetAlreadyConnectedToAnotherFilterTooltip": "Cette cible est déjà connectée depuis une autre source. Impossible de la connecter depuis plusieurs sources en même temps",
+        "applyDimensionSelectionModeDisabledTooltip": "La sélection multiple est désactivée car ce filtre est connecté à « Appliquer la dimension ». Déconnectez « Appliquer la dimension » pour utiliser le mode de sélection multiple.",
+        "applyDimensionMultipleSelectionDisabledTooltip": "« Appliquer la dimension » ne peut être connecté que lorsque le mode de sélection du filtre est « Unique ». Passez le mode de sélection de la mise en page sur « Unique » pour connecter cette cible.",
+        "targetAlreadyConnectedToTimeTooltip": "Le temps de la carte depuis « Appliquer la dimension » ne peut être connecté que seul. Il ne peut pas être connecté avec d'autres cibles de dimension en même temps."
       },
       "tray": {
         "title": "Widgets",
diff --git a/web/client/translations/data.it-IT.json b/web/client/translations/data.it-IT.json
index d962d787884..4fb080afbf2 100644
--- a/web/client/translations/data.it-IT.json
+++ b/web/client/translations/data.it-IT.json
@@ -2534,6 +2534,8 @@
         "interactionsTabLabel": "Interazioni",
         "onSelectionChange": "Al cambio selezione",
         "applyFilter": "Applica filtro",
+        "applyDimension": "Applica dimensione",
+        "noConnectableNodesAvailable": "Nessun nodo collegabile disponibile",
 
         "selectAll": "Seleziona tutto",
         "clear": "Cancella",
@@ -2583,6 +2585,7 @@
         "missingParametersMessage": "Selezionare i campi richiesti per generare l'elenco dei filtri",
         "fetchError": "Impossibile recuperare i dati",
         "unsupportedVariantMessage": "Variante filtro non supportata: {variant}.",
+        "mapTimeRangeDisabledMessage": "Non può essere utilizzato quando l'intervallo è abilitato.",
         "sliderSingleItemError": "Il filtro con slider richiede almeno due valori selezionabili.",
         "noSelectableItems": "Nessun elemento filtro selezionabile.",
         "filters": "Filtri",
@@ -2599,8 +2602,15 @@
         "filterTitlePlaceholder": "Titolo filtro...",
         "editFilterTitleTooltip": "Clicca per modificare il titolo del filtro",
         "addNewFilterTooltip": "Clicca per aggiungere nuovo filtro",
+        "addOptionalTargetTooltip": "Aggiungi target opzionale",
+        "removeOptionalTargetConfirmTitle": "Eliminare il target?",
+        "removeOptionalTargetConfirmContent": "Tutte le interazioni collegate da questo target verranno eliminate.",
         "applyStyle": "Applica stile",
-        "targetAlreadyConnectedToStyleTooltip": "Il target è già connesso a uno stile. Non è possibile connettersi a più stili contemporaneamente"
+        "targetAlreadyConnectedToStyleTooltip": "Il target è già connesso a uno stile. Non è possibile connettersi a più stili contemporaneamente",
+        "targetAlreadyConnectedToAnotherFilterTooltip": "Questo target è già connesso da un'altra sorgente. Non può essere connesso da più sorgenti contemporaneamente",
+        "applyDimensionSelectionModeDisabledTooltip": "La selezione multipla è disabilitata perché questo filtro è collegato ad «Applica dimensione». Scollega «Applica dimensione» per usare la modalità di selezione multipla.",
+        "applyDimensionMultipleSelectionDisabledTooltip": "«Applica dimensione» può essere collegato solo quando la modalità di selezione del filtro è «Singola». Imposta la modalità di selezione del layout su «Singola» per collegare questo target.",
+        "targetAlreadyConnectedToTimeTooltip": "L'ora della mappa da «Applica dimensione» può essere collegata solo da sola. Non può essere collegata contemporaneamente ad altri obiettivi di dimensione."
       },
       "tray": {
         "title": "widget",
diff --git a/web/client/utils/InteractionUtils.js b/web/client/utils/InteractionUtils.js
index a4d6b81ac59..77b6ad437b5 100644
--- a/web/client/utils/InteractionUtils.js
+++ b/web/client/utils/InteractionUtils.js
@@ -1,6 +1,7 @@
 export const DATATYPES = {
     LAYER_FILTER: 'LAYER_FILTER',
-    LAYER_STYLE: 'LAYER_STYLE'
+    LAYER_STYLE: 'LAYER_STYLE',
+    LAYER_DIMENSION: 'LAYER_DIMENSION'
 };
 
 export const EVENTS = {
@@ -9,19 +10,22 @@ export const EVENTS = {
 
 export const TARGET_TYPES = {
     APPLY_FILTER: 'applyFilter',
-    APPLY_STYLE: 'applyStyle'
+    APPLY_STYLE: 'applyStyle',
+    APPLY_DIMENSION: 'applyDimension'
 };
 
 // Human-readable labels for target types
 export const TARGET_TYPE_LABELS = {
     [TARGET_TYPES.APPLY_FILTER]: 'Apply filter',
-    [TARGET_TYPES.APPLY_STYLE]: 'Apply style'
+    [TARGET_TYPES.APPLY_STYLE]: 'Apply style',
+    [TARGET_TYPES.APPLY_DIMENSION]: 'Apply dimension'
 };
 
 // Glyph icons for target types
 export const TARGET_TYPE_GLYPHS = {
     [TARGET_TYPES.APPLY_FILTER]: 'filter',
-    [TARGET_TYPES.APPLY_STYLE]: 'style'
+    [TARGET_TYPES.APPLY_STYLE]: 'style',
+    [TARGET_TYPES.APPLY_DIMENSION]: 'record'
 };
 
 /**
@@ -29,12 +33,13 @@ export const TARGET_TYPE_GLYPHS = {
  * Values are arrays to support multiple targets per event.
  */
 export const EVENT_TARGET_MAP = {
-    [EVENTS.FILTER_CHANGE]: [TARGET_TYPES.APPLY_FILTER, TARGET_TYPES.APPLY_STYLE]
+    [EVENTS.FILTER_CHANGE]: [TARGET_TYPES.APPLY_FILTER, TARGET_TYPES.APPLY_STYLE, TARGET_TYPES.APPLY_DIMENSION]
 };
 
 export const TARGET_EVENT_DATA_TYPES = {
     [TARGET_TYPES.APPLY_FILTER]: DATATYPES.LAYER_FILTER,
-    [TARGET_TYPES.APPLY_STYLE]: DATATYPES.LAYER_STYLE
+    [TARGET_TYPES.APPLY_STYLE]: DATATYPES.LAYER_STYLE,
+    [TARGET_TYPES.APPLY_DIMENSION]: DATATYPES.LAYER_DIMENSION
 };
 
 // Events available by widget type
@@ -103,65 +108,6 @@ export function createLayerConstraint(name) {
     };
 }
 
-export const getDirectlyPluggableTargets = (item, event) => {
-    const interactionMetadata = item?.interactionMetadata;
-    if (!interactionMetadata) return [];
-    return (interactionMetadata?.targets || []).filter( t =>{
-        return t.expectedDataType === event.dataType &&
-        JSON.stringify(t.constraints) === JSON.stringify(event?.constraints);
-    }
-    );
-};
-export const getConfigurableTargets = (item, event) => {
-    const interactionMetadata = item?.interactionMetadata;
-    if (!interactionMetadata) return [];
-    return (interactionMetadata?.targets || []).filter( t =>
-        t.expectedDataType === event.dataType &&
-        JSON.stringify(t.constraints) !== JSON.stringify(event?.constraints)
-    );
-};
-
-export const isConfigurationValidForTarget = () => true; // TODO: implement configuration validation rules
-
-export const getConfiguredTargets = (item, event, configuration) => {
-    const interactionMetadata = item?.interactionMetadata;
-    if (!interactionMetadata) return [];
-    return (interactionMetadata?.targets || []).filter( t =>
-        t.expectedDataType === event.dataType &&
-        isConfigurationValidForTarget(configuration, t, event)
-    );
-};
-
-/**
- * Determines if an item is directly pluggable or configured to force plug.
- * @param {object} node the node object with interactionMetadata from interactionTree
- * @param {object} target the target object with expectedDataType and constraint
- * @param {object} configuration the configuration object (default: {})
- * @returns {object} object with directlyPluggable and configuredToForcePlug boolean flags
- */
-export function getItemPluggableStatus(node, target, configuration = {}) {
-    const interactionMetadata = node?.interactionMetadata;
-    if (!interactionMetadata) {
-        return {
-            directlyPluggable: false,
-            configuredToForcePlug: false
-        };
-    }
-
-    // Check if directly pluggable: constraints match
-    const directlyPluggable = (interactionMetadata?.targets || []).find(t => {
-        return t.expectedDataType === target.expectedDataType &&
-            JSON.stringify(t.constraints) === JSON.stringify(target?.constraints);
-    }) !== undefined;
-
-    // Check if configured to force plug
-    const configuredToForcePlug = configuration?.forcePlug === true;
-
-    return {
-        directlyPluggable,
-        configuredToForcePlug
-    };
-}
 
 /**
  * Creates base properties shared by both element and collection nodes.
@@ -178,6 +124,22 @@ function createBaseProperties(title, icon, id) {
     };
 }
 
+/**
+ * Creates a base collection tree node structure.
+ * @param {string} title the collection title
+ * @param {array} children the children array
+ * @param {string} icon optional icon identifier
+ * @param {string} id optional id
+ * @returns {object} the base collection tree node
+ */
+function createBaseCollectionNode(title, children = [], icon, id) {
+    return {
+        type: "collection",
+        ...createBaseProperties(title, icon, id),
+        staticallyNamedCollection: true,
+        ...(children.length > 0 ? {children} : {})
+    };
+}
 /**
  * Creates a base element tree node structure.
  * @param {object} item the item object (widget, trace, etc.)
@@ -193,22 +155,173 @@ function createBaseElementNode(item, icon, title) {
 }
 
 /**
- * Creates a base collection tree node structure.
- * @param {string} title the collection title
- * @param {array} children the children array
- * @param {string} icon optional icon identifier
- * @param {string} id optional id
- * @returns {object} the base collection tree node
+ * Returns true if the layer supports interactions
+ * @param {object} layer the layer
+ * @returns {boolean}
  */
-function createBaseCollectionNode(title, children = [], icon, id) {
+export function isInteractionSupported(layer) {
+    return ['wms', 'wfs'].includes(layer?.type) && layer.group !== "background";
+}
+
+
+function hasDimension(layer, dimensionNames = []) {
+    return (layer?.dimensions || []).some(dim => {
+        const dimName = (dim?.name || '').toLowerCase();
+        return dimensionNames.includes(dimName);
+    });
+}
+
+function hasTimeDimension(layer) {
+    return hasDimension(layer, ['time']);
+}
+
+function hasElevationDimension(layer) {
+    return hasDimension(layer, ['elevation']);
+}
+
+function createDimensionConstraints(layer, constrainByLayer = false) {
+    return constrainByLayer && layer?.name ? {
+        layer: createLayerConstraint(layer.name)
+    } : {};
+}
+
+function normalizeValueAttributeType(valueAttributeType) {
+    return (valueAttributeType || '').toLowerCase();
+}
+
+function getAllowedDimensionNames(valueAttributeType) {
+    const normalizedType = normalizeValueAttributeType(valueAttributeType);
+    const allowedDimensions = new Set();
+
+    if (['date', 'date-time', 'datetime'].includes(normalizedType)) {
+        allowedDimensions.add('time');
+    }
+
+    if (normalizedType === 'number') {
+        allowedDimensions.add('elevation');
+    }
+
+    return allowedDimensions;
+}
+
+export function hasAllowedDimensionTarget(layer, valueAttributeType) {
+    const allowedDimensions = getAllowedDimensionNames(valueAttributeType);
+    if (allowedDimensions.size === 0) {
+        return false;
+    }
+    return (layer?.dimensions || []).some(dim => allowedDimensions.has((dim?.name || '').toLowerCase()));
+}
+
+export function filterDimensionTreeByValueAttributeType(tree, valueAttributeType) {
+    const allowedDimensions = getAllowedDimensionNames(valueAttributeType);
+    if (allowedDimensions.size === 0) {
+        return null;
+    }
+
+    const getNodeDimensionName = (node) => {
+        const nodeId = (node?.id || '').toLowerCase();
+        if (nodeId.includes('elevation')) {
+            return 'elevation';
+        }
+        if (nodeId.includes('time')) {
+            return 'time';
+        }
+        return null;
+    };
+
+    const pruneNode = (node) => {
+        if (!node) {
+            return null;
+        }
+
+        const children = Array.isArray(node.children)
+            ? node.children.map(pruneNode).filter(Boolean)
+            : [];
+
+        const nodeDimension = getNodeDimensionName(node);
+        if (nodeDimension && !allowedDimensions.has(nodeDimension)) {
+            return null;
+        }
+
+        if (node.type === 'collection' && children.length === 0) {
+            return null;
+        }
+
+        return children.length > 0
+            ? { ...node, children }
+            : { ...node };
+    };
+
+    return pruneNode(tree);
+}
+
+function createDimensionTargetMetadata(layer, dimension, { constrainByLayer = false } = {}) {
     return {
-        type: "collection",
-        ...createBaseProperties(title, icon, id),
-        staticallyNamedCollection: true,
-        ...(children.length > 0 ? {children} : {})
+        targetType: TARGET_TYPES.APPLY_DIMENSION,
+        expectedDataType: DATATYPES.LAYER_DIMENSION,
+        constraints: createDimensionConstraints(layer, constrainByLayer),
+        layer: {
+            name: layer?.name
+        },
+        dimension
+    };
+}
+
+function createDimensionLeafNode(layer, dimension) {
+    const icon = dimension === 'time' ? 'time' : 'arrow-up';
+    return {
+        type: 'element',
+        id: `params.${dimension}`,
+        title: dimension === 'time' ? 'Time' : 'Elevation',
+        icon,
+        nodePathMode: 'dot',
+        interactionMetadata: {
+            targets: [createDimensionTargetMetadata(layer, dimension, { constrainByLayer: true })]
+        }
+    };
+}
+
+function createMapTimeLeafNode(layer) {
+    return {
+        type: 'element',
+        id: 'time',
+        title: 'Time',
+        icon: 'time',
+        nodePathMode: 'dot',
+        interactionMetadata: {
+            targets: [createDimensionTargetMetadata(layer, 'time', { constrainByLayer: false })]
+        }
     };
 }
 
+function createLayerDimensionNodes(layer, { timelineEnabled = false } = {}) {
+    const dimensionNodes = [];
+    if (!timelineEnabled && hasTimeDimension(layer)) {
+        dimensionNodes.push(createDimensionLeafNode(layer, 'time'));
+    }
+    if (hasElevationDimension(layer)) {
+        dimensionNodes.push(createDimensionLeafNode(layer, 'elevation'));
+    }
+    return dimensionNodes;
+}
+
+function createLayerDimensionCollection(layerNode, dimensionNodes) {
+    return dimensionNodes.length > 0 ? {
+        type: 'collection',
+        title: layerNode.title,
+        icon: '1-layer',
+        id: layerNode.id,
+        preserveWhenSingleChild: true,
+        children: dimensionNodes
+    } : null;
+}
+
+/**
+ * Generates collection nodes for each map config, where each collection contains layer nodes.
+ * Each map config contains a layers array property.
+ * @param {object[]} maps array of map configs, each containing a layers array property
+ * @returns {object} a collection tree node named "maps" containing all map collection nodes
+ */
 export function generateLayerMetadataTree(layer) {
     const baseNode = createBaseElementNode(layer, '1-layer');
     return {
@@ -225,38 +338,84 @@ export function generateLayerMetadataTree(layer) {
         }
     };
 }
+
+function createLayerTreeNode(layer, { timelineEnabled = false } = {}) {
+    const layerNode = generateLayerMetadataTree(layer);
+    const dimensionNodes = createLayerDimensionNodes(layer, { timelineEnabled });
+    const dimensionCollection = createLayerDimensionCollection(layerNode, dimensionNodes);
+    return [layerNode, dimensionCollection].filter(Boolean);
+}
+
+function createLayerNodesForLayers(layers = [], options = {}) {
+    return layers
+        .filter(isInteractionSupported)
+        .flatMap(layer => createLayerTreeNode(layer, options));
+}
+
+function createMapTimeNode(layers = [], { timelineEnabled = false } = {}) {
+    const supportedLayers = layers.filter(isInteractionSupported);
+
+    if (timelineEnabled) {
+        const timeLayer = supportedLayers.find(hasTimeDimension);
+        if (timeLayer) {
+            return createMapTimeLeafNode(timeLayer);
+        }
+    }
+
+    return null;
+}
+
 /**
- * Returns true if the layer supports interactions
- * @param {object} layer the layer
- * @returns {boolean}
+ * Determines if an item is directly pluggable or configured to force plug.
+ * @param {object} node the node object with interactionMetadata from interactionTree
+ * @param {object} target the target object with expectedDataType and constraint
+ * @param {object} configuration the configuration object (default: {})
+ * @returns {object} object with directlyPluggable and configuredToForcePlug boolean flags
  */
-export function isInteractionSupported(layer) {
-    return ['wms', 'wfs'].includes(layer?.type) && layer.group !== "background";
+export function getItemPluggableStatus(node, target, configuration = {}) {
+    const interactionMetadata = node?.interactionMetadata;
+    if (!interactionMetadata) {
+        return {
+            directlyPluggable: false,
+            configuredToForcePlug: false
+        };
+    }
+
+    // Check if directly pluggable: constraints match
+    const directlyPluggable = (interactionMetadata?.targets || []).find(t => {
+        return t.expectedDataType === target.expectedDataType &&
+            JSON.stringify(t.constraints) === JSON.stringify(target?.constraints);
+    }) !== undefined;
+
+    // Check if configured to force plug
+    const configuredToForcePlug = configuration?.forcePlug === true;
+
+    return {
+        directlyPluggable,
+        configuredToForcePlug
+    };
 }
 
+
 /**
  * Returns the layers metadata tree array.
+ * Each supported layer expands into a layer element node and, when needed,
+ * a sibling dimension collection node.
  * @param {object[]} layers array of layers
  * @returns {object[]}
  */
 export function generateLayersMetadataTree(layers) {
-    return layers.filter(isInteractionSupported).map(generateLayerMetadataTree);
+    return createLayerNodesForLayers(layers);
 }
 
-/**
- * Generates collection nodes for each map config, where each collection contains layer nodes.
- * Each map config contains a layers array property.
- * @param {object[]} maps array of map configs, each containing a layers array property
- * @returns {object} a collection tree node named "maps" containing all map collection nodes
- */
-export function generateMapWidgetLayersTree(maps) {
+export function generateMapWidgetLayersTree(maps, options = {}) {
     if (!maps || !Array.isArray(maps)) {
         return createBaseCollectionNode("Maps", [], "1-map", "maps");
     }
     const mapCollectionNodes = maps
         .filter(map => map?.layers && Array.isArray(map.layers))
         .map(map => {
-            const layerNodes = generateLayersMetadataTree(map.layers);
+            const layerNodes = createLayerNodesForLayers(map.layers, options);
             const layersCollection = createBaseCollectionNode(
                 "Layers",
                 layerNodes,
@@ -396,8 +555,8 @@ export function generateCounterWidgetTreeNode(widget) {
  * @param {object} widget the map widget object
  * @returns {object} the map widget metadata tree node
  */
-export function generateMapWidgetTreeNode(widget) {
-    const mapsCollection = generateMapWidgetLayersTree(widget.maps);
+export function generateMapWidgetTreeNode(widget, options = {}) {
+    const mapsCollection = generateMapWidgetLayersTree(widget.maps, options);
     const baseNode = createBaseElementNode(widget, '1-map');
     return {
         ...baseNode,
@@ -442,7 +601,7 @@ export function generateDynamicFilterWidgetTreeNode(widget) {
  * @param {object} widget the widget object
  * @returns {object} the widget metadata tree node
  */
-export function generateWidgetTreeNode(widget) {
+export function generateWidgetTreeNode(widget, options = {}) {
     switch (widget?.widgetType) {
     case "chart":
         return generateChartWidgetTreeNode(widget);
@@ -451,7 +610,7 @@ export function generateWidgetTreeNode(widget) {
     case "counter":
         return generateCounterWidgetTreeNode(widget);
     case "map":
-        return generateMapWidgetTreeNode(widget);
+        return generateMapWidgetTreeNode(widget, options);
     case "filter":
         return generateDynamicFilterWidgetTreeNode(widget);
     default:
@@ -483,6 +642,9 @@ export function addNodePathToTree(node, currentPath = "") {
     } else if (node.staticallyNamedCollection && node.id) {
         // Statically named collection (widgets, traces, layers, etc.): use dot notation
         nodePath = currentPath === "" ? node.id : `${currentPath}.${node.id}`;
+    } else if (node.nodePathMode === 'dot' && node.id) {
+        // Explicit dot-path nodes (e.g. dimension nodes under a layer)
+        nodePath = currentPath === "" ? node.id : `${currentPath}.${node.id}`;
     } else if (node.id) {
         // Element (widget, chart, trace, etc.): use brackets with id
         nodePath = `${currentPath}[${node.id}]`;
@@ -509,20 +671,21 @@ export function addNodePathToTree(node, currentPath = "") {
  * @param {array} widgets array of widget objects
  * @returns {object} the root tree node with widgets collection as child TODO: CONSIDER FOR MAP also
  */
-export function generateRootTree(widgets, mapLayers) {
+export function generateRootTree(widgets, mapLayers, options = {}) {
     const widgetsArray = widgets || [];
     const widgetNodes = widgetsArray
         .filter(widget => widget !== null && widget !== undefined)
-        .map(widget => generateWidgetTreeNode(widget));
+        .map(widget => generateWidgetTreeNode(widget, options));
 
     const mapLayersNodes = mapLayers?.length > 0 ? [
-        createBaseCollectionNode("Layers", generateLayersMetadataTree(mapLayers), "1-layer", "layers")
+        createBaseCollectionNode("Layers", createLayerNodesForLayers(mapLayers, options), "1-layer", "layers")
     ] : [];
+    const mapTimeNode = createMapTimeNode(mapLayers || [], options);
 
     const widgetsCollection = createBaseCollectionNode("Widgets", widgetNodes, "widgets", "widgets");
     const collections = [widgetsCollection];
     if (mapLayersNodes.length > 0) {
-        const mapsCollection = createBaseCollectionNode("Map", mapLayersNodes, "1-map", "map");
+        const mapsCollection = createBaseCollectionNode("Map", [mapTimeNode, ...mapLayersNodes].filter(Boolean), "1-map", "map");
         collections.push(mapsCollection);
     }
 
@@ -563,6 +726,8 @@ export function detachSingleChildCollections(tree, excludeChecksOn = []) {
         if (node.type === 'collection' &&
             processedChildren.length === 1 &&
             processedChildren[0]?.type === 'collection' &&
+            !node.preserveWhenSingleChild &&
+            !processedChildren[0]?.preserveWhenSingleChild &&
             shouldDetach(processedChildren[0].id)) {
             // Move the child collection's children to this node
             const singleChild = processedChildren[0];
@@ -642,12 +807,21 @@ export function getPossibleTargetsEditingWidget(widgetType, layerInvolved) {
             constraints: layerInvolved ? {
                 layer: createLayerConstraint(layerInvolved.name)
             } : {}
+        },
+        {
+            title: TARGET_TYPE_LABELS[TARGET_TYPES.APPLY_DIMENSION],
+            targetType: TARGET_TYPES.APPLY_DIMENSION,
+            glyph: TARGET_TYPE_GLYPHS[TARGET_TYPES.APPLY_DIMENSION],
+            expectedDataType: TARGET_EVENT_DATA_TYPES[TARGET_TYPES.APPLY_DIMENSION],
+            constraints: createDimensionConstraints(layerInvolved, false)
         }
         ];
     }
     return [];
 }
 
+export const FILTER_WIDGET_OPTIONAL_TARGET_TYPES = [TARGET_TYPES.APPLY_DIMENSION];
+
 /**
  * Finds a node by its id in the tree and returns the node object.
  * @param {object} tree root metadata tree
@@ -710,6 +884,24 @@ export function isAnyLayerPath(nodePath) {
     return /^map\.layers/.test(nodePath) || /\.maps\[[^\]]+\]\.layers\[[^\]]+\]/.test(nodePath);
 }
 
+/**
+ * Returns true when the interaction target points to the global map time field.
+ * @param {string} nodePath the node path to check
+ * @returns {boolean}
+ */
+export function isMapTimeTarget(nodePath) {
+    return !!nodePath && /(?:^|\.)map\.time$/.test(nodePath);
+}
+
+/**
+ * Returns true when the interaction target points to a layer time or elevation dimension.
+ * @param {string} nodePath the node path to check
+ * @returns {boolean}
+ */
+export function isLayerDimensionTarget(nodePath) {
+    return isAnyLayerPath(nodePath) && /(?:^|\.)params\.(?:time|elevation)$/.test(nodePath);
+}
+
 /**
  * Extracts a trace object from a widget object using a node path.
  * Loops through all charts and traces to find the matching trace by ID.
diff --git a/web/client/utils/__tests__/InteractionUtils-test.js b/web/client/utils/__tests__/InteractionUtils-test.js
index a387c3e579c..fe57e8779e0 100644
--- a/web/client/utils/__tests__/InteractionUtils-test.js
+++ b/web/client/utils/__tests__/InteractionUtils-test.js
@@ -7,8 +7,13 @@ import {
     generateCounterWidgetTreeNode,
     generateMapWidgetTreeNode,
     generateDynamicFilterWidgetTreeNode,
+    generateLayersMetadataTree,
     detachSingleChildCollections,
-    addNodePathToTree
+    addNodePathToTree,
+    filterDimensionTreeByValueAttributeType,
+    hasAllowedDimensionTarget,
+    isMapTimeTarget,
+    isLayerDimensionTarget
 } from '../InteractionUtils';
 
 // Shared test data for all widget tests
@@ -124,6 +129,34 @@ describe('InteractionUtils', () => {
         });
     });
 
+    describe('isMapTimeTarget', () => {
+        it('returns true for a map.time target node path', () => {
+            expect(isMapTimeTarget('map.time')).toBe(true);
+        });
+
+        it('returns false for non-map-time targets', () => {
+            expect(isMapTimeTarget('map.layers[layer-1]')).toBe(false);
+            expect(isMapTimeTarget('widgets[foo].maps[bar].time')).toBe(false);
+        });
+    });
+
+    describe('isLayerDimensionTarget', () => {
+        it('returns true for layer time and elevation target node paths', () => {
+            expect(isLayerDimensionTarget('map.layers[layer-1].params.time')).toBe(true);
+            expect(isLayerDimensionTarget('map.layers[layer-1].params.elevation')).toBe(true);
+            expect(isLayerDimensionTarget('widgets[map-widget].maps[map-1].layers[layer-1].params.time')).toBe(true);
+            expect(isLayerDimensionTarget('widgets[map-widget].maps[map-1].layers[layer-1].params.elevation')).toBe(true);
+        });
+
+        it('returns false for non-layer-dimension targets', () => {
+            expect(isLayerDimensionTarget('map.time')).toBe(false);
+            expect(isLayerDimensionTarget('widgets[foo].maps[bar].time')).toBe(false);
+            expect(isLayerDimensionTarget('widgets[foo].params.time')).toBe(false);
+            expect(isLayerDimensionTarget('map.layers[layer-1]')).toBe(false);
+            expect(isLayerDimensionTarget('map.layers[layer-1].params.style')).toBe(false);
+        });
+    });
+
     describe('generateTableWidgetTreeNode', () => {
         it('generates table widget tree node with layer and interaction metadata', () => {
             const tree = generateTableWidgetTreeNode(testWidgets.tableWidget);
@@ -157,6 +190,152 @@ describe('InteractionUtils', () => {
             expect(tree.children.length).toBe(1);
             expect(tree.children[0].id).toBe('maps');
         });
+
+
+        it('generates layer element and dimension collection for each supported layer', () => {
+            const layers = [{
+                name: 'layer-1',
+                id: 'layer-1',
+                type: 'wms',
+                group: 'overlay',
+                dimensions: [{
+                    name: 'time'
+                }]
+            }];
+
+            const tree = generateLayersMetadataTree(layers);
+
+            expect(tree.length).toBe(2);
+            expect(tree[0].type).toBe('element');
+            expect(tree[0].id).toBe('layer-1');
+            expect(tree[1].type).toBe('collection');
+            expect(tree[1].id).toBe('layer-1');
+            expect(tree[1].children.length).toBe(1);
+            expect(tree[1].children[0].type).toBe('element');
+            expect(tree[1].children[0].id).toBe('params.time');
+            expect(tree[1].children[0].title).toBe('Time');
+            expect(tree[1].children[0].interactionMetadata.targets[0].constraints.layer.name).toBe('layer-1');
+        });
+
+
+        it('filters dimension nodes by value attribute type', () => {
+            const tree = {
+                type: 'collection',
+                id: 'root',
+                children: [
+                    {
+                        type: 'element',
+                        id: 'foo',
+                        title: 'Foo'
+                    },
+                    {
+                        type: 'collection',
+                        id: 'layer-1',
+                        children: [
+                            {
+                                type: 'element',
+                                id: 'params.time',
+                                title: 'Time'
+                            },
+                            {
+                                type: 'element',
+                                id: 'params.elevation',
+                                title: 'Elevation'
+                            }
+                        ]
+                    }
+                ]
+            };
+
+            const dateTree = filterDimensionTreeByValueAttributeType(tree, 'date');
+            expect(dateTree.children[1].children.length).toBe(1);
+            expect(dateTree.children[1].children[0].id).toBe('params.time');
+
+            const numberTree = filterDimensionTreeByValueAttributeType(tree, 'number');
+            expect(numberTree.children[1].children.length).toBe(1);
+            expect(numberTree.children[1].children[0].id).toBe('params.elevation');
+
+            expect(filterDimensionTreeByValueAttributeType(tree, 'string')).toBe(null);
+        });
+
+        it('detects whether a layer has an allowed dimension target for a value attribute type', () => {
+            const layer = {
+                name: 'layer-1',
+                dimensions: [
+                    { name: 'time' },
+                    { name: 'elevation' }
+                ]
+            };
+
+            expect(hasAllowedDimensionTarget(layer, 'date')).toBe(true);
+            expect(hasAllowedDimensionTarget(layer, 'number')).toBe(true);
+            expect(hasAllowedDimensionTarget(layer, 'string')).toBe(false);
+        });
+
+        it('uses dot nodePath mode for dimension nodes under a layer', () => {
+            const rootNode = {
+                id: 'root',
+                type: 'collection',
+                staticallyNamedCollection: true,
+                children: [
+                    {
+                        id: 'widgets',
+                        type: 'collection',
+                        staticallyNamedCollection: true,
+                        children: [
+                            {
+                                id: 'map-widget-1',
+                                type: 'collection',
+                                children: [
+                                    {
+                                        id: 'maps',
+                                        type: 'collection',
+                                        staticallyNamedCollection: true,
+                                        children: [
+                                            {
+                                                id: 'map-1',
+                                                type: 'collection',
+                                                children: [
+                                                    {
+                                                        id: 'layers',
+                                                        type: 'collection',
+                                                        staticallyNamedCollection: true,
+                                                        children: [
+                                                            {
+                                                                id: 'layer-1',
+                                                                type: 'element',
+                                                                children: [
+                                                                    {
+                                                                        id: 'params.time',
+                                                                        type: 'element',
+                                                                        nodePathMode: 'dot'
+                                                                    }
+                                                                ]
+                                                            }
+                                                        ]
+                                                    }
+                                                ]
+                                            }
+                                        ]
+                                    }
+                                ]
+                            }
+                        ]
+                    }
+                ]
+            };
+
+            const result = addNodePathToTree(rootNode);
+            const widgetsCollection = result.children[0];
+            const mapWidget = widgetsCollection.children[0];
+            const mapsCollection = mapWidget.children[0];
+            const mapCollection = mapsCollection.children[0];
+            const layersCollection = mapCollection.children[0];
+            const layerNode = layersCollection.children[0];
+            const timeNode = layerNode.children[0];
+
+            expect(timeNode.nodePath).toBe('widgets[map-widget-1].maps[map-1].layers[layer-1].params.time');
+        });
     });
 
     describe('generateDynamicFilterWidgetTreeNode', () => {
@@ -224,6 +403,26 @@ describe('InteractionUtils', () => {
             expect(counterWidget.id).toBe('counter-widget-1');
             expect(counterWidget.type).toBe('element');
         });
+
+        it('places map time at the root map level when timeline is enabled', () => {
+            const rootTree = generateRootTree([], [{
+                name: 'layer-1',
+                id: 'layer-1',
+                type: 'wms',
+                group: 'overlay',
+                dimensions: [{
+                    name: 'time'
+                }]
+            }], {
+                timelineEnabled: true
+            });
+
+            const mapCollection = rootTree.children[1];
+
+            expect(mapCollection.id).toBe('map');
+            expect(mapCollection.children[0].id).toBe('time');
+            expect(mapCollection.children[1].id).toBe('layers');
+        });
     });
 
     describe('filterTreeWithTarget', () => {
@@ -345,6 +544,30 @@ describe('InteractionUtils', () => {
             expect(tracesCollection?.id).toBe('traces');
             expect(tracesCollection.nodePath).toBe('trace-collection-node-path');
         });
+
+        it('should preserve flagged layer dimension collections when they are the only child', () => {
+            const tree = {
+                type: 'collection',
+                id: 'root',
+                children: [{
+                    type: 'collection',
+                    id: 'layers',
+                    children: [{
+                        type: 'collection',
+                        id: 'layer-1',
+                        preserveWhenSingleChild: true,
+                        children: [{
+                            type: 'element',
+                            id: 'elevation'
+                        }]
+                    }]
+                }]
+            };
+
+            const result = detachSingleChildCollections(tree);
+            expect(result.children[0].id).toBe('layer-1');
+            expect(result.children[0].children[0].id).toBe('elevation');
+        });
     });
 
     describe('addNodePathToTree', () => {