diff --git a/packages/x-date-pickers-pro/src/DateRangeCalendar/DateRangeCalendar.tsx b/packages/x-date-pickers-pro/src/DateRangeCalendar/DateRangeCalendar.tsx
index 6c6379c2b433d..32a6810da1c36 100644
--- a/packages/x-date-pickers-pro/src/DateRangeCalendar/DateRangeCalendar.tsx
+++ b/packages/x-date-pickers-pro/src/DateRangeCalendar/DateRangeCalendar.tsx
@@ -221,6 +221,7 @@ const DateRangeCalendar = React.forwardRef(function DateRangeCalendar(
     name: 'DateRangeCalendar',
     timezone: timezoneProp,
     value: valueProp,
+    referenceDate,
     defaultValue,
     onChange,
     valueManager: rangeValueManager,
diff --git a/packages/x-date-pickers-pro/src/internals/hooks/useMultiInputRangeField/useMultiInputDateRangeField.ts b/packages/x-date-pickers-pro/src/internals/hooks/useMultiInputRangeField/useMultiInputDateRangeField.ts
index 5aecc79b1600c..651ebdbd216c0 100644
--- a/packages/x-date-pickers-pro/src/internals/hooks/useMultiInputRangeField/useMultiInputDateRangeField.ts
+++ b/packages/x-date-pickers-pro/src/internals/hooks/useMultiInputRangeField/useMultiInputDateRangeField.ts
@@ -42,6 +42,7 @@ export const useMultiInputDateRangeField = <
   const {
     value: valueProp,
     defaultValue,
+    referenceDate,
     format,
     formatDensity,
     shouldRespectLeadingZeros,
@@ -60,6 +61,7 @@ export const useMultiInputDateRangeField = <
     timezone: timezoneProp,
     value: valueProp,
     defaultValue,
+    referenceDate,
     onChange,
     valueManager: rangeValueManager,
   });
diff --git a/packages/x-date-pickers-pro/src/internals/hooks/useMultiInputRangeField/useMultiInputDateTimeRangeField.ts b/packages/x-date-pickers-pro/src/internals/hooks/useMultiInputRangeField/useMultiInputDateTimeRangeField.ts
index 6fee46fcc61af..021ef4f196b11 100644
--- a/packages/x-date-pickers-pro/src/internals/hooks/useMultiInputRangeField/useMultiInputDateTimeRangeField.ts
+++ b/packages/x-date-pickers-pro/src/internals/hooks/useMultiInputRangeField/useMultiInputDateTimeRangeField.ts
@@ -42,6 +42,7 @@ export const useMultiInputDateTimeRangeField = <
   const {
     value: valueProp,
     defaultValue,
+    referenceDate,
     format,
     formatDensity,
     shouldRespectLeadingZeros,
@@ -60,6 +61,7 @@ export const useMultiInputDateTimeRangeField = <
     timezone: timezoneProp,
     value: valueProp,
     defaultValue,
+    referenceDate,
     onChange,
     valueManager: rangeValueManager,
   });
