@tldraw/store 3.16.0-internal.a478398270c6 → 3.16.0-next.15f085081fd5

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tldraw/store",
-  "description": "A tiny little drawing app (store).",
-  "version": "3.16.0-internal.a478398270c6",
+  "description": "tldraw infinite canvas SDK (store).",
+  "version": "3.16.0-next.15f085081fd5",
   "author": {
     "name": "tldraw Inc.",
     "email": "hello@tldraw.com"
@@ -17,6 +17,7 @@
   },
   "keywords": [
     "tldraw",
+    "sdk",
     "drawing",
     "app",
     "development",
@@ -31,19 +32,20 @@
     "src"
   ],
   "scripts": {
-    "test-ci": "lazy inherit",
-    "test": "yarn run -T jest",
-    "test-coverage": "lazy inherit",
+    "test-ci": "yarn run -T vitest run --passWithNoTests",
+    "test": "yarn run -T vitest --passWithNoTests",
+    "test-coverage": "yarn run -T vitest run --coverage --passWithNoTests",
     "build": "yarn run -T tsx ../../internal/scripts/build-package.ts",
     "build-api": "yarn run -T tsx ../../internal/scripts/build-api.ts",
     "prepack": "yarn run -T tsx ../../internal/scripts/prepack.ts",
     "postpack": "../../internal/scripts/postpack.sh",
     "pack-tarball": "yarn pack",
-    "lint": "yarn run -T tsx ../../internal/scripts/lint.ts"
+    "lint": "yarn run -T tsx ../../internal/scripts/lint.ts",
+    "context": "yarn run -T tsx ../../internal/scripts/context.ts"
   },
   "dependencies": {
-    "@tldraw/state": "3.16.0-internal.a478398270c6",
-    "@tldraw/utils": "3.16.0-internal.a478398270c6"
+    "@tldraw/state": "3.16.0-next.15f085081fd5",
+    "@tldraw/utils": "3.16.0-next.15f085081fd5"
   },
   "peerDependencies": {
     "react": "^18.2.0 || ^19.0.0"
@@ -51,17 +53,8 @@
   "devDependencies": {
     "@peculiar/webcrypto": "^1.5.0",
     "lazyrepo": "0.0.0-alpha.27",
-    "raf": "^3.4.1"
-  },
-  "jest": {
-    "preset": "../../internal/config/jest/node/jest-preset.js",
-    "setupFiles": [
-      "./setupTests.js",
-      "raf/polyfill"
-    ],
-    "moduleNameMapper": {
-      "^~(.*)": "<rootDir>/src/$1"
-    }
+    "raf": "^3.4.1",
+    "vitest": "^3.2.4"
   },
   "module": "dist-esm/index.mjs",
   "source": "src/index.ts",

package/src/lib/RecordsDiff.ts

@@ -42,15 +42,21 @@ export function isRecordsDiffEmpty<T extends UnknownRecord>(diff: RecordsDiff<T>
  * Squash a collection of diffs into a single diff.
  *
  * @param diffs - An array of diffs to squash.
+ * @param options - An optional object with a `mutateFirstDiff` property. If `mutateFirstDiff` is true, the first diff in the array will be mutated in-place.
  * @returns A single diff that represents the squashed diffs.
  * @public
  */
 export function squashRecordDiffs<T extends UnknownRecord>(
-	diffs: RecordsDiff<T>[]
+	diffs: RecordsDiff<T>[],
+	options?: {
+		mutateFirstDiff?: boolean
+	}
 ): RecordsDiff<T> {
-	const result = { added: {}, removed: {}, updated: {} } as RecordsDiff<T>
+	const result = options?.mutateFirstDiff
+		? diffs[0]
+		: ({ added: {}, removed: {}, updated: {} } as RecordsDiff<T>)
 
-	squashRecordDiffsMutable(result, diffs)
+	squashRecordDiffsMutable(result, options?.mutateFirstDiff ? diffs.slice(1) : diffs)
 	return result
 }
 

package/src/lib/StoreSchema.ts

@@ -107,6 +107,7 @@ export class StoreSchema<R extends UnknownRecord, P = unknown> {
 
 	readonly migrations: Record<string, MigrationSequence> = {}
 	readonly sortedMigrations: readonly Migration[]
+	private readonly migrationCache = new WeakMap<SerializedSchema, Result<Migration[], string>>()
 
 	private constructor(
 		public readonly types: {
@@ -158,10 +159,17 @@ export class StoreSchema<R extends UnknownRecord, P = unknown> {
 		}
 	}
 
-	// TODO: use a weakmap to store the result of this function
 	public getMigrationsSince(persistedSchema: SerializedSchema): Result<Migration[], string> {
+		// Check cache first
+		const cached = this.migrationCache.get(persistedSchema)
+		if (cached) {
+			return cached
+		}
+
 		const upgradeResult = upgradeSchema(persistedSchema)
 		if (!upgradeResult.ok) {
+			// Cache the error result
+			this.migrationCache.set(persistedSchema, upgradeResult)
 			return upgradeResult
 		}
 		const schema = upgradeResult.value
@@ -178,7 +186,10 @@ export class StoreSchema<R extends UnknownRecord, P = unknown> {
 		}
 
 		if (sequenceIdsToInclude.size === 0) {
-			return Result.ok([])
+			const result = Result.ok([])
+			// Cache the empty result
+			this.migrationCache.set(persistedSchema, result)
+			return result
 		}
 
 		const allMigrationsToInclude = new Set<MigrationId>()
@@ -197,7 +208,10 @@ export class StoreSchema<R extends UnknownRecord, P = unknown> {
 			const idx = this.migrations[sequenceId].sequence.findIndex((m) => m.id === theirVersionId)
 			// todo: better error handling
 			if (idx === -1) {
-				return Result.err('Incompatible schema?')
+				const result = Result.err('Incompatible schema?')
+				// Cache the error result
+				this.migrationCache.set(persistedSchema, result)
+				return result
 			}
 			for (const migration of this.migrations[sequenceId].sequence.slice(idx + 1)) {
 				allMigrationsToInclude.add(migration.id)
@@ -205,7 +219,12 @@ export class StoreSchema<R extends UnknownRecord, P = unknown> {
 		}
 
 		// collect any migrations
-		return Result.ok(this.sortedMigrations.filter(({ id }) => allMigrationsToInclude.has(id)))
+		const result = Result.ok(
+			this.sortedMigrations.filter(({ id }) => allMigrationsToInclude.has(id))
+		)
+		// Cache the result
+		this.migrationCache.set(persistedSchema, result)
+		return result
 	}
 
 	migratePersistedRecord(
@@ -263,7 +282,10 @@ export class StoreSchema<R extends UnknownRecord, P = unknown> {
 		return { type: 'success', value: record }
 	}
 
-	migrateStoreSnapshot(snapshot: StoreSnapshot<R>): MigrationResult<SerializedStore<R>> {
+	migrateStoreSnapshot(
+		snapshot: StoreSnapshot<R>,
+		opts?: { mutateInputStore?: boolean }
+	): MigrationResult<SerializedStore<R>> {
 		let { store } = snapshot
 		const migrations = this.getMigrationsSince(snapshot.schema)
 		if (!migrations.ok) {
@@ -276,7 +298,9 @@ export class StoreSchema<R extends UnknownRecord, P = unknown> {
 			return { type: 'success', value: store }
 		}
 
-		store = structuredClone(store)
+		if (!opts?.mutateInputStore) {
+			store = structuredClone(store)
+		}
 
 		try {
 			for (const migration of migrationsToApply) {
@@ -286,13 +310,13 @@ export class StoreSchema<R extends UnknownRecord, P = unknown> {
 						if (!shouldApply) continue
 						const result = migration.up!(record as any)
 						if (result) {
-							store[id as keyof typeof store] = structuredClone(result) as any
+							store[id as keyof typeof store] = result as any
 						}
 					}
 				} else if (migration.scope === 'store') {
 					const result = migration.up!(store)
 					if (result) {
-						store = structuredClone(result) as any
+						store = result as any
 					}
 				} else {
 					exhaustiveSwitchError(migration)

package/src/lib/test/AtomMap.test.ts

@@ -1,4 +1,5 @@
 import { react, transaction } from '@tldraw/state'
+import { vi } from 'vitest'
 import { AtomMap } from '../AtomMap'
 
 describe('AtomMap', () => {
@@ -11,7 +12,7 @@ describe('AtomMap', () => {
 	})
 
 	function testReactor(name: string, fn: () => any) {
-		const cb = jest.fn(fn)
+		const cb = vi.fn(fn)
 		const cleanup = react(name, cb)
 		cleanupFns.push(() => cleanup())
 		return cb

package/src/lib/test/dependsOn.test.ts

@@ -26,7 +26,7 @@ describe('dependsOn', () => {
 				}
 			)
 		}).toThrowErrorMatchingInlineSnapshot(
-			`"Migration 'foo/1' depends on missing migration 'bar/1'"`
+			`[Error: Migration 'foo/1' depends on missing migration 'bar/1']`
 		)
 	})
 
@@ -108,7 +108,7 @@ describe('standalone dependsOn', () => {
 				}
 			)
 		}).toThrowErrorMatchingInlineSnapshot(
-			`"Migration 'foo/1' depends on missing migration 'bar/1'"`
+			`[Error: Migration 'foo/1' depends on missing migration 'bar/1']`
 		)
 	})
 

package/src/lib/test/migrationCaching.test.ts

@@ -0,0 +1,209 @@
+/* eslint-disable @typescript-eslint/no-deprecated */
+import { assert } from '@tldraw/utils'
+import {
+	BaseRecord,
+	Migration,
+	RecordId,
+	createMigrationIds,
+	createMigrationSequence,
+	createRecordType,
+} from '../../'
+import { StoreSchema } from '../StoreSchema'
+
+interface TestRecord extends BaseRecord<'test', RecordId<TestRecord>> {
+	name: string
+	version: number
+}
+
+describe('StoreSchema migration caching', () => {
+	// Create migration IDs
+	const TestVersions = createMigrationIds('com.tldraw.test', {
+		AddVersion: 1,
+		UpdateVersion: 2,
+	})
+
+	// Create a simple schema with migrations
+	const createTestSchema = (version: number) => {
+		const TestRecordType = createRecordType<TestRecord>('test', {
+			scope: 'document',
+		})
+
+		const sequence: Migration[] = []
+
+		if (version > 1) {
+			sequence.push({
+				id: TestVersions.AddVersion,
+				scope: 'record',
+				up: (record: any) => {
+					// Mutate the record in place
+					record.version = 2
+					// Don't return anything
+				},
+				down: (record: any) => {
+					record.version = 1
+					// Don't return anything
+				},
+			})
+		}
+
+		if (version > 2) {
+			sequence.push({
+				id: TestVersions.UpdateVersion,
+				scope: 'record',
+				up: (record: any) => {
+					record.version = 3
+					// Don't return anything
+				},
+				down: (record: any) => {
+					record.version = 2
+					// Don't return anything
+				},
+			})
+		}
+
+		const schema = StoreSchema.create(
+			{
+				test: TestRecordType,
+			},
+			{
+				migrations: [createMigrationSequence({ sequenceId: 'com.tldraw.test', sequence })],
+			}
+		)
+
+		return schema
+	}
+
+	it('should cache migration results and return same array reference', () => {
+		const schema = createTestSchema(3)
+		const oldSchema = schema.serializeEarliestVersion()
+
+		// First call should create the migrations array
+		const migrations1 = schema.getMigrationsSince(oldSchema)
+		assert(migrations1.ok)
+		expect(migrations1.value).toHaveLength(2)
+
+		// Second call should return the same array reference (cached)
+		const migrations2 = schema.getMigrationsSince(oldSchema)
+		assert(migrations2.ok)
+		expect(migrations2.value).toBe(migrations1.value) // Same array reference
+
+		// Third call should also return the same array reference
+		const migrations3 = schema.getMigrationsSince(oldSchema)
+		assert(migrations3.ok)
+		expect(migrations3.value).toBe(migrations1.value)
+	})
+
+	it('should not cache when schema versions are different', () => {
+		const schema = createTestSchema(3)
+		const oldSchema = schema.serializeEarliestVersion()
+
+		// Call with original schema
+		const migrations1 = schema.getMigrationsSince(oldSchema)
+		expect(migrations1.ok).toBe(true)
+		if (!migrations1.ok) throw new Error('Expected migrations1 to be ok')
+
+		// Create a different schema version by using a schema with version 2
+		const schemaV2 = createTestSchema(2)
+		const schemaV2Serialized = schemaV2.serializeEarliestVersion()
+		const migrations2 = schema.getMigrationsSince(schemaV2Serialized)
+		expect(migrations2.ok).toBe(true)
+		if (!migrations2.ok) throw new Error('Expected migrations2 to be ok')
+
+		// Should be different arrays (no cache hit)
+		expect(migrations2.value).not.toBe(migrations1.value)
+	})
+
+	it('should handle mutateInputStore: true with migrators that return void', () => {
+		const schema = createTestSchema(3)
+		const oldSchema = schema.serializeEarliestVersion()
+
+		const store = {
+			test1: {
+				id: 'test1',
+				name: 'Test 1',
+				version: 1,
+				typeName: 'test',
+			},
+			test2: {
+				id: 'test2',
+				name: 'Test 2',
+				version: 1,
+				typeName: 'test',
+			},
+		}
+
+		// Test with mutateInputStore: true
+		const result1 = schema.migrateStoreSnapshot(
+			{ store, schema: oldSchema },
+			{ mutateInputStore: true }
+		)
+
+		assert(result1.type === 'success')
+		expect((result1.value as any).test1.version).toBe(3)
+		expect((result1.value as any).test2.version).toBe(3)
+
+		// The input store should be mutated in place
+		expect(result1.value).toBe(store)
+	})
+
+	it('should handle mutateInputStore: false with migrators that return void', () => {
+		const schema = createTestSchema(3)
+		const oldSchema = schema.serializeEarliestVersion()
+
+		const store = {
+			test1: {
+				id: 'test1',
+				name: 'Test 1',
+				version: 1,
+				typeName: 'test',
+			},
+		}
+
+		// Test with mutateInputStore: false (default)
+		const result = schema.migrateStoreSnapshot({ store, schema: oldSchema })
+
+		assert(result.type === 'success')
+		expect((result.value as any).test1.version).toBe(3)
+
+		// The input store should NOT be mutated
+		expect(store.test1.version).toBe(1)
+	})
+
+	it('should handle empty migration list caching', () => {
+		const schema = createTestSchema(1) // No migrations
+		const oldSchema = schema.serializeEarliestVersion()
+
+		// First call
+		const migrations1 = schema.getMigrationsSince(oldSchema)
+		assert(migrations1.ok)
+
+		expect(migrations1.value).toHaveLength(0)
+
+		// Second call should return same array reference
+		const migrations2 = schema.getMigrationsSince(oldSchema)
+		assert(migrations2.ok)
+		expect(migrations2.value).toBe(migrations1.value)
+		expect(migrations2.value).toHaveLength(0)
+	})
+
+	it('should handle incompatible schema caching', () => {
+		const schema = createTestSchema(3)
+		const incompatibleSchema = {
+			schemaVersion: 1 as const,
+			storeVersion: 1,
+			recordVersions: {
+				test: {
+					version: 999, // Much higher version than what we support
+				},
+			},
+		}
+
+		// First call should fail
+		const migrations1 = schema.getMigrationsSince(incompatibleSchema)
+		expect(migrations1.ok).toBe(false)
+
+		// Second call should also fail (but might be cached)
+		const migrations2 = schema.getMigrationsSince(incompatibleSchema)
+		expect(migrations2.ok).toBe(false)
+	})
+})

package/src/lib/test/recordStore.test.ts

@@ -1,4 +1,5 @@
 import { Computed, react, RESET_VALUE, transact } from '@tldraw/state'
+import { vi } from 'vitest'
 import { BaseRecord, RecordId } from '../BaseRecord'
 import { createMigrationSequence } from '../migrate'
 import { RecordsDiff, reverseRecordsDiff } from '../RecordsDiff'
@@ -206,7 +207,7 @@ describe('Store', () => {
 
 	it('allows adding onAfterChange callbacks that see the final state of the world', () => {
 		/* ADDING */
-		const onAfterCreate = jest.fn((current) => {
+		const onAfterCreate = vi.fn((current) => {
 			expect(current).toEqual(
 				Author.create({ name: 'J.R.R Tolkein', id: Author.createId('tolkein') })
 			)
@@ -218,7 +219,7 @@ describe('Store', () => {
 		expect(onAfterCreate).toHaveBeenCalledTimes(1)
 
 		/* UPDATING */
-		const onAfterChange = jest.fn((prev, current) => {
+		const onAfterChange = vi.fn((prev, current) => {
 			expect(prev.name).toBe('J.R.R Tolkein')
 			expect(current.name).toBe('Butch Cassidy')
 
@@ -231,7 +232,7 @@ describe('Store', () => {
 		expect(onAfterChange).toHaveBeenCalledTimes(1)
 
 		/* REMOVING */
-		const onAfterDelete = jest.fn((prev) => {
+		const onAfterDelete = vi.fn((prev) => {
 			if (prev.typeName === 'author') {
 				expect(prev.name).toBe('Butch Cassidy')
 			}
@@ -309,7 +310,7 @@ describe('Store', () => {
 	})
 
 	it('supports listening for changes to the whole store', async () => {
-		const listener = jest.fn()
+		const listener = vi.fn()
 		store.listen(listener)
 
 		transact(() => {
@@ -336,7 +337,7 @@ describe('Store', () => {
 
 		await new Promise((resolve) => requestAnimationFrame(resolve))
 		expect(listener).toHaveBeenCalledTimes(1)
-		expect(listener.mock.lastCall[0]).toMatchInlineSnapshot(`
+		expect(listener.mock.lastCall?.[0]).toMatchInlineSnapshot(`
 		{
 		  "changes": {
 		    "added": {
@@ -391,7 +392,7 @@ describe('Store', () => {
 		await new Promise((resolve) => requestAnimationFrame(resolve))
 		expect(listener).toHaveBeenCalledTimes(2)
 
-		expect(listener.mock.lastCall[0]).toMatchInlineSnapshot(`
+		expect(listener.mock.lastCall?.[0]).toMatchInlineSnapshot(`
 		{
 		  "changes": {
 		    "added": {},
@@ -444,7 +445,7 @@ describe('Store', () => {
 		await new Promise((resolve) => requestAnimationFrame(resolve))
 		expect(listener).toHaveBeenCalledTimes(3)
 
-		expect(listener.mock.lastCall[0]).toMatchInlineSnapshot(`
+		expect(listener.mock.lastCall?.[0]).toMatchInlineSnapshot(`
 		{
 		  "changes": {
 		    "added": {},
@@ -480,7 +481,7 @@ describe('Store', () => {
 	})
 
 	it('supports filtering history by scope', () => {
-		const listener = jest.fn()
+		const listener = vi.fn()
 		store.listen(listener, {
 			scope: 'session',
 		})
@@ -521,7 +522,7 @@ describe('Store', () => {
 	})
 
 	it('supports filtering history by scope (2)', () => {
-		const listener = jest.fn()
+		const listener = vi.fn()
 		store.listen(listener, {
 			scope: 'document',
 		})
@@ -550,7 +551,7 @@ describe('Store', () => {
 	})
 
 	it('supports filtering history by source', () => {
-		const listener = jest.fn()
+		const listener = vi.fn()
 		store.listen(listener, {
 			source: 'remote',
 		})
@@ -600,7 +601,7 @@ describe('Store', () => {
 	})
 
 	it('supports filtering history by source (user)', () => {
-		const listener = jest.fn()
+		const listener = vi.fn()
 		store.listen(listener, {
 			source: 'user',
 		})
@@ -658,7 +659,7 @@ describe('Store', () => {
 			// @ts-expect-error
 			globalThis.__FORCE_RAF_IN_TESTS__ = true
 			store.put([Author.create({ name: 'J.R.R Tolkein', id: Author.createId('tolkein') })])
-			const firstListener = jest.fn()
+			const firstListener = vi.fn()
 			store.listen(firstListener)
 			expect(firstListener).toHaveBeenCalledTimes(0)
 
@@ -666,7 +667,7 @@ describe('Store', () => {
 
 			expect(firstListener).toHaveBeenCalledTimes(0)
 
-			const secondListener = jest.fn()
+			const secondListener = vi.fn()
 
 			store.listen(secondListener)
 
@@ -707,7 +708,7 @@ describe('Store', () => {
 		const id = Author.createId('tolkein')
 		store.put([Author.create({ name: 'J.R.R Tolkein', id })])
 
-		const listener = jest.fn()
+		const listener = vi.fn()
 		store.listen(listener)
 
 		// Return the exact same value that came in
@@ -717,7 +718,7 @@ describe('Store', () => {
 	})
 
 	it('tells listeners the source of the changes so they can decide if they want to run or not', async () => {
-		const listener = jest.fn()
+		const listener = vi.fn()
 		store.listen(listener)
 
 		store.put([Author.create({ name: 'Jimmy Beans', id: Author.createId('jimmy') })])
@@ -824,7 +825,7 @@ describe('snapshots', () => {
 		expect(() => {
 			// @ts-expect-error
 			store2.loadStoreSnapshot(snapshot1)
-		}).toThrowErrorMatchingInlineSnapshot(`"Missing definition for record type author"`)
+		}).toThrowErrorMatchingInlineSnapshot(`[Error: Missing definition for record type author]`)
 	})
 
 	it('throws errors when loading a snapshot with a different schema', () => {
@@ -839,12 +840,12 @@ describe('snapshots', () => {
 
 		expect(() => {
 			store2.loadStoreSnapshot(snapshot1 as any)
-		}).toThrowErrorMatchingInlineSnapshot(`"Missing definition for record type author"`)
+		}).toThrowErrorMatchingInlineSnapshot(`[Error: Missing definition for record type author]`)
 	})
 
 	it('migrates the snapshot', () => {
 		const snapshot1 = store.getStoreSnapshot()
-		const up = jest.fn((s: any) => {
+		const up = vi.fn((s: any) => {
 			s['book:lotr'].numPages = 42
 		})
 
@@ -969,7 +970,7 @@ describe('diffs', () => {
 	})
 	it('produces diffs from `addHistoryInterceptor`', () => {
 		const diffs: any[] = []
-		const interceptor = jest.fn((diff) => diffs.push(diff))
+		const interceptor = vi.fn((diff) => diffs.push(diff))
 		store.addHistoryInterceptor(interceptor)
 
 		store.put([
@@ -1095,15 +1096,15 @@ describe('callbacks', () => {
 		numPages: 1,
 	})
 
-	let onAfterCreate: jest.Mock
-	let onAfterChange: jest.Mock
-	let onAfterDelete: jest.Mock
+	let onAfterCreate: ReturnType<typeof vi.fn>
+	let onAfterChange: ReturnType<typeof vi.fn>
+	let onAfterDelete: ReturnType<typeof vi.fn>
 
-	let onBeforeCreate: jest.Mock
-	let onBeforeChange: jest.Mock
-	let onBeforeDelete: jest.Mock
+	let onBeforeCreate: ReturnType<typeof vi.fn>
+	let onBeforeChange: ReturnType<typeof vi.fn>
+	let onBeforeDelete: ReturnType<typeof vi.fn>
 
-	let onOperationComplete: jest.Mock
+	let onOperationComplete: ReturnType<typeof vi.fn>
 
 	beforeEach(() => {
 		store = new Store({
@@ -1113,15 +1114,15 @@ describe('callbacks', () => {
 			}),
 		})
 
-		onAfterCreate = jest.fn((record) => callbacks.push({ type: 'create', record }))
-		onAfterChange = jest.fn((from, to) => callbacks.push({ type: 'change', from, to }))
-		onAfterDelete = jest.fn((record) => callbacks.push({ type: 'delete', record }))
+		onAfterCreate = vi.fn((record) => callbacks.push({ type: 'create', record }))
+		onAfterChange = vi.fn((from, to) => callbacks.push({ type: 'change', from, to }))
+		onAfterDelete = vi.fn((record) => callbacks.push({ type: 'delete', record }))
 
-		onBeforeCreate = jest.fn((record) => record)
-		onBeforeChange = jest.fn((_from, to) => to)
-		onBeforeDelete = jest.fn((_record) => {})
+		onBeforeCreate = vi.fn((record) => record)
+		onBeforeChange = vi.fn((_from, to) => to)
+		onBeforeDelete = vi.fn((_record) => {})
 
-		onOperationComplete = jest.fn(() => callbacks.push({ type: 'complete' }))
+		onOperationComplete = vi.fn(() => callbacks.push({ type: 'complete' }))
 		callbacks = []
 
 		store.sideEffects.registerAfterCreateHandler('book', onAfterCreate)
@@ -1161,12 +1162,12 @@ describe('callbacks', () => {
 
 	it('bails out if too many callbacks are fired', () => {
 		let limit = 10
-		onAfterCreate.mockImplementation((record) => {
+		onAfterCreate.mockImplementation((record: any) => {
 			if (record.numPages < limit) {
 				store.put([{ ...record, numPages: record.numPages + 1 }])
 			}
 		})
-		onAfterChange.mockImplementation((from, to) => {
+		onAfterChange.mockImplementation((from: any, to: any) => {
 			if (to.numPages < limit) {
 				store.put([{ ...to, numPages: to.numPages + 1 }])
 			}
@@ -1181,7 +1182,9 @@ describe('callbacks', () => {
 		store.clear()
 		expect(() => {
 			store.put([book2])
-		}).toThrowErrorMatchingInlineSnapshot(`"Maximum store update depth exceeded, bailing out"`)
+		}).toThrowErrorMatchingInlineSnapshot(
+			`[Error: Maximum store update depth exceeded, bailing out]`
+		)
 	})
 
 	it('keeps firing operation complete callbacks until all are cleared', () => {
@@ -1197,7 +1200,7 @@ describe('callbacks', () => {
 
 		store.put([book1])
 
-		onAfterChange.mockImplementation((prev, next) => {
+		onAfterChange.mockImplementation((prev: any, next: any) => {
 			if ([0, 1, 2, 5, 6].includes(step)) {
 				step++
 				store.put([{ ...next, numPages: next.numPages + 1 }])