@tldraw/editor 3.16.0-next.df90ce0ff566 → 3.16.0-next.e57e478c23e0

package/src/lib/license/Watermark.tsx

@@ -86,15 +86,15 @@ To remove the watermark, please purchase a license at tldraw.dev.
 
 	.${className} {
 		position: absolute;
-		bottom: var(--space-2);
-		right: var(--space-2);
+		bottom: max(var(--tl-space-2), env(safe-area-inset-bottom));
+		right: max(var(--tl-space-2), env(safe-area-inset-right));
 		width: 96px;
 		height: 32px;
 		display: flex;
 		align-items: center;
 		justify-content: center;
-		z-index: var(--layer-watermark) !important;
-		background-color: color-mix(in srgb, var(--color-background) 62%, transparent);
+		z-index: var(--tl-layer-watermark) !important;
+		background-color: color-mix(in srgb, var(--tl-color-background) 62%, transparent);
 		opacity: 1;
 		border-radius: 5px;
 		pointer-events: all;
@@ -108,7 +108,7 @@ To remove the watermark, please purchase a license at tldraw.dev.
 		height: 32px;
 		pointer-events: all;
 		cursor: inherit;
-		color: var(--color-text);
+		color: var(--tl-color-text);
 		opacity: .38;
 		border: 0;
 		padding: 0;
@@ -116,12 +116,12 @@ To remove the watermark, please purchase a license at tldraw.dev.
 	}
 
 	.${className}[data-debug='true'] {
-		bottom: 46px;
+		bottom: max(46px, env(safe-area-inset-bottom));
 	}
 
 	.${className}[data-mobile='true'] {
 		border-radius: 4px 0px 0px 4px;
-		right: -2px;
+		right: max(-2px, calc(env(safe-area-inset-right) - 2px));
 		width: 8px;
 		height: 48px;
 	}
@@ -137,7 +137,7 @@ To remove the watermark, please purchase a license at tldraw.dev.
 		}
 
 		.${className}:hover {
-			background-color: var(--color-background);
+			background-color: var(--tl-color-background);
 			transition: background-color 0.2s ease-in-out;
 			transition-delay: 0.32s;
 		}

package/src/lib/license/useLicenseManagerState.ts

@@ -1,7 +1,7 @@
 import { useValue } from '@tldraw/state-react'
-import { LicenseManager } from './LicenseManager'
+import { LicenseManager, LicenseState } from './LicenseManager'
 
 /** @internal */