diff --git a/packages/x-date-pickers-pro/src/internals/hooks/useMultiInputRangeField/useMultiInputTimeRangeField.ts b/packages/x-date-pickers-pro/src/internals/hooks/useMultiInputRangeField/useMultiInputTimeRangeField.ts
index 6fbf229d94f66..6b9d4c42313f0 100644
--- a/packages/x-date-pickers-pro/src/internals/hooks/useMultiInputRangeField/useMultiInputTimeRangeField.ts
+++ b/packages/x-date-pickers-pro/src/internals/hooks/useMultiInputRangeField/useMultiInputTimeRangeField.ts
@@ -42,6 +42,7 @@ export const useMultiInputTimeRangeField = <
   const {
     value: valueProp,
     defaultValue,
+    referenceDate,
     format,
     formatDensity,
     shouldRespectLeadingZeros,
@@ -62,6 +63,7 @@ export const useMultiInputTimeRangeField = <
     defaultValue,
     onChange,
     valueManager: rangeValueManager,
+    referenceDate,
   });
 
   const { validationError, getValidationErrorForNewValue } = useValidation({
diff --git a/packages/x-date-pickers/src/DateCalendar/DateCalendar.tsx b/packages/x-date-pickers/src/DateCalendar/DateCalendar.tsx
index f1c2c33ee4390..8e6d3f8882226 100644
--- a/packages/x-date-pickers/src/DateCalendar/DateCalendar.tsx
+++ b/packages/x-date-pickers/src/DateCalendar/DateCalendar.tsx
@@ -156,6 +156,7 @@ export const DateCalendar = React.forwardRef(function DateCalendar(
     timezone: timezoneProp,
     value: valueProp,
     defaultValue,
+    referenceDate: referenceDateProp,
     onChange,
     valueManager: singleItemValueManager,
   });
diff --git a/packages/x-date-pickers/src/DigitalClock/DigitalClock.tsx b/packages/x-date-pickers/src/DigitalClock/DigitalClock.tsx
index 028ff68457e93..ed52313e052d6 100644
--- a/packages/x-date-pickers/src/DigitalClock/DigitalClock.tsx
+++ b/packages/x-date-pickers/src/DigitalClock/DigitalClock.tsx
@@ -163,6 +163,7 @@ export const DigitalClock = React.forwardRef(function DigitalClock(
     timezone: timezoneProp,
     value: valueProp,
     defaultValue,
+    referenceDate: referenceDateProp,
     onChange,
     valueManager: singleItemValueManager,
   });
diff --git a/packages/x-date-pickers/src/MonthCalendar/MonthCalendar.tsx b/packages/x-date-pickers/src/MonthCalendar/MonthCalendar.tsx
index 1e7b9bf6038a4..0667892ee47c3 100644
--- a/packages/x-date-pickers/src/MonthCalendar/MonthCalendar.tsx
+++ b/packages/x-date-pickers/src/MonthCalendar/MonthCalendar.tsx
@@ -114,6 +114,7 @@ export const MonthCalendar = React.forwardRef(function MonthCalendar(
     timezone: timezoneProp,
     value: valueProp,
     defaultValue,
+    referenceDate: referenceDateProp,
     onChange,
     valueManager: singleItemValueManager,
   });
diff --git a/packages/x-date-pickers/src/MultiSectionDigitalClock/MultiSectionDigitalClock.tsx b/packages/x-date-pickers/src/MultiSectionDigitalClock/MultiSectionDigitalClock.tsx
index 05c7b74fb5689..0ecf6f91c1aa1 100644
--- a/packages/x-date-pickers/src/MultiSectionDigitalClock/MultiSectionDigitalClock.tsx
+++ b/packages/x-date-pickers/src/MultiSectionDigitalClock/MultiSectionDigitalClock.tsx
@@ -113,6 +113,7 @@ export const MultiSectionDigitalClock = React.forwardRef(function MultiSectionDi
     timezone: timezoneProp,
     value: valueProp,
     defaultValue,
+    referenceDate: referenceDateProp,
     onChange,
     valueManager: singleItemValueManager,
   });
diff --git a/packages/x-date-pickers/src/TimeClock/TimeClock.tsx b/packages/x-date-pickers/src/TimeClock/TimeClock.tsx
index dd5c2a046c583..71207b92481bc 100644
--- a/packages/x-date-pickers/src/TimeClock/TimeClock.tsx
+++ b/packages/x-date-pickers/src/TimeClock/TimeClock.tsx
@@ -114,6 +114,7 @@ export const TimeClock = React.forwardRef(function TimeClock(
     timezone: timezoneProp,
     value: valueProp,
     defaultValue,
+    referenceDate: referenceDateProp,
     onChange,
     valueManager: singleItemValueManager,
   });
diff --git a/packages/x-date-pickers/src/YearCalendar/YearCalendar.tsx b/packages/x-date-pickers/src/YearCalendar/YearCalendar.tsx
index 39a4a8c9a1779..423c78caf2df1 100644
--- a/packages/x-date-pickers/src/YearCalendar/YearCalendar.tsx
+++ b/packages/x-date-pickers/src/YearCalendar/YearCalendar.tsx
@@ -124,6 +124,7 @@ export const YearCalendar = React.forwardRef(function YearCalendar(
     timezone: timezoneProp,
     value: valueProp,
     defaultValue,
+    referenceDate: referenceDateProp,
     onChange,
     valueManager: singleItemValueManager,
   });
diff --git a/packages/x-date-pickers/src/internals/hooks/useField/useFieldState.ts b/packages/x-date-pickers/src/internals/hooks/useField/useFieldState.ts
index 6dc432fc0d124..d89b552637ef8 100644
--- a/packages/x-date-pickers/src/internals/hooks/useField/useFieldState.ts
+++ b/packages/x-date-pickers/src/internals/hooks/useField/useFieldState.ts
@@ -114,6 +114,7 @@ export const useFieldState = <
     timezone: timezoneProp,
     value: valueProp,
     defaultValue,
+    referenceDate: referenceDateProp,
     onChange,
     valueManager,
   });
