@pyreon/state-tree 0.11.5 → 0.11.6

package/src/tests/edge-cases.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,
@@ -8,12 +8,12 @@ import {
   model,
   onPatch,
   resetAllHooks,
-} from "../index"
+} from '../index'
 
 // ─── Fixtures ─────────────────────────────────────────────────────────────────
 
 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),
@@ -21,7 +21,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),
     replaceProfile: (p: any) => self.profile.set(p),
@@ -42,8 +42,8 @@ const Counter = model({
 
 // ─── 1. Nested model deletion ────────────────────────────────────────────────
 
-describe("nested model deletion", () => {
-  it("replacing a nested child model updates snapshot correctly", () => {
+describe('nested model deletion', () => {
+  it('replacing a nested child model updates snapshot correctly', () => {
     const Child = model({
       state: { value: 0 },
       actions: (self) => ({
@@ -52,7 +52,7 @@ describe("nested model deletion", () => {
     })
 
     const Parent = model({
-      state: { child: Child, label: "parent" },
+      state: { child: Child, label: 'parent' },
       actions: (self) => ({
         replaceChild: (c: any) => self.child.set(c),
         setLabel: (l: string) => self.label.set(l),
@@ -61,12 +61,12 @@ describe("nested model deletion", () => {
 
     const parent = Parent.create({
       child: { value: 10 },
-      label: "original",
+      label: 'original',
     })
 
     expect(getSnapshot(parent)).toEqual({
       child: { value: 10 },
-      label: "original",
+      label: 'original',
     })
 
     // Replace child with a new instance
@@ -76,11 +76,11 @@ describe("nested model deletion", () => {
     // Snapshot should reflect the new child
     expect(getSnapshot(parent)).toEqual({
       child: { value: 99 },
-      label: "original",
+      label: 'original',
     })
   })
 
-  it("nested patches stop propagating after child replacement", () => {
+  it('nested patches stop propagating after child replacement', () => {
     const Child = model({
       state: { x: 0 },
       actions: (self) => ({
@@ -104,20 +104,20 @@ describe("nested model deletion", () => {
     // Mutate old child — should propagate
     oldChild.setX(2)
     expect(patches).toHaveLength(1)
-    expect(patches[0]).toEqual({ op: "replace", path: "/child/x", value: 2 })
+    expect(patches[0]).toEqual({ op: 'replace', path: '/child/x', value: 2 })
 
     // Replace child
     const newChild = Child.create({ x: 50 })
     parent.replaceChild(newChild)
     expect(patches).toHaveLength(2)
-    expect(patches[1]!.path).toBe("/child")
+    expect(patches[1]!.path).toBe('/child')
   })
 })
 
 // ─── 2. Snapshot edge cases ──────────────────────────────────────────────────
 
-describe("snapshot edge cases", () => {
-  it("handles null values in state", () => {
+describe('snapshot edge cases', () => {
+  it('handles null values in state', () => {
     const M = model({
       state: { data: null as string | null },
       actions: (self) => ({
@@ -128,14 +128,14 @@ describe("snapshot edge cases", () => {
     const m = M.create()
     expect(getSnapshot(m)).toEqual({ data: null })
 
-    m.setData("hello")
-    expect(getSnapshot(m)).toEqual({ data: "hello" })
+    m.setData('hello')
+    expect(getSnapshot(m)).toEqual({ data: 'hello' })
 
     m.setData(null)
     expect(getSnapshot(m)).toEqual({ data: null })
   })
 
-  it("handles empty arrays in state", () => {
+  it('handles empty arrays in state', () => {
     const M = model({
       state: { items: [] as number[] },
       actions: (self) => ({
@@ -150,8 +150,8 @@ describe("snapshot edge cases", () => {
     expect(getSnapshot(m)).toEqual({ items: [1, 2, 3] })
   })
 
-  it("handles Date objects in state", () => {
-    const now = new Date("2025-01-01T00:00:00Z")
+  it('handles Date objects in state', () => {
+    const now = new Date('2025-01-01T00:00:00Z')
     const M = model({
       state: { createdAt: now },
     })
@@ -159,23 +159,23 @@ describe("snapshot edge cases", () => {
     const m = M.create()
     const snap = getSnapshot(m)
     expect(snap.createdAt).toBeInstanceOf(Date)
-    expect((snap.createdAt as Date).toISOString()).toBe("2025-01-01T00:00:00.000Z")
+    expect((snap.createdAt as Date).toISOString()).toBe('2025-01-01T00:00:00.000Z')
   })
 
-  it("handles undefined initial values by falling back to defaults", () => {
+  it('handles undefined initial values by falling back to defaults', () => {
     const M = model({
-      state: { x: 10, y: "hello", z: true },
+      state: { x: 10, y: 'hello', z: true },
     })
 
     // Pass undefined for all — should use defaults
     const m = M.create()
-    expect(getSnapshot(m)).toEqual({ x: 10, y: "hello", z: true })
+    expect(getSnapshot(m)).toEqual({ x: 10, y: 'hello', z: true })
   })
 
-  it("handles complex nested objects in state", () => {
+  it('handles complex nested objects in state', () => {
     const M = model({
       state: {
-        config: { theme: "dark", fontSize: 14, plugins: ["a", "b"] },
+        config: { theme: 'dark', fontSize: 14, plugins: ['a', 'b'] },
       },
       actions: (self) => ({
         setConfig: (c: any) => self.config.set(c),
@@ -184,22 +184,22 @@ describe("snapshot edge cases", () => {
 
     const m = M.create()
     expect(getSnapshot(m)).toEqual({
-      config: { theme: "dark", fontSize: 14, plugins: ["a", "b"] },
+      config: { theme: 'dark', fontSize: 14, plugins: ['a', 'b'] },
     })
 
-    m.setConfig({ theme: "light", fontSize: 16, plugins: [] })
+    m.setConfig({ theme: 'light', fontSize: 16, plugins: [] })
     expect(getSnapshot(m)).toEqual({
-      config: { theme: "light", fontSize: 16, plugins: [] },
+      config: { theme: 'light', fontSize: 16, plugins: [] },
     })
   })
 })
 
 // ─── 3. Patch replay ─────────────────────────────────────────────────────────
 
-describe("patch replay", () => {
-  it("replaying recorded patches on a fresh instance reproduces final state", () => {
+describe('patch replay', () => {
+  it('replaying recorded patches on a fresh instance reproduces final state', () => {
     const M = model({
-      state: { a: 0, b: "" },
+      state: { a: 0, b: '' },
       actions: (self) => ({
         setA: (v: number) => self.a.set(v),
         setB: (v: string) => self.b.set(v),
@@ -211,9 +211,9 @@ describe("patch replay", () => {
     onPatch(original, (p) => patches.push({ ...p }))
 
     original.setA(1)
-    original.setB("hello")
+    original.setB('hello')
     original.setA(2)
-    original.setB("world")
+    original.setB('world')
     original.setA(42)
 
     expect(patches).toHaveLength(5)
@@ -224,10 +224,10 @@ describe("patch replay", () => {
 
     expect(getSnapshot(replica)).toEqual(getSnapshot(original))
     expect(replica.a()).toBe(42)
-    expect(replica.b()).toBe("world")
+    expect(replica.b()).toBe('world')
   })
 
-  it("replaying patches preserves intermediate state transitions", () => {
+  it('replaying patches preserves intermediate state transitions', () => {
     const c = Counter.create()
     const patches: Patch[] = []
     onPatch(c, (p) => patches.push({ ...p }))
@@ -248,8 +248,8 @@ describe("patch replay", () => {
 
 // ─── 4. Patch with nested operations ─────────────────────────────────────────
 
-describe("patch with nested operations", () => {
-  it("applies replace on deeply nested model property", () => {
+describe('patch with nested operations', () => {
+  it('applies replace on deeply nested model property', () => {
     const Leaf = model({
       state: { value: 0 },
       actions: (self) => ({
@@ -258,168 +258,168 @@ describe("patch with nested operations", () => {
     })
 
     const Branch = model({
-      state: { leaf: Leaf, tag: "" },
+      state: { leaf: Leaf, tag: '' },
       actions: (self) => ({
         setTag: (t: string) => self.tag.set(t),
       }),
     })
 
     const Root = model({
-      state: { branch: Branch, name: "root" },
+      state: { branch: Branch, name: 'root' },
       actions: (self) => ({
         setName: (n: string) => self.name.set(n),
       }),
     })
 
     const root = Root.create({
-      branch: { leaf: { value: 1 }, tag: "a" },
-      name: "root",
+      branch: { leaf: { value: 1 }, tag: 'a' },
+      name: 'root',
     })
 
     // Apply patch to deeply nested leaf
-    applyPatch(root, { op: "replace", path: "/branch/leaf/value", value: 999 })
+    applyPatch(root, { op: 'replace', path: '/branch/leaf/value', value: 999 })
     expect(root.branch().leaf().value()).toBe(999)
 
     // Apply patch to intermediate level
-    applyPatch(root, { op: "replace", path: "/branch/tag", value: "updated" })
-    expect(root.branch().tag()).toBe("updated")
+    applyPatch(root, { op: 'replace', path: '/branch/tag', value: 'updated' })
+    expect(root.branch().tag()).toBe('updated')
 
     // Apply patch to top level
-    applyPatch(root, { op: "replace", path: "/name", value: "new-root" })
-    expect(root.name()).toBe("new-root")
+    applyPatch(root, { op: 'replace', path: '/name', value: 'new-root' })
+    expect(root.name()).toBe('new-root')
   })
 
-  it("records nested patches with correct paths", () => {
+  it('records nested patches with correct paths', () => {
     const app = App.create({
-      profile: { name: "Alice", bio: "dev" },
-      title: "Test",
+      profile: { name: 'Alice', bio: 'dev' },
+      title: 'Test',
     })
 
     const patches: Patch[] = []
     onPatch(app, (p) => patches.push({ ...p }))
 
-    app.profile().rename("Bob")
-    app.profile().setBio("engineer")
-    app.setTitle("New Title")
+    app.profile().rename('Bob')
+    app.profile().setBio('engineer')
+    app.setTitle('New Title')
 
     expect(patches).toEqual([
-      { op: "replace", path: "/profile/name", value: "Bob" },
-      { op: "replace", path: "/profile/bio", value: "engineer" },
-      { op: "replace", path: "/title", value: "New Title" },
+      { op: 'replace', path: '/profile/name', value: 'Bob' },
+      { op: 'replace', path: '/profile/bio', value: 'engineer' },
+      { op: 'replace', path: '/title', value: 'New Title' },
     ])
   })
 
-  it("replays nested patches on fresh instance", () => {
+  it('replays nested patches on fresh instance', () => {
     const app = App.create({
-      profile: { name: "Alice", bio: "" },
-      title: "v1",
+      profile: { name: 'Alice', bio: '' },
+      title: 'v1',
     })
 
     const patches: Patch[] = []
     onPatch(app, (p) => patches.push({ ...p }))
 
-    app.profile().rename("Carol")
-    app.setTitle("v2")
+    app.profile().rename('Carol')
+    app.setTitle('v2')
 
     const fresh = App.create({
-      profile: { name: "Alice", bio: "" },
-      title: "v1",
+      profile: { name: 'Alice', bio: '' },
+      title: 'v1',
     })
     applyPatch(fresh, patches)
 
-    expect(fresh.profile().name()).toBe("Carol")
-    expect(fresh.title()).toBe("v2")
+    expect(fresh.profile().name()).toBe('Carol')
+    expect(fresh.title()).toBe('v2')
   })
 })
 
 // ─── 5. Middleware error handling ─────────────────────────────────────────────
 
-describe("middleware error handling", () => {
-  it("throwing middleware does not corrupt state", () => {
+describe('middleware error handling', () => {
+  it('throwing middleware does not corrupt state', () => {
     const c = Counter.create({ count: 5 })
 
     addMiddleware(c, (_call, _next) => {
-      throw new Error("middleware boom")
+      throw new Error('middleware boom')
     })
 
-    expect(() => c.inc()).toThrow("middleware boom")
+    expect(() => c.inc()).toThrow('middleware boom')
     // State should remain unchanged since the action never ran
     expect(c.count()).toBe(5)
   })
 
-  it("error in middleware after next() does not undo the action", () => {
+  it('error in middleware after next() does not undo the action', () => {
     const c = Counter.create({ count: 0 })
 
     addMiddleware(c, (call, next) => {
       next(call)
-      throw new Error("post-action error")
+      throw new Error('post-action error')
     })
 
-    expect(() => c.inc()).toThrow("post-action error")
+    expect(() => c.inc()).toThrow('post-action error')
     // The action DID run before the error
     expect(c.count()).toBe(1)
   })
 
-  it("error in one middleware prevents subsequent middlewares from running", () => {
+  it('error in one middleware prevents subsequent middlewares from running', () => {
     const c = Counter.create()
     const log: string[] = []
 
     addMiddleware(c, (_call, _next) => {
-      log.push("first")
-      throw new Error("first fails")
+      log.push('first')
+      throw new Error('first fails')
     })
 
     addMiddleware(c, (call, next) => {
-      log.push("second")
+      log.push('second')
       return next(call)
     })
 
-    expect(() => c.inc()).toThrow("first fails")
+    expect(() => c.inc()).toThrow('first fails')
     // Only the first middleware ran (Koa-style: first wraps second)
-    expect(log).toEqual(["first"])
+    expect(log).toEqual(['first'])
     expect(c.count()).toBe(0)
   })
 })
 
 // ─── 6. Middleware chain order ────────────────────────────────────────────────
 
-describe("middleware chain order", () => {
-  it("middlewares fire in registration order (Koa-style onion)", () => {
+describe('middleware chain order', () => {
+  it('middlewares fire in registration order (Koa-style onion)', () => {
     const c = Counter.create()
     const log: string[] = []
 
     addMiddleware(c, (call, next) => {
-      log.push("A:before")
+      log.push('A:before')
       const result = next(call)
-      log.push("A:after")
+      log.push('A:after')
       return result
     })
 
     addMiddleware(c, (call, next) => {
-      log.push("B:before")
+      log.push('B:before')
       const result = next(call)
-      log.push("B:after")
+      log.push('B:after')
       return result
     })
 
     addMiddleware(c, (call, next) => {
-      log.push("C:before")
+      log.push('C:before')
       const result = next(call)
-      log.push("C:after")
+      log.push('C:after')
       return result
     })
 
     c.inc()
 
-    expect(log).toEqual(["A:before", "B:before", "C:before", "C:after", "B:after", "A:after"])
+    expect(log).toEqual(['A:before', 'B:before', 'C:before', 'C:after', 'B:after', 'A:after'])
   })
 
-  it("middleware can modify action args before passing to next", () => {
+  it('middleware can modify action args before passing to next', () => {
     const c = Counter.create()
 
     addMiddleware(c, (call, next) => {
       // Double the argument to add()
-      if (call.name === "add") {
+      if (call.name === 'add') {
         return next({ ...call, args: [(call.args[0] as number) * 2] })
       }
       return next(call)
@@ -429,9 +429,9 @@ describe("middleware chain order", () => {
     expect(c.count()).toBe(10)
   })
 
-  it("middleware can replace action result", () => {
+  it('middleware can replace action result', () => {
     const M = model({
-      state: { value: "" },
+      state: { value: '' },
       actions: (self) => ({
         getValue: () => {
           return self.value()
@@ -441,28 +441,28 @@ describe("middleware chain order", () => {
     })
 
     const m = M.create()
-    m.setValue("original")
+    m.setValue('original')
 
     addMiddleware(m, (call, next) => {
       const result = next(call)
-      if (call.name === "getValue") {
+      if (call.name === 'getValue') {
         return `intercepted:${result}`
       }
       return result
     })
 
-    expect(m.getValue()).toBe("intercepted:original")
+    expect(m.getValue()).toBe('intercepted:original')
   })
 })
 
 // ─── 7. Hook singleton behavior ──────────────────────────────────────────────
 
-describe("hook singleton behavior", () => {
+describe('hook singleton behavior', () => {
   afterEach(() => resetAllHooks())
 
-  it("asHook returns the same hook function for the same id", () => {
-    const useCounter1 = Counter.asHook("singleton-test")
-    const useCounter2 = Counter.asHook("singleton-test")
+  it('asHook returns the same hook function for the same id', () => {
+    const useCounter1 = Counter.asHook('singleton-test')
+    const useCounter2 = Counter.asHook('singleton-test')
 
     // The hook functions may be different references but the instance they return is the same
     const instance1 = useCounter1()
@@ -470,9 +470,9 @@ describe("hook singleton behavior", () => {
     expect(instance1).toBe(instance2)
   })
 
-  it("mutations via one hook reference are visible via another", () => {
-    const useA = Counter.asHook("shared-hook")
-    const useB = Counter.asHook("shared-hook")
+  it('mutations via one hook reference are visible via another', () => {
+    const useA = Counter.asHook('shared-hook')
+    const useB = Counter.asHook('shared-hook')
 
     useA().inc()
     useA().inc()
@@ -481,18 +481,18 @@ describe("hook singleton behavior", () => {
     expect(useA().doubled()).toBe(4)
   })
 
-  it("different models with same hook id share the same registry entry", () => {
+  it('different models with same hook id share the same registry entry', () => {
     // First model claims the id
-    const useFirst = Counter.asHook("conflict-id")
+    const useFirst = Counter.asHook('conflict-id')
     const instance = useFirst()
 
     // Second model with same id returns the already-created instance (Counter, not Profile)
-    const useSecond = Profile.asHook("conflict-id")
+    const useSecond = Profile.asHook('conflict-id')
     expect(useSecond()).toBe(instance)
   })
 
-  it("resetAllHooks makes subsequent calls create fresh instances", () => {
-    const useC = Counter.asHook("fresh-test")
+  it('resetAllHooks makes subsequent calls create fresh instances', () => {
+    const useC = Counter.asHook('fresh-test')
     const old = useC()
     old.add(100)
 
@@ -506,18 +506,18 @@ describe("hook singleton behavior", () => {
 
 // ─── 8. Model with no actions ────────────────────────────────────────────────
 
-describe("model with no actions", () => {
-  it("creates instance with only state", () => {
+describe('model with no actions', () => {
+  it('creates instance with only state', () => {
     const ReadOnly = model({
-      state: { x: 10, y: "hello" },
+      state: { x: 10, y: 'hello' },
     })
 
     const r = ReadOnly.create()
     expect(r.x()).toBe(10)
-    expect(r.y()).toBe("hello")
+    expect(r.y()).toBe('hello')
   })
 
-  it("supports views without actions", () => {
+  it('supports views without actions', () => {
     const Derived = model({
       state: { a: 3, b: 4 },
       views: (self) => ({
@@ -531,20 +531,20 @@ describe("model with no actions", () => {
     expect(d.product()).toBe(12)
   })
 
-  it("snapshots work on action-less models", () => {
+  it('snapshots work on action-less models', () => {
     const M = model({ state: { val: 42 } })
     const m = M.create({ val: 100 })
     expect(getSnapshot(m)).toEqual({ val: 100 })
   })
 
-  it("applySnapshot works on action-less models", () => {
+  it('applySnapshot works on action-less models', () => {
     const M = model({ state: { val: 0 } })
     const m = M.create()
     applySnapshot(m, { val: 999 })
     expect(m.val()).toBe(999)
   })
 
-  it("onPatch works on action-less models when signals are set directly", () => {
+  it('onPatch works on action-less models when signals are set directly', () => {
     const M = model({ state: { val: 0 } })
     const m = M.create()
     const patches: Patch[] = []
@@ -553,10 +553,10 @@ describe("model with no actions", () => {
     // Set via tracked signal directly
     m.val.set(5)
     expect(patches).toHaveLength(1)
-    expect(patches[0]).toEqual({ op: "replace", path: "/val", value: 5 })
+    expect(patches[0]).toEqual({ op: 'replace', path: '/val', value: 5 })
   })
 
-  it("middleware can be added to action-less models (no-op since no actions)", () => {
+  it('middleware can be added to action-less models (no-op since no actions)', () => {
     const M = model({ state: { val: 0 } })
     const m = M.create()
     const log: string[] = []
@@ -577,32 +577,32 @@ describe("model with no actions", () => {
 
 // ─── 9. applySnapshot with partial data ──────────────────────────────────────
 
-describe("applySnapshot with partial data", () => {
-  it("only updates specified fields, keeps others unchanged", () => {
+describe('applySnapshot with partial data', () => {
+  it('only updates specified fields, keeps others unchanged', () => {
     const M = model({
-      state: { name: "default", age: 0, active: false },
+      state: { name: 'default', age: 0, active: false },
       actions: (self) => ({
         setName: (n: string) => self.name.set(n),
         setAge: (a: number) => self.age.set(a),
       }),
     })
 
-    const m = M.create({ name: "Alice", age: 30, active: true })
+    const m = M.create({ name: 'Alice', age: 30, active: true })
 
     // Only update name
-    applySnapshot(m, { name: "Bob" })
-    expect(m.name()).toBe("Bob")
+    applySnapshot(m, { name: 'Bob' })
+    expect(m.name()).toBe('Bob')
     expect(m.age()).toBe(30)
     expect(m.active()).toBe(true)
 
     // Only update age
     applySnapshot(m, { age: 25 })
-    expect(m.name()).toBe("Bob")
+    expect(m.name()).toBe('Bob')
     expect(m.age()).toBe(25)
     expect(m.active()).toBe(true)
   })
 
-  it("empty snapshot changes nothing", () => {
+  it('empty snapshot changes nothing', () => {
     const M = model({ state: { x: 1, y: 2 } })
     const m = M.create()
 
@@ -611,20 +611,20 @@ describe("applySnapshot with partial data", () => {
     expect(m.y()).toBe(2)
   })
 
-  it("partial nested snapshot updates only specified nested fields", () => {
+  it('partial nested snapshot updates only specified nested fields', () => {
     const app = App.create({
-      profile: { name: "Alice", bio: "dev" },
-      title: "Old",
+      profile: { name: 'Alice', bio: 'dev' },
+      title: 'Old',
     })
 
     // Update only the nested profile name, leave bio unchanged
-    applySnapshot(app, { profile: { name: "Bob" } } as any)
-    expect(app.profile().name()).toBe("Bob")
-    expect(app.profile().bio()).toBe("dev")
-    expect(app.title()).toBe("Old")
+    applySnapshot(app, { profile: { name: 'Bob' } } as any)
+    expect(app.profile().name()).toBe('Bob')
+    expect(app.profile().bio()).toBe('dev')
+    expect(app.title()).toBe('Old')
   })
 
-  it("applySnapshot batches updates — effect fires once", () => {
+  it('applySnapshot batches updates — effect fires once', () => {
     const M = model({ state: { a: 0, b: 0, c: 0 } })
     const m = M.create()
 
@@ -644,8 +644,8 @@ describe("applySnapshot with partial data", () => {
 
 // ─── 10. onPatch listener cleanup ────────────────────────────────────────────
 
-describe("onPatch listener cleanup", () => {
-  it("unsubscribe prevents further callbacks", () => {
+describe('onPatch listener cleanup', () => {
+  it('unsubscribe prevents further callbacks', () => {
     const c = Counter.create()
     const patches: Patch[] = []
     const unsub = onPatch(c, (p) => patches.push(p))
@@ -660,7 +660,7 @@ describe("onPatch listener cleanup", () => {
     expect(patches).toHaveLength(1) // No new patches after unsub
   })
 
-  it("multiple listeners can be independently unsubscribed", () => {
+  it('multiple listeners can be independently unsubscribed', () => {
     const c = Counter.create()
     const logA: Patch[] = []
     const logB: Patch[] = []
@@ -685,7 +685,7 @@ describe("onPatch listener cleanup", () => {
     expect(logB).toHaveLength(2)
   })
 
-  it("double unsubscribe is safe (no-op)", () => {
+  it('double unsubscribe is safe (no-op)', () => {
     const c = Counter.create()
     const unsub = onPatch(c, () => {})
 
@@ -693,7 +693,7 @@ describe("onPatch listener cleanup", () => {
     expect(() => unsub()).not.toThrow()
   })
 
-  it("listener added after unsub receives only new patches", () => {
+  it('listener added after unsub receives only new patches', () => {
     const c = Counter.create()
     const log1: Patch[] = []
     const log2: Patch[] = []