-export function useLicenseManagerState(licenseManager: LicenseManager) {
+export function useLicenseManagerState(licenseManager: LicenseManager): LicenseState {
 	return useValue('watermarkState', () => licenseManager.state.get(), [licenseManager])
 }

package/src/lib/options.ts

@@ -27,6 +27,8 @@ export interface TldrawOptions {
 	readonly multiClickDurationMs: number
 	readonly coarseDragDistanceSquared: number
 	readonly dragDistanceSquared: number
+	readonly uiDragDistanceSquared: number
+	readonly uiCoarseDragDistanceSquared: number
 	readonly defaultSvgPadding: number
 	readonly cameraSlideFriction: number
 	readonly gridSteps: readonly {
@@ -53,6 +55,7 @@ export interface TldrawOptions {
 	readonly flattenImageBoundsPadding: number
 	readonly laserDelayMs: number
 	readonly maxExportDelayMs: number
+	readonly tooltipDelayMs: number
 	/**
 	 * How long should previews created by {@link Editor.createTemporaryAssetPreview} last before
 	 * they expire? Defaults to 3 minutes.
@@ -97,6 +100,10 @@ export const defaultTldrawOptions = {
 	multiClickDurationMs: 200,
 	coarseDragDistanceSquared: 36, // 6 squared
 	dragDistanceSquared: 16, // 4 squared
+	uiDragDistanceSquared: 16, // 4 squared
+	// it's really easy to accidentally drag from the toolbar on mobile, so we use a much larger
+	// threshold than usual here to try and prevent accidental drags.
+	uiCoarseDragDistanceSquared: 625, // 25 squared
 	defaultSvgPadding: 32,
 	cameraSlideFriction: 0.09,
 	gridSteps: [
@@ -124,6 +131,7 @@ export const defaultTldrawOptions = {
 	flattenImageBoundsPadding: 16,
 	laserDelayMs: 1200,
 	maxExportDelayMs: 5000,
+	tooltipDelayMs: 700,
 	temporaryAssetPreviewLifetimeMs: 180000,
 	actionShortcutsLocation: 'swap',
 	createTextOnCanvasDoubleClick: true,

package/src/lib/primitives/Box.test.ts

@@ -510,6 +510,132 @@ describe('Box', () => {
 		})
 	})
 
+	describe('Box.ContainsApproximately', () => {
+		it('returns true when first box exactly contains second', () => {
+			const boxA = new Box(0, 0, 100, 100)
+			const boxB = new Box(10, 10, 50, 50)
+			expect(Box.ContainsApproximately(boxA, boxB)).toBe(true)
+		})
+
+		it('returns false when first box clearly does not contain second', () => {
+			const boxA = new Box(0, 0, 50, 50)
+			const boxB = new Box(10, 10, 100, 100)
+			expect(Box.ContainsApproximately(boxA, boxB)).toBe(false)
+		})
+
+		it('returns true when containment is within default precision tolerance', () => {
+			// Box B extends very slightly outside A (within floating-point precision)
+			const boxA = new Box(0, 0, 100, 100)
+			const boxB = new Box(10, 10, 80, 80)
+			// Move B's max edges just slightly outside A's bounds
+			boxB.w = 90.000000000001 // maxX = 100.000000000001 (slightly beyond 100)
+			boxB.h = 90.000000000001 // maxY = 100.000000000001 (slightly beyond 100)
+
+			expect(Box.ContainsApproximately(boxA, boxB)).toBe(true)
+			expect(Box.Contains(boxA, boxB)).toBe(false) // strict contains would fail
+		})
+
+		it('returns false when containment exceeds default precision tolerance', () => {
+			const boxA = new Box(0, 0, 100, 100)
+			const boxB = new Box(10, 10, 80, 80)
+			// Move B's max edges clearly outside A's bounds
+			boxB.w = 95 // maxX = 105 (clearly beyond 100)
+			boxB.h = 95 // maxY = 105 (clearly beyond 100)
+
+			expect(Box.ContainsApproximately(boxA, boxB)).toBe(false)
+		})
+
+		it('respects custom precision parameter', () => {
+			const boxA = new Box(0, 0, 100, 100)
+			const boxB = new Box(10, 10, 85, 85) // maxX=95, maxY=95
+
+			// With loose precision (10), should contain (95 is within 100-10=90 tolerance)
+			expect(Box.ContainsApproximately(boxA, boxB, 10)).toBe(true)
+
+			// With tight precision (4), should still contain (95 is within 100-4=96)
+			expect(Box.ContainsApproximately(boxA, boxB, 4)).toBe(true)
+
+			// Since 95 < 100, the precision parameter doesn't affect containment here
+			expect(Box.ContainsApproximately(boxA, boxB, 4.9)).toBe(true)
+		})
+
+		it('handles negative coordinates correctly', () => {
+			const boxA = new Box(-50, -50, 100, 100) // bounds: (-50,-50) to (50,50)
+			const boxB = new Box(-40, -40, 79.999999999, 79.999999999) // bounds: (-40,-40) to (39.999999999, 39.999999999)
+
+			expect(Box.ContainsApproximately(boxA, boxB)).toBe(true)
+		})
+
+		it('handles edge case where boxes are identical', () => {
+			const boxA = new Box(10, 20, 100, 200)
+			const boxB = new Box(10, 20, 100, 200)
+
+			expect(Box.ContainsApproximately(boxA, boxB)).toBe(true)
+		})
+
+		it('handles edge case where inner box touches outer box edges', () => {
+			const boxA = new Box(0, 0, 100, 100)
+			const boxB = new Box(0, 0, 100, 100) // exactly the same
+
+			expect(Box.ContainsApproximately(boxA, boxB)).toBe(true)
+
+			// Slightly smaller inner box
+			const boxC = new Box(0.000001, 0.000001, 99.999998, 99.999998)
+			expect(Box.ContainsApproximately(boxA, boxC)).toBe(true)
+		})
+
+		it('handles floating-point precision issues in real-world scenarios', () => {
+			// Simulate common floating-point arithmetic issues
+			const containerBox = new Box(0, 0, 100, 100)
+
+			// Box that should be contained but has floating-point errors
+			const innerBox = new Box(10, 10, 80, 80)
+			// Simulate floating-point arithmetic that results in tiny overruns
+			innerBox.w = 90.00000000000001 // maxX = 100.00000000000001 (tiny overrun)
+			innerBox.h = 90.00000000000001 // maxY = 100.00000000000001 (tiny overrun)
+
+			expect(Box.ContainsApproximately(containerBox, innerBox)).toBe(true)
+			expect(Box.Contains(containerBox, innerBox)).toBe(false) // strict contains fails due to precision
+		})
+
+		it('fails when any edge exceeds tolerance', () => {
+			const boxA = new Box(10, 10, 100, 100) // bounds: (10,10) to (110,110)
+
+			// Test each edge exceeding tolerance
+			const testCases = [
+				{ name: 'left edge', box: new Box(5, 20, 80, 80) }, // minX too small
+				{ name: 'top edge', box: new Box(20, 5, 80, 80) }, // minY too small
+				{ name: 'right edge', box: new Box(20, 20, 95, 80) }, // maxX too large (20+95=115 > 110)
+				{ name: 'bottom edge', box: new Box(20, 20, 80, 95) }, // maxY too large (20+95=115 > 110)
+			]
+
+			testCases.forEach(({ box }) => {
+				expect(Box.ContainsApproximately(boxA, box, 1)).toBe(false) // tight precision
+			})
+		})
+
+		it('works with zero-sized dimensions', () => {
+			const boxA = new Box(0, 0, 100, 100)
+			const boxB = new Box(50, 50, 0, 0) // zero-sized box (point)
+
+			expect(Box.ContainsApproximately(boxA, boxB)).toBe(true)
+		})
+
+		it('handles precision parameter edge cases', () => {
+			const boxA = new Box(0, 0, 100, 100)
+			const boxB = new Box(10, 10, 91, 91) // maxX=101, maxY=101 (clearly outside)
+
+			// Zero precision should work like strict Contains
+			expect(Box.ContainsApproximately(boxA, boxB, 0)).toBe(false)
+
+			// Small precision should still fail (101 > 100)
+			expect(Box.ContainsApproximately(boxA, boxB, 0.5)).toBe(false)
+
+			// Sufficient precision should succeed (101 <= 100 + 2)
+			expect(Box.ContainsApproximately(boxA, boxB, 2)).toBe(true)
+		})
+	})
+
 	describe('Box.Includes', () => {
 		it('returns true when boxes collide or contain', () => {
 			const boxA = new Box(0, 0, 50, 50)

package/src/lib/primitives/Box.ts

@@ -1,6 +1,6 @@
 import { BoxModel } from '@tldraw/tlschema'
 import { Vec, VecLike } from './Vec'
-import { PI, PI2, toPrecision } from './utils'
+import { approximatelyLte, PI, PI2, toPrecision } from './utils'
 
 /** @public */
 export type BoxLike = BoxModel | Box
@@ -417,6 +417,15 @@ export class Box {
 		return A.minX < B.minX && A.minY < B.minY && A.maxY > B.maxY && A.maxX > B.maxX
 	}
 
+	static ContainsApproximately(A: Box, B: Box, precision?: number) {
+		return (
+			approximatelyLte(A.minX, B.minX, precision) &&
+			approximatelyLte(A.minY, B.minY, precision) &&
+			approximatelyLte(B.maxX, A.maxX, precision) &&
+			approximatelyLte(B.maxY, A.maxY, precision)
+		)
+	}
+
 	static Includes(A: Box, B: Box) {
 		return Box.Collides(A, B) || Box.Contains(A, B)
 	}

package/src/lib/primitives/Vec.ts

@@ -240,11 +240,6 @@ export class Vec {
 		return Vec.EqualsXY(this, x, y)
 	}
 
-	/** @deprecated use `uni` instead */
-	norm() {
-		return this.uni()
-	}
-
 	toFixed() {
 		this.x = toFixed(this.x)
 		this.y = toFixed(this.y)

package/src/lib/primitives/geometry/Geometry2d.ts

@@ -9,6 +9,8 @@ import {
 	intersectLineSegmentPolyline,
 	intersectPolys,
 	linesIntersect,
+	polygonIntersectsPolyline,
+	polygonsIntersect,
 } from '../intersect'
 import { approximately, pointInPolygon } from '../utils'
 
@@ -227,25 +229,6 @@ export abstract class Geometry2d {
 		return distanceAlongRoute / length
 	}
 
-	/** @deprecated Iterate the vertices instead. */
-	nearestPointOnLineSegment(A: VecLike, B: VecLike): Vec {
-		const { vertices } = this
-		let nearest: Vec | undefined
-		let dist = Infinity
-		let d: number, p: Vec, q: Vec
-		for (let i = 0; i < vertices.length; i++) {
-			p = vertices[i]
-			q = Vec.NearestPointOnLineSegment(A, B, p, true)
-			d = Vec.Dist2(p, q)
-			if (d < dist) {
-				dist = d
-				nearest = q
-			}
-		}
-		if (!nearest) throw Error('nearest point not found')
-		return nearest
-	}
-
 	isPointInBounds(point: VecLike, margin = 0) {
 		const { bounds } = this
 		return !(
@@ -256,6 +239,53 @@ export abstract class Geometry2d {
 		)
 	}
 
+	overlapsPolygon(_polygon: VecLike[]): boolean {
+		const polygon = _polygon.map((v) => Vec.From(v))
+
+		// Otherwise, check if the geometry itself overlaps the polygon
+		const { vertices, center, isFilled, isEmptyLabel, isClosed } = this
+
+		// We'll do things in order of cheapest to most expensive checks
+
+		// Skip empty labels
+		if (isEmptyLabel) return false
+
+		// If any of the geometry's vertices are inside the polygon, it's inside
+		if (vertices.some((v) => pointInPolygon(v, polygon))) {
+			return true
+		}
+
+		// If the geometry is filled and closed and its center is inside the polygon, it's inside
+		if (isClosed) {
+			if (isFilled) {
+				// If closed and filled, check if the center is inside the polygon
+				if (pointInPolygon(center, polygon)) {
+					return true
+				}
+
+				// ..then, slightly more expensive check, see the geometry covers the entire polygon but not its center
+				if (polygon.every((v) => pointInPolygon(v, vertices))) {
+					return true
+				}
+			}
+
+			// If any the geometry's vertices intersect the edge of the polygon, it's inside.
+			// for example when a rotated rectangle is moved over the corner of a parent rectangle
+			// If the geometry is closed, intersect as a polygon
+			if (polygonsIntersect(polygon, vertices)) {
+				return true
+			}
+		} else {
+			// If the geometry is not closed, intersect as a polyline
+			if (polygonIntersectsPolyline(polygon, vertices)) {
+				return true
+			}
+		}
+
+		// If none of the above checks passed, the geometry is outside the polygon
+		return false
+	}
+
 	transform(transform: MatModel, opts?: TransformedGeometry2dOptions): Geometry2d {
 		return new TransformedGeometry2d(this, transform, opts)
 	}

package/src/lib/primitives/geometry/Group2d.ts

@@ -236,4 +236,8 @@ export class Group2d extends Geometry2d {
 	getSvgPathData(): string {
 		return this.children.map((c, i) => (c.isLabel ? '' : c.getSvgPathData(i === 0))).join(' ')
 	}
+
+	overlapsPolygon(polygon: VecLike[]): boolean {
+		return this.children.some((child) => child.overlapsPolygon(polygon))
+	}
 }

package/src/lib/utils/EditorAtom.ts

@@ -0,0 +1,37 @@
+import { atom, Atom } from '@tldraw/state'
+import { WeakCache } from '@tldraw/utils'
+import { Editor } from '../editor/Editor'
+
+/**
+ * An Atom that is scoped to the lifetime of an Editor.
+ *
+ * This is useful for storing UI state for tldraw applications. Keeping state scoped to an editor
+ * instead of stored in a global atom can prevent issues with state being shared between editors
+ * when navigating between pages, or when multiple editor instances are used on the same page.
+ *
+ * @public
+ */
+export class EditorAtom<T> {
+	private states = new WeakCache<Editor, Atom<T>>()
+
+	constructor(
+		private name: string,
+		private getInitialState: (editor: Editor) => T
+	) {}
+
+	getAtom(editor: Editor): Atom<T> {
+		return this.states.get(editor, () => atom(this.name, this.getInitialState(editor)))
+	}
+
+	get(editor: Editor): T {
+		return this.getAtom(editor).get()
+	}
+
+	update(editor: Editor, update: (state: T) => T): T {
+		return this.getAtom(editor).update(update)
+	}
+
+	set(editor: Editor, state: T): T {
+		return this.getAtom(editor).set(state)
+	}
+}

package/src/lib/utils/reparenting.ts

@@ -2,15 +2,7 @@ import { EMPTY_ARRAY } from '@tldraw/state'
 import { TLGroupShape, TLParentId, TLShape, TLShapeId } from '@tldraw/tlschema'
 import { IndexKey, compact, getIndexAbove, getIndexBetween } from '@tldraw/utils'
 import { Editor } from '../editor/Editor'
-import { Vec } from '../primitives/Vec'
-import { Geometry2d } from '../primitives/geometry/Geometry2d'
-import { Group2d } from '../primitives/geometry/Group2d'
-import {
-	intersectPolygonPolygon,
-	polygonIntersectsPolyline,
-	polygonsIntersect,
-} from '../primitives/intersect'
-import { pointInPolygon } from '../primitives/utils'
+import { intersectPolygonPolygon } from '../primitives/intersect'
 
 /**
  * Reparents shapes that are no longer contained within their parent shapes.
@@ -189,68 +181,10 @@ function getOverlappingShapes<T extends TLShape[] | TLShapeId[]>(
 
 		const geometry = editor.getShapeGeometry(childId)
 
-		return doesGeometryOverlapPolygon(geometry, parentPolygonInShapeShape)
+		return geometry.overlapsPolygon(parentPolygonInShapeShape)
 	})
 }
 
-/**
- * @public
- */
-export function doesGeometryOverlapPolygon(
-	geometry: Geometry2d,
-	parentCornersInShapeSpace: Vec[]
-): boolean {
-	// If the child is a group, check if any of its children overlap the box
-	if (geometry instanceof Group2d) {
-		return geometry.children.some((childGeometry) =>
-			doesGeometryOverlapPolygon(childGeometry, parentCornersInShapeSpace)
-		)
-	}
-
-	// Otherwise, check if the geometry overlaps the box
-	const { vertices, center, isFilled, isEmptyLabel, isClosed } = geometry
-
-	// We'll do things in order of cheapest to most expensive checks
-
-	// Skip empty labels
-	if (isEmptyLabel) return false
-
-	// If any of the shape's vertices are inside the occluder, it's inside
-	if (vertices.some((v) => pointInPolygon(v, parentCornersInShapeSpace))) {
-		return true
-	}
-
-	// If the shape is filled and closed and its center is inside the parent, it's inside
-	if (isClosed) {
-		if (isFilled) {
-			// If closed and filled, check if the center is inside the parent
-			if (pointInPolygon(center, parentCornersInShapeSpace)) {
-				return true
-			}
-
-			// ..then, slightly more expensive check, see the shape covers the entire parent but not its center
-			if (parentCornersInShapeSpace.every((v) => pointInPolygon(v, vertices))) {
-				return true
-			}
-		}
-
-		// If any the shape's vertices intersect the edge of the occluder, it's inside.
-		// for example when a rotated rectangle is moved over the corner of a parent rectangle
-		// If the child shape is closed, intersect as a polygon
-		if (polygonsIntersect(parentCornersInShapeSpace, vertices)) {
-			return true
-		}
-	} else {
-		// if the child shape is not closed, intersect as a polyline
-		if (polygonIntersectsPolyline(parentCornersInShapeSpace, vertices)) {
-			return true
-		}
-	}
-
-	// If none of the above checks passed, the shape is outside the parent
-	return false
-}
-
 /**
  * Get the shapes that will be reparented to new parents when the shapes are dropped.
  *
@@ -354,7 +288,7 @@ export function getDroppedShapesToNewParents(
 				.applyToPoints(parentPagePolygon)
 
 			// If the shape overlaps the parent polygon, reparent it to that parent
-			if (doesGeometryOverlapPolygon(editor.getShapeGeometry(shape), parentPolygonInShapeSpace)) {
+			if (editor.getShapeGeometry(shape).overlapsPolygon(parentPolygonInShapeSpace)) {
 				// Use the util to check if the shape can be reparented to the parent
 				if (
 					!editor.getShapeUtil(parentShape).canReceiveNewChildrenOfType?.(parentShape, shape.type)

package/src/lib/utils/sync/LocalIndexedDb.test.ts

@@ -1,12 +1,13 @@
 import { createTLSchema } from '@tldraw/tlschema'
 import { openDB } from 'idb'
+import { vi } from 'vitest'
 import { hardReset } from './hardReset'
 import { getAllIndexDbNames, LocalIndexedDb } from './LocalIndexedDb'
 
 const schema = createTLSchema({ shapes: {}, bindings: {} })
 describe('LocalIndexedDb', () => {
 	beforeEach(() => {
-		jest.useRealTimers()
+		vi.useRealTimers()
 	})
 	afterEach(async () => {
 		await hardReset({ shouldReload: false })

package/src/lib/utils/sync/TLLocalSyncClient.test.ts

@@ -1,6 +1,6 @@
 import { PageRecordType } from '@tldraw/tlschema'
 import { IndexKey, promiseWithResolve } from '@tldraw/utils'
-import { afterEach } from 'node:test'
+import { Mock, vi } from 'vitest'
 import { createTLStore } from '../../config/createTLStore'
 import { TLLocalSyncClient } from './TLLocalSyncClient'
 import { hardReset } from './hardReset'
@@ -10,20 +10,20 @@ class BroadcastChannelMock {
 	constructor(_name: string) {
 		// noop
 	}
-	postMessage = jest.fn((_msg: any) => {
+	postMessage = vi.fn((_msg: any) => {
 		// noop
 	})
-	close = jest.fn(() => {
+	close = vi.fn(() => {
 		// noop
 	})
 }
 
 function testClient(channel = new BroadcastChannelMock('test')) {
 	const store = createTLStore({ shapeUtils: [], bindingUtils: [] })
-	const onLoad = jest.fn(() => {
+	const onLoad = vi.fn(() => {
 		return
 	})
-	const onLoadError = jest.fn(() => {
+	const onLoadError = vi.fn(() => {
 		return
 	})
 	const client = new TLLocalSyncClient(
@@ -36,26 +36,26 @@ function testClient(channel = new BroadcastChannelMock('test')) {
 		channel
 	)
 
-	client.db.storeSnapshot = jest.fn(() => Promise.resolve())
-	client.db.storeChanges = jest.fn(() => Promise.resolve())
+	client.db.storeSnapshot = vi.fn(() => Promise.resolve())
+	client.db.storeChanges = vi.fn(() => Promise.resolve())
 
 	return {
-		client: client as { db: { storeSnapshot: jest.Mock; storeChanges: jest.Mock } } & typeof client,
+		client: client as { db: { storeSnapshot: Mock; storeChanges: Mock } } & typeof client,
 		store,
 		onLoad,
 		onLoadError,
 		channel,
 		tick: async () => {
-			jest.advanceTimersByTime(500)
+			vi.advanceTimersByTime(500)
 			await Promise.resolve()
 			await client.db.pending()
-			jest.advanceTimersByTime(500)
+			vi.advanceTimersByTime(500)
 			await Promise.resolve()
 		},
 	}
 }
 
-const reloadMock = jest.fn()
+const reloadMock = vi.fn()
 
 beforeAll(() => {
 	Object.defineProperty(window, 'location', {
@@ -65,14 +65,14 @@ beforeAll(() => {
 })
 
 beforeEach(() => {
-	jest.clearAllMocks()
+	vi.clearAllMocks()
 })
 
 afterEach(async () => {
 	await hardReset({ shouldReload: false })
 })
 
-jest.useFakeTimers()
+vi.useFakeTimers()
 
 test('the client connects on instantiation, announcing its schema', async () => {
 	const { channel, tick } = testClient()
@@ -86,7 +86,7 @@ test('the client connects on instantiation, announcing its schema', async () =>
 test('when a client receives an announce with a newer schema version it reloads itself', async () => {
 	const { client, channel, onLoadError, tick } = testClient()
 	await tick()
-	jest.advanceTimersByTime(10000)
+	vi.advanceTimersByTime(10000)
 	expect(reloadMock).not.toHaveBeenCalled()
 	channel.onmessage?.({
 		data: {
@@ -104,7 +104,7 @@ test('when a client receives an announce with a newer schema version it reloads
 test('when a client receives an announce with a newer schema version shortly after loading it does not reload but instead reports a loadError', async () => {
 	const { client, channel, onLoadError, tick } = testClient()
 	await tick()
-	jest.advanceTimersByTime(1000)
+	vi.advanceTimersByTime(1000)
 	expect(reloadMock).not.toHaveBeenCalled()
 	channel.onmessage?.({
 		data: {

package/src/version.ts

@@ -1,9 +1,9 @@
 // This file is automatically generated by internal/scripts/refresh-assets.ts.
 // Do not edit manually. Or do, I'm a comment, not a cop.
 
-export const version = '3.16.0-next.df90ce0ff566'
+export const version = '3.16.0-next.e57e478c23e0'
 export const publishDates = {
 	major: '2024-09-13T14:36:29.063Z',
-	minor: '2025-07-30T14:02:35.815Z',
-	patch: '2025-07-30T14:02:35.815Z',
+	minor: '2025-09-08T07:48:02.447Z',
+	patch: '2025-09-08T07:48:02.447Z',
 }

package/dist-cjs/lib/utils/nearestMultiple.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/lib/utils/nearestMultiple.ts"],
-  "sourcesContent": ["// Euclidean algorithm to find the GCD\nfunction gcd(a: number, b: number): number {\n\treturn b === 0 ? a : gcd(b, a % b)\n}\n\n// Returns the lowest value that the given number can be multiplied by to reach an integer\nexport function nearestMultiple(float: number) {\n\tconst decimal = float.toString().split('.')[1]\n\tif (!decimal) return 1\n\tconst denominator = Math.pow(10, decimal.length)\n\tconst numerator = parseInt(decimal, 10)\n\treturn denominator / gcd(numerator, denominator)\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,SAAS,IAAI,GAAW,GAAmB;AAC1C,SAAO,MAAM,IAAI,IAAI,IAAI,GAAG,IAAI,CAAC;AAClC;AAGO,SAAS,gBAAgB,OAAe;AAC9C,QAAM,UAAU,MAAM,SAAS,EAAE,MAAM,GAAG,EAAE,CAAC;AAC7C,MAAI,CAAC,QAAS,QAAO;AACrB,QAAM,cAAc,KAAK,IAAI,IAAI,QAAQ,MAAM;AAC/C,QAAM,YAAY,SAAS,SAAS,EAAE;AACtC,SAAO,cAAc,IAAI,WAAW,WAAW;AAChD;",
-  "names": []
-}

package/dist-esm/lib/utils/nearestMultiple.mjs

@@ -1,14 +0,0 @@
-function gcd(a, b) {
-  return b === 0 ? a : gcd(b, a % b);
-}
-function nearestMultiple(float) {
-  const decimal = float.toString().split(".")[1];
-  if (!decimal) return 1;
-  const denominator = Math.pow(10, decimal.length);
-  const numerator = parseInt(decimal, 10);
-  return denominator / gcd(numerator, denominator);
-}
-export {
-  nearestMultiple
-};
-//# sourceMappingURL=nearestMultiple.mjs.map

package/dist-esm/lib/utils/nearestMultiple.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/lib/utils/nearestMultiple.ts"],
-  "sourcesContent": ["// Euclidean algorithm to find the GCD\nfunction gcd(a: number, b: number): number {\n\treturn b === 0 ? a : gcd(b, a % b)\n}\n\n// Returns the lowest value that the given number can be multiplied by to reach an integer\nexport function nearestMultiple(float: number) {\n\tconst decimal = float.toString().split('.')[1]\n\tif (!decimal) return 1\n\tconst denominator = Math.pow(10, decimal.length)\n\tconst numerator = parseInt(decimal, 10)\n\treturn denominator / gcd(numerator, denominator)\n}\n"],
-  "mappings": "AACA,SAAS,IAAI,GAAW,GAAmB;AAC1C,SAAO,MAAM,IAAI,IAAI,IAAI,GAAG,IAAI,CAAC;AAClC;AAGO,SAAS,gBAAgB,OAAe;AAC9C,QAAM,UAAU,MAAM,SAAS,EAAE,MAAM,GAAG,EAAE,CAAC;AAC7C,MAAI,CAAC,QAAS,QAAO;AACrB,QAAM,cAAc,KAAK,IAAI,IAAI,QAAQ,MAAM;AAC/C,QAAM,YAAY,SAAS,SAAS,EAAE;AACtC,SAAO,cAAc,IAAI,WAAW,WAAW;AAChD;",
-  "names": []
-}