diff --git a/packages/x-date-pickers/src/internals/hooks/usePicker/usePickerValue.ts b/packages/x-date-pickers/src/internals/hooks/usePicker/usePickerValue.ts
index 0f123bc6e9a62..9814fcf8cf748 100644
--- a/packages/x-date-pickers/src/internals/hooks/usePicker/usePickerValue.ts
+++ b/packages/x-date-pickers/src/internals/hooks/usePicker/usePickerValue.ts
@@ -168,6 +168,7 @@ export const usePickerValue = <
     defaultValue: inDefaultValue,
     closeOnSelect = variant === 'desktop',
     timezone: timezoneProp,
+    referenceDate,
   } = props;
 
   const { current: defaultValue } = React.useRef(inDefaultValue);
@@ -218,6 +219,7 @@ export const usePickerValue = <
     timezone: timezoneProp,
     value: inValueWithoutRenderTimezone,
     defaultValue,
+    referenceDate,
     onChange,
     valueManager,
   });
diff --git a/packages/x-date-pickers/src/internals/hooks/usePicker/usePickerValue.types.ts b/packages/x-date-pickers/src/internals/hooks/usePicker/usePickerValue.types.ts
index 8741bd6838eef..decce9645687d 100644
--- a/packages/x-date-pickers/src/internals/hooks/usePicker/usePickerValue.types.ts
+++ b/packages/x-date-pickers/src/internals/hooks/usePicker/usePickerValue.types.ts
@@ -257,7 +257,10 @@ export interface UsePickerValueNonStaticProps {
 export interface UsePickerValueProps<TValue, TError>
   extends UsePickerValueBaseProps<TValue, TError>,
     UsePickerValueNonStaticProps,
-    TimezoneProps {}
+    TimezoneProps {
+  // We don't add JSDoc here because we want the `referenceDate` JSDoc to be the one from the view which has more context.
+  referenceDate?: PickerValidDate;
+}
 
 export interface UsePickerValueParams<
   TValue,
diff --git a/packages/x-date-pickers/src/internals/hooks/useValueWithTimezone.test.tsx b/packages/x-date-pickers/src/internals/hooks/useValueWithTimezone.test.tsx
new file mode 100644
index 0000000000000..b74ec03b2deea
--- /dev/null
+++ b/packages/x-date-pickers/src/internals/hooks/useValueWithTimezone.test.tsx
@@ -0,0 +1,108 @@
+import * as React from 'react';
+import { expect } from 'chai';
+import { screen } from '@mui/internal-test-utils';
+import { PickersTimezone, PickerValidDate } from '@mui/x-date-pickers/models';
+import { createPickerRenderer } from 'test/utils/pickers';
+import { useValueWithTimezone } from './useValueWithTimezone';
+import { singleItemValueManager } from '../utils/valueManagers';
+
+describe('useValueWithTimezone', () => {
+  const { render, adapter } = createPickerRenderer({
+    clock: 'fake',
+    adapterName: 'luxon',
+  });
+
+  function runTest(params: {
+    timezone: PickersTimezone | undefined;
+    value: PickerValidDate | null | undefined;
+    defaultValue: PickerValidDate | null | undefined;
+    referenceDate: PickerValidDate | undefined;
+    expectedTimezone: PickersTimezone;
+  }) {
+    const { expectedTimezone, ...other } = params;
+
+    function TestComponent(props: typeof other) {
+      const { timezone } = useValueWithTimezone({
+        ...props,
+        valueManager: singleItemValueManager,
+        onChange: () => {},
+      });
+
+      return <div data-testid="result">{timezone}</div>;
+    }
+
+    render(<TestComponent {...other} />);
+
+    expect(screen.getByTestId('result').textContent).to.equal(expectedTimezone);
+  }
+
+  it('should use the timezone parameter when provided', () => {
+    runTest({
+      timezone: 'America/New_York',
+      value: undefined,
+      defaultValue: undefined,
+      referenceDate: undefined,
+      expectedTimezone: 'America/New_York',
+    });
+  });
+
+  it('should use the timezone parameter over the value parameter when both are provided', () => {
+    runTest({
+      timezone: 'America/New_York',
+      value: adapter.date(undefined, 'Europe/Paris'),
+      defaultValue: undefined,
+      referenceDate: undefined,
+      expectedTimezone: 'America/New_York',
+    });
+  });
+
+  it('should use the value parameter when provided', () => {
+    runTest({
+      timezone: undefined,
+      value: adapter.date(undefined, 'America/New_York'),
+      defaultValue: undefined,
+      referenceDate: undefined,
+      expectedTimezone: 'America/New_York',
+    });
+  });
+
+  it('should use the value parameter over the defaultValue parameter when both are provided', () => {
+    runTest({
+      timezone: undefined,
+      value: adapter.date(undefined, 'America/New_York'),
+      defaultValue: adapter.date(undefined, 'Europe/Paris'),
+      referenceDate: undefined,
+      expectedTimezone: 'America/New_York',
+    });
+  });
+
+  it('should use the defaultValue parameter when provided', () => {
+    runTest({
+      timezone: undefined,
+      value: undefined,
+      defaultValue: adapter.date(undefined, 'America/New_York'),
+      referenceDate: undefined,
+      expectedTimezone: 'America/New_York',
+    });
+  });
+
+  it('should use the referenceDate parameter when provided', () => {
+    runTest({
+      timezone: undefined,
+      value: undefined,
+      defaultValue: undefined,
+      referenceDate: adapter.date(undefined, 'America/New_York'),
+      expectedTimezone: 'America/New_York',
+    });
+  });
+
+  it('should use the "default" timezone is there is no way to deduce the user timezone', () => {
+    runTest({
+      timezone: undefined,
+      value: undefined,
+      defaultValue: undefined,
+      referenceDate: undefined,
+      expectedTimezone: 'default',
+    });
+  });
+});
diff --git a/packages/x-date-pickers/src/internals/hooks/useValueWithTimezone.ts b/packages/x-date-pickers/src/internals/hooks/useValueWithTimezone.ts
index f16b6f51410dc..852ad3dc5c8d2 100644
--- a/packages/x-date-pickers/src/internals/hooks/useValueWithTimezone.ts
+++ b/packages/x-date-pickers/src/internals/hooks/useValueWithTimezone.ts
@@ -3,7 +3,7 @@ import useEventCallback from '@mui/utils/useEventCallback';
 import useControlled from '@mui/utils/useControlled';
 import { useUtils } from './useUtils';
 import type { PickerValueManager } from './usePicker';
-import { PickersTimezone } from '../../models';
+import { PickersTimezone, PickerValidDate } from '../../models';
 
 /**
  * Hooks making sure that:
@@ -14,15 +14,10 @@ export const useValueWithTimezone = <TValue, TChange extends (...params: any[])
   timezone: timezoneProp,
   value: valueProp,
   defaultValue,
+  referenceDate,
   onChange,
   valueManager,
-}: {
-  timezone: PickersTimezone | undefined;
-  value: TValue | undefined;
-  defaultValue: TValue | undefined;
-  onChange: TChange | undefined;
-  valueManager: PickerValueManager<TValue, any>;
-}) => {
+}: UseValueWithTimezoneParameters<TValue, TChange>) => {
   const utils = useUtils();
 
   const firstDefaultValue = React.useRef(defaultValue);
@@ -41,7 +36,16 @@ export const useValueWithTimezone = <TValue, TChange extends (...params: any[])
     return valueManager.setTimezone(utils, inputTimezone, newValue);
   });
 
-  const timezoneToRender = timezoneProp ?? inputTimezone ?? 'default';
+  let timezoneToRender: PickersTimezone;
+  if (timezoneProp) {
+    timezoneToRender = timezoneProp;
+  } else if (inputTimezone) {
+    timezoneToRender = inputTimezone;
+  } else if (referenceDate) {
+    timezoneToRender = utils.getTimezone(referenceDate);
+  } else {
+    timezoneToRender = 'default';
+  }
 
   const valueWithTimezoneToRender = React.useMemo(
     () => valueManager.setTimezone(utils, timezoneToRender, inputValue),
@@ -64,16 +68,10 @@ export const useControlledValueWithTimezone = <TValue, TChange extends (...param
   timezone: timezoneProp,
   value: valueProp,
   defaultValue,
+  referenceDate,
   onChange: onChangeProp,
   valueManager,
-}: {
-  name: string;
-  timezone: PickersTimezone | undefined;
-  value: TValue | undefined;
-  defaultValue: TValue | undefined;
-  onChange: TChange | undefined;
-  valueManager: PickerValueManager<TValue, any>;
-}) => {
+}: UseControlledValueWithTimezoneParameters<TValue, TChange>) => {
   const [valueWithInputTimezone, setValue] = useControlled({
     name,
     state: 'value',
@@ -90,7 +88,29 @@ export const useControlledValueWithTimezone = <TValue, TChange extends (...param
     timezone: timezoneProp,
     value: valueWithInputTimezone,
     defaultValue: undefined,
+    referenceDate,
     onChange,
     valueManager,
   });
 };
+
+interface UseValueWithTimezoneParameters<TValue, TChange extends (...params: any[]) => void> {
+  timezone: PickersTimezone | undefined;
+  value: TValue | undefined;
+  defaultValue: TValue | undefined;
+  /**
+   * The reference date as passed to `props.referenceDate`.
+   * It does not need to have its default value.
+   * This is only used to determine the timezone to use when `props.value` and `props.defaultValue` are not defined.
+   */
+  referenceDate: PickerValidDate | undefined;
+  onChange: TChange | undefined;
+  valueManager: PickerValueManager<TValue, any>;
+}
+
+interface UseControlledValueWithTimezoneParameters<
+  TValue,
+  TChange extends (...params: any[]) => void,
+> extends UseValueWithTimezoneParameters<TValue, TChange> {
+  name: string;
+}
diff --git a/packages/x-internals/src/types/DefaultizedProps.ts b/packages/x-internals/src/types/DefaultizedProps.ts
new file mode 100644
index 0000000000000..b246a631c4483
--- /dev/null
+++ b/packages/x-internals/src/types/DefaultizedProps.ts
@@ -0,0 +1,15 @@
+/**
+ * Combines a type with required and additional properties.
+ *
+ * @template P - The original type.
+ * @template RequiredProps - The keys to make required.
+ * @template AdditionalProps - Additional properties to include.
+ */
+
+export type DefaultizedProps<
+  P extends {},
+  RequiredProps extends keyof P,
+  AdditionalProps extends {} = {},
+> = Omit<P, RequiredProps | keyof AdditionalProps> &
+  Required<Pick<P, RequiredProps>> &
+  AdditionalProps;
diff --git a/packages/x-internals/src/types/MakeOptional.ts b/packages/x-internals/src/types/MakeOptional.ts
new file mode 100644
index 0000000000000..8d00e7a99bd6f
--- /dev/null
+++ b/packages/x-internals/src/types/MakeOptional.ts
@@ -0,0 +1,7 @@
+/**
+ * Makes specified keys in a type optional.
+ *
+ * @template T - The original type.
+ * @template K - The keys to make optional.
+ */
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
diff --git a/packages/x-internals/src/types/MakeRequired.ts b/packages/x-internals/src/types/MakeRequired.ts
new file mode 100644
index 0000000000000..0cd2af7a89541
--- /dev/null
+++ b/packages/x-internals/src/types/MakeRequired.ts
@@ -0,0 +1,8 @@
+/**
+ * Makes specified keys in a type required.
+ *
+ * @template T - The original type.
+ * @template K - The keys to make required.
+ */
+
+export type MakeRequired<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
diff --git a/packages/x-internals/src/types/SlotComponentPropsFromProps.ts b/packages/x-internals/src/types/SlotComponentPropsFromProps.ts
new file mode 100644
index 0000000000000..fcffe0aa3c958
--- /dev/null
+++ b/packages/x-internals/src/types/SlotComponentPropsFromProps.ts
@@ -0,0 +1,13 @@
+/**
+ * Defines the props for a slot component, which can be either partial props with overrides or a function returning such props.
+ *
+ * @template TProps - The original props type.
+ * @template TOverrides - The overrides type.
+ * @template TOwnerState - The owner state type.
+ */
+
+export type SlotComponentPropsFromProps<
+  TProps extends {},
+  TOverrides extends {},
+  TOwnerState extends {},
+> = (Partial<TProps> & TOverrides) | ((ownerState: TOwnerState) => Partial<TProps> & TOverrides);
diff --git a/packages/x-internals/src/types/index.ts b/packages/x-internals/src/types/index.ts
index 025b7036d0971..43d0d70371584 100644
--- a/packages/x-internals/src/types/index.ts
+++ b/packages/x-internals/src/types/index.ts
@@ -1,17 +1,4 @@
-export type MakeOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
-
-export type MakeRequired<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
-
-export type DefaultizedProps<
-  P extends {},
-  RequiredProps extends keyof P,
-  AdditionalProps extends {} = {},
-> = Omit<P, RequiredProps | keyof AdditionalProps> &
-  Required<Pick<P, RequiredProps>> &
-  AdditionalProps;
-
-export type SlotComponentPropsFromProps<
-  TProps extends {},
-  TOverrides extends {},
-  TOwnerState extends {},
-> = (Partial<TProps> & TOverrides) | ((ownerState: TOwnerState) => Partial<TProps> & TOverrides);
+export * from './DefaultizedProps';
+export * from './MakeOptional';
+export * from './MakeRequired';
+export * from './SlotComponentPropsFromProps';
diff --git a/packages/x-tree-view/src/TreeItemProvider/TreeItemProvider.tsx b/packages/x-tree-view/src/TreeItemProvider/TreeItemProvider.tsx
index 6994ee378e950..30036f8078b4d 100644
--- a/packages/x-tree-view/src/TreeItemProvider/TreeItemProvider.tsx
+++ b/packages/x-tree-view/src/TreeItemProvider/TreeItemProvider.tsx
@@ -2,13 +2,16 @@ import PropTypes from 'prop-types';
 import { TreeItemProviderProps } from './TreeItemProvider.types';
 import { useTreeViewContext } from '../internals/TreeViewProvider';
 import { generateTreeItemIdAttribute } from '../internals/corePlugins/useTreeViewId/useTreeViewId.utils';
