@pyreon/state-tree 0.10.0 → 0.11.0

package/src/tests/model.test.ts

@@ -1,5 +1,5 @@
-import { computed, effect } from '@pyreon/reactivity'
-import type { Patch } from '../index'
+import { computed, effect } from "@pyreon/reactivity"
+import type { Patch } from "../index"
 import {
   addMiddleware,
   applyPatch,
@@ -9,8 +9,8 @@ import {
   onPatch,
   resetAllHooks,
   resetHook,
-} from '../index'
-import { instanceMeta } from '../registry'
+} from "../index"
+import { instanceMeta } from "../registry"
 
 // ─── Fixtures ─────────────────────────────────────────────────────────────────
 
@@ -29,7 +29,7 @@ const Counter = model({
 })
 
 const Profile = model({
-  state: { name: '', bio: '' },
+  state: { name: "", bio: "" },
   actions: (self) => ({
     rename: (n: string) => self.name.set(n),
     setBio: (b: string) => self.bio.set(b),
@@ -37,7 +37,7 @@ const Profile = model({
 })
 
 const App = model({
-  state: { profile: Profile, title: 'My App' },
+  state: { profile: Profile, title: "My App" },
   actions: (self) => ({
     setTitle: (t: string) => self.title.set(t),
   }),
@@ -45,54 +45,54 @@ const App = model({
 
 // ─── State signals ─────────────────────────────────────────────────────────────
 
-describe('state signals', () => {
-  it('create() returns instance with callable signals', () => {
+describe("state signals", () => {
+  it("create() returns instance with callable signals", () => {
     const c = Counter.create()
-    expect(typeof c.count).toBe('function')
+    expect(typeof c.count).toBe("function")
     expect(c.count()).toBe(0)
   })
 
-  it('uses defaults when no initial value supplied', () => {
+  it("uses defaults when no initial value supplied", () => {
     const c = Counter.create()
     expect(c.count()).toBe(0)
   })
 
-  it('overrides defaults with supplied initial values', () => {
+  it("overrides defaults with supplied initial values", () => {
     const c = Counter.create({ count: 42 })
     expect(c.count()).toBe(42)
   })
 
-  it('partial initial — unspecified keys use defaults', () => {
-    const NamedCounter = model({ state: { count: 0, label: 'default' } })
+  it("partial initial — unspecified keys use defaults", () => {
+    const NamedCounter = model({ state: { count: 0, label: "default" } })
     const c = NamedCounter.create({ count: 10 })
     expect(c.count()).toBe(10)
-    expect(c.label()).toBe('default')
+    expect(c.label()).toBe("default")
   })
 })
 
 // ─── Actions ──────────────────────────────────────────────────────────────────
 
-describe('actions', () => {
-  it('actions update state signals', () => {
+describe("actions", () => {
+  it("actions update state signals", () => {
     const c = Counter.create()
     c.inc()
     expect(c.count()).toBe(1)
   })
 
-  it('actions with arguments work correctly', () => {
+  it("actions with arguments work correctly", () => {
     const c = Counter.create()
     c.add(5)
     expect(c.count()).toBe(5)
   })
 
-  it('self closure allows reading current signal values', () => {
+  it("self closure allows reading current signal values", () => {
     const c = Counter.create({ count: 3 })
     c.inc()
     c.inc()
     expect(c.count()).toBe(5)
   })
 
-  it('actions can call other actions via self (Proxy)', () => {
+  it("actions can call other actions via self (Proxy)", () => {
     const M = model({
       state: { x: 0 },
       actions: (self) => ({
@@ -111,20 +111,20 @@ describe('actions', () => {
 
 // ─── Views ────────────────────────────────────────────────────────────────────
 
-describe('views', () => {
-  it('views return computed signals', () => {
+describe("views", () => {
+  it("views return computed signals", () => {
     const c = Counter.create({ count: 5 })
     expect(c.doubled()).toBe(10)
   })
 
-  it('views recompute when state changes', () => {
+  it("views recompute when state changes", () => {
     const c = Counter.create({ count: 3 })
     expect(c.doubled()).toBe(6)
     c.inc()
     expect(c.doubled()).toBe(8)
   })
 
-  it('views are reactive in effects', () => {
+  it("views are reactive in effects", () => {
     const c = Counter.create()
     const observed: boolean[] = []
     effect(() => {
@@ -138,34 +138,34 @@ describe('views', () => {
 
 // ─── asHook ───────────────────────────────────────────────────────────────────
 
-describe('asHook', () => {
+describe("asHook", () => {
   afterEach(() => resetAllHooks())
 
-  it('returns the same instance for the same id', () => {
-    const useC = Counter.asHook('hook-test')
+  it("returns the same instance for the same id", () => {
+    const useC = Counter.asHook("hook-test")
     expect(useC()).toBe(useC())
   })
 
-  it('different ids give independent instances', () => {
-    const useA = Counter.asHook('hook-a')
-    const useB = Counter.asHook('hook-b')
+  it("different ids give independent instances", () => {
+    const useA = Counter.asHook("hook-a")
+    const useB = Counter.asHook("hook-b")
     useA().inc()
     expect(useA().count()).toBe(1)
     expect(useB().count()).toBe(0)
   })
 
-  it('resetHook clears a singleton so next call creates fresh instance', () => {
-    const useC = Counter.asHook('hook-reset')
+  it("resetHook clears a singleton so next call creates fresh instance", () => {
+    const useC = Counter.asHook("hook-reset")
     useC().add(10)
     expect(useC().count()).toBe(10)
 
-    resetHook('hook-reset')
+    resetHook("hook-reset")
     expect(useC().count()).toBe(0)
   })
 
-  it('resetAllHooks clears all singletons', () => {
-    const useA = Counter.asHook('hook-all-a')
-    const useB = Counter.asHook('hook-all-b')
+  it("resetAllHooks clears all singletons", () => {
+    const useA = Counter.asHook("hook-all-a")
+    const useB = Counter.asHook("hook-all-b")
     useA().inc()
     useB().add(5)
 
@@ -174,46 +174,42 @@ describe('asHook', () => {
     expect(useB().count()).toBe(0)
   })
 
-  it('resetHook on non-existent id is a no-op', () => {
-    expect(() => resetHook('no-such-hook')).not.toThrow()
+  it("resetHook on non-existent id is a no-op", () => {
+    expect(() => resetHook("no-such-hook")).not.toThrow()
   })
 })
 
 // ─── Error guards ────────────────────────────────────────────────────────────
 
-describe('error guards', () => {
-  it('onPatch throws for non-model-instance', () => {
+describe("error guards", () => {
+  it("onPatch throws for non-model-instance", () => {
     expect(() =>
       onPatch({} as object, () => {
         /* noop */
       }),
-    ).toThrow('[@pyreon/state-tree]')
+    ).toThrow("[@pyreon/state-tree]")
   })
 
-  it('addMiddleware throws for non-model-instance', () => {
-    expect(() => addMiddleware({} as object, (_c, n) => n(_c))).toThrow(
-      '[@pyreon/state-tree]',
-    )
+  it("addMiddleware throws for non-model-instance", () => {
+    expect(() => addMiddleware({} as object, (_c, n) => n(_c))).toThrow("[@pyreon/state-tree]")
   })
 
-  it('applySnapshot throws for non-model-instance', () => {
-    expect(() => applySnapshot({} as object, {})).toThrow(
-      '[@pyreon/state-tree]',
-    )
+  it("applySnapshot throws for non-model-instance", () => {
+    expect(() => applySnapshot({} as object, {})).toThrow("[@pyreon/state-tree]")
   })
 })
 
 // ─── getSnapshot ──────────────────────────────────────────────────────────────
 
-describe('getSnapshot', () => {
-  it('returns a plain JS object', () => {
+describe("getSnapshot", () => {
+  it("returns a plain JS object", () => {
     const c = Counter.create({ count: 7 })
     const snap = getSnapshot(c)
     expect(snap).toEqual({ count: 7 })
-    expect(typeof snap.count).toBe('number')
+    expect(typeof snap.count).toBe("number")
   })
 
-  it('snapshot reflects current state after mutations', () => {
+  it("snapshot reflects current state after mutations", () => {
     const c = Counter.create()
     c.inc()
     c.inc()
@@ -221,29 +217,29 @@ describe('getSnapshot', () => {
     expect(getSnapshot(c)).toEqual({ count: 3 })
   })
 
-  it('throws for non-model-instance values', () => {
-    expect(() => getSnapshot({} as object)).toThrow('[@pyreon/state-tree]')
+  it("throws for non-model-instance values", () => {
+    expect(() => getSnapshot({} as object)).toThrow("[@pyreon/state-tree]")
   })
 })
 
 // ─── applySnapshot ────────────────────────────────────────────────────────────
 
-describe('applySnapshot', () => {
-  it('restores state from a plain snapshot', () => {
+describe("applySnapshot", () => {
+  it("restores state from a plain snapshot", () => {
     const c = Counter.create({ count: 10 })
     applySnapshot(c, { count: 0 })
     expect(c.count()).toBe(0)
   })
 
-  it('partial snapshot — only specified keys are updated', () => {
-    const NamedCounter = model({ state: { count: 0, label: 'x' } })
-    const c = NamedCounter.create({ count: 5, label: 'hello' })
+  it("partial snapshot — only specified keys are updated", () => {
+    const NamedCounter = model({ state: { count: 0, label: "x" } })
+    const c = NamedCounter.create({ count: 5, label: "hello" })
     applySnapshot(c, { count: 99 })
     expect(c.count()).toBe(99)
-    expect(c.label()).toBe('hello')
+    expect(c.label()).toBe("hello")
   })
 
-  it('batch: effects fire once even for multi-field updates', () => {
+  it("batch: effects fire once even for multi-field updates", () => {
     const M = model({ state: { a: 0, b: 0 } })
     const m = M.create()
     let effectRuns = 0
@@ -262,17 +258,17 @@ describe('applySnapshot', () => {
 
 // ─── onPatch ──────────────────────────────────────────────────────────────────
 
-describe('onPatch', () => {
-  it('fires when a signal is written', () => {
+describe("onPatch", () => {
+  it("fires when a signal is written", () => {
     const c = Counter.create()
     const patches: Patch[] = []
     onPatch(c, (p) => patches.push(p))
     c.inc()
     expect(patches).toHaveLength(1)
-    expect(patches[0]).toEqual({ op: 'replace', path: '/count', value: 1 })
+    expect(patches[0]).toEqual({ op: "replace", path: "/count", value: 1 })
   })
 
-  it('does NOT fire when value is unchanged', () => {
+  it("does NOT fire when value is unchanged", () => {
     const c = Counter.create()
     const patches: Patch[] = []
     onPatch(c, (p) => patches.push(p))
@@ -280,7 +276,7 @@ describe('onPatch', () => {
     expect(patches).toHaveLength(0)
   })
 
-  it('unsub stops patch events', () => {
+  it("unsub stops patch events", () => {
     const c = Counter.create()
     const patches: Patch[] = []
     const unsub = onPatch(c, (p) => patches.push(p))
@@ -289,7 +285,7 @@ describe('onPatch', () => {
     expect(patches).toHaveLength(0)
   })
 
-  it('includes correct value in patch', () => {
+  it("includes correct value in patch", () => {
     const c = Counter.create()
     const values: number[] = []
     onPatch(c, (p) => values.push(p.value as number))
@@ -301,8 +297,8 @@ describe('onPatch', () => {
 
 // ─── addMiddleware ────────────────────────────────────────────────────────────
 
-describe('addMiddleware', () => {
-  it('intercepts action calls', () => {
+describe("addMiddleware", () => {
+  it("intercepts action calls", () => {
     const c = Counter.create()
     const intercepted: string[] = []
     addMiddleware(c, (call, next) => {
@@ -310,17 +306,17 @@ describe('addMiddleware', () => {
       return next(call)
     })
     c.inc()
-    expect(intercepted).toContain('inc')
+    expect(intercepted).toContain("inc")
   })
 
-  it('next() executes the action', () => {
+  it("next() executes the action", () => {
     const c = Counter.create()
     addMiddleware(c, (call, next) => next(call))
     c.add(5)
     expect(c.count()).toBe(5)
   })
 
-  it('middleware can prevent action from running by not calling next', () => {
+  it("middleware can prevent action from running by not calling next", () => {
     const c = Counter.create()
     addMiddleware(c, (_call, _next) => {
       /* block */
@@ -329,25 +325,25 @@ describe('addMiddleware', () => {
     expect(c.count()).toBe(0)
   })
 
-  it('multiple middlewares run in registration order', () => {
+  it("multiple middlewares run in registration order", () => {
     const c = Counter.create()
     const log: string[] = []
     addMiddleware(c, (call, next) => {
-      log.push('A')
+      log.push("A")
       next(call)
       log.push("A'")
     })
     addMiddleware(c, (call, next) => {
-      log.push('B')
+      log.push("B")
       next(call)
       log.push("B'")
     })
     c.inc()
     // Koa-style: A→B→action→B'→A' (inner middleware unwraps first)
-    expect(log).toEqual(['A', 'B', "B'", "A'"])
+    expect(log).toEqual(["A", "B", "B'", "A'"])
   })
 
-  it('unsub removes the middleware', () => {
+  it("unsub removes the middleware", () => {
     const c = Counter.create()
     const log: string[] = []
     const unsub = addMiddleware(c, (call, next) => {
@@ -362,8 +358,8 @@ describe('addMiddleware', () => {
 
 // ─── patch.ts trackedSignal coverage ─────────────────────────────────────────
 
-describe('trackedSignal extra paths', () => {
-  it('subscribe on a state signal works (trackedSignal.subscribe)', () => {
+describe("trackedSignal extra paths", () => {
+  it("subscribe on a state signal works (trackedSignal.subscribe)", () => {
     const c = Counter.create()
     const calls: number[] = []
     const unsub = c.count.subscribe(() => {
@@ -377,13 +373,13 @@ describe('trackedSignal extra paths', () => {
     expect(calls).toHaveLength(1)
   })
 
-  it('update on a state signal uses the updater function (trackedSignal.update)', () => {
+  it("update on a state signal uses the updater function (trackedSignal.update)", () => {
     const c = Counter.create({ count: 5 })
     c.count.update((n: number) => n * 2)
     expect(c.count()).toBe(10)
   })
 
-  it('peek on a state signal reads without tracking (trackedSignal.peek)', () => {
+  it("peek on a state signal reads without tracking (trackedSignal.peek)", () => {
     const c = Counter.create({ count: 42 })
     expect(c.count.peek()).toBe(42)
   })
@@ -391,8 +387,8 @@ describe('trackedSignal extra paths', () => {
 
 // ─── patch.ts snapshotValue coverage ─────────────────────────────────────────
 
-describe('patch snapshotValue', () => {
-  it('emits a snapshot (not a live instance) when setting a nested model signal', () => {
+describe("patch snapshotValue", () => {
+  it("emits a snapshot (not a live instance) when setting a nested model signal", () => {
     // When a nested model instance is set as a value and a patch listener is active,
     // snapshotValue should recursively serialize the nested model.
     const Inner = model({
@@ -403,7 +399,7 @@ describe('patch snapshotValue', () => {
     })
 
     const Outer = model({
-      state: { child: Inner, label: 'hi' },
+      state: { child: Inner, label: "hi" },
       actions: (self) => ({
         replaceChild: (newChild: any) => self.child.set(newChild),
       }),
@@ -418,22 +414,22 @@ describe('patch snapshotValue', () => {
     outer.replaceChild(newInner)
 
     expect(patches).toHaveLength(1)
-    expect(patches[0]!.op).toBe('replace')
-    expect(patches[0]!.path).toBe('/child')
+    expect(patches[0]!.op).toBe("replace")
+    expect(patches[0]!.path).toBe("/child")
     // The value should be a plain snapshot, not the live model instance
     expect(patches[0]!.value).toEqual({ x: 99, y: 42 })
     expect(patches[0]!.value).not.toBe(newInner)
   })
 
-  it('snapshotValue recursively serializes deeply nested model instances', () => {
+  it("snapshotValue recursively serializes deeply nested model instances", () => {
     const Leaf = model({
       state: { val: 0 },
     })
     const Mid = model({
-      state: { leaf: Leaf, tag: 'mid' },
+      state: { leaf: Leaf, tag: "mid" },
     })
     const Root = model({
-      state: { mid: Mid, name: 'root' },
+      state: { mid: Mid, name: "root" },
       actions: (self) => ({
         replaceMid: (m: any) => self.mid.set(m),
       }),
@@ -443,13 +439,13 @@ describe('patch snapshotValue', () => {
     const patches: Patch[] = []
     onPatch(root, (p) => patches.push(p))
 
-    const newMid = Mid.create({ leaf: { val: 77 }, tag: 'new' })
+    const newMid = Mid.create({ leaf: { val: 77 }, tag: "new" })
     root.replaceMid(newMid)
 
-    expect(patches[0]!.value).toEqual({ leaf: { val: 77 }, tag: 'new' })
+    expect(patches[0]!.value).toEqual({ leaf: { val: 77 }, tag: "new" })
   })
 
-  it('snapshotValue returns the object as-is when it has no meta (!meta branch)', () => {
+  it("snapshotValue returns the object as-is when it has no meta (!meta branch)", () => {
     // To trigger the !meta branch in snapshotValue, we need isModelInstance to return true
     // for an object that has no actual meta. We do this by temporarily registering a
     // fake object in instanceMeta, making it pass isModelInstance, then deleting the meta
@@ -476,7 +472,7 @@ describe('patch snapshotValue', () => {
     // but with stateKeys that reference properties that don't exist on the object (!sig branch)
     const fakeInstance = {} as any
     instanceMeta.set(fakeInstance, {
-      stateKeys: ['missing'],
+      stateKeys: ["missing"],
       patchListeners: new Set(),
       middlewares: [],
       emitPatch: () => {
@@ -490,12 +486,12 @@ describe('patch snapshotValue', () => {
     expect(patches[0]!.value).toEqual({})
   })
 
-  it('snapshotValue handles stateKey with nested model value recursively in patches', () => {
+  it("snapshotValue handles stateKey with nested model value recursively in patches", () => {
     // Ensure the recursive path in snapshotValue is covered:
     // when a stateKey's peek() returns a model instance, it recurses.
     const Leaf = model({ state: { v: 1 } })
     const Branch = model({
-      state: { leaf: Leaf, tag: 'a' },
+      state: { leaf: Leaf, tag: "a" },
     })
     const Root = model({
       state: { branch: Branch },
@@ -508,24 +504,24 @@ describe('patch snapshotValue', () => {
     const patches: Patch[] = []
     onPatch(root, (p) => patches.push(p))
 
-    const newBranch = Branch.create({ leaf: { v: 99 }, tag: 'b' })
+    const newBranch = Branch.create({ leaf: { v: 99 }, tag: "b" })
     root.replaceBranch(newBranch)
 
-    expect(patches[0]!.value).toEqual({ leaf: { v: 99 }, tag: 'b' })
+    expect(patches[0]!.value).toEqual({ leaf: { v: 99 }, tag: "b" })
   })
 })
 
 // ─── middleware.ts edge cases ────────────────────────────────────────────────
 
-describe('middleware edge cases', () => {
-  it('action runs directly when middleware array is empty (idx >= length branch)', () => {
+describe("middleware edge cases", () => {
+  it("action runs directly when middleware array is empty (idx >= length branch)", () => {
     const c = Counter.create()
     // No middleware added — dispatch(0, call) hits idx >= meta.middlewares.length immediately
     c.inc()
     expect(c.count()).toBe(1)
   })
 
-  it('skips falsy middleware entries (!mw branch)', () => {
+  it("skips falsy middleware entries (!mw branch)", () => {
     const c = Counter.create()
     // Add a real middleware so the array is non-empty
     addMiddleware(c, (call, next) => next(call))
@@ -537,7 +533,7 @@ describe('middleware edge cases', () => {
     expect(c.count()).toBe(1)
   })
 
-  it('double-unsub is a no-op (indexOf returns -1 branch)', () => {
+  it("double-unsub is a no-op (indexOf returns -1 branch)", () => {
     const c = Counter.create()
     const unsub = addMiddleware(c, (call, next) => next(call))
     unsub()
@@ -548,8 +544,8 @@ describe('middleware edge cases', () => {
 
 // ─── snapshot.ts edge cases ──────────────────────────────────────────────────
 
-describe('snapshot edge cases', () => {
-  it('getSnapshot skips keys whose signal does not exist (!sig branch)', () => {
+describe("snapshot edge cases", () => {
+  it("getSnapshot skips keys whose signal does not exist (!sig branch)", () => {
     // Create an instance then tamper with it to have a missing signal for a state key
     const c = Counter.create({ count: 5 })
     // Delete the signal to simulate the !sig branch
@@ -559,7 +555,7 @@ describe('snapshot edge cases', () => {
     expect(snap).toEqual({})
   })
 
-  it('applySnapshot skips keys not present in the snapshot object', () => {
+  it("applySnapshot skips keys not present in the snapshot object", () => {
     const M = model({ state: { a: 1, b: 2, c: 3 } })
     const m = M.create({ a: 10, b: 20, c: 30 })
     // Only apply 'b' — 'a' and 'c' should remain unchanged
@@ -569,7 +565,7 @@ describe('snapshot edge cases', () => {
     expect(m.c()).toBe(30)
   })
 
-  it('applySnapshot skips keys whose signal does not exist (!sig branch)', () => {
+  it("applySnapshot skips keys whose signal does not exist (!sig branch)", () => {
     const c = Counter.create({ count: 5 })
     // Delete the signal to simulate the !sig branch in applySnapshot
     delete (c as any).count
@@ -580,95 +576,95 @@ describe('snapshot edge cases', () => {
 
 // ─── Nested models ────────────────────────────────────────────────────────────
 
-describe('nested models', () => {
-  it('creates nested instance from snapshot', () => {
+describe("nested models", () => {
+  it("creates nested instance from snapshot", () => {
     const app = App.create({
-      profile: { name: 'Alice', bio: 'dev' },
-      title: 'App',
+      profile: { name: "Alice", bio: "dev" },
+      title: "App",
     })
-    expect(app.profile().name()).toBe('Alice')
+    expect(app.profile().name()).toBe("Alice")
   })
 
-  it('nested instance has its own actions', () => {
+  it("nested instance has its own actions", () => {
     const app = App.create({
-      profile: { name: 'Alice', bio: '' },
-      title: 'App',
+      profile: { name: "Alice", bio: "" },
+      title: "App",
     })
-    app.profile().rename('Bob')
-    expect(app.profile().name()).toBe('Bob')
+    app.profile().rename("Bob")
+    expect(app.profile().name()).toBe("Bob")
   })
 
-  it('nested defaults used when no snapshot provided', () => {
+  it("nested defaults used when no snapshot provided", () => {
     const app = App.create()
-    expect(app.profile().name()).toBe('')
-    expect(app.title()).toBe('My App')
+    expect(app.profile().name()).toBe("")
+    expect(app.title()).toBe("My App")
   })
 
-  it('getSnapshot recursively serializes nested instances', () => {
+  it("getSnapshot recursively serializes nested instances", () => {
     const app = App.create({
-      profile: { name: 'Alice', bio: 'dev' },
-      title: 'Hello',
+      profile: { name: "Alice", bio: "dev" },
+      title: "Hello",
     })
     const snap = getSnapshot(app)
     expect(snap).toEqual({
-      profile: { name: 'Alice', bio: 'dev' },
-      title: 'Hello',
+      profile: { name: "Alice", bio: "dev" },
+      title: "Hello",
     })
   })
 
-  it('onPatch emits nested path for nested state change', () => {
-    const app = App.create({ profile: { name: 'Alice', bio: '' }, title: '' })
+  it("onPatch emits nested path for nested state change", () => {
+    const app = App.create({ profile: { name: "Alice", bio: "" }, title: "" })
     const patches: Patch[] = []
     onPatch(app, (p) => patches.push(p))
-    app.profile().rename('Bob')
+    app.profile().rename("Bob")
     expect(patches).toHaveLength(1)
     expect(patches[0]).toEqual({
-      op: 'replace',
-      path: '/profile/name',
-      value: 'Bob',
+      op: "replace",
+      path: "/profile/name",
+      value: "Bob",
     })
   })
 
-  it('applySnapshot restores nested state', () => {
+  it("applySnapshot restores nested state", () => {
     const app = App.create({
-      profile: { name: 'Alice', bio: '' },
-      title: 'old',
+      profile: { name: "Alice", bio: "" },
+      title: "old",
     })
-    applySnapshot(app, { profile: { name: 'Carol', bio: 'new' }, title: 'new' })
-    expect(app.profile().name()).toBe('Carol')
-    expect(app.title()).toBe('new')
+    applySnapshot(app, { profile: { name: "Carol", bio: "new" }, title: "new" })
+    expect(app.profile().name()).toBe("Carol")
+    expect(app.title()).toBe("new")
   })
 })
 
 // ─── applyPatch ──────────────────────────────────────────────────────────────
 
-describe('applyPatch', () => {
-  it('applies a single replace patch', () => {
+describe("applyPatch", () => {
+  it("applies a single replace patch", () => {
     const c = Counter.create({ count: 0 })
-    applyPatch(c, { op: 'replace', path: '/count', value: 42 })
+    applyPatch(c, { op: "replace", path: "/count", value: 42 })
     expect(c.count()).toBe(42)
   })
 
-  it('applies an array of patches', () => {
+  it("applies an array of patches", () => {
     const c = Counter.create({ count: 0 })
     applyPatch(c, [
-      { op: 'replace', path: '/count', value: 1 },
-      { op: 'replace', path: '/count', value: 2 },
-      { op: 'replace', path: '/count', value: 3 },
+      { op: "replace", path: "/count", value: 1 },
+      { op: "replace", path: "/count", value: 2 },
+      { op: "replace", path: "/count", value: 3 },
     ])
     expect(c.count()).toBe(3)
   })
 
-  it('applies patch to nested model instance', () => {
+  it("applies patch to nested model instance", () => {
     const app = App.create({
-      profile: { name: 'Alice', bio: '' },
-      title: 'old',
+      profile: { name: "Alice", bio: "" },
+      title: "old",
     })
-    applyPatch(app, { op: 'replace', path: '/profile/name', value: 'Bob' })
-    expect(app.profile().name()).toBe('Bob')
+    applyPatch(app, { op: "replace", path: "/profile/name", value: "Bob" })
+    expect(app.profile().name()).toBe("Bob")
   })
 
-  it('roundtrips with onPatch — record and replay', () => {
+  it("roundtrips with onPatch — record and replay", () => {
     const c = Counter.create({ count: 0 })
     const patches: Patch[] = []
     onPatch(c, (p) => patches.push({ ...p }))
@@ -679,9 +675,9 @@ describe('applyPatch', () => {
     expect(c.count()).toBe(12)
     expect(patches).toHaveLength(3)
     // Verify patches contain the final values at each step
-    expect(patches[0]).toEqual({ op: 'replace', path: '/count', value: 1 })
-    expect(patches[1]).toEqual({ op: 'replace', path: '/count', value: 2 })
-    expect(patches[2]).toEqual({ op: 'replace', path: '/count', value: 12 })
+    expect(patches[0]).toEqual({ op: "replace", path: "/count", value: 1 })
+    expect(patches[1]).toEqual({ op: "replace", path: "/count", value: 2 })
+    expect(patches[2]).toEqual({ op: "replace", path: "/count", value: 12 })
 
     // Replay on a fresh instance
     const c2 = Counter.create({ count: 0 })
@@ -689,30 +685,28 @@ describe('applyPatch', () => {
     expect(c2.count()).toBe(12)
   })
 
-  it('throws for non-model instance', () => {
-    expect(() =>
-      applyPatch({}, { op: 'replace', path: '/x', value: 1 }),
-    ).toThrow('not a model instance')
+  it("throws for non-model instance", () => {
+    expect(() => applyPatch({}, { op: "replace", path: "/x", value: 1 })).toThrow(
+      "not a model instance",
+    )
   })
 
-  it('throws for empty path', () => {
+  it("throws for empty path", () => {
     const c = Counter.create({ count: 0 })
-    expect(() => applyPatch(c, { op: 'replace', path: '', value: 1 })).toThrow(
-      'empty path',
-    )
+    expect(() => applyPatch(c, { op: "replace", path: "", value: 1 })).toThrow("empty path")
   })
 
-  it('throws for unknown state key', () => {
+  it("throws for unknown state key", () => {
     const c = Counter.create({ count: 0 })
-    expect(() =>
-      applyPatch(c, { op: 'replace', path: '/nonexistent', value: 1 }),
-    ).toThrow('unknown state key')
+    expect(() => applyPatch(c, { op: "replace", path: "/nonexistent", value: 1 })).toThrow(
+      "unknown state key",
+    )
   })
 
-  it('throws for unsupported op', () => {
+  it("throws for unsupported op", () => {
     const c = Counter.create({ count: 0 })
-    expect(() =>
-      applyPatch(c, { op: 'add' as any, path: '/count', value: 1 }),
-    ).toThrow('unsupported op "add"')
+    expect(() => applyPatch(c, { op: "add" as any, path: "/count", value: 1 })).toThrow(
+      'unsupported op "add"',
+    )
   })
 })