@tldraw/state 5.5.0-next.f9308d324e1c → 5.5.1

package/src/lib/EffectScheduler.ts

@@ -58,6 +58,10 @@ class __EffectScheduler__<Result> implements EffectScheduler<Result> {
 	/** @internal */
 	private _scheduleCount = 0
 	/** @internal */
+	private _executeDepth = 0
+	/** @internal */
+	private _wasScheduledWhileExecuting = false
+	/** @internal */
 	__debug_ancestor_epochs__: Map<Signal<any, any>, number> | null = null
 
 	/**
@@ -113,7 +117,7 @@ class __EffectScheduler__<Result> implements EffectScheduler<Result> {
 			this._scheduleEffect(this.maybeExecute)
 		} else {
 			// otherwise execute right now!
-			this.execute()
+			this.maybeExecute()
 		}
 	}
 
@@ -122,6 +126,13 @@ class __EffectScheduler__<Result> implements EffectScheduler<Result> {
 	readonly maybeExecute = () => {
 		// bail out if we have been detached before this runs
 		if (!this._isActivelyListening) return
+		// A set inside the running effect flushed synchronously back to this scheduler (only possible
+		// outside the reaction phase, e.g. the first run of `react()`). Running now would open a second
+		// capture frame inside the open one and corrupt `parents`, so re-check after the run instead.
+		if (this._executeDepth > 0) {
+			this._wasScheduledWhileExecuting = true
+			return
+		}
 		this.execute()
 	}
 
@@ -159,6 +170,32 @@ class __EffectScheduler__<Result> implements EffectScheduler<Result> {
 	 * @public
 	 */
 	execute(): Result {
+		// A direct re-entrant `execute()` from inside the effect is unsupported (both runs share one
+		// `parents`); it is left to run so the outer run can at least finish normally.
+		if (this._executeDepth > 0) return this.executeOnce()
+		// a run that threw may have left this set
+		this._wasScheduledWhileExecuting = false
+		let result = this.executeOnce()
+		// If a set inside the run reached this scheduler (see `maybeExecute`), settle it now the way
+		// the reaction phase's cleanup pass would: run again while the parents keep changing.
+		for (let depth = 0; this._wasScheduledWhileExecuting; depth++) {
+			this._wasScheduledWhileExecuting = false
+			if (depth >= 1000) {
+				throw new Error('Reaction update depth limit exceeded')
+			}
+			if (!this._isActivelyListening) break
+			if (!haveParentsChanged(this)) {
+				this.lastReactedEpoch = getGlobalEpoch()
+				break
+			}
+			result = this.executeOnce()
+		}
+		return result
+	}
+
+	private executeOnce(): Result {
+		// A counter rather than a flag: a nested `execute()` must not mark the outer run as finished.
+		this._executeDepth++
 		try {
 			startCapturingParents(this)
 			// Important! We have to make a note of the current epoch before running the effect.
@@ -170,6 +207,7 @@ class __EffectScheduler__<Result> implements EffectScheduler<Result> {
 			return result
 		} finally {
 			stopCapturingParents()
+			this._executeDepth--
 		}
 	}
 }

package/src/lib/__tests__/propagation.test.ts

@@ -76,7 +76,7 @@ describe('setting atoms during the reaction phase (P)', () => {
 		expect(b.get()).toBe(1)
 	})
 
-	it('[P5] throws an error if it gets into a loop', () => {
+	it('[P5][P8] throws an error if it gets into a loop', () => {
 		expect(() => {
 			const a = atom('', 0)
 
@@ -380,3 +380,98 @@ describe('actively-listening computeds stay fresh (C2)', () => {
 		expect(c.get()).toBe(1)
 	})
 })
+
+describe('effects that set atoms outside the reaction phase (P8)', () => {
+	// Regression: a first run happens outside a reaction phase, so a set inside it flushed
+	// synchronously and re-entered execute() for the same scheduler. The nested capture frame then
+	// truncated the parents captured by the outer run — `b` was dropped while `b.children` still
+	// held the effect, so `b.set()` never reached the effect again.
+	it.each([
+		['react()', (fn: () => void) => react('r', fn)],
+		['reactor.start()', (fn: () => void) => reactor('r', fn).start()],
+		[
+			'execute()',
+			(fn: () => void) => {
+				const scheduler = new EffectScheduler('r', fn)
+				scheduler.attach()
+				scheduler.execute()
+			},
+		],
+	])(
+		'[P8] a first run via %s that sets one of its own parents re-runs after it instead of nesting',
+		(_, start) => {
+			const initialized = atom('initialized', false)
+			const b = atom('b', 0)
+			const log: string[] = []
+
+			start(() => {
+				log.push('start')
+				if (!initialized.get()) initialized.set(true)
+				log.push(`b=${b.get()}`)
+				log.push('end')
+			})
+
+			// the set changed a parent read before it, so the effect runs once more, sequentially
+			expect(log).toEqual(['start', 'b=0', 'end', 'start', 'b=0', 'end'])
+
+			b.set(1)
+			expect(log.slice(6)).toEqual(['start', 'b=1', 'end'])
+		}
+	)
+
+	it('[P8][E4] skips the extra run when none of the parents it captured have changed', () => {
+		const a = atom('a', 0)
+		let readsA = true
+		let runs = 0
+
+		const scheduler = new EffectScheduler('r', () => {
+			runs++
+			if (readsA) {
+				a.get()
+			} else {
+				a.set(1)
+			}
+		})
+		scheduler.attach()
+		scheduler.execute()
+
+		// `a` is a parent from the first run, so this run's set schedules the effect. But the run
+		// drops `a` instead of reading it, so by the time it finishes nothing it depends on changed.
+		readsA = false
+		scheduler.execute()
+		expect(scheduler.scheduleCount).toBe(1)
+		expect(runs).toBe(2)
+	})
+
+	it('[P8][E7] does not re-run an effect that was detached during its first run', () => {
+		const a = atom('a', 0)
+		let runs = 0
+
+		const scheduler = new EffectScheduler('r', () => {
+			runs++
+			a.set(a.get() + 1)
+			scheduler.detach()
+		})
+		scheduler.attach()
+		scheduler.execute()
+
+		expect(scheduler.scheduleCount).toBe(1)
+		expect(runs).toBe(1)
+	})
+
+	it('[P8] a first run that throws is not re-entered by its own set', () => {
+		const a = atom('a', 0)
+		let runs = 0
+
+		const scheduler = new EffectScheduler('r', () => {
+			runs++
+			a.set(a.get() + 1)
+			throw new Error('boom')
+		})
+		scheduler.attach()
+
+		expect(() => scheduler.execute()).toThrow('boom')
+		expect(scheduler.scheduleCount).toBe(1)
+		expect(runs).toBe(1)
+	})
+})

package/src/lib/capture.ts

@@ -100,30 +100,31 @@ export function startCapturingParents(child: Child) {
 export function stopCapturingParents() {
 	const frame = inst.stack!
 	inst.stack = frame.below
+	const { child, offset, maybeRemoved } = frame
 
-	if (frame.offset < frame.child.parents.length) {
-		for (let i = frame.offset; i < frame.child.parents.length; i++) {
-			const maybeRemovedParent = frame.child.parents[i]
-			if (!frame.child.parentSet.has(maybeRemovedParent)) {
-				detach(maybeRemovedParent, frame.child)
+	if (offset < child.parents.length) {
+		for (let i = offset; i < child.parents.length; i++) {
+			const maybeRemovedParent = child.parents[i]
+			if (!child.parentSet.has(maybeRemovedParent)) {
+				detach(maybeRemovedParent, child)
 			}
 		}
 
-		frame.child.parents.length = frame.offset
-		frame.child.parentEpochs.length = frame.offset
+		child.parents.length = offset
+		child.parentEpochs.length = offset
 	}
 
-	if (frame.maybeRemoved) {
-		for (let i = 0; i < frame.maybeRemoved.length; i++) {
-			const maybeRemovedParent = frame.maybeRemoved[i]
-			if (!frame.child.parentSet.has(maybeRemovedParent)) {
-				detach(maybeRemovedParent, frame.child)
+	if (maybeRemoved) {
+		for (let i = 0; i < maybeRemoved.length; i++) {
+			const maybeRemovedParent = maybeRemoved[i]
+			if (!child.parentSet.has(maybeRemovedParent)) {
+				detach(maybeRemovedParent, child)
 			}
 		}
 	}
 
-	if (frame.child.__debug_ancestor_epochs__) {
-		captureAncestorEpochs(frame.child, frame.child.__debug_ancestor_epochs__)
+	if (child.__debug_ancestor_epochs__) {
+		captureAncestorEpochs(child, child.__debug_ancestor_epochs__)
 	}
 }
 
@@ -148,36 +149,38 @@ export function stopCapturingParents() {
  * @internal
  */
 export function maybeCaptureParent(p: Signal<any, any>) {
-	if (inst.stack) {
-		// `add` returns false when the parent was already captured this run. In array mode both
-		// `has` and `add` scan with indexOf, so going straight to `add` halves the scans per
-		// captured parent.
-		if (!inst.stack.child.parentSet.add(p)) {
-			return
-		}
+	const stack = inst.stack
+	if (!stack) return
+	const { child } = stack
 
-		if (inst.stack.child.isActivelyListening) {
-			attach(p, inst.stack.child)
-		}
+	// `add` returns false when the parent was already captured this run. In array mode both
+	// `has` and `add` scan with indexOf, so going straight to `add` halves the scans per
+	// captured parent.
+	if (!child.parentSet.add(p)) {
+		return
+	}
 
-		// Parents are recorded in deref order. If the slot at this offset held a different parent
-		// last run, that parent may have moved later in the order or been dropped; only
-		// stopCapturingParents can tell, so remember it for then.
-		if (inst.stack.offset < inst.stack.child.parents.length) {
-			const maybeRemovedParent = inst.stack.child.parents[inst.stack.offset]
-			if (maybeRemovedParent !== p) {
-				if (!inst.stack.maybeRemoved) {
-					inst.stack.maybeRemoved = [maybeRemovedParent]
-				} else {
-					inst.stack.maybeRemoved.push(maybeRemovedParent)
-				}
+	if (child.isActivelyListening) {
+		attach(p, child)
+	}
+
+	// Parents are recorded in deref order. If the slot at this offset held a different parent
+	// last run, that parent may have moved later in the order or been dropped; only
+	// stopCapturingParents can tell, so remember it for then.
+	if (stack.offset < child.parents.length) {
+		const maybeRemovedParent = child.parents[stack.offset]
+		if (maybeRemovedParent !== p) {
+			if (!stack.maybeRemoved) {
+				stack.maybeRemoved = [maybeRemovedParent]
+			} else {
+				stack.maybeRemoved.push(maybeRemovedParent)
 			}
 		}
-
-		inst.stack.child.parents[inst.stack.offset] = p
-		inst.stack.child.parentEpochs[inst.stack.offset] = p.lastChangedEpoch
-		inst.stack.offset++
 	}
+
+	child.parents[stack.offset] = p
+	child.parentEpochs[stack.offset] = p.lastChangedEpoch
+	stack.offset++
 }
 
 /**
@@ -212,13 +215,11 @@ export function whyAmIRunning() {
 function captureAncestorEpochs(child: Child, ancestorEpochs: Map<Signal<any>, number>) {
 	for (let i = 0; i < child.parents.length; i++) {
 		const parent = child.parents[i]
-		const epoch = child.parentEpochs[i]
-		ancestorEpochs.set(parent, epoch)
+		ancestorEpochs.set(parent, child.parentEpochs[i])
 		if (isComputed(parent)) {
 			captureAncestorEpochs(parent as any, ancestorEpochs)
 		}
 	}
-	return ancestorEpochs
 }
 
 type ChangeTree = { [signalName: string]: ChangeTree } | null
@@ -232,9 +233,7 @@ function collectChangedAncestors(
 		if (!ancestorEpochs.has(parent)) {
 			continue
 		}
-		const prevEpoch = ancestorEpochs.get(parent)
-		const currentEpoch = parent.lastChangedEpoch
-		if (currentEpoch !== prevEpoch) {
+		if (parent.lastChangedEpoch !== ancestorEpochs.get(parent)) {
 			if (isComputed(parent)) {
 				changeTree[parent.name] = collectChangedAncestors(parent as any, ancestorEpochs)
 			} else {

package/src/lib/helpers.ts

@@ -75,9 +75,9 @@ export function attach(parent: Signal<any>, child: Child) {
  * @internal
  */
 export function equals(a: any, b: any): boolean {
-	const shallowEquals =
+	return (
 		a === b || Object.is(a, b) || Boolean(a && b && typeof a.equals === 'function' && a.equals(b))
-	return shallowEquals
+	)
 }
 
 /**

package/src/lib/transactions.ts

@@ -17,13 +17,8 @@ class Transaction {
 
 	initialAtomValues = new Map<_Atom, any>()
 
-	// eslint-disable-next-line tldraw/no-setter-getter
-	get isRoot() {
-		return this.parent === null
-	}
-
 	commit() {
-		if (this.isRoot) {
+		if (this.parent === null) {
 			// For root transactions, flush changed atoms
 			flushChanges(this.initialAtomValues.keys())
 			return