+import { useSelector } from '../internals/hooks/useSelector';
+import { selectorTreeViewId } from '../internals/corePlugins/useTreeViewId/useTreeViewId.selectors';
 
 /**
  * @ignore - internal component.
  */
 function TreeItemProvider(props: TreeItemProviderProps) {
   const { children, itemId, id } = props;
-  const { wrapItem, instance, treeId } = useTreeViewContext<[]>();
+  const { wrapItem, instance, store } = useTreeViewContext<[]>();
+  const treeId = useSelector(store, selectorTreeViewId);
   const idAttribute = generateTreeItemIdAttribute({ itemId, treeId, id });
 
   return wrapItem({ children, itemId, instance, idAttribute });
diff --git a/packages/x-tree-view/src/internals/corePlugins/useTreeViewId/useTreeViewId.ts b/packages/x-tree-view/src/internals/corePlugins/useTreeViewId/useTreeViewId.ts
index c6c0489eb5898..542f1591781e0 100644
--- a/packages/x-tree-view/src/internals/corePlugins/useTreeViewId/useTreeViewId.ts
+++ b/packages/x-tree-view/src/internals/corePlugins/useTreeViewId/useTreeViewId.ts
@@ -21,13 +21,10 @@ export const useTreeViewId: TreeViewPlugin<UseTreeViewIdSignature> = ({ params,
 
   const treeId = useSelector(store, selectorTreeViewId);
 
-  const pluginContextValue = React.useMemo(() => ({ treeId }), [treeId]);
-
   return {
     getRootProps: () => ({
       id: treeId,
     }),
-    contextValue: pluginContextValue,
   };
 };
 
diff --git a/packages/x-tree-view/src/internals/corePlugins/useTreeViewId/useTreeViewId.types.ts b/packages/x-tree-view/src/internals/corePlugins/useTreeViewId/useTreeViewId.types.ts
index 6704907447de9..d583f9ab90596 100644
--- a/packages/x-tree-view/src/internals/corePlugins/useTreeViewId/useTreeViewId.types.ts
+++ b/packages/x-tree-view/src/internals/corePlugins/useTreeViewId/useTreeViewId.types.ts
@@ -17,13 +17,8 @@ export interface UseTreeViewIdState {
   };
 }
 
-interface UseTreeViewIdContextValue {
-  treeId: string | undefined;
-}
-
 export type UseTreeViewIdSignature = TreeViewPluginSignature<{
   params: UseTreeViewIdParameters;
   defaultizedParams: UseTreeViewIdDefaultizedParameters;
   state: UseTreeViewIdState;
-  contextValue: UseTreeViewIdContextValue;
 }>;
diff --git a/packages/x-tree-view/src/internals/plugins/useTreeViewFocus/useTreeViewFocus.ts b/packages/x-tree-view/src/internals/plugins/useTreeViewFocus/useTreeViewFocus.ts
index 04eabd9802c06..7cbc8d042cd78 100644
--- a/packages/x-tree-view/src/internals/plugins/useTreeViewFocus/useTreeViewFocus.ts
+++ b/packages/x-tree-view/src/internals/plugins/useTreeViewFocus/useTreeViewFocus.ts
@@ -59,13 +59,17 @@ export const useTreeViewFocus: TreeViewPlugin<UseTreeViewFocusSignature> = ({
   }, [store, models.selectedItems.value]);
 
   const setFocusedItemId = useEventCallback((itemId: string | null) => {
-    const focusedItemId = selectorFocusedItemId(store.value);
-    if (focusedItemId !== itemId) {
-      store.update((prevState) => ({
+    store.update((prevState) => {
+      const focusedItemId = selectorFocusedItemId(prevState);
+      if (focusedItemId === itemId) {
+        return prevState;
+      }
+
+      return {
         ...prevState,
         focus: { ...prevState.focus, focusedItemId: itemId },
-      }));
-    }
+      };
+    });
   });
 
   const isItemVisible = (itemId: string) => {
diff --git a/packages/x-tree-view/src/internals/plugins/useTreeViewJSXItems/useTreeViewJSXItems.tsx b/packages/x-tree-view/src/internals/plugins/useTreeViewJSXItems/useTreeViewJSXItems.tsx
index 347080cea4749..d94f19d66fc29 100644
--- a/packages/x-tree-view/src/internals/plugins/useTreeViewJSXItems/useTreeViewJSXItems.tsx
+++ b/packages/x-tree-view/src/internals/plugins/useTreeViewJSXItems/useTreeViewJSXItems.tsx
@@ -17,6 +17,8 @@ import {
 import { TreeViewItemDepthContext } from '../../TreeViewItemDepthContext';
 import { generateTreeItemIdAttribute } from '../../corePlugins/useTreeViewId/useTreeViewId.utils';
 import { isItemExpandable } from '../../../hooks/useTreeItemUtils/useTreeItemUtils';
+import { useSelector } from '../../hooks/useSelector';
+import { selectorTreeViewId } from '../../corePlugins/useTreeViewId/useTreeViewId.selectors';
 
 export const useTreeViewJSXItems: TreeViewPlugin<UseTreeViewJSXItemsSignature> = ({
   instance,
@@ -113,7 +115,7 @@ export const useTreeViewJSXItems: TreeViewPlugin<UseTreeViewJSXItemsSignature> =
 };
 
 const useTreeViewJSXItemsItemPlugin: TreeViewItemPlugin = ({ props, rootRef, contentRef }) => {
-  const { instance, store, treeId } = useTreeViewContext<[UseTreeViewJSXItemsSignature]>();
+  const { instance, store } = useTreeViewContext<[UseTreeViewJSXItemsSignature]>();
   const { children, disabled = false, label, itemId, id } = props;
 
   const parentContext = React.useContext(TreeViewChildrenItemContext);
@@ -131,6 +133,7 @@ const useTreeViewJSXItemsItemPlugin: TreeViewItemPlugin = ({ props, rootRef, con
   const expandable = isItemExpandable(children);
   const pluginContentRef = React.useRef<HTMLDivElement>(null);
   const handleContentRef = useForkRef(pluginContentRef, contentRef);
+  const treeId = useSelector(store, selectorTreeViewId);
 
   // Prevent any flashing
   useEnhancedEffect(() => {
diff --git a/packages/x-tree-view/src/useTreeItem/useTreeItem.ts b/packages/x-tree-view/src/useTreeItem/useTreeItem.ts
index 939973e40fa50..5627597a1c415 100644
--- a/packages/x-tree-view/src/useTreeItem/useTreeItem.ts
+++ b/packages/x-tree-view/src/useTreeItem/useTreeItem.ts
@@ -29,6 +29,7 @@ import { useSelector } from '../internals/hooks/useSelector';
 import { selectorIsItemTheDefaultFocusableItem } from '../internals/plugins/useTreeViewFocus/useTreeViewFocus.selectors';
 import { generateTreeItemIdAttribute } from '../internals/corePlugins/useTreeViewId/useTreeViewId.utils';
 import { selectorCanItemBeFocused } from '../internals/plugins/useTreeViewItems/useTreeViewItems.selectors';
+import { selectorTreeViewId } from '../internals/corePlugins/useTreeViewId/useTreeViewId.selectors';
 
 export const useTreeItem = <
   TSignatures extends UseTreeItemMinimalPlugins = UseTreeItemMinimalPlugins,
@@ -42,7 +43,6 @@ export const useTreeItem = <
     selection: { disableSelection, checkboxSelection },
     expansion: { expansionTrigger },
     label: labelContext,
-    treeId,
     instance,
     publicAPI,
     store,
@@ -71,6 +71,7 @@ export const useTreeItem = <
   const handleContentRef = useForkRef(contentRef, contentRefObject)!;
   const checkboxRef = React.useRef<HTMLButtonElement>(null);
 
+  const treeId = useSelector(store, selectorTreeViewId);
   const idAttribute = generateTreeItemIdAttribute({ itemId, treeId, id });
   const shouldBeAccessibleWithTab = useSelector(
     store,
diff --git a/test/utils/tree-view/fakeContextValue.ts b/test/utils/tree-view/fakeContextValue.ts
index 3898a7e7c242f..d98130dcf3f69 100644
--- a/test/utils/tree-view/fakeContextValue.ts
+++ b/test/utils/tree-view/fakeContextValue.ts
@@ -27,7 +27,6 @@ export const getFakeContextValue = (
     disableSelection: false,
     selectionPropagation: {},
   },
-  treeId: 'mui-tree-view-1',
   rootRef: {
     current: null,
   },