refactor(utils): improve state handling with try-finally and enhance safety checks

- Wrapped state application logic in `try-finally` blocks to ensure cleanup (`isTimeTraveling`, `paused`, `hydrating`) regardless of errors.
- Improved safety by skipping operations during invalid states (e.g., `hydration`/`disposed` in `persist`).
- Added `shallowEqual` utility export to utils index.

Author: codeBelt

src/utils/devtools/devtools.ts

@@ -90,22 +90,25 @@ export function devtools<T extends object>(
           const newState = JSON.parse(message.state) as Record<string, unknown>;
           isTimeTraveling = true;
 
-          // Apply state back to the proxy, skipping getters and methods
-          for (const key of Object.keys(newState)) {
-            // Skip getters
-            if (findGetterDescriptor(proxyStore, key)?.get) continue;
-            // Skip methods
-            if (
-              typeof (proxyStore as Record<string, unknown>)[key] === 'function'
-            ) {
-              continue;
+          try {
+            // Apply state back to the proxy, skipping getters and methods
+            for (const key of Object.keys(newState)) {
+              // Skip getters
+              if (findGetterDescriptor(proxyStore, key)?.get) continue;
+              // Skip methods
+              if (
+                typeof (proxyStore as Record<string, unknown>)[key] ===
+                'function'
+              ) {
+                continue;
+              }
+              (proxyStore as Record<string, unknown>)[key] = newState[key];
             }
-            (proxyStore as Record<string, unknown>)[key] = newState[key];
+          } finally {
+            isTimeTraveling = false;
           }
-
-          isTimeTraveling = false;
         } catch {
-          isTimeTraveling = false;
+          // JSON.parse failed — ignore corrupted DevTools state.
         }
       }
     }

src/utils/history/history.ts

@@ -96,16 +96,22 @@ export function withHistory<T extends object>(
       if (pointer <= 0) return;
       pointer--;
       paused = true;
-      applySnapshot(history[pointer]);
-      paused = false;
+      try {
+        applySnapshot(history[pointer]);
+      } finally {
+        paused = false;
+      }
     },
 
     redo() {
       if (pointer >= history.length - 1) return;
       pointer++;
       paused = true;
-      applySnapshot(history[pointer]);
-      paused = false;
+      try {
+        applySnapshot(history[pointer]);
+      } finally {
+        paused = false;
+      }
     },
 
     get canUndo() {

src/utils/index.ts

@@ -22,3 +22,4 @@ export type {
 } from './persist/persist';
 export {persist} from './persist/persist';
 export {subscribeKey} from './subscribe-key/subscribe-key';
+export {shallowEqual} from './equality/equality';

src/utils/persist/persist.ts

@@ -211,8 +211,7 @@ function resolveProperties<T extends object>(
   for (const key of Object.keys(snap)) {
     // Skip getters (they live on the prototype, but snapshot installs them).
     // We check the original store's target for getter descriptors.
-    if (findGetterDescriptor(Object.getPrototypeOf(proxyStore), key)?.get)
-      continue;
+    if (findGetterDescriptor(proxyStore, key)?.get) continue;
     // Skip functions (methods).
     const value = (proxyStore as Record<string, unknown>)[key];
     if (typeof value === 'function') continue;
@@ -308,6 +307,7 @@ export function persist<T extends object>(
   // ── State ────────────────────────────────────────────────────────────────
 
   let disposed = false;
+  let hydrating = false;
   let debounceTimer: ReturnType<typeof setTimeout> | null = null;
   let hydratedFlag = false;
   let expiredFlag = false;
@@ -352,7 +352,7 @@ export function persist<T extends object>(
 
   /** Schedule a debounced write (or write immediately if debounce is 0). */
   function scheduleWrite(): void {
-    if (disposed) return;
+    if (disposed || hydrating) return;
 
     if (debounceMs <= 0) {
       void writeToStorage();
@@ -427,10 +427,12 @@ export function persist<T extends object>(
     let merged: Record<string, unknown>;
     if (typeof merge === 'function') {
       merged = merge(state, currentState);
+    } else if (merge === 'replace') {
+      // Only use persisted keys — new defaults not in storage are dropped.
+      merged = state;
     } else {
-      // Both 'shallow' and 'replace' assign persisted keys onto the store.
-      // The difference is conceptual for nested objects, but at this level
-      // both just assign the persisted value per key.
+      // 'shallow': persisted values overwrite current, but properties not
+      // in storage keep their current (default) value.
       merged = {...currentState, ...state};
     }
 
@@ -446,7 +448,12 @@ export function persist<T extends object>(
   async function hydrateFromStorage(): Promise<void> {
     const raw = await storage.getItem(name);
     if (raw !== null) {
-      applyPersistedState(raw);
+      hydrating = true;
+      try {
+        applyPersistedState(raw);
+      } finally {
+        hydrating = false;
+      }
     }
   }
 
@@ -539,10 +546,12 @@ export function persist<T extends object>(
     },
 
     async clear() {
+      if (disposed) return;
       await storage.removeItem(name);
     },
 
     async rehydrate() {
+      expiredFlag = false;
       await hydrateFromStorage();
       if (!hydratedFlag) {
         hydratedFlag = true;