diff --git a/functions/src/index.ts b/functions/src/index.ts
index 6141010..3fa6242 100644
--- a/functions/src/index.ts
+++ b/functions/src/index.ts
@@ -73,6 +73,19 @@ exports.addUserToTree = functions.https.onCall(async (data: { email: string; tre
         return currentMembers;
       }
     });
+    const treeMembersRefV2 = admin.database().ref(`trees/${treeId}/membersV2`);
+    await treeMembersRefV2.transaction((currentMembers: { [key: string]: string | boolean } | null) => {
+      if (currentMembers === null) {
+        const newMembers: { [key: string]: string } = {};
+        newMembers[userId] = email; // 新しいメンバーとして追加
+        return newMembers;
+      } else {
+        if (!Object.prototype.hasOwnProperty.call(currentMembers, userId)) {
+          currentMembers[userId] = email; // メンバーが存在しなければ追加
+        }
+        return currentMembers;
+      }
+    });
 
     // users/$userId/treeListにtreeIdを追加
     const userTreeListRef = admin.database().ref(`users/${userId}/treeList`);
@@ -86,6 +99,10 @@ exports.addUserToTree = functions.https.onCall(async (data: { email: string; tre
       }
     });
 
+    // trees/$treeId/timestampに現在の時間を追加
+    const timestampRef = admin.database().ref(`trees/${treeId}/timestamp`);
+    await timestampRef.set(Date.now());
+
     return { success: true };
   } catch (error) {
     console.error('Error adding user to tree:', error);
@@ -138,6 +155,19 @@ exports.removeUserFromTree = functions.https.onCall(async (data: { treeId: strin
         }
       }
     });
+    const treeMembersRefV2 = admin.database().ref(`trees/${treeId}/membersV2`);
+    await treeMembersRefV2.transaction((currentMembers: { [key: string]: string } | null) => {
+      if (currentMembers === null) {
+        return currentMembers; // 何もしない
+      } else {
+        if (Object.prototype.hasOwnProperty.call(currentMembers, userId)) {
+          delete currentMembers[userId]; // userIdをキーとして持つプロパティを削除
+          return currentMembers;
+        } else {
+          return currentMembers; // ユーザーが見つからない場合は何もしない
+        }
+      }
+    });
 
     // users/$userId/treeListからtreeIdを削除
     const userTreeListRef = admin.database().ref(`users/${userId}/treeList`);
@@ -155,6 +185,10 @@ exports.removeUserFromTree = functions.https.onCall(async (data: { treeId: strin
       }
     });
 
