@talex-touch/utils 1.0.42 → 1.0.45

package/renderer/storage/base-storage.ts

@@ -1,12 +1,16 @@
 import type { UnwrapNestedRefs, WatchHandle } from 'vue'
 import type { ITouchClientChannel } from '../../channel'
+import type { ITuffTransport } from '../../transport'
+import type {
+  StorageGetVersionedResponse,
+  StorageSaveRequest,
+  StorageSaveResult,
+  StorageUpdateNotification,
+} from '../../transport/events/types'
 import { useDebounceFn } from '@vueuse/core'
-import {
-  reactive,
-
-  watch,
-
-} from 'vue'
+import { reactive, ref, toRaw, watch } from 'vue'
+import { isElectronRenderer } from '../../env'
+import { StorageEvents } from '../../transport/events'
 
 /**
  * Interface representing the external communication channel.
@@ -19,16 +23,16 @@ export interface IStorageChannel extends ITouchClientChannel {
    * @param payload Event payload
    */
   send: (event: string, payload: unknown) => Promise<unknown>
+}
 
-  /**
-   * Synchronous send interface
-   * @param event Event name
-   * @param payload Event payload
-   */
-  sendSync: (event: string, payload: unknown) => unknown
+export type StorageInitMode = 'auto' | 'sync' | 'async'
+
+export interface TouchStorageOptions {
+  initMode?: StorageInitMode
 }
 
 let channel: IStorageChannel | null = null
+let transport: ITuffTransport | null = null
 
 /**
  * Initializes the global channel for communication.
@@ -41,12 +45,20 @@ let channel: IStorageChannel | null = null
  *
  * initStorageChannel({
  *   send: ipcRenderer.invoke.bind(ipcRenderer),
- *   sendSync: ipcRenderer.sendSync.bind(ipcRenderer),
  * });
  * ```
  */
 export function initStorageChannel(c: IStorageChannel): void {
   channel = c
+  initializeStorageInstances()
+}
+
+/**
+ * Initializes the global TuffTransport for storage operations.
+ */
+export function initStorageTransport(t: ITuffTransport): void {
+  transport = t
+  initializeStorageInstances()
 }
 
 /**
@@ -68,6 +80,12 @@ function getGlobalStorageMap(): GlobalStorageMap {
 
 export const storages: GlobalStorageMap = getGlobalStorageMap()
 
+function initializeStorageInstances(): void {
+  for (const storage of storages.values()) {
+    storage.initializeChannel()
+  }
+}
+
 const GLOBAL_SINGLETON_KEY = '__talex_touch_storage_singletons__'
 type StorageSingletonMap = Map<string, unknown>
 
@@ -113,14 +131,38 @@ export function createStorageProxy<T extends object>(key: string, factory: () =>
   })
 }
 
+export function createStorageDataProxy<TData extends object>(
+  storage: { data: TData },
+): TData {
+  return new Proxy({} as TData, {
+    get(_target, prop) {
+      const data = storage.data as Record<PropertyKey, unknown>
+      const value = data[prop as PropertyKey]
+      return typeof value === 'function' ? value.bind(data) : value
+    },
+    set(_target, prop, value) {
+      (storage.data as Record<PropertyKey, unknown>)[prop as PropertyKey] = value
+      return true
+    },
+    has(_target, prop) {
+      return prop in (storage.data as Record<PropertyKey, unknown>)
+    },
+    ownKeys() {
+      return Reflect.ownKeys(storage.data as Record<PropertyKey, unknown>)
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+      return Object.getOwnPropertyDescriptor(
+        storage.data as Record<PropertyKey, unknown>,
+        prop,
+      )
+    },
+  })
+}
+
 /**
  * Save result from main process
  */
