@tldraw/sync-core 5.2.0-canary.4a316fdfb2bb → 5.2.0-canary.4e00299c3e28

package/src/lib/MicrotaskNotifier.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { vi } from 'vitest'
 import { MicrotaskNotifier } from './MicrotaskNotifier'
 
 // Helper to flush all pending microtasks
@@ -17,239 +17,159 @@ describe('MicrotaskNotifier', () => {
 		consoleErrorSpy.mockRestore()
 	})
 
-	describe('basic functionality', () => {
-		it('calls registered listeners when notified', async () => {
+	describe('deferred delivery (MN1)', () => {
+		it('[MN1] does not call listeners synchronously', () => {
 			const notifier = new MicrotaskNotifier<[string]>()
 			const listener = vi.fn()
 
 			notifier.register(listener)
-			await flushMicrotasks() // Wait for registration
-
 			notifier.notify('hello')
-			await flushMicrotasks() // Wait for notification
 
-			expect(listener).toHaveBeenCalledWith('hello')
-			expect(listener).toHaveBeenCalledTimes(1)
+			expect(listener).not.toHaveBeenCalled()
 		})
 
-		it('calls multiple listeners', async () => {
-			const notifier = new MicrotaskNotifier<[number]>()
+		it('[MN1] delivers the notification arguments to every listener on a microtask', async () => {
+			const notifier = new MicrotaskNotifier<[string, number, boolean]>()
 			const listener1 = vi.fn()
 			const listener2 = vi.fn()
-			const listener3 = vi.fn()
 
 			notifier.register(listener1)
 			notifier.register(listener2)
-			notifier.register(listener3)
-			await flushMicrotasks()
-
-			notifier.notify(42)
-			await flushMicrotasks()
-
-			expect(listener1).toHaveBeenCalledWith(42)
-			expect(listener2).toHaveBeenCalledWith(42)
-			expect(listener3).toHaveBeenCalledWith(42)
-		})
-
-		it('supports multiple arguments', async () => {
-			const notifier = new MicrotaskNotifier<[string, number, boolean]>()
-			const listener = vi.fn()
-
-			notifier.register(listener)
 			await flushMicrotasks()
 
 			notifier.notify('test', 123, true)
 			await flushMicrotasks()
 
-			expect(listener).toHaveBeenCalledWith('test', 123, true)
+			expect(listener1).toHaveBeenCalledExactlyOnceWith('test', 123, true)
+			expect(listener2).toHaveBeenCalledExactlyOnceWith('test', 123, true)
 		})
 
-		it('supports object arguments', async () => {
-			const notifier = new MicrotaskNotifier<[{ id: string; value: number }]>()
-			const listener = vi.fn()
+		it('[MN1] delivers multiple notifications in order', async () => {
+			const notifier = new MicrotaskNotifier<[number]>()
+			const calls: number[] = []
+			const listener = vi.fn((n: number) => calls.push(n))
 
 			notifier.register(listener)
 			await flushMicrotasks()
 
-			const obj = { id: 'abc', value: 100 }
-			notifier.notify(obj)
+			notifier.notify(1)
+			notifier.notify(2)
+			notifier.notify(3)
 			await flushMicrotasks()
 
-			expect(listener).toHaveBeenCalledWith(obj)
+			expect(calls).toEqual([1, 2, 3])
 		})
 
-		it('unsubscribe removes the listener', async () => {
+		it('[MN1] notify with no listeners does not throw', async () => {
 			const notifier = new MicrotaskNotifier<[string]>()
-			const listener = vi.fn()
-
-			const unsubscribe = notifier.register(listener)
-			await flushMicrotasks()
-
-			unsubscribe()
 
-			notifier.notify('should not receive')
+			expect(() => notifier.notify('test')).not.toThrow()
 			await flushMicrotasks()
-
-			expect(listener).not.toHaveBeenCalled()
 		})
 	})
 
-	describe('microtask deferral', () => {
-		it('does not call listeners synchronously', () => {
+	describe('deferred registration (MN2)', () => {
+		it('[MN2] a listener misses notifications issued before register was called', async () => {
 			const notifier = new MicrotaskNotifier<[string]>()
 			const listener = vi.fn()
 
+			notifier.notify('before registration')
 			notifier.register(listener)
-			notifier.notify('hello')
+			await flushMicrotasks()
 
-			// Listener should not be called yet (registration is deferred)
 			expect(listener).not.toHaveBeenCalled()
 		})
 
-		it('defers registration to microtask queue', async () => {
+		it('[MN2] a listener receives notifications issued after register in the same synchronous block', async () => {
 			const notifier = new MicrotaskNotifier<[string]>()
 			const listener = vi.fn()
 
+			// Both register and notify queue microtasks; microtasks run FIFO, so
+			// the add runs first and the notification is delivered
 			notifier.register(listener)
-
-			// Notify immediately - since both register and notify queue microtasks,
-			// and microtasks execute in FIFO order, the add runs first, then notify
 			notifier.notify('same sync block')
 
 			await flushMicrotasks()
 
-			// Listener DOES receive it because microtasks are FIFO ordered:
-			// 1. add listener
-			// 2. notify
-			expect(listener).toHaveBeenCalledWith('same sync block')
+			expect(listener).toHaveBeenCalledExactlyOnceWith('same sync block')
 		})
 
-		it('does not receive notifications that completed before registration was queued', async () => {
+		it('[MN2] registering during a notification defers the new listener to later notifications', async () => {
 			const notifier = new MicrotaskNotifier<[string]>()
-			const listener = vi.fn()
-
-			// Notify first
-			notifier.notify('before registration')
-			await flushMicrotasks() // Notification completes
+			const lateListener = vi.fn()
+			const listener1 = vi.fn(() => {
+				notifier.register(lateListener)
+			})
 
-			// Register after
-			notifier.register(listener)
+			notifier.register(listener1)
 			await flushMicrotasks()
 
-			// Listener should NOT have been called for the earlier notification
-			expect(listener).not.toHaveBeenCalled()
-		})
+			notifier.notify('first')
+			await flushMicrotasks()
 
-		it('notifications after registration completes are received', async () => {
-			const notifier = new MicrotaskNotifier<[string]>()
-			const listener = vi.fn()
+			expect(lateListener).not.toHaveBeenCalled()
 
-			notifier.register(listener)
-			await flushMicrotasks() // Wait for registration
+			await flushMicrotasks() // late registration completes
 
-			notifier.notify('after registration')
+			notifier.notify('second')
 			await flushMicrotasks()
 
-			expect(listener).toHaveBeenCalledWith('after registration')
+			expect(lateListener).toHaveBeenCalledExactlyOnceWith('second')
 		})
 	})
 
-	describe('race conditions and edge cases', () => {
-		it('unsubscribing before add microtask runs prevents registration', async () => {
+	describe('unsubscribing (MN3)', () => {
+		it('[MN3] unsubscribe is synchronous and stops future notifications', async () => {
 			const notifier = new MicrotaskNotifier<[string]>()
 			const listener = vi.fn()
+			const other = vi.fn()
 
 			const unsubscribe = notifier.register(listener)
-			unsubscribe() // Unsubscribe immediately, before add microtask runs
-
+			notifier.register(other)
 			await flushMicrotasks()
 
+			unsubscribe()
 			notifier.notify('should not receive')
 			await flushMicrotasks()
 
 			expect(listener).not.toHaveBeenCalled()
+			// other listeners are unaffected
+			expect(other).toHaveBeenCalledExactlyOnceWith('should not receive')
 		})
 
-		it('double unsubscribe is safe', async () => {
+		it('[MN3] unsubscribing before the add microtask runs prevents the registration entirely', async () => {
 			const notifier = new MicrotaskNotifier<[string]>()
 			const listener = vi.fn()
 
 			const unsubscribe = notifier.register(listener)
-			await flushMicrotasks()
+			unsubscribe() // before the add microtask runs
 
-			// Call unsubscribe multiple times
-			unsubscribe()
-			unsubscribe()
-			unsubscribe()
+			await flushMicrotasks()
 
-			notifier.notify('test')
+			notifier.notify('should not receive')
 			await flushMicrotasks()
 
 			expect(listener).not.toHaveBeenCalled()
 		})
 
-		it('unsubscribing one listener does not affect others', async () => {
+		it('[MN3] double unsubscribe is safe', async () => {
 			const notifier = new MicrotaskNotifier<[string]>()
-			const listener1 = vi.fn()
-			const listener2 = vi.fn()
-			const listener3 = vi.fn()
-
-			const unsub1 = notifier.register(listener1)
-			notifier.register(listener2)
-			notifier.register(listener3)
-			await flushMicrotasks()
-
-			unsub1()
+			const listener = vi.fn()
 
-			notifier.notify('test')
+			const unsubscribe = notifier.register(listener)
 			await flushMicrotasks()
 
-			expect(listener1).not.toHaveBeenCalled()
-			expect(listener2).toHaveBeenCalledWith('test')
-			expect(listener3).toHaveBeenCalledWith('test')
-		})
-
-		it('error in one listener does not prevent others from being called', async () => {
-			const notifier = new MicrotaskNotifier<[string]>()
-			const errorListener = vi.fn(() => {
-				throw new Error('listener error')
-			})
-			const normalListener = vi.fn()
-
-			notifier.register(errorListener)
-			notifier.register(normalListener)
-			await flushMicrotasks()
+			unsubscribe()
+			unsubscribe()
+			unsubscribe()
 
 			notifier.notify('test')
 			await flushMicrotasks()
 
-			expect(errorListener).toHaveBeenCalled()
-			expect(normalListener).toHaveBeenCalled()
-			expect(consoleErrorSpy).toHaveBeenCalledWith(
-				'Error in MicrotaskNotifier listener',
-				expect.any(Error)
-			)
-		})
-
-		it('multiple rapid notifications are all delivered', async () => {
-			const notifier = new MicrotaskNotifier<[number]>()
-			const listener = vi.fn()
-
-			notifier.register(listener)
-			await flushMicrotasks()
-
-			notifier.notify(1)
-			notifier.notify(2)
-			notifier.notify(3)
-			await flushMicrotasks()
-
-			expect(listener).toHaveBeenCalledTimes(3)
-			expect(listener).toHaveBeenNthCalledWith(1, 1)
-			expect(listener).toHaveBeenNthCalledWith(2, 2)
-			expect(listener).toHaveBeenNthCalledWith(3, 3)
+			expect(listener).not.toHaveBeenCalled()
 		})
 
-		it('registering the same function twice creates independent subscriptions', async () => {
+		it('[MN3] registering the same function twice', async () => {
 			const notifier = new MicrotaskNotifier<[string]>()
 			const listener = vi.fn()
 
@@ -260,37 +180,29 @@ describe('MicrotaskNotifier', () => {
 			notifier.notify('test')
 			await flushMicrotasks()
 
-			// Same function registered twice, but Set deduplicates
-			// So it should only be called once
+			// The listener set deduplicates the same function reference, so it is
+			// only called once per notification
 			expect(listener).toHaveBeenCalledTimes(1)
 
-			// Unsubscribing the first should remove it
+			// Unsubscribing via the first registration removes the function for
+			// both registrations
 			unsub1()
 			notifier.notify('test2')
 			await flushMicrotasks()
 
-			// The second registration is the same function, already removed by unsub1
-			// Actually, since it's the same function reference, unsub1 removed it
-			// and unsub2 would try to remove it again (which is a no-op)
 			expect(listener).toHaveBeenCalledTimes(1)
 		})
 
-		it('unsubscribing during notification iteration is safe', async () => {
+		it('[MN3] unsubscribing during notification iteration takes effect for later notifications', async () => {
 			const notifier = new MicrotaskNotifier<[string]>()
-			const results: string[] = []
 			let unsub2: (() => void) | undefined = undefined
 
 			const listener1 = vi.fn(() => {
-				results.push('listener1')
 				// Unsubscribe listener2 while iteration is in progress
 				unsub2?.()
 			})
-			const listener2 = vi.fn(() => {
-				results.push('listener2')
-			})
-			const listener3 = vi.fn(() => {
-				results.push('listener3')
-			})
+			const listener2 = vi.fn()
+			const listener3 = vi.fn()
 
 			notifier.register(listener1)
 			unsub2 = notifier.register(listener2)
@@ -300,14 +212,9 @@ describe('MicrotaskNotifier', () => {
 			notifier.notify('test')
 			await flushMicrotasks()
 
-			// All listeners should have been called because Set iteration
-			// continues over the original snapshot
 			expect(listener1).toHaveBeenCalled()
-			// listener2 might or might not be called depending on iteration order
-			// But listener3 should definitely be called
 			expect(listener3).toHaveBeenCalled()
 
-			// After the notification, listener2 should be unsubscribed
 			listener1.mockClear()
 			listener2.mockClear()
 			listener3.mockClear()
@@ -319,111 +226,29 @@ describe('MicrotaskNotifier', () => {
 			expect(listener2).not.toHaveBeenCalled()
 			expect(listener3).toHaveBeenCalled()
 		})
-
-		it('registering during notification is deferred', async () => {
-			const notifier = new MicrotaskNotifier<[string]>()
-			const lateListener = vi.fn()
-			const results: string[] = []
-
-			const listener1 = vi.fn(() => {
-				results.push('listener1')
-				// Register a new listener during notification
-				notifier.register(lateListener)
-			})
-
-			notifier.register(listener1)
-			await flushMicrotasks()
-
-			notifier.notify('first')
-			await flushMicrotasks()
-
-			// lateListener was registered during notification but deferred
-			expect(lateListener).not.toHaveBeenCalled()
-
-			// Now the late listener should be registered
-			await flushMicrotasks()
-
-			notifier.notify('second')
-			await flushMicrotasks()
-
-			expect(lateListener).toHaveBeenCalledWith('second')
-		})
-
-		it('handles interleaved register/notify/unsubscribe', async () => {
-			const notifier = new MicrotaskNotifier<[number]>()
-			const listener = vi.fn()
-
-			// Register
-			const unsub = notifier.register(listener)
-
-			// Notify in the same sync block - listener will receive this
-			// because microtasks are FIFO (add first, then notify)
-			notifier.notify(1)
-
-			await flushMicrotasks()
-
-			expect(listener).toHaveBeenCalledWith(1)
-			expect(listener).toHaveBeenCalledTimes(1)
-
-			// Notify again after registration
-			notifier.notify(2)
-			await flushMicrotasks()
-
-			expect(listener).toHaveBeenCalledWith(2)
-			expect(listener).toHaveBeenCalledTimes(2)
-
-			// Unsubscribe
-			unsub()
-
-			// Notify after unsubscribe
-			notifier.notify(3)
-			await flushMicrotasks()
-
-			expect(listener).toHaveBeenCalledTimes(2) // No new calls after unsubscribe
-		})
-
-		it('notifications are processed in order', async () => {
-			const notifier = new MicrotaskNotifier<[number]>()
-			const calls: number[] = []
-			const listener = vi.fn((n: number) => calls.push(n))
-
-			notifier.register(listener)
-			await flushMicrotasks()
-
-			notifier.notify(1)
-			notifier.notify(2)
-			notifier.notify(3)
-			await flushMicrotasks()
-
-			expect(calls).toEqual([1, 2, 3])
-		})
 	})
 
-	describe('empty notifier', () => {
-		it('notify with no listeners does not throw', async () => {
+	describe('listener errors (MN4)', () => {
+		it('[MN4] a listener that throws is caught and logged, and remaining listeners still run', async () => {
 			const notifier = new MicrotaskNotifier<[string]>()
+			const errorListener = vi.fn(() => {
+				throw new Error('listener error')
+			})
+			const normalListener = vi.fn()
 
-			expect(() => {
-				notifier.notify('test')
-			}).not.toThrow()
-
+			notifier.register(errorListener)
+			notifier.register(normalListener)
 			await flushMicrotasks()
-		})
-
-		it('notify after all listeners unsubscribed does not throw', async () => {
-			const notifier = new MicrotaskNotifier<[string]>()
-			const listener = vi.fn()
 
-			const unsub = notifier.register(listener)
+			notifier.notify('test')
 			await flushMicrotasks()
 
-			unsub()
-
-			expect(() => {
-				notifier.notify('test')
-			}).not.toThrow()
-
-			await flushMicrotasks()
+			expect(errorListener).toHaveBeenCalled()
+			expect(normalListener).toHaveBeenCalled()
+			expect(consoleErrorSpy).toHaveBeenCalledWith(
+				'Error in MicrotaskNotifier listener',
+				expect.any(Error)
+			)
 		})
 	})
 })

package/src/lib/{NodeSqliteSyncWrapper.test.ts → NodeSqliteWrapper.test.ts}

@@ -2,7 +2,7 @@ import { DatabaseSync } from 'node:sqlite'
 import { beforeEach, describe, expect, it } from 'vitest'
 import { NodeSqliteWrapper } from './NodeSqliteWrapper'
 
-describe('NodeSqliteSyncWrapper', () => {
+describe('NodeSqliteWrapper', () => {
 	let db: DatabaseSync
 	let wrapper: NodeSqliteWrapper
 
@@ -13,7 +13,7 @@ describe('NodeSqliteSyncWrapper', () => {
 	})
 
 	describe('exec', () => {
-		it('executes DDL statements', () => {
+		it('[NW1] executes DDL statements', () => {
 			wrapper.exec('CREATE TABLE another (id INTEGER PRIMARY KEY)')
 			// Verify table exists by inserting
 			wrapper.prepare('INSERT INTO another (id) VALUES (?)').run(1)
@@ -21,7 +21,7 @@ describe('NodeSqliteSyncWrapper', () => {
 			expect(results).toEqual([{ id: 1 }])
 		})
 
-		it('executes multi-statement DDL', () => {
+		it('[NW1] executes multi-statement DDL', () => {
 			wrapper.exec(`
 				CREATE TABLE t1 (id INTEGER PRIMARY KEY);
 				CREATE TABLE t2 (id INTEGER PRIMARY KEY);
@@ -39,7 +39,7 @@ describe('NodeSqliteSyncWrapper', () => {
 
 	describe('prepare', () => {
 		describe('all()', () => {
-			it('returns all results as an array', () => {
+			it('[NW1] returns all results as an array', () => {
 				wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(1, 'alice', 100)
 				wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(2, 'bob', 200)
 
@@ -53,7 +53,7 @@ describe('NodeSqliteSyncWrapper', () => {
 				])
 			})
 
-			it('handles queries with bindings', () => {
+			it('[NW1] handles queries with bindings', () => {
 				wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(1, 'alice', 100)
 				wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(2, 'bob', 200)
 
@@ -64,7 +64,7 @@ describe('NodeSqliteSyncWrapper', () => {
 				expect(results).toEqual([{ name: 'bob' }])
 			})
 
-			it('returns empty array for DML statements', () => {
+			it('[NW1] returns empty array for DML statements', () => {
 				wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(1, 'alice', 100)
 
 				const stmt = wrapper.prepare('UPDATE test SET value = ? WHERE id = ?')
@@ -77,7 +77,7 @@ describe('NodeSqliteSyncWrapper', () => {
 				expect(result).toEqual([{ value: 999 }])
 			})
 
-			it('handles INSERT with RETURNING clause', () => {
+			it('[NW1] handles INSERT with RETURNING clause', () => {
 				const results = wrapper
 					.prepare<{
 						id: number
@@ -92,7 +92,7 @@ describe('NodeSqliteSyncWrapper', () => {
 		})
 
 		describe('iterate()', () => {
-			it('returns results via iteration', () => {
+			it('[NW1] returns results via iteration', () => {
 				wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(1, 'alice', 100)
 				wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(2, 'bob', 200)
 
@@ -110,7 +110,7 @@ describe('NodeSqliteSyncWrapper', () => {
 				])
 			})
 
-			it('handles queries with bindings', () => {
+			it('[NW1] handles queries with bindings', () => {
 				wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(1, 'alice', 100)
 				wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(2, 'bob', 200)
 				wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(3, 'carol', 300)
@@ -127,7 +127,7 @@ describe('NodeSqliteSyncWrapper', () => {
 		})
 
 		describe('run()', () => {
-			it('executes DML without returning results', () => {
+			it('[NW1] executes DML without returning results', () => {
 				wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(1, 'alice', 100)
 
 				// Verify the insert happened
@@ -135,7 +135,7 @@ describe('NodeSqliteSyncWrapper', () => {
 				expect(results).toEqual([{ id: 1 }])
 			})
 
-			it('executes UPDATE', () => {
+			it('[NW1] executes UPDATE', () => {
 				wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(1, 'alice', 100)
 				wrapper.prepare('UPDATE test SET value = ? WHERE id = ?').run(999, 1)
 
@@ -145,7 +145,7 @@ describe('NodeSqliteSyncWrapper', () => {
 				expect(results).toEqual([{ value: 999 }])
 			})
 
-			it('executes DELETE', () => {
+			it('[NW1] executes DELETE', () => {
 				wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(1, 'alice', 100)
 				wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(2, 'bob', 200)
 				wrapper.prepare('DELETE FROM test WHERE id = ?').run(1)
@@ -156,7 +156,7 @@ describe('NodeSqliteSyncWrapper', () => {
 		})
 
 		describe('prepared statement reuse', () => {
-			it('can be reused with different bindings', () => {
+			it('[NW1] can be reused with different bindings', () => {
 				const insert = wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)')
 				insert.run(1, 'alice', 100)
 				insert.run(2, 'bob', 200)
@@ -166,7 +166,7 @@ describe('NodeSqliteSyncWrapper', () => {
 				expect(results).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }])
 			})
 
-			it('iterate can be called multiple times', () => {
+			it('[NW1] iterate can be called multiple times', () => {
 				wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(1, 'alice', 100)
 				wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(2, 'bob', 200)
 
@@ -189,7 +189,7 @@ describe('NodeSqliteSyncWrapper', () => {
 			})
 		})
 
-		it('only executes first statement in multi-statement SQL (node:sqlite limitation)', () => {
+		it('[NW1] only executes first statement in multi-statement SQL (node:sqlite limitation)', () => {
 			// node:sqlite's prepare() silently ignores statements after the first semicolon
 			wrapper.prepare('INSERT INTO test (id) VALUES (1); INSERT INTO test (id) VALUES (2)').run()
 
@@ -198,7 +198,7 @@ describe('NodeSqliteSyncWrapper', () => {
 			expect(results).toEqual([{ id: 1 }])
 		})
 
-		it('handles string with semicolon in value (not multi-statement)', () => {
+		it('[NW1] handles string with semicolon in value (not multi-statement)', () => {
 			wrapper
 				.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)')
 				.run(1, 'hello; world', 100)
@@ -209,7 +209,7 @@ describe('NodeSqliteSyncWrapper', () => {
 	})
 
 	describe('transaction', () => {
-		it('commits on success', () => {
+		it('[NW2] commits on success', () => {
 			wrapper.transaction(() => {
 				wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(1, 'alice', 100)
 				wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(2, 'bob', 200)
@@ -219,7 +219,7 @@ describe('NodeSqliteSyncWrapper', () => {
 			expect(results).toEqual([{ id: 1 }, { id: 2 }])
 		})
 
-		it('rolls back on error', () => {
+		it('[NW2] rolls back on error', () => {
 			expect(() => {
 				wrapper.transaction(() => {
 					wrapper
@@ -233,7 +233,7 @@ describe('NodeSqliteSyncWrapper', () => {
 			expect(results).toEqual([])
 		})
 
-		it('returns the callback result', () => {
+		it('[NW2] returns the callback result', () => {
 			const result = wrapper.transaction(() => {
 				wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(1, 'alice', 100)
 				return 'done'
@@ -242,7 +242,7 @@ describe('NodeSqliteSyncWrapper', () => {
 			expect(result).toBe('done')
 		})
 
-		it('supports nested reads within transaction', () => {
+		it('[NW2] supports nested reads within transaction', () => {
 			wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(1, 'alice', 100)
 
 			const result = wrapper.transaction(() => {
@@ -257,16 +257,20 @@ describe('NodeSqliteSyncWrapper', () => {
 			expect(result).toBe(150)
 		})
 
-		it('re-throws the original error after rollback', () => {
+		it('[NW2] rolls back and rethrows the original error', () => {
 			const customError = new Error('custom error')
 
-			try {
+			expect(() => {
 				wrapper.transaction(() => {
+					wrapper
+						.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)')
+						.run(1, 'alice', 100)
 					throw customError
 				})
-			} catch (e) {
-				expect(e).toBe(customError)
-			}
+			}).toThrow(customError)
+
+			// the write was rolled back
+			expect(wrapper.prepare('SELECT * FROM test').all()).toEqual([])
 		})
 	})
 })