fix(shared-state): preserve local undo during initial reads

Track updates while the initial snapshot is pending. Restoring the original object after a local edit must not make a stale snapshot current again.

Add an undo regression and retain initial synchronization after unchanged mutations. All required checks and the WebSocket/SSE service-discovery workflows pass.

Author: SaKaNa-Y

packages/devframe/src/client/rpc-shared-state.test.ts

@@ -98,6 +98,35 @@ describe('initial shared-state snapshots', () => {
     expect(setCalls).toHaveLength(1)
   })
 
+  it('keeps a local undo that restores the initial object while the snapshot is pending', async () => {
+    const { host, snapshot, setCalls } = setup()
+    const state = await host.get('k', { initialValue: { count: 0 } })
+    const initialValue = state.value()
+    state.mutate((draft) => {
+      draft.count = 2
+    })
+    state.mutate(() => initialValue)
+    expect(state.value()).toBe(initialValue)
+    expect(setCalls.map(([, value]) => value)).toEqual([{ count: 2 }, { count: 0 }])
+
+    snapshot.resolve({ count: 1 })
+    await snapshot.promise
+    expect(state.value()).toBe(initialValue)
+    expect(setCalls).toHaveLength(2)
+  })
+
+  it('applies the initial snapshot after a mutation that leaves the value unchanged', async () => {
+    const { host, snapshot, setCalls } = setup()
+    const state = await host.get('k', { initialValue: { count: 0 } })
+    state.mutate((draft) => {
+      draft.count = 0
+    })
+    snapshot.resolve({ count: 1 })
+    await snapshot.promise
+    expect(state.value()).toEqual({ count: 1 })
+    expect(setCalls).toEqual([])
+  })
+
   it('forwards a local write triggered by the initial snapshot', async () => {
     const { host, snapshot, setCalls } = setup()
     const state = await host.get('k', { initialValue: { count: 0 } })

packages/devframe/src/client/rpc-shared-state.ts

@@ -100,17 +100,21 @@ export function createRpcSharedStateClientHost(rpc: DevframeRpcClient): RpcShare
           sharedState.set(key, state)
           for (const fn of keyAddedListeners)
             fn(key)
-          const initialState = state.value()
+          let stateUpdated = false
+          const stopTrackingUpdates = state.on('updated', () => {
+            stateUpdated = true
+          })
           const initialSyncId = nanoid()
           rpc.call('devframe:rpc:server-state:get', key)
             .then((serverState) => {
               // A pending read must not replace a newer update or a deleted state.
-              if (serverState !== undefined && sharedState.get(key) === state && state.value() === initialState)
+              if (serverState !== undefined && sharedState.get(key) === state && !stateUpdated)
                 state.mutate(() => mergeWithInitialValue(key, serverState), initialSyncId)
             })
             .catch((error) => {
               console.error('Error getting server state', error)
             })
+            .finally(stopTrackingUpdates)
           stateDisposers.set(key, registerSharedState(key, state, initialSyncId))
           return state
         }