-export interface SaveResult {
-  success: boolean
-  version: number
-  conflict?: boolean
-}
+export type SaveResult = StorageSaveResult
 
 /**
  * A reactive storage utility with optional auto-save and update subscriptions.
@@ -138,6 +180,17 @@ export class TouchStorage<T extends object> {
   #skipNextWatchTrigger = false
   #currentVersion = 0
   #isRemoteUpdate = false
+  #hydrated = false
+  readonly #hydratedPromise: Promise<void>
+  #resolveHydratedPromise: (() => void) | null = null
+  #pendingSave = false
+  #localDirty = false
+  #lastSyncedSnapshot: T | null = null
+
+  /**
+   * Reactive saving state — true while a save is in flight.
+   */
+  public readonly savingState = ref(false)
 
   /**
    * The reactive data exposed to users.
@@ -146,7 +199,8 @@ export class TouchStorage<T extends object> {
 
   /**
    * Creates a new reactive storage instance.
-   * IMPORTANT: `initStorageChannel()` must be called before creating any TouchStorage instances.
+   * NOTE: `initStorageChannel()` or `initStorageTransport()` can be called later;
+   * storage will sync once the channel/transport is ready.
    *
    * @param qName Globally unique name for the instance
    * @param initData Initial data to populate the storage
@@ -156,20 +210,25 @@ export class TouchStorage<T extends object> {
    *
    * @example
    * ```ts
-   * // First initialize the channel
+   * // First initialize the channel or transport
    * initStorageChannel(touchChannel);
    *
    * // Then create storage instances
    * const settings = new TouchStorage('settings', { darkMode: false });
    * ```
    */