+    // trees/$treeId/timestampに現在の時間を追加
+    const timestampRef = admin.database().ref(`trees/${treeId}/timestamp`);
+    await timestampRef.set(Date.now());
+
     return { success: true };
   } catch (error) {
     console.error('Error removing user from tree:', error);
@@ -187,10 +221,26 @@ exports.createNewTree = functions.https.onCall(async (data: { items: ServerTreeI
     const db = admin.database();
     const treesRef = db.ref('trees');
     const newTreeRef = treesRef.push();
+    const emails = await Promise.all(
+      Object.keys(members).map(async (uid) => {
+        const userRecord = await admin.auth().getUser(uid);
+        return userRecord.email;
+      })
+    );
+    const membersV2: { [key: string]: string } = {};
+    Object.keys(members).forEach((uid, index) => {
+      const email = emails[index];
+      if (email) {
+        membersV2[uid] = email;
+      } else {
+        throw new Error('Email not found for UID: ' + uid);
+      }
+    });
     await newTreeRef.set({
       items: items,
       name: name,
       members: members,
+      membersV2: membersV2,
     });
     return newTreeRef.key;
   } catch (error) {
@@ -217,4 +267,25 @@ exports.copyFileInStorage = functions.https.onCall(async (data: { sourcePath: st
     console.error('Error copying file:', error);
     throw new functions.https.HttpsError('unknown', 'Failed to copy file');
   }
+});
+
+// 指定されたuidリストを指定されたタイムスタンプで更新
+exports.updateTimestamps = functions.https.onCall(async (data: { uids: string[], timestamp: number }) => {
+  const { uids, timestamp } = data;
+  if (!uids || !Array.isArray(uids) || !timestamp) {
+    throw new functions.https.HttpsError('invalid-argument', 'The function must be called with valid "uids" and "timestamp".');
+  }
+  try {
+    const db = admin.database();
+    await Promise.all(
+      uids.map(async (uid) => {
+        const userRef = db.ref(`users/${uid}`);
+        await userRef.update({ timestamp: timestamp });
+      })
+    );
+    return { success: true };
+  } catch (error) {
+    console.error('Error updating timestamps:', error);
+    throw new functions.https.HttpsError('unknown', 'Failed to update timestamps');
+  }
 });
\ No newline at end of file
diff --git a/package-lock.json b/package-lock.json
index 5b2e5cd..b3e9887 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "tasktree-s",
-  "version": "2.0.0",
+  "version": "1.1.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "tasktree-s",
-      "version": "2.0.0",
+      "version": "1.1.2",
       "dependencies": {
         "@capacitor-firebase/authentication": "^5.4.1",
         "@capacitor/android": "^5.7.4",
@@ -27,6 +27,8 @@
         "@fontsource/m-plus-1p": "^5.0.18",
         "@mui/icons-material": "^5.15.15",
         "@mui/material": "^5.15.15",
+        "dexie": "^4.0.4",
+        "dexie-react-hooks": "^1.1.7",
         "firebase": "^10.6.0",
         "immer": "^10.0.4",
         "lodash": "^4.17.21",
@@ -4542,6 +4544,21 @@
         "url": "https://github.com/sponsors/wooorm"
       }
     },
+    "node_modules/dexie": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/dexie/-/dexie-4.0.4.tgz",
+      "integrity": "sha512-wFzwWSUdi+MC3jiFeQcCp9nInR7EaX8edzYY+4wmiITkQAiSnHpe4Wo2o5Ce5tJZe2nqt7mLW91MsW4GYx3ziQ=="
+    },
+    "node_modules/dexie-react-hooks": {
+      "version": "1.1.7",
+      "resolved": "https://registry.npmjs.org/dexie-react-hooks/-/dexie-react-hooks-1.1.7.tgz",
+      "integrity": "sha512-Lwv5W0Hk+uOW3kGnsU9GZoR1er1B7WQ5DSdonoNG+focTNeJbHW6vi6nBoX534VKI3/uwHebYzSw1fwY6a7mTw==",
+      "peerDependencies": {
+        "@types/react": ">=16",
+        "dexie": "^3.2 || ^4.0.1-alpha",
+        "react": ">=16"
+      }
+    },
     "node_modules/dezalgo": {
       "version": "1.0.4",
       "resolved": "https://registry.npmjs.org/dezalgo/-/dezalgo-1.0.4.tgz",
diff --git a/package.json b/package.json
index 5ce7c1c..57df48e 100644
--- a/package.json
+++ b/package.json
@@ -29,6 +29,8 @@
     "@fontsource/m-plus-1p": "^5.0.18",
     "@mui/icons-material": "^5.15.15",
     "@mui/material": "^5.15.15",
+    "dexie": "^4.0.4",
+    "dexie-react-hooks": "^1.1.7",
     "firebase": "^10.6.0",
     "immer": "^10.0.4",
     "lodash": "^4.17.21",
diff --git a/src/components/HomePage.tsx b/src/components/HomePage.tsx
index 2a59689..a0be748 100644
--- a/src/components/HomePage.tsx
+++ b/src/components/HomePage.tsx
@@ -219,10 +219,10 @@ export function HomePage() {
                   Appleでログイン
                 </Button>
                 <Button
-                  onClick={() => {
+                  onClick={async () => {
                     setIsOffline(true);
                     setIsLoggedIn(true);
-                    handleCreateOfflineTree();
+                    await handleCreateOfflineTree();
                   }}
                   variant='contained'
                   sx={{ textTransform: 'none' }}
diff --git a/src/components/SortableList/SortableList.tsx b/src/components/SortableList/SortableList.tsx
index 4735308..755ff6e 100644
--- a/src/components/SortableList/SortableList.tsx
+++ b/src/components/SortableList/SortableList.tsx
@@ -35,7 +35,7 @@ export const SortableList: FC<SortableListProps> = ({ handleListClick, setDrawer
         onDragStart={(event) => {
           setActiveId(event.active.id as number);
         }}
-        onDragEnd={(event) => {
+        onDragEnd={async (event) => {
           setActiveId(null);
           const { active, over } = event;
           if (over == null || active.id === over.id) {
@@ -45,7 +45,7 @@ export const SortableList: FC<SortableListProps> = ({ handleListClick, setDrawer
           const newIndex = treesList.findIndex((item) => item.id === over.id);
           const newItems = arrayMove(treesList, oldIndex, newIndex);
           setTreesList(newItems);
-          saveTreesListDb(newItems);
+          await saveTreesListDb(newItems);
         }}
       >
         <SortableContext items={treesList}>
diff --git a/src/components/SortableTree/SortableTree.tsx b/src/components/SortableTree/SortableTree.tsx
index 84b632a..ec635cf 100644
--- a/src/components/SortableTree/SortableTree.tsx
+++ b/src/components/SortableTree/SortableTree.tsx
@@ -132,6 +132,7 @@ export function SortableTree({ collapsible, indicator = false, indentationWidth
 
     // コンポーネントのアンマウント時にイベントリスナーを削除
     return () => window.removeEventListener('resize', handleResize);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 
   const measuring = {
diff --git a/src/components/TreeSettingsAccordion.tsx b/src/components/TreeSettingsAccordion.tsx
index 4c45364..4a23f31 100644
--- a/src/components/TreeSettingsAccordion.tsx
+++ b/src/components/TreeSettingsAccordion.tsx
@@ -148,11 +148,11 @@ export function TreeSettingsAccordion() {
                 onClick={(e) => e.stopPropagation()}
                 onCompositionStart={() => setIsComposing(true)}
                 onCompositionEnd={() => setIsComposing(false)}
-                onKeyDown={(e) => {
+                onKeyDown={async (e) => {
                   if (e.key === 'Enter' && !isComposing) {
                     e.preventDefault(); // エンターキーのデフォルト動作を防ぐ
                     if (editedTreeName && editedTreeName !== '') {
-                      handleTreeNameSubmit(editedTreeName);
+                      await handleTreeNameSubmit(editedTreeName);
                     }
                     setIsAccordionExpanded(false);
                   }
diff --git a/src/hooks/useAppStateManagement.ts b/src/hooks/useAppStateManagement.ts
index ed0e65f..8a8154a 100644
--- a/src/hooks/useAppStateManagement.ts
+++ b/src/hooks/useAppStateManagement.ts
@@ -63,29 +63,29 @@ export const useAppStateManagement = () => {
   };
 
   // ダークモードと完了済みアイテムの非表示設定を保存 ------------------------------------------------
-  const saveAppSettingsDb = (darkModeNew: boolean, hideDoneItemsNew: boolean) => {
+  const saveAppSettingsDb = async (darkModeNew: boolean, hideDoneItemsNew: boolean) => {
     const db = getDatabase();
     if (!uid || !db) {
       return;
     }
     try {
       const userSettingsRef = ref(db, `users/${uid}/settings`);
-      saveTimeStampDb();
-      set(userSettingsRef, { darkMode: darkModeNew, hideDoneItems: hideDoneItemsNew });
+      await saveTimeStampDb();
+      await set(userSettingsRef, { darkMode: darkModeNew, hideDoneItems: hideDoneItemsNew });
     } catch (error) {
       handleError(error);
     }
   }
 
   // クイックメモをデータベースに保存する関数 ---------------------------------------------------------------------------
-  const saveQuickMemoDb = (quickMemoText: string) => {
+  const saveQuickMemoDb = async (quickMemoText: string) => {
     if (!uid) {
       return;
     }
     try {
       const quickMemoRef = ref(getDatabase(), `users/${uid}/quickMemo`);
-      saveTimeStampDb();
-      set(quickMemoRef, quickMemoText);
+      await saveTimeStampDb();
+      await set(quickMemoRef, quickMemoText);
     } catch (error) {
       handleError('クイックメモの変更をデータベースに保存できませんでした。\n\n' + error);
     }
diff --git a/src/hooks/useAttachedFile.ts b/src/hooks/useAttachedFile.ts
index ed1f6b4..a5f4c78 100644
--- a/src/hooks/useAttachedFile.ts
+++ b/src/hooks/useAttachedFile.ts
@@ -113,7 +113,7 @@ export const useAttachedFile = () => {
           const newItems: TreeItem[] = JSON.parse(JSON.stringify(items));
           const updatedItems = await deleteAttachedFile(newItems, fileName);
           setItems(updatedItems);
-          saveItemsDb(updatedItems, currentTree!);
+          await saveItemsDb(updatedItems, currentTree!);
         }
       }
     }
diff --git a/src/hooks/useDatabase.ts b/src/hooks/useDatabase.ts
index 8d4dfab..e713ace 100644
--- a/src/hooks/useDatabase.ts
+++ b/src/hooks/useDatabase.ts
@@ -1,5 +1,8 @@
+import { indexedDb as idb } from '../indexedDb';
 import { UniqueIdentifier } from '@dnd-kit/core';
+import { getFunctions, httpsCallable } from 'firebase/functions';
 import { useAppStateStore } from '../store/appStateStore';
+import { useTreeStateStore } from '../store/treeStateStore';
 import { useDialogStore } from '../store/dialogStore';
 import { TreeItems, TreesList, TreesListItem, TreesListItemIncludingItems } from '../types/types';
 import { isTreeItemArray, validateTreeItems } from '../components/SortableTree/utilities';
@@ -11,54 +14,105 @@ import { useError } from './useError';
 
 export const useDatabase = () => {
   const uid = useAppStateStore((state) => state.uid);
+  const currentTree = useTreeStateStore((state) => state.currentTree);
+  const currentTreeMembers = useTreeStateStore((state) => state.currentTreeMembers);
   const setLocalTimestamp = useAppStateStore((state) => state.setLocalTimestamp);
   const showDialog = useDialogStore((state) => state.showDialog);
 
   const { handleError } = useError();
 
   // タイムスタンプをデータベースに保存する関数 ---------------------------------------------------------------------------
-  const saveTimeStampDb = () => {
+  const saveTimeStampDb = async () => {
     if (!uid) {
       return;
     }
     try {
       const newTimestamp = Date.now();
+
+      // ローカルのタイムスタンプを更新
       setLocalTimestamp(newTimestamp);
+
+      // indexDBのタイムスタンプを更新
+      await idb.appstate.update(1, { timestamp: newTimestamp });
+
+      // ユーザーのタイムスタンプを更新
       const timestampRef = ref(getDatabase(), `users/${uid}/timestamp`);
-      set(timestampRef, newTimestamp);
+      await set(timestampRef, newTimestamp);
+
+      // ユーザーのタイムスタンプV2を更新
+      const timestampV2Ref = ref(getDatabase(), `users/${uid}/timestampV2`);
+      await set(timestampV2Ref, newTimestamp);
+
+      // ツリーのタイムスタンプを更新
+      if (currentTree) {
+        const treeRef = ref(getDatabase(), `trees/${currentTree}/timestamp`);
+        await set(treeRef, newTimestamp);
+      }
+
+      // 自分以外のメンバーのuidを抽出してタイムスタンプを更新
+      const treeMemberUids = currentTreeMembers?.filter((member) => member.uid !== uid).map((member) => member.uid);
+      if (treeMemberUids && treeMemberUids.length > 0) {
+        const functions = getFunctions();
+        const updateTimestamps = httpsCallable(functions, 'updateTimestamps');
+        await updateTimestamps({ uids: treeMemberUids, timestamp: newTimestamp });
+      }
+
       return;
     } catch (error) {
       handleError('タイムスタンプの保存に失敗しました。\n\n' + error);
     }
   };
 
+  // ツリーのタイムスタンプを取得する関数 ---------------------------------------------------------------------------
+  const loadTreeTimeStampFromDb = async (targetTree: UniqueIdentifier): Promise<number | null> => {
+    if (!uid || !targetTree) {
+      return null;
+    }
+    try {
+      const treeRef = ref(getDatabase(), `trees/${targetTree}/timestamp`);
+      return await get(treeRef)
+        .then((snapshot) => {
+          if (snapshot.exists()) {
+            return snapshot.val();
+          }
+          return null;
+        })
+        .catch(() => {
+          return null;
+        });
+    } catch (error) {
+      handleError('タイムスタンプの取得に失敗しました。\n\n' + error);
+      return null;
+    }
+  };
+
   // itemsをデータベースに保存する関数 ---------------------------------------------------------------------------
-  const saveItemsDb = (newItems: TreeItems, targetTree: UniqueIdentifier) => {
+  const saveItemsDb = async (newItems: TreeItems, targetTree: UniqueIdentifier) => {
     if (!uid || !targetTree || !newItems) {
       return;
     }
     try {
       // newItemsの内容をチェック
       if (!isTreeItemArray(newItems)) {
-        showDialog('ツリーデータが不正のため、データベースへの保存がキャンセルされました。修正するにはツリーデータをダウンロードし、手動で修正してください。\n\n※ツリーデータが配列ではありません。', 'Error');
+        await showDialog('ツリーデータが不正のため、データベースへの保存がキャンセルされました。修正するにはツリーデータをダウンロードし、手動で修正してください。\n\n※ツリーデータが配列ではありません。', 'Error');
         return;
       }
 
       // newItemsの内容を詳細にチェック
       const result = validateTreeItems(newItems);
       if (result !== '') {
-        showDialog('ツリーデータが不正のため、データベースへの保存がキャンセルされました。修正するにはツリーデータをダウンロードし、手動で修正してください。\n\n' + result, 'Error');
+        await showDialog('ツリーデータが不正のため、データベースへの保存がキャンセルされました。修正するにはツリーデータをダウンロードし、手動で修正してください。\n\n' + result, 'Error');
         return;
       }
 
       const treeStateRef = ref(getDatabase(), `trees/${targetTree}/items`);
       // 更新対象が存在するかチェック
-      get(treeStateRef)
+      await get(treeStateRef)
         .then(async (snapshot) => {
           if (snapshot.exists()) {
             // 存在する場合、更新を実行
-            saveTimeStampDb();
-            set(treeStateRef, newItems).catch((error) => {
+            await saveTimeStampDb();
+            await set(treeStateRef, newItems).catch((error) => {
               handleError('データベースの保存に失敗しました。code:3\n\n' + error);
             });
           } else {
@@ -75,14 +129,14 @@ export const useDatabase = () => {
   };
 
   // treesListをデータベースに保存する関数 ---------------------------------------------------------------------------
-  const saveTreesListDb = (newTreesList: TreesList) => {
+  const saveTreesListDb = async (newTreesList: TreesList) => {
     if (!uid) {
       return;
     }
     try {
       const userTreeListRef = ref(getDatabase(), `users/${uid}/treeList`);
-      saveTimeStampDb();
-      set(
+      await saveTimeStampDb();
+      await set(
         userTreeListRef,
         newTreesList.map((tree) => tree.id)
       );
@@ -92,25 +146,25 @@ export const useDatabase = () => {
   };
 
   // currentTreeNameをデータベースに保存する関数 ---------------------------------------------------------------------------
-  const saveCurrentTreeNameDb = (editedTreeName: string, targetTree: UniqueIdentifier | null) => {
+  const saveCurrentTreeNameDb = async (editedTreeName: string, targetTree: UniqueIdentifier | null) => {
     if (!uid || !targetTree || !editedTreeName) {
       return;
     }
     try {
       const treeNameRef = ref(getDatabase(), `trees/${targetTree}/name`);
-      saveTimeStampDb();
-      set(treeNameRef, editedTreeName);
+      await saveTimeStampDb();
+      await set(treeNameRef, editedTreeName);
     } catch (error) {
       handleError('ツリー名の変更をデータベースに保存できませんでした。\n\n' + error);
     }
   };
 
   // データベースからツリーを削除する関数 ---------------------------------------------------------------------------
-  const deleteTreeFromDb = (targetTree: UniqueIdentifier) => {
+  const deleteTreeFromDb = async (targetTree: UniqueIdentifier) => {
     const treeRef = ref(getDatabase(), `trees/${targetTree}`);
     try {
-      saveTimeStampDb();
-      set(treeRef, null);
+      await saveTimeStampDb();
+      await set(treeRef, null);
     } catch (error) {
       handleError('ツリーの削除に失敗しました。\n\n' + error);
     }
@@ -211,6 +265,8 @@ export const useDatabase = () => {
                 id: treesListItem.id,
                 name: treeData.name,
                 members: treeData.members,
+                membersV2: treeData.membersV2,
+                timestamp: treeData.timestamp,
                 items: treeData.items,
               };
               return treeItemsIncludingItems;
@@ -232,6 +288,7 @@ export const useDatabase = () => {
     saveItemsDb,
     saveTreesListDb,
     saveCurrentTreeNameDb,
+    loadTreeTimeStampFromDb,
     loadTreesListFromDb,
     loadTreeNameFromDb,
     loadItemsFromDb,
diff --git a/src/hooks/useIndexedDb.ts b/src/hooks/useIndexedDb.ts
new file mode 100644
index 0000000..4b990d2
--- /dev/null
+++ b/src/hooks/useIndexedDb.ts
@@ -0,0 +1,440 @@
+import { indexedDb as idb } from '../indexedDb';
+import { UniqueIdentifier } from '@dnd-kit/core';
+import type { TreeItems, TreesList, TreesListItemIncludingItems, MemberItems } from '../types/types';
+import { getFunctions, httpsCallable } from 'firebase/functions';
+import { getDatabase, ref, set } from 'firebase/database';
+import { isTreeItemArray, validateTreeItems, ensureChildrenProperty } from '../components/SortableTree/utilities';
+import { useAppStateManagement } from './useAppStateManagement';
+import { useTreeManagement } from './useTreeManagement';
+import { useDatabase } from './useDatabase';
+import { useError } from './useError';
+import { useAppStateStore } from '../store/appStateStore';
+import { useTreeStateStore } from '../store/treeStateStore';
+import { useDialogStore } from '../store/dialogStore';
+
+export const useIndexedDb = () => {
+  const uid = useAppStateStore((state) => state.uid);
+  const darkMode = useAppStateStore((state) => state.darkMode);
+  const setDarkMode = useAppStateStore((state) => state.setDarkMode);
+  const hideDoneItems = useAppStateStore((state) => state.hideDoneItems);
+  const setHideDoneItems = useAppStateStore((state) => state.setHideDoneItems);
+  const quickMemoText = useAppStateStore((state) => state.quickMemoText);
+  const setQuickMemoText = useAppStateStore((state) => state.setQuickMemoText);
+  const localTimestamp = useAppStateStore((state) => state.localTimestamp);
+  const setLocalTimestamp = useAppStateStore((state) => state.setLocalTimestamp);
+  const treesList = useTreeStateStore((state) => state.treesList);
+  const setTreesList = useTreeStateStore((state) => state.setTreesList);
+  const showDialog = useDialogStore((state) => state.showDialog);
+
+  const { loadSettingsFromDb, loadQuickMemoFromDb } = useAppStateManagement();
+  const { loadTreesList } = useTreeManagement();
+  const { loadTreeTimeStampFromDb, loadAllTreesDataFromDb, loadTreeNameFromDb, loadMembersFromDb, loadItemsFromDb } = useDatabase();
+  const { handleError } = useError();
+
+
+  // FirebaseRealtimeDatabaseとIndexedデータベースを同期する ------------------------------------------------
+  const syncDb = async () => {
+    try {
+      setLocalTimestamp(Date.now());
+      await loadSettingsFromDb();
+      await loadQuickMemoFromDb();
+      await loadTreesList();
+      await idb.appstate.clear();
+      await idb.appstate.put({
+        id: 1,
+        timestamp: localTimestamp,
+        quickMemo: quickMemoText,
+        settings: {
+          darkMode: darkMode,
+          hideDoneItems: hideDoneItems,
+        },
+        treesList: treesList,
+      });
+      const allTreesData = await loadAllTreesDataFromDb(treesList);
+      if (allTreesData) {
+        await idb.treestate.clear();
+        for (const treeData of allTreesData) {
+          const treeTimestampRef = ref(getDatabase(), `trees/${treeData.id}/timestamp`);
+          await set(treeTimestampRef, localTimestamp);
+          const timestampV2Ref = ref(getDatabase(), `users/${uid}/timestampV2`);
+          await set(timestampV2Ref, localTimestamp);
+          if (treeData.members) {
+            const functions = getFunctions();
+            const getUserEmails = httpsCallable(functions, 'getUserEmails');
+            const uids = Object.keys(treeData.members);
+            const result = await getUserEmails({ userIds: uids });
+            const emails = (result.data as { emails: string[] }).emails;
+            const membersV2: { [key: string]: string } = {};
+            for (const [i, uid] of uids.entries()) {
+              membersV2[uid] = emails[i];
+            }
+            const treeMembersV2Ref = ref(getDatabase(), `trees/${treeData.id}/membersV2`);
+            await set(treeMembersV2Ref, membersV2);
+            const ensuredItems = ensureChildrenProperty(treeData.items);
+            if (ensuredItems && isTreeItemArray(ensuredItems)) {
+              await idb.treestate.put({
+                id: treeData.id,
+                name: treeData.name,
+                members: treeData.members,
+                membersV2: membersV2,
+                timestamp: treeData.timestamp,
+                items: ensuredItems,
+              });
+            } else {
+              await showDialog('データベースのツリーが正しくありません。 ' + treeData.name, 'Error');
+            }
+          }
+        }
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  }
+
+  // データベースが空かどうかをチェックして、空の場合は初期データを同期 ------------------------------------------------
+  const checkAndSyncDb = async () => {
+    if (!uid) {
+      return;
+    }
+    try {
+      // データベースが空かどうかをチェック
+      const isEmpty = await idb.appstate.count() === 0;
+      if (isEmpty) {
+        // データベースが空の場合、初期データを登録
+        await syncDb();
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  };
+
+  // IndexedデータベースからAppの設定を読み込む ------------------------------------------------
+  const loadSettingsFromIdb = async () => {
+    try {
+      const appState = await idb.appstate.get(1);
+      if (appState) {
+        setQuickMemoText(appState.quickMemo);
+        setTreesList(appState.treesList);
+        setDarkMode(appState.settings.darkMode);
+        setHideDoneItems(appState.settings.hideDoneItems);
+        setLocalTimestamp(appState.timestamp);
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  }
+
+  // Indexedデータベースからクイックメモを読み込む ------------------------------------------------
+  const loadQuickMemoFromIdb = async () => {
+    try {
+      const appState = await idb.appstate.get(1);
+      if (appState) {
+        setQuickMemoText(appState.quickMemo);
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  }
+
+  // Indexedデータベースからツリーリストを読み込む ------------------------------------------------
+  const loadTreesListFromIdb = async () => {
+    try {
+      const appState = await idb.appstate.get(1);
+      if (appState) {
+        setTreesList(appState.treesList);
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  }
+
+  // IndexedデータベースからDarkMode設定を読み込む ------------------------------------------------
+  const loadDarkModeFromIdb = async () => {
+    try {
+      const appState = await idb.appstate.get(1);
+      if (appState) {
+        setDarkMode(appState.settings.darkMode);
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  }
+
+  // Indexedデータベースから完了済みアイテムの非表示設定を読み込む ------------------------------------------------
+  const loadHideDoneItemsFromIdb = async () => {
+    try {
+      const appState = await idb.appstate.get(1);
+      if (appState) {
+        setHideDoneItems(appState.settings.hideDoneItems);
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  }
+
+  // Indexedデータベースから指定されたツリーのデータを読み込む ------------------------------------------------
+  const loadCurrentTreeDataFromIdb = async (targetTree: UniqueIdentifier) => {
+    try {
+      const treeData = await idb.treestate.get(targetTree);
+      if (treeData) {
+        const ensuredItems = ensureChildrenProperty(treeData.items);
+        const ensuredTreeData = { ...treeData, items: ensuredItems };
+        return ensuredTreeData;
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  }
+
+  // IndexedデータベースにItemsを保存 ------------------------------------------------
+  const saveItemsIdb = async (newItems: TreeItems, targetTree: UniqueIdentifier) => {
+    if (!uid || !targetTree || !newItems) {
+      return;
+    }
+    try {
+      // newItemsの内容をチェック
+      if (!isTreeItemArray(newItems)) {
+        return;
+      }
+
+      // newItemsの内容を詳細にチェック
+      const result = validateTreeItems(newItems);
+      if (result !== '') {
+        return;
+      }
+
+      const treeData = await idb.treestate.get(targetTree);
+      if (treeData) {
+        treeData.items = newItems;
+        treeData.timestamp = Date.now();
+        await idb.treestate.put(treeData);
+      } else {
+        await showDialog('ローカルデータベースのツリーが見つかりませんでした。', 'Error');
+        return;
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  }
+
+  // Indexedデータベースにツリーリストを保存 ------------------------------------------------
+  const saveTreesListIdb = async (newTreesList: TreesList) => {
+    try {
+      await idb.appstate.update(1, { treesList: newTreesList });
+    } catch (error) {
+      handleError(error);
+    }
+  }
+
+  // Indexedデータベースに現在のツリー名を保存 ------------------------------------------------
+  const saveCurrentTreeNameIdb = async (editedTreeName: string, targetTree: UniqueIdentifier | null) => {
+    if (!uid || !targetTree || !editedTreeName) {
+      return;
+    }
+    try {
+      const treeData = await idb.treestate.get(targetTree);
+      if (treeData) {
+        treeData.name = editedTreeName;
+        treeData.timestamp = Date.now();
+        await idb.treestate.put(treeData);
+      } else {
+        await showDialog('ローカルデータベースのツリーが見つかりませんでした。', 'Error');
+        return;
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  }
+
+  // Indexedデータベースにクイックメモを保存 ------------------------------------------------
+  const saveQuickMemoIdb = async (quickMemoText: string) => {
+    try {
+      await idb.appstate.update(1, { quickMemo: quickMemoText });
+    } catch (error) {
+      handleError(error);
+    }
+  }
+
+  // Indexedデータベースにメンバーを追加 ------------------------------------------------
+  const updateMembersIdb = async (targetTree: UniqueIdentifier, newMembers: { uid: string; email: string }[]) => {
+    if (!uid || !targetTree || !newMembers) {
+      return;
+    }
+    try {
+      const treeData = await idb.treestate.get(targetTree);
+      if (treeData) {
+        const members: string[] = [];
+        const membersV2: { [key: string]: string } = {};
+        newMembers.forEach((member) => {
+          members.push(member.uid);
+          membersV2[member.uid] = member.email;
+        });
+        treeData.members = members;
+        treeData.membersV2 = membersV2;
+        treeData.timestamp = Date.now();
+        await idb.treestate.put(treeData);
+      } else {
+        await showDialog('ローカルデータベースのツリーが見つかりませんでした。', 'Error');
+        return;
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  }
+
+  // Indexedデータベースからユーザーを削除 ------------------------------------------------
+  const deleteMemberIdb = async (targetTree: UniqueIdentifier, targetUid: string) => {
+    if (!uid || !targetTree || !targetUid) {
+      return;
+    }
+    try {
+      const treeData = await idb.treestate.get(targetTree);
+      if (treeData && treeData.members && treeData.membersV2) {
+        const index = treeData.members.indexOf(targetUid);
+        if (index !== -1) {
+          treeData.members.splice(index, 1);
+        }
+        delete treeData.membersV2[targetUid];
+        treeData.timestamp = Date.now();
+        await idb.treestate.put(treeData);
+      } else {
+        await showDialog('ローカルデータベースのツリーが見つかりませんでした。', 'Error');
+        return;
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  }
+
+  // Indexedデータベースから指定されたツリーを削除 ------------------------------------------------
+  const deleteTreeIdb = async (targetTree: UniqueIdentifier) => {
+    if (!uid || !targetTree) {
+      return;
+    }
+    try {
+      await idb.treestate.delete(targetTree);
+    } catch (error) {
+      handleError(error);
+    }
+  }
+
+  // 指定されたツリーのデータをIndexedデータベースに保存 ------------------------------------------------
+  const copyTreeDataToIdbFromDb = async (targetTree: UniqueIdentifier) => {
+    const treeData: TreesListItemIncludingItems = {
+      id: targetTree,
+      name: '',
+      members: [],
+      membersV2: {},
+      timestamp: -1,
+      items: [],
+    };
+    // ツリーアイテムを取得
+    try {
+      const treeItems = await loadItemsFromDb(targetTree);
+      if (treeItems) {
+        const data: TreeItems = treeItems;
+        const itemsWithChildren = ensureChildrenProperty(data);
+        if (isTreeItemArray(itemsWithChildren)) {
+          treeData.items = itemsWithChildren;
+        } else {
+          throw new Error('取得したデータがTreeItem[]型ではありません。');
+        }
+      } else {
+        treeData.items = [];
+      }
+    } catch (error) {
+      await showDialog('ツリーアイテムの取得に失敗しました。\n\n' + error, 'Error');
+      return;
+    }
+
+    // ツリー名を取得
+    try {
+      const treeName = await loadTreeNameFromDb(targetTree);
+      if (treeName) {
+        treeData.name = treeName;
+      } else {
+        treeData.name = undefined;
+      }
+    } catch (error) {
+      await showDialog('ツリー名の取得に失敗しました。\n\n' + error, 'Error');
+      return;
+    }
+
+    // メンバーリストからメールアドレスリストを取得するFirebase関数
+    const getMemberEmails = async (memberList: string[]) => {
+      const functions = getFunctions();
+      const getUserEmails = httpsCallable(functions, 'getUserEmails');
+
+      try {
+        const result = await getUserEmails({ userIds: memberList });
+        // レスポンスの処理
+        const emails = (result.data as { emails: string[] }).emails;
+        return emails; // ここでemailsを返す
+      } catch (error) {
+        await showDialog('メンバーのメールアドレスの取得に失敗しました。\n\n' + error, 'Error');
+        return []; // エラーが発生した場合は空の配列を返す
+      }
+    };
+
+    // ツリーメンバーを取得
+    try {
+      const treeMembers = await loadMembersFromDb(targetTree);
+      if (treeMembers) {
+        const membersObject = treeMembers;
+        const uids = Object.keys(membersObject); // UIDのリストを取得
+
+        // UIDリストを使用して、メールアドレスを取得
+        const emails = await getMemberEmails(uids);
+        // メンバーリストとメールアドレスを組み合わせてオブジェクトの配列を作成
+        const membersWithEmails: MemberItems = {};
+        for (const [i, uid] of uids.entries()) {
+          membersWithEmails[uid] = emails[i];
+        }
+        treeData.membersV2 = membersWithEmails;
+      } else {
+        treeData.membersV2 = {};
+      }
+    } catch (error) {
+      await showDialog('ツリーメンバーの取得に失敗しました。\n\n' + error, 'Error');
+      return;
+    }
+
+    // タイムスタンプを取得
+    try {
+      const treeTimestamp = await loadTreeTimeStampFromDb(targetTree);
+      if (treeTimestamp) {
+        treeData.timestamp = treeTimestamp;
+      }
+    } catch (error) {
+      await showDialog('ツリータイムスタンプの取得に失敗しました。\n\n' + error, 'Error');
+      return;
+    }
+
+    // Indexedデータベースに保存
+    try {
+      await idb.treestate.put(treeData);
+    } catch (error) {
+      await showDialog('Indexedデータベースへの保存に失敗しました。\n\n' + error, 'Error');
+    }
+  }
+
+  return {
+    syncDb,
+    checkAndSyncDb,
+    loadSettingsFromIdb,
+    loadQuickMemoFromIdb,
+    loadTreesListFromIdb,
+    loadDarkModeFromIdb,
+    loadHideDoneItemsFromIdb,
+    loadCurrentTreeDataFromIdb,
+    saveItemsIdb,
+    saveTreesListIdb,
+    saveCurrentTreeNameIdb,
+    saveQuickMemoIdb,
+    updateMembersIdb,
+    deleteMemberIdb,
+    deleteTreeIdb,
+    copyTreeDataToIdbFromDb,
+  };
+};
+
diff --git a/src/hooks/useObserve.ts b/src/hooks/useObserve.ts
index 400d856..525e9b3 100644
--- a/src/hooks/useObserve.ts
+++ b/src/hooks/useObserve.ts
@@ -1,11 +1,13 @@
 import { useEffect } from 'react';
 import isEqual from 'lodash/isEqual';
+import { get } from 'firebase/database';
 import { useTreeStateStore } from '../store/treeStateStore';
 import { useTreeManagement } from './useTreeManagement';
 import { useAppStateManagement } from './useAppStateManagement';
 import { useDialogStore } from '../store/dialogStore';
 import { useError } from './useError';
 import { useDatabase } from './useDatabase';
+import { useIndexedDb } from './useIndexedDb';
 import { getDatabase, ref, onValue, } from 'firebase/database';
 import { useAppStateStore } from '../store/appStateStore';
 import { Preferences } from '@capacitor/preferences';
@@ -18,6 +20,7 @@ export const useObserve = () => {
   const setIsLoading = useAppStateStore((state) => state.setIsLoading);
   const quickMemoText = useAppStateStore((state) => state.quickMemoText);
   const setQuickMemoText = useAppStateStore((state) => state.setQuickMemoText);
+  const treesList = useTreeStateStore((state) => state.treesList);
   const items = useTreeStateStore((state) => state.items);
   const currentTree = useTreeStateStore((state) => state.currentTree);
   const currentTreeName = useTreeStateStore((state) => state.currentTreeName);
@@ -28,7 +31,17 @@ export const useObserve = () => {
 
   const { loadTreesList, loadCurrentTreeData, handleLoadedContent } = useTreeManagement();
   const { saveItemsDb } = useDatabase();
-  const { loadSettingsFromDb, loadQuickMemoFromDb, saveQuickMemoDb } = useAppStateManagement();
+  const { syncDb,
+    checkAndSyncDb,
+    loadSettingsFromIdb,
+    loadQuickMemoFromIdb,
+    loadTreesListFromIdb,
+    saveItemsIdb,
+    saveTreesListIdb,
+    saveQuickMemoIdb,
+    copyTreeDataToIdbFromDb
+  } = useIndexedDb();
+  const { loadQuickMemoFromDb, saveQuickMemoDb } = useAppStateManagement();
   const { handleError } = useError();
 
   // サーバのタイムスタンプを監視 ------------------------------------------------
@@ -37,9 +50,10 @@ export const useObserve = () => {
       return;
     }
     if (!isLoading) setIsLoading(true);
-    await loadSettingsFromDb();
-    await loadTreesList();
-    await loadQuickMemoFromDb();
+    await checkAndSyncDb();
+    await loadSettingsFromIdb();
+    await loadTreesListFromIdb();
+    await loadQuickMemoFromIdb();
     // ローカルストレージからitems_offlineとtreeName_offline、quick_memo_offlineを読み込む
     const { value: itemsOffline } = await Preferences.get({ key: `items_offline` });
     const { value: treeNameOffline } = await Preferences.get({ key: `treeName_offline` });
@@ -72,9 +86,35 @@ export const useObserve = () => {
       const currentLocalTimestamp = useAppStateStore.getState().localTimestamp;
       if (serverTimestamp && serverTimestamp > currentLocalTimestamp) {
         setLocalTimestamp(serverTimestamp);
-        await loadSettingsFromDb();
         await loadTreesList();
+        await saveTreesListIdb(treesList);
         await loadQuickMemoFromDb();
+        // treesListを反復して、タイムスタンプをチェックし、最新のツリーをコピー
+        const treeIds = treesList.map((tree) => tree.id);
+        let treeUpdateCount = 0;
+        for (const treeId of treeIds) {
+          const treeRef = ref(getDatabase(), `trees/${treeId}`);
+          await get(treeRef).then(async (snapshot) => {
+            if (snapshot.exists()) {
+              const data = snapshot.val();
+              if (data.timestamp > currentLocalTimestamp) {
+                await copyTreeDataToIdbFromDb(treeId);
+                treeUpdateCount++;
+              }
+            }
+          });
+        }
+        if (treeUpdateCount == 0) {
+          const timestampV2Ref = ref(getDatabase(), `users/${uid}/timestampV2`);
+          await get(timestampV2Ref).then(async (snapshot) => {
+            if (snapshot.exists()) {
+              const data = snapshot.val();
+              if (data <= serverTimestamp) {
+                await syncDb();
+              }
+            }
+          });
+        }
         const currentTree = useTreeStateStore.getState().currentTree;
         if (currentTree) {
           await loadCurrentTreeData(currentTree);
@@ -111,7 +151,11 @@ export const useObserve = () => {
           }
         } else {
           // オンラインモードの場合、データベースに保存
-          saveItemsDb(items, currentTree);
+          const asyncFunc = async () => {
+            await saveItemsIdb(items, currentTree);
+            await saveItemsDb(items, currentTree);
+          }
+          asyncFunc();
         }
         setPrevItems(items);
       } catch (error) {
@@ -138,7 +182,11 @@ export const useObserve = () => {
             value: quickMemoText,
           });
         } else {
-          saveQuickMemoDb(quickMemoText);
+          const asyncFunc = async () => {
+            await saveQuickMemoIdb(quickMemoText);
+            await saveQuickMemoDb(quickMemoText);
+          }
+          asyncFunc();
         }
       } catch (error) {
         handleError('クイックメモの変更をデータベースに保存できませんでした。\n\n' + error);
diff --git a/src/hooks/useTreeManagement.ts b/src/hooks/useTreeManagement.ts
index 4d4086a..bb3e9d6 100644
--- a/src/hooks/useTreeManagement.ts
+++ b/src/hooks/useTreeManagement.ts
@@ -1,7 +1,7 @@
 import { useCallback } from 'react';
 import { UniqueIdentifier } from '@dnd-kit/core';
 import { TreeItem, TreesList, TreesListItem, TreesListItemIncludingItems } from '../types/types';
-import { isTreeItemArray, ensureChildrenProperty } from '../components/SortableTree/utilities';
+import { isTreeItemArray } from '../components/SortableTree/utilities';
 import { initialItems, initialOfflineItems } from '../components/SortableTree/mock';
 import { getFunctions, httpsCallable } from 'firebase/functions';
 import { useAppStateStore } from '../store/appStateStore';
@@ -9,6 +9,7 @@ import { useTreeStateStore } from '../store/treeStateStore';
 import { useAttachedFile } from './useAttachedFile';
 import { useError } from './useError';
 import { useDatabase } from './useDatabase';
+import { useIndexedDb } from './useIndexedDb';
 import { useDialogStore, useInputDialogStore } from '../store/dialogStore';
 import { Capacitor } from '@capacitor/core';
 import { Filesystem, Directory, Encoding } from '@capacitor/filesystem';
@@ -52,11 +53,17 @@ export const useTreeManagement = () => {
     saveCurrentTreeNameDb,
     loadTreesListFromDb,
     loadTreeNameFromDb,
-    loadItemsFromDb,
-    loadMembersFromDb,
     loadAllTreesDataFromDb,
     deleteTreeFromDb,
   } = useDatabase();
+  const { copyTreeDataToIdbFromDb,
+    loadCurrentTreeDataFromIdb,
+    loadTreesListFromIdb,
+    saveItemsIdb,
+    saveTreesListIdb,
+    saveCurrentTreeNameIdb,
+    deleteTreeIdb
+  } = useIndexedDb();
   const { deleteFile } = useAttachedFile();
 
   // ツリーリストをDBから取得する ---------------------------------------------------------------------------
@@ -104,13 +111,12 @@ export const useTreeManagement = () => {
   };
 
   // ターゲットIDのitems、name、membersをDBからロードする ---------------------------------------------------------------------------
-
-  // 本編
   const loadCurrentTreeData = async (targetTree: UniqueIdentifier) => {
     if (!isLoading) setIsLoading(true);
     // デバウンスで前のツリーの状態変更が残っていたら保存
     if (prevCurrentTree && prevCurrentTree !== targetTree && prevItems.length !== 0 && prevItems !== items) {
-      saveItemsDb(items, prevCurrentTree);
+      await saveItemsIdb(prevItems, prevCurrentTree);
+      await saveItemsDb(prevItems, prevCurrentTree);
       setPrevItems(items);
     }
 
@@ -118,63 +124,17 @@ export const useTreeManagement = () => {
       if (!uid) {
         throw new Error('ユーザーがログインしていません。');
       }
-
-      // ツリーアイテムを取得
-      const treeItems = await loadItemsFromDb(targetTree);
-      if (treeItems) {
-        const data: TreeItem[] = treeItems;
-        const itemsWithChildren = ensureChildrenProperty(data);
-        if (isTreeItemArray(itemsWithChildren)) {
-          setPrevItems([]);
-          setPrevCurrentTree(targetTree);
-          setItems(itemsWithChildren);
-        } else {
-          throw new Error('取得したデータがTreeItem[]型ではありません。');
-        }
-      } else {
-        setItems([]);
-      }
-
-      // ツリー名を取得
-      const treeName = await loadTreeNameFromDb(targetTree);
-      if (treeName) {
-        setCurrentTreeName(treeName);
-      } else {
-        setCurrentTreeName(null);
-      }
-
-      // メンバーリストからメールアドレスリストを取得するFirebase関数
-      const getMemberEmails = async (memberList: string[]) => {
-        const functions = getFunctions();
-        const getUserEmails = httpsCallable(functions, 'getUserEmails');
-
-        try {
-          const result = await getUserEmails({ userIds: memberList });
-          // レスポンスの処理
-          const emails = (result.data as { emails: string[] }).emails;
-          return emails; // ここでemailsを返す
-        } catch (error) {
-          await showDialog('メンバーのメールアドレスの取得に失敗しました。\n\n' + error, 'Error');
-          return []; // エラーが発生した場合は空の配列を返す
+      const treeData = await loadCurrentTreeDataFromIdb(targetTree);
+      if (treeData && treeData.name && treeData.membersV2 && treeData.items) {
+        setCurrentTreeName(treeData.name);
+        const members: { uid: string; email: string }[] = [];
+        for (const member in treeData.membersV2) {
+          members.push({ uid: member, email: treeData.membersV2[member] });
         }
-      };
-
-      // ツリーメンバーを取得
-      const treeMembers = await loadMembersFromDb(targetTree);
-      if (treeMembers) {
-        const membersObject = treeMembers;
-        const uids = Object.keys(membersObject); // UIDのリストを取得
-
-        // UIDリストを使用して、メールアドレスを取得
-        const emails = await getMemberEmails(uids);
-        // メンバーリストとメールアドレスを組み合わせてオブジェクトの配列を作成
-        const membersWithEmails = uids.map((uid, index) => ({
-          uid,
-          email: emails[index], // 対応するメールアドレス
-        }));
-        setCurrentTreeMembers(membersWithEmails);
-      } else {
-        setCurrentTreeMembers(null);
+        setCurrentTreeMembers(members);
+        setPrevItems([]);
+        setPrevCurrentTree(targetTree);
+        setItems(treeData.items);
       }
 
       setIsLoading(false);
@@ -216,10 +176,12 @@ export const useTreeManagement = () => {
     setIsAccordionExpanded(false);
 
     try {
-      deleteTreeFromDb(targetTree);
+      await deleteTreeIdb(targetTree);
+      await deleteTreeFromDb(targetTree);
       const updatedTreesList = treesList ? treesList.filter((tree) => tree.id !== targetTree) : [];
       setTreesList(updatedTreesList);
-      saveTreesListDb(updatedTreesList);
+      await saveTreesListIdb(updatedTreesList);
+      await saveTreesListDb(updatedTreesList);
     } catch (error) {
       await showDialog('ツリーの削除に失敗しました。\n\n' + error, 'Error');
     }
@@ -232,7 +194,7 @@ export const useTreeManagement = () => {
       true
     );
     if (result) {
-      await deleteTree(currentTree as string);
+      await deleteTree(currentTree as UniqueIdentifier);
     }
   };
 
@@ -301,9 +263,11 @@ export const useTreeManagement = () => {
         const newTree = { id: newTreeRef as UniqueIdentifier, name: '新しいツリー' };
         const updatedTreesListWithNewTree = treesList ? [...treesList, newTree] : [newTree];
         setTreesList(updatedTreesListWithNewTree);
-        saveTreesListDb(updatedTreesListWithNewTree);
+        await saveTreesListIdb(updatedTreesListWithNewTree);
+        await saveTreesListDb(updatedTreesListWithNewTree);
+        await copyTreeDataToIdbFromDb(newTreeRef as UniqueIdentifier);
         await loadCurrentTreeData(newTreeRef as UniqueIdentifier);
-        await loadTreesList();
+        await loadTreesListFromIdb();
       }
 
       //タイマーをクリア
@@ -435,6 +399,7 @@ export const useTreeManagement = () => {
                 [uid]: true,
               }
             );
+            await copyTreeDataToIdbFromDb(newTreeRef as UniqueIdentifier);
             if (!newTreeRef) {
               throw new Error('ツリーのデータベースへの保存に失敗しました。');
             }
@@ -445,8 +410,9 @@ export const useTreeManagement = () => {
             temporaryTreesList = [...temporaryTreesList, loadedTreeObject];
           }
           setTreesList(temporaryTreesList);
-          saveTreesListDb(temporaryTreesList);
-          await loadTreesList();
+          await saveTreesListIdb(temporaryTreesList);
+          await saveTreesListDb(temporaryTreesList);
+          await loadTreesListFromIdb();
           await showDialog('複数のツリーが正常に読み込まれました。', 'Information');
         } else {
           // 単体のツリーが含まれる場合、treeStateをDBに保存
@@ -481,8 +447,10 @@ export const useTreeManagement = () => {
             }
             if (isLoading) setIsLoading(false);
             setTreesList(updatedTreesListWithLoadedTree);
-            saveTreesListDb(updatedTreesListWithLoadedTree);
-            await loadTreesList();
+            await saveTreesListIdb(updatedTreesListWithLoadedTree);
+            await saveTreesListDb(updatedTreesListWithLoadedTree);
+            await loadTreesListFromIdb();
+            await copyTreeDataToIdbFromDb(newTreeRef as UniqueIdentifier);
             await loadCurrentTreeData(newTreeRef as UniqueIdentifier);
             setIsLoading(false);
             const result = await showDialog('ファイルが正常に読み込まれました。', 'Information');
@@ -621,13 +589,14 @@ export const useTreeManagement = () => {
   };
 
   // ツリー名の変更 ---------------------------------------------------------------------------
-  const handleTreeNameSubmit = (editedTreeName: string) => {
+  const handleTreeNameSubmit = async (editedTreeName: string) => {
     if (editedTreeName !== null && editedTreeName !== '' && editedTreeName !== currentTreeName) {
       setCurrentTreeName(editedTreeName);
       if (isOffline) {
         Preferences.set({ key: `treeName_offline`, value: editedTreeName });
       } else {
-        saveCurrentTreeNameDb(editedTreeName, currentTree);
+        await saveCurrentTreeNameIdb(editedTreeName, currentTree);
+        await saveCurrentTreeNameDb(editedTreeName, currentTree);
       }
       if (treesList) {
         const newList = treesList.map((tree) => {
@@ -637,7 +606,8 @@ export const useTreeManagement = () => {
           return tree;
         });
         setTreesList(newList);
-        saveTreesListDb(newList);
+        await saveTreesListIdb(newList);
+        await saveTreesListDb(newList);
       }
     }
   };
@@ -661,7 +631,8 @@ export const useTreeManagement = () => {
         email,
         treeId: currentTree,
       });
-      loadCurrentTreeData(currentTree);
+      await copyTreeDataToIdbFromDb(currentTree);
+      await loadCurrentTreeData(currentTree);
       setIsLoading(false);
       return Promise.resolve(result.data);
     } catch (error) {
@@ -704,7 +675,19 @@ export const useTreeManagement = () => {
           treeId: currentTree,
           userId: rescievedUid,
         });
-        loadCurrentTreeData(currentTree);
+        if (uid && uid === rescievedUid) {
+          setCurrentTree(null);
+          setCurrentTreeName(null);
+          setCurrentTreeMembers(null);
+          setPrevCurrentTree(null);
+          setPrevItems([]);
+          setItems([]);
+          setIsAccordionExpanded(false);
+          await deleteTreeIdb(currentTree);
+        } else {
+          await copyTreeDataToIdbFromDb(currentTree);
+          await loadCurrentTreeData(currentTree);
+        }
         setIsLoading(false);
         return Promise.resolve(result.data);
       } catch (error) {
diff --git a/src/indexedDb.ts b/src/indexedDb.ts
new file mode 100644
index 0000000..b81524a
--- /dev/null
+++ b/src/indexedDb.ts
@@ -0,0 +1,30 @@
+import Dexie, { Table } from 'dexie';
+import { UniqueIdentifier } from '@dnd-kit/core';
+import type { TreesListItemIncludingItems, TreesList } from './types/types';
+
+interface AppStateItem {
+  id: number;
+  timestamp: number;
+  quickMemo: string;
+  settings: {
+    darkMode: boolean;
+    hideDoneItems: boolean;
+  };
+  treesList: TreesList;
+}
+
+class MyDexieDB extends Dexie {
+  appstate!: Table<AppStateItem, number>;  // <データ型, プライマリキーの型>
+  treestate!: Table<TreesListItemIncludingItems, UniqueIdentifier>;
+
+  constructor() {
+    super("taskTreesDatabase");
+    this.version(1).stores({
+      appstate: 'id, timestamp, quickMemo, settings, treeList',
+      treestate: 'id, name, members, membersV2, timestamp, items'
+    });
+  }
+}
+
+export const indexedDb = new MyDexieDB();
+
diff --git a/src/main.tsx b/src/main.tsx
index cd6f779..bddbef0 100644
--- a/src/main.tsx
+++ b/src/main.tsx
@@ -1,10 +1,10 @@
-//import React from 'react';
+import React from 'react';
 import ReactDOM from 'react-dom/client';
 import './index.css';
 import App from './components/App';
 
 ReactDOM.createRoot(document.getElementById('root')!).render(
-  //<React.StrictMode>
-  <App />
-  //</React.StrictMode>
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>
 );
diff --git a/src/types/types.ts b/src/types/types.ts
index 16868e0..1c3b039 100644
--- a/src/types/types.ts
+++ b/src/types/types.ts
@@ -21,11 +21,17 @@ export type TreesListItem = {
 
 export type TreesList = TreesListItem[];
 
+export type MemberItems = {
+  [key: string]: string;
+};
+
 export type TreesListItemIncludingItems = {
   id?: UniqueIdentifier;
   name?: string;
-  currentTreeName?: string;
+  currentTreeName?: string; //旧バージョンからの移行用 普段は使用しない
   members?: string[];
+  membersV2?: MemberItems;
+  timestamp?: number;
   items: TreeItems;
 };