-  constructor(qName: string, initData: T, onUpdate?: () => void) {
-    if (!channel) {
-      throw new Error(
-        `TouchStorage: Cannot create storage "${qName}" before channel is initialized. `
-        + 'Please call initStorageChannel() first.',
-      )
+  constructor(
+    qName: string,
+    initData: T,
+    onUpdate?: () => void,
+    options?: TouchStorageOptions,
+  ) {
+    if (!channel && !transport) {
+      if (isElectronRenderer()) {
+        // Allow lazy initialization; channel/transport can be set later.
+      }
     }
+    void options
 
     if (storages.has(qName)) {
       throw new Error(`Storage "${qName}" already exists`)
@@ -178,6 +237,10 @@ export class TouchStorage<T extends object> {
     this.#qualifiedName = qName
     this.originalData = initData
     this.data = reactive({ ...initData }) as UnwrapNestedRefs<T>
+    this.#lastSyncedSnapshot = cloneValue(initData) as T
+    this.#hydratedPromise = new Promise((resolve) => {
+      this.#resolveHydratedPromise = resolve
+    })
 
     if (onUpdate)
       this._onUpdate.push(onUpdate)
@@ -185,8 +248,10 @@ export class TouchStorage<T extends object> {
     // Register to storages map immediately
     storages.set(qName, this)
 
-    // Initialize channel-dependent operations immediately
-    this.#initializeChannel()
+    if (channel || transport) {
+      // Initialize channel-dependent operations immediately when ready
+      this.#initializeChannel()
+    }
   }
 
   /**
@@ -200,53 +265,158 @@ export class TouchStorage<T extends object> {
 
     this.#channelInitialized = true
 
-    // Try to get versioned data first, fallback to legacy
-    const versionedResult = channel!.sendSync('storage:get-versioned', this.#qualifiedName) as { data: Partial<T>, version: number } | null
-    if (versionedResult) {
-      this.#currentVersion = versionedResult.version
-      this.assignData(versionedResult.data, true, true)
+    void this.#loadFromRemoteWithVersion()
+
+    this.#registerUpdateListener()
+
+    // Start auto-save watcher AFTER initial data load
+    if (this.#autoSave && !this.#autoSaveStopHandle) {
+      this.#startAutoSaveWatcher()
     }
-    else {
-      const result = channel!.sendSync('storage:get', this.#qualifiedName)
-      const parsed = result ? (result as Partial<T>) : {}
-      this.#currentVersion = 1
-      this.assignData(parsed, true, true)
+  }
+
+  public initializeChannel(): void {
+    this.#initializeChannel()
+  }
+
+  #notifyHydrated(): void {
+    if (!this.#hydrated)
+      return
+    if (this.#resolveHydratedPromise) {
+      this.#resolveHydratedPromise()
+      this.#resolveHydratedPromise = null
+    }
+  }
+
+  async #getVersionedAsync(): Promise<StorageGetVersionedResponse | null> {
+    if (transport) {
+      return await transport.send(StorageEvents.app.getVersioned, { key: this.#qualifiedName })
+    }
+    if (channel) {
+      return await channel.send('storage:get-versioned', this.#qualifiedName) as StorageGetVersionedResponse | null
+    }
+    return null
+  }
+
+  async #getAsync(): Promise<Partial<T>> {
+    if (transport) {
+      const data = await transport.send(StorageEvents.app.get, { key: this.#qualifiedName })
+      return (data as Partial<T>) ?? {}
+    }
+    if (channel) {
+      const result = await channel.send('storage:get', this.#qualifiedName)
+      return result ? (result as Partial<T>) : {}
+    }
+    return {}
+  }
+
+  async #saveRemote(request: StorageSaveRequest): Promise<SaveResult> {
+    if (transport) {
+      return await transport.send(StorageEvents.app.save, request)
+    }
+    if (channel) {
+      return await channel.send('storage:save', request) as SaveResult
+    }
+    return { success: false, version: 0 }
+  }
+
+  #registerUpdateListener(): void {
+    if (transport) {
+      transport.stream(StorageEvents.app.updated, undefined, {
+        onData: (payload: StorageUpdateNotification) => {
+          const { key, version } = payload
+          if (key !== this.#qualifiedName) {
+            return
+          }
+
+          if (version === undefined || version > this.#currentVersion) {
+            void this.#loadFromRemoteWithVersion()
+          }
+        },
+      }).catch((error) => {
+        console.error('[TouchStorage] Failed to subscribe to storage updates:', error)
+      })
+      return
+    }
+
+    if (!channel) {
+      return
     }
 
     // Register update listener - only triggered for OTHER windows' changes
     // (source window is excluded by main process)
-    channel!.regChannel('storage:update', ({ data }) => {
+    channel.regChannel(StorageEvents.legacy.update.toEventName(), ({ data }) => {
       const { name, version } = data as { name: string, version?: number }
 
       if (name === this.#qualifiedName) {
         // Only reload if remote version is newer
         if (version === undefined || version > this.#currentVersion) {
-          this.#loadFromRemoteWithVersion()
+          void this.#loadFromRemoteWithVersion()
         }
       }
     })
-
-    // Start auto-save watcher AFTER initial data load
-    if (this.#autoSave && !this.#autoSaveStopHandle) {
-      this.#startAutoSaveWatcher()
-    }
   }
 
   /**
    * Load from remote and update version
    * @private
    */
-  #loadFromRemoteWithVersion(): void {
-    if (!channel)
+  async #loadFromRemoteWithVersion(): Promise<void> {
+    if (!channel && !transport) {
       return
+    }
+    try {
+      const versionedResult = await this.#getVersionedAsync()
+      if (versionedResult) {
+        const shouldApply = versionedResult.version > this.#currentVersion || !this.#hydrated
+        if (shouldApply) {
+          const patch = this.#localDirty
+            ? buildPatch(this.#lastSyncedSnapshot ?? {}, toRaw(this.data))
+            : null
+          const patchHasChanges = Boolean(patch && (patch.set.length > 0 || patch.unset.length > 0))
+          const remoteData = (versionedResult.data ?? {}) as Partial<T>
+          console.debug(`[TouchStorage] HYDRATE("${this.#qualifiedName}") remote version=${versionedResult.version}, background.source=`, (remoteData as any)?.background?.source)
+
+          this.#currentVersion = versionedResult.version
+          this.#isRemoteUpdate = true
+          this.assignData(remoteData, true, true)
+          if (patchHasChanges && patch) {
+            this.#applyPatchSilently(patch)
+            this.#localDirty = true
+          }
+          else {
+            this.#localDirty = false
+          }
+          this.#isRemoteUpdate = false
+
+          this.#lastSyncedSnapshot = cloneValue(toRaw(this.data) as T) as T
+          this.#hydrated = true
+          this.#notifyHydrated()
+          if (this.#pendingSave || patchHasChanges) {
+            this.#pendingSave = false
+            void this.saveToRemote({ force: true })
+          }
+        }
+        return
+      }
 
-    const versionedResult = channel.sendSync('storage:get-versioned', this.#qualifiedName) as { data: Partial<T>, version: number } | null
-    if (versionedResult && versionedResult.version > this.#currentVersion) {
-      this.#currentVersion = versionedResult.version
-      // Mark as remote update to skip auto-save
+      const result = await this.#getAsync()
+      this.#currentVersion = Math.max(this.#currentVersion, 1)
       this.#isRemoteUpdate = true
-      this.assignData(versionedResult.data, true, true)
+      this.assignData(result as Partial<T>, true, true)
       this.#isRemoteUpdate = false
+      this.#lastSyncedSnapshot = cloneValue(toRaw(this.data) as T) as T
+      this.#hydrated = true
+      this.#notifyHydrated()
+      if (this.#pendingSave) {
+        this.#pendingSave = false
+        void this.saveToRemote({ force: true })
+      }
+    }
+    catch (error) {
+      console.error(`[TouchStorage] Failed to load "${this.#qualifiedName}" from remote:`, error)
+      this.#hydrated = true
+      this.#notifyHydrated()
     }
   }
 
@@ -262,6 +432,16 @@ export class TouchStorage<T extends object> {
     return this.#qualifiedName
   }
 
+  isHydrated(): boolean {
+    return this.#hydrated
+  }
+
+  whenHydrated(): Promise<void> {
+    if (this.#hydrated)
+      return Promise.resolve()
+    return this.#hydratedPromise
+  }
+
   /**
    * Checks whether auto-save is currently enabled.
    *
@@ -285,35 +465,63 @@ export class TouchStorage<T extends object> {
    * await store.saveToRemote();
    * ```
    */
-  saveToRemote = useDebounceFn(async (options?: { force?: boolean }): Promise<void> => {
-    if (!channel) {
-      throw new Error('TouchStorage: channel not initialized')
+  async #executeSave(options?: { force?: boolean }): Promise<void> {
+    if (!channel && !transport) {
+      console.warn(`[TouchStorage] #executeSave("${this.#qualifiedName}") SKIP: no channel/transport`)
+      if (isElectronRenderer()) {
+        throw new Error('TouchStorage: channel not initialized')
+      }
+      return
     }
 
     if (this.#assigning && !options?.force) {
+      console.warn(`[TouchStorage] #executeSave("${this.#qualifiedName}") SKIP: assigning (force=${options?.force})`)
       return
     }
 
     // Skip save if this is a remote update (to avoid echo)
     if (this.#isRemoteUpdate) {
+      console.warn(`[TouchStorage] #executeSave("${this.#qualifiedName}") SKIP: isRemoteUpdate`)
+      return
+    }
+    if (!this.#hydrated) {
+      console.warn(`[TouchStorage] #executeSave("${this.#qualifiedName}") SKIP: not hydrated, queueing`)
+      this.#pendingSave = true
+      this.#localDirty = true
       return
     }
 
-    const result = await channel.send('storage:save', {
-      key: this.#qualifiedName,
-      content: JSON.stringify(this.data),
-      clear: false,
-      version: this.#currentVersion,
-    }) as SaveResult
-
-    if (result.success) {
-      this.#currentVersion = result.version
+    const rawData = toRaw(this.data)
+    console.debug(`[TouchStorage] #executeSave("${this.#qualifiedName}") SAVING, background.source=`, (rawData as any)?.background?.source)
+
+    this.savingState.value = true
+    try {
+      const result = await this.#saveRemote({
+        key: this.#qualifiedName,
+        value: rawData,
+        clear: false,
+        version: this.#currentVersion,
+      })
+
+      if (result.success) {
+        console.debug(`[TouchStorage] #executeSave("${this.#qualifiedName}") SUCCESS, version=${result.version}`)
+        this.#currentVersion = result.version
+        this.#lastSyncedSnapshot = cloneValue(toRaw(this.data) as T) as T
+        this.#localDirty = false
+      }
+      else if (result.conflict) {
+        // Conflict detected - reload from remote
+        console.warn(`[TouchStorage] Conflict detected for "${this.#qualifiedName}", reloading...`)
+        void this.#loadFromRemoteWithVersion()
+      }
     }
-    else if (result.conflict) {
-      // Conflict detected - reload from remote
-      console.warn(`[TouchStorage] Conflict detected for "${this.#qualifiedName}", reloading...`)
-      this.#loadFromRemoteWithVersion()
+    finally {
+      this.savingState.value = false
     }
+  }
+
+  saveToRemote = useDebounceFn(async (options?: { force?: boolean }): Promise<void> => {
+    return this.#executeSave(options)
   }, 300)
 
   /**
@@ -355,11 +563,12 @@ export class TouchStorage<T extends object> {
 
         this.#runAutoSavePipeline()
       },
-      { deep: true, immediate: true },
+      { deep: true },
     )
   }
 
   #runAutoSavePipeline(options?: { force?: boolean }): void {
+    this.#localDirty = true
     this._onUpdate.forEach((fn) => {
       try {
         fn()
@@ -372,6 +581,32 @@ export class TouchStorage<T extends object> {
     this.saveToRemote(options)
   }
 
+  #applyPatchSilently(patch: StoragePatch): void {
+    if (patch.set.length === 0 && patch.unset.length === 0) {
+      return
+    }
+
+    if (this.#autoSave) {
+      this.#assigning = true
+    }
+
+    applyPatch(this.data as Record<string, unknown>, patch)
+
+    if (this.#autoSave) {
+      this.#skipNextWatchTrigger = true
+      const resetAssigning = () => {
+        this.#assigning = false
+      }
+
+      if (typeof queueMicrotask === 'function') {
+        queueMicrotask(resetAssigning)
+      }
+      else {
+        Promise.resolve().then(resetAssigning)
+      }
+    }
+  }
+
   /**
    * Registers a callback that runs when data changes (only triggered in auto-save mode).
    *
@@ -465,6 +700,25 @@ export class TouchStorage<T extends object> {
     return this
   }
 
+  /**
+   * Applies remote snapshot data without triggering local auto-save echo.
+   *
+   * @param data Snapshot data pulled from remote sync source.
+   * @returns The current instance for chaining
+   */
+  applyRemoteSnapshot(data: Partial<T>): this {
+    this.#isRemoteUpdate = true
+    try {
+      this.assignData(data, true, true)
+      this.#lastSyncedSnapshot = cloneValue(toRaw(this.data) as T) as T
+      this.#localDirty = false
+    }
+    finally {
+      this.#isRemoteUpdate = false
+    }
+    return this
+  }
+
   /**
    * Reloads data from remote storage and applies it.
    *
@@ -476,13 +730,29 @@ export class TouchStorage<T extends object> {
    * ```
    */
   async reloadFromRemote(): Promise<this> {
-    if (!channel) {
+    if (!channel && !transport) {
       throw new Error('TouchStorage: channel not initialized')
     }
 
-    const result = await channel.send('storage:reload', this.#qualifiedName)
-    const parsed = result ? (result as Partial<T>) : {}
-    this.assignData(parsed, true)
+    const versionedResult = await this.#getVersionedAsync()
+    if (versionedResult) {
+      this.#currentVersion = versionedResult.version
+      this.#isRemoteUpdate = true
+      this.assignData(versionedResult.data as Partial<T>, true, true)
+      this.#isRemoteUpdate = false
+      this.#lastSyncedSnapshot = cloneValue(toRaw(this.data) as T) as T
+      this.#hydrated = true
+      this.#notifyHydrated()
+      return this
+    }
+
+    const parsed = await this.#getAsync()
+    this.#isRemoteUpdate = true
+    this.assignData(parsed as Partial<T>, true, true)
+    this.#isRemoteUpdate = false
+    this.#lastSyncedSnapshot = cloneValue(toRaw(this.data) as T) as T
+    this.#hydrated = true
+    this.#notifyHydrated()
 
     return this
   }
@@ -499,12 +769,12 @@ export class TouchStorage<T extends object> {
    * ```
    */
   loadFromRemote(): this {
-    if (!channel) {
+    if (!channel && !transport) {
       // Channel not initialized yet, data will be loaded when channel is ready
       return this
     }
 
-    this.#loadFromRemoteWithVersion()
+    void this.#loadFromRemoteWithVersion()
     return this
   }
 
@@ -521,17 +791,13 @@ export class TouchStorage<T extends object> {
    * This bypasses debouncing and saves immediately
    */
   saveSync(): void {
-    if (!channel)
+    if (!channel && !transport)
       return
     if (this.#isRemoteUpdate)
       return
 
-    channel.sendSync('storage:save-sync', {
-      key: this.#qualifiedName,
-      content: JSON.stringify(this.data),
-      clear: false,
-      version: this.#currentVersion,
-    })
+    console.debug(`[TouchStorage] saveSync("${this.#qualifiedName}") called, background.source=`, (toRaw(this.data) as any)?.background?.source)
+    void this.#executeSave({ force: true })
   }
 
   /**
@@ -564,3 +830,163 @@ export class TouchStorage<T extends object> {
     return this
   }
 }
+
+interface StoragePatch {
+  set: Array<{ path: string[], value: unknown }>
+  unset: Array<string[]>
+}
+
+function buildPatch(base: unknown, current: unknown): StoragePatch {
+  const patch: StoragePatch = { set: [], unset: [] }
+  walkDiff(base, current, [], patch)
+  return patch
+}
+
+function walkDiff(base: unknown, current: unknown, path: string[], patch: StoragePatch): void {
+  if (isPlainObject(base) && isPlainObject(current)) {
+    const baseKeys = Object.keys(base)
+    const currentKeys = Object.keys(current)
+    const currentSet = new Set(currentKeys)
+
+    for (const key of baseKeys) {
+      if (!currentSet.has(key) || (current as Record<string, unknown>)[key] === undefined) {
+        patch.unset.push([...path, key])
+      }
+    }
+
+    for (const key of currentKeys) {
+      const currentValue = (current as Record<string, unknown>)[key]
+      if (currentValue === undefined) {
+        continue
+      }
+      if (!(key in (base as Record<string, unknown>))) {
+        patch.set.push({ path: [...path, key], value: cloneValue(currentValue) })
+        continue
+      }
+      walkDiff((base as Record<string, unknown>)[key], currentValue, [...path, key], patch)
+    }
+    return
+  }
+
+  if (isEqual(base, current)) {
+    return
+  }
+
+  if (path.length > 0) {
+    patch.set.push({ path: [...path], value: cloneValue(current) })
+  }
+}
+
+function applyPatch(target: Record<string, unknown>, patch: StoragePatch): Record<string, unknown> {
+  for (const path of patch.unset) {
+    unsetByPath(target, path)
+  }
+  for (const entry of patch.set) {
+    setByPath(target, entry.path, cloneValue(entry.value))
+  }
+  return target
+}
+
+function setByPath(target: Record<string, unknown>, path: string[], value: unknown): void {
+  if (path.length === 0) {
+    return
+  }
+  let cursor: Record<string, unknown> = target
+  for (let i = 0; i < path.length - 1; i++) {
+    const key = path[i]
+    if (!key)
+      continue
+    const next = cursor[key]
+    if (!isPlainObject(next)) {
+      cursor[key] = {}
+    }
+    cursor = cursor[key] as Record<string, unknown>
+  }
+  const lastKey = path[path.length - 1]
+  if (!lastKey)
+    return
+  cursor[lastKey] = value
+}
+
+function unsetByPath(target: Record<string, unknown>, path: string[]): void {
+  if (path.length === 0) {
+    return
+  }
+  let cursor: Record<string, unknown> = target
+  for (let i = 0; i < path.length - 1; i++) {
+    const key = path[i]
+    if (!key)
+      return
+    const next = cursor[key]
+    if (!isPlainObject(next)) {
+      return
+    }
+    cursor = next as Record<string, unknown>
+  }
+  const lastKey = path[path.length - 1]
+  if (!lastKey)
+    return
+  delete cursor[lastKey]
+}
+
+function isEqual(left: unknown, right: unknown): boolean {
+  if (left === right) {
+    return true
+  }
+  if (left instanceof Date && right instanceof Date) {
+    return left.getTime() === right.getTime()
+  }
+  if (Array.isArray(left) && Array.isArray(right)) {
+    if (left.length !== right.length) {
+      return false
+    }
+    for (let i = 0; i < left.length; i++) {
+      if (!isEqual(left[i], right[i])) {
+        return false
+      }
+    }
+    return true
+  }
+  if (isPlainObject(left) && isPlainObject(right)) {
+    const leftKeys = Object.keys(left)
+    const rightKeys = Object.keys(right)
+    if (leftKeys.length !== rightKeys.length) {
+      return false
+    }
+    for (const key of leftKeys) {
+      if (!isEqual(left[key], right[key])) {
+        return false
+      }
+    }
+    return true
+  }
+  return false
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  if (!value || typeof value !== 'object') {
+    return false
+  }
+  if (Array.isArray(value)) {
+    return false
+  }
+  const proto = Object.getPrototypeOf(value)
+  return proto === Object.prototype || proto === null
+}
+
+function cloneValue<T>(value: T): T {
+  if (typeof structuredClone === 'function') {
+    try {
+      return structuredClone(value)
+    }
+    catch {
+      // fall through
+    }
+  }
+  try {
+    return JSON.parse(JSON.stringify(value)) as T
+  }
+  catch {
+    return value
+  }
+}