@tldraw/state 5.3.2 → 5.4.0-canary.02cd0bd3b597

package/src/lib/Computed.ts

@@ -150,7 +150,7 @@ export interface ComputedOptions<Value, Diff> {
 	/**
 	 * The maximum number of diffs to keep in the history buffer.
 	 *
-	 * If you don't need to compute diffs, or if you will supply diffs manually via {@link Atom.set}, you can leave this as `undefined` and no history buffer will be created.
+	 * If you don't need diffs, leave this as `undefined` and no history buffer will be created. Diffs supplied via {@link withDiff} or {@link ComputedOptions.computeDiff} are only recorded when this is set.
 	 *
 	 * If you expect the value to be part of an active effect subscription all the time, and to not change multiple times inside of a single transaction, you can set this to a relatively low number (e.g. 10).
 	 *
@@ -294,31 +294,43 @@ class __UNSAFE__Computed<Value, Diff = unknown> implements Computed<Value, Diff>
 			const result = this.derive(this.state, this.lastCheckedEpoch)
 			const newState = result instanceof WithDiff ? result.value : result
 			const isUninitialized = this.state === UNINITIALIZED
+			// `derive` may have advanced the epoch, so re-read it here, but only once — the whole
+			// commit below belongs to a single epoch.
+			const epoch = getGlobalEpoch()
 			if (isUninitialized || !this.isEqual(this.state, newState)) {
 				if (this.historyBuffer && !isUninitialized) {
+					// Only `undefined` means "no diff supplied"; `null` can be a legitimate diff.
 					const diff = result instanceof WithDiff ? result.diff : undefined
 					this.historyBuffer.pushEntry(
 						this.lastChangedEpoch,
-						getGlobalEpoch(),
-						diff ??
-							this.computeDiff?.(this.state, newState, this.lastCheckedEpoch, getGlobalEpoch()) ??
-							RESET_VALUE
+						epoch,
+						diff !== undefined
+							? diff
+							: this.computeDiff
+								? this.computeDiff(this.state, newState, this.lastCheckedEpoch, epoch)
+								: RESET_VALUE
 					)
 				}
-				this.lastChangedEpoch = getGlobalEpoch()
+				this.lastChangedEpoch = epoch
 				this.state = newState
 			}
 			this.error = null
-			this.lastCheckedEpoch = getGlobalEpoch()
+			this.lastCheckedEpoch = epoch
 
 			return this.state
 		} catch (e) {
 			// if a derived value throws an error, we reset the state to UNINITIALIZED
-			if (this.state !== UNINITIALIZED) {
+			const epoch = getGlobalEpoch()
+			// Entering the error state (from a value, or from never having computed) is a change;
+			// throwing again while already in it is not. Checking `error` rather than `state` matters
+			// for a first run that throws: `state` is already UNINITIALIZED then, and leaving
+			// `lastChangedEpoch` at GLOBAL_START_EPOCH would keep `isNew` true and re-run `derive` on
+			// every read instead of rethrowing the cached error.
+			if (this.error === null) {
 				this.state = UNINITIALIZED as unknown as Value
-				this.lastChangedEpoch = getGlobalEpoch()
+				this.lastChangedEpoch = epoch
 			}
-			this.lastCheckedEpoch = getGlobalEpoch()
+			this.lastCheckedEpoch = epoch
 			// we also clear the history buffer if an error was thrown
 			if (this.historyBuffer) {
 				this.historyBuffer.clear()
@@ -370,74 +382,23 @@ export const _Computed = singleton('Computed', () => __UNSAFE__Computed)
  */
 export type _Computed = InstanceType<typeof __UNSAFE__Computed>
 
-function computedMethodLegacyDecorator(
-	options: ComputedOptions<any, any> = {},
-	_target: any,
-	key: string,
-	descriptor: PropertyDescriptor
-) {
-	const originalMethod = descriptor.value
-	const derivationKey = Symbol.for('__@tldraw/state__computed__' + key)
-
-	descriptor.value = function (this: any) {
-		let d = this[derivationKey] as Computed<any> | undefined
-
-		if (!d) {
-			d = new _Computed(key, originalMethod!.bind(this) as any, options)
-			Object.defineProperty(this, derivationKey, {
-				enumerable: false,
-				configurable: false,
-				writable: false,
-				value: d,
-			})
-		}
-		return d.get()
-	}
-	descriptor.value[isComputedMethodKey] = true
-
-	return descriptor
-}
-
-function computedGetterLegacyDecorator(
-	options: ComputedOptions<any, any> = {},
-	_target: any,
-	key: string,
-	descriptor: PropertyDescriptor
-) {
-	const originalMethod = descriptor.get
-	const derivationKey = Symbol.for('__@tldraw/state__computed__' + key)
+// Set on every decorated wrapper: the symbol its per-instance computed is stored under.
+const derivationKeyKey = '@@__computedDerivationKey__@@'
 
-	descriptor.get = function (this: any) {
-		let d = this[derivationKey] as Computed<any> | undefined
-
-		if (!d) {
-			d = new _Computed(key, originalMethod!.bind(this) as any, options)
-			Object.defineProperty(this, derivationKey, {
-				enumerable: false,
-				configurable: false,
-				writable: false,
-				value: d,
-			})
-		}
-		return d.get()
-	}
-
-	return descriptor
-}
-
-function computedMethodTc39Decorator<This extends object, Value>(
-	options: ComputedOptions<Value, any>,
-	compute: () => Value,
-	context: ClassMethodDecoratorContext<This, () => Value>
-) {
-	assert(context.kind === 'method', '@computed can only be used on methods')
-	const derivationKey = Symbol.for('__@tldraw/state__computed__' + String(context.name))
+/**
+ * Builds the method (or getter) body that `@computed` installs: a per-instance, lazily-created
+ * computed over the original method. The storage symbol is unique per decoration rather than
+ * `Symbol.for(name)` so that a subclass which overrides a `@computed` method and calls
+ * `super.method()` reaches the superclass's computed instead of re-entering its own.
+ */
+function makeComputedWrapper(name: string, compute: () => any, options: ComputedOptions<any, any>) {
+	const derivationKey = Symbol('__@tldraw/state__computed__' + name)
 
-	const fn = function (this: any) {
+	const wrapper = function (this: any) {
 		let d = this[derivationKey] as Computed<any> | undefined
 
 		if (!d) {
-			d = new _Computed(String(context.name), compute.bind(this) as any, options)
+			d = new _Computed(name, compute.bind(this) as any, options)
 			Object.defineProperty(this, derivationKey, {
 				enumerable: false,
 				configurable: false,
@@ -446,9 +407,9 @@ function computedMethodTc39Decorator<This extends object, Value>(
 			})
 		}
 		return d.get()
-	}
-	fn[isComputedMethodKey] = true
-	return fn
+	} as any
+	wrapper[derivationKeyKey] = derivationKey
+	return wrapper
 }
 
 function computedDecorator(
@@ -459,20 +420,20 @@ function computedDecorator(
 ) {
 	if (args.length === 2) {
 		const [originalMethod, context] = args
-		return computedMethodTc39Decorator(options, originalMethod, context)
+		assert(context.kind === 'method', '@computed can only be used on methods')
+		return makeComputedWrapper(String(context.name), originalMethod, options)
 	} else {
 		const [_target, key, descriptor] = args
 		if (descriptor.get) {
 			logComputedGetterWarning()
-			return computedGetterLegacyDecorator(options, _target, key, descriptor)
+			descriptor.get = makeComputedWrapper(key, descriptor.get, options)
 		} else {
-			return computedMethodLegacyDecorator(options, _target, key, descriptor)
+			descriptor.value = makeComputedWrapper(key, descriptor.value, options)
 		}
+		return descriptor
 	}
 }
 
-const isComputedMethodKey = '@@__isComputedMethod__@@'
-
 /**
  * Retrieves the underlying computed instance for a given property created with the `computed`
  * decorator.
@@ -481,7 +442,7 @@ const isComputedMethodKey = '@@__isComputedMethod__@@'
  * ```ts
  * class Counter {
  *   max = 100
- *   count = atom(0)
+ *   count = atom('count', 0)
  *
  *   @computed getRemaining() {
  *     return this.max - this.count.get()
@@ -502,19 +463,29 @@ const isComputedMethodKey = '@@__isComputedMethod__@@'
 export function getComputedInstance<Obj extends object, Prop extends keyof Obj>(
 	obj: Obj,
 	propertyName: Prop
-): Computed<Obj[Prop]> {
-	const key = Symbol.for('__@tldraw/state__computed__' + propertyName.toString())
-	let inst = obj[key as keyof typeof obj] as Computed<Obj[Prop]> | undefined
-	if (!inst) {
-		// deref to make sure it exists first
-		const val = obj[propertyName]
-		if (typeof val === 'function' && (val as any)[isComputedMethodKey]) {
-			val.call(obj)
+): Computed<Obj[Prop] extends () => infer Value ? Value : Obj[Prop]> {
+	// The nearest decorated wrapper (a method, or a legacy getter) on the prototype chain knows
+	// which symbol the instance's computed is stored under.
+	for (let proto: any = obj; proto; proto = Object.getPrototypeOf(proto)) {
+		const descriptor = Object.getOwnPropertyDescriptor(proto, propertyName)
+		const wrapper = descriptor?.get ?? descriptor?.value
+		const key = wrapper?.[derivationKeyKey]
+		if (!key) continue
+
+		let inst = (obj as any)[key]
+		if (!inst) {
+			// calling the wrapper creates the computed (before it first derives, so a throwing derive
+			// still leaves the instance behind)
+			try {
+				wrapper.call(obj)
+			} catch {
+				// the caller asked for the instance, not its value
+			}
+			inst = (obj as any)[key]
 		}
-
-		inst = obj[key as keyof typeof obj] as Computed<Obj[Prop]> | undefined
+		return inst
 	}
-	return inst as any
+	return undefined as any
 }
 
 /**
@@ -535,7 +506,7 @@ export function getComputedInstance<Obj extends object, Prop extends keyof Obj>(
  * ```ts
  * class Counter {
  *   max = 100
- *   count = atom<number>(0)
+ *   count = atom('count', 0)
  *
  *   @computed getRemaining() {
  *     return this.max - this.count.get()
@@ -549,7 +520,7 @@ export function getComputedInstance<Obj extends object, Prop extends keyof Obj>(
  * ```ts
  * class Counter {
  *   max = 100
- *   count = atom<number>(0)
+ *   count = atom('count', 0)
  *
  *   @computed({isEqual: (a, b) => a === b})
  *   getRemaining() {
@@ -661,7 +632,8 @@ export function computed<Value, Diff = unknown>(
  * @public
  */
 export function computed() {
-	if (arguments.length === 1) {
+	if (arguments.length <= 1) {
+		// decorator factory: `@computed(options)` or `@computed()`
 		const options = arguments[0]
 		return (...args: any) => computedDecorator(options, args)
 	} else if (typeof arguments[0] === 'string') {

package/src/lib/EffectScheduler.ts

@@ -29,12 +29,9 @@ export interface EffectSchedulerOptions {
 	 * 	}
 	 * }
 	 * const stop = react('set page title', () => {
-	 * 	document.title = doc.title,
-	 * }, scheduleEffect)
+	 * 	document.title = doc.title
+	 * }, { scheduleEffect })
 	 * ```
-	 *
-	 * @param execute - A function that will execute the effect.
-	 * @returns void
 	 */
 	// eslint-disable-next-line tldraw/method-signature-style
 	scheduleEffect?: (execute: () => void) => void
@@ -95,12 +92,16 @@ class __EffectScheduler__<Result> implements EffectScheduler<Result> {
 		// bail out if no atoms have changed since the last time we ran this effect
 		if (this.lastReactedEpoch === getGlobalEpoch()) return
 
-		// bail out if we have parents and they have not changed since last time
-		if (this.parents.length && !haveParentsChanged(this)) {
+		// An effect that has run before (or captured parents before throwing) only needs to run
+		// again if one of those parents changed; that includes an effect that captured no parents at
+		// all. An effect that has never run always runs.
+		if (
+			(this.lastReactedEpoch !== GLOBAL_START_EPOCH || this.parents.length > 0) &&
+			!haveParentsChanged(this)
+		) {
 			this.lastReactedEpoch = getGlobalEpoch()
 			return
 		}
-		// if we don't have parents it's probably the first time this is running.
 		this.scheduleEffect()
 	}
 

package/src/lib/HistoryBuffer.ts

@@ -1,3 +1,4 @@
+import { EMPTY_ARRAY } from './helpers'
 import { RESET_VALUE } from './types'
 
 /**
@@ -15,6 +16,9 @@ type RangeTuple<Diff> = [fromEpoch: number, toEpoch: number, diff: Diff]
  * The buffer uses a wrap-around strategy to maintain a fixed-size history of the most recent
  * changes, automatically overwriting older entries when the capacity is exceeded.
  *
+ * Entries must be contiguous (`entry[k].toEpoch === entry[k+1].fromEpoch`); `getChangesSince`
+ * relies on that to find the entry covering an epoch.
+ *
  * @example
  * ```ts
  * const buffer = new HistoryBuffer<string>(5)
@@ -54,12 +58,14 @@ export class HistoryBuffer<Diff> {
 	/**
 	 * Adds a diff entry to the history buffer, representing a change between two epochs.
 	 *
-	 * If the diff is undefined, the operation is ignored. If the diff is RESET_VALUE,
-	 * the entire buffer is cleared to indicate that historical tracking should restart.
+	 * If the diff is RESET_VALUE, or undefined (meaning no diff is available), the entire buffer is
+	 * cleared to indicate that historical tracking should restart. Silently skipping an entry would
+	 * leave a gap, and a later `getChangesSince` from before the gap would return an incomplete
+	 * diff list rather than RESET_VALUE.
 	 *
 	 * @param lastComputedEpoch - The epoch when the previous value was computed
 	 * @param currentEpoch - The epoch when the current value was computed
-	 * @param diff - The diff representing the change, or RESET_VALUE to clear history
+	 * @param diff - The diff representing the change, or RESET_VALUE / undefined to clear history
 	 * @example
 	 * ```ts
 	 * const buffer = new HistoryBuffer<string>(5)
@@ -67,12 +73,8 @@ export class HistoryBuffer<Diff> {
 	 * buffer.pushEntry(1, 2, RESET_VALUE) // Clears the buffer
 	 * ```
 	 */
-	pushEntry(lastComputedEpoch: number, currentEpoch: number, diff: Diff | RESET_VALUE) {
-		if (diff === undefined) {
-			return
-		}
-
-		if (diff === RESET_VALUE) {
+	pushEntry(lastComputedEpoch: number, currentEpoch: number, diff: Diff | RESET_VALUE | undefined) {
+		if (diff === RESET_VALUE || diff === undefined) {
 			this.clear()
 			return
 		}
@@ -139,7 +141,7 @@ export class HistoryBuffer<Diff> {
 
 			// If the first element is already too early, bail
 			if (i === 0 && sinceEpoch >= toEpoch) {
-				return []
+				return EMPTY_ARRAY
 			}
 
 			// If the element is since the given epoch, return an array with all diffs from this element and all following elements

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

@@ -91,6 +91,24 @@ describe(ArraySet, () => {
 		expect(as.add(1)).toBe(true)
 	})
 
+	it('[AS4] a fresh ArraySet answers every query as empty and survives remove and clear', () => {
+		const as = new ArraySet<number>()
+
+		expect(as.has(1)).toBe(false)
+		expect(as.size()).toBe(0)
+		expect(as.isEmpty).toBe(true)
+		expect([...as]).toEqual([])
+		expect(get(as)).toEqual(new Set())
+
+		expect(as.remove(1)).toBe(false)
+		as.clear()
+
+		expect(as.isEmpty).toBe(true)
+		expect(as.add(1)).toBe(true)
+		expect(as.has(1)).toBe(true)
+		expect(as.size()).toBe(1)
+	})
+
 	it('works with small numbers of things', () => {
 		const as = new ArraySet<number>()
 
@@ -172,25 +190,33 @@ function runTest(seed: number) {
 	const s = new Set<number>()
 	const r = rng(seed)
 
-	const nums = new Array(ARRAY_SIZE_THRESHOLD * 2).fill(0).map(() => Math.floor(r() * 100))
+	// Enough candidates, and enough bias toward adds, that the set fills past the promotion
+	// threshold rather than hovering below it in array mode forever.
+	const nums = new Array(ARRAY_SIZE_THRESHOLD * 4).fill(0).map(() => Math.floor(r() * 100))
 
 	for (let i = 0; i < 1000; i++) {
 		const num = nums[Math.floor(r() * nums.length)]
 
 		const choice = r()
-		if (choice < 0.45) {
-			as.add(num)
-			s.add(num)
-		} else if (choice < 0.9) {
-			as.remove(num)
-			s.delete(num)
-		} else {
-			as.clear()
-			s.clear()
-		}
-
 		try {
+			if (choice < 0.55) {
+				expect(as.add(num)).toBe(!s.has(num))
+				s.add(num)
+			} else if (choice < 0.95) {
+				expect(as.remove(num)).toBe(s.has(num))
+				s.delete(num)
+			} else {
+				as.clear()
+				s.clear()
+			}
+
 			expect(get(as)).toEqual(s)
+			expect(new Set([...as])).toEqual(s)
+			expect(as.size()).toBe(s.size)
+			expect(as.isEmpty).toBe(s.size === 0)
+			for (const n of nums) {
+				expect(as.has(n)).toBe(s.has(n))
+			}
 		} catch (e) {
 			console.error('Failed on iteration', i, 'with seed', seed)
 			throw e
@@ -198,7 +224,7 @@ function runTest(seed: number) {
 	}
 }
 
-describe('fuzzing this thing (if this fails tell david)', () => {
+describe('fuzzing against a reference Set', () => {
 	new Array(10).fill(0).forEach(() => {
 		const seed = Math.floor(Math.random() * 1000000)
 		it(`fuzz with seed ${seed}`, () => {

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

@@ -233,6 +233,24 @@ describe('reactor (E)', () => {
 		r.scheduler.maybeScheduleEffect()
 		expect(rfn).toHaveBeenCalledTimes(1)
 	})
+
+	it('[E2][E9] an effect that captured no parents does not re-run on start() after unrelated changes', () => {
+		const unrelated = atom('', 0)
+		const rfn = vi.fn()
+		const r = reactor('', rfn)
+
+		r.start()
+		expect(rfn).toHaveBeenCalledTimes(1)
+
+		r.stop()
+		unrelated.set(1)
+		r.start()
+		// no parent changed (there are none), so there is nothing to react to
+		expect(rfn).toHaveBeenCalledTimes(1)
+
+		r.start({ force: true })
+		expect(rfn).toHaveBeenCalledTimes(2)
+	})
 })
 
 describe('custom scheduling (E6, E7)', () => {

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

@@ -47,13 +47,16 @@ describe('HistoryBuffer', () => {
 		expect(buf.getChangesSince(0)).toEqual(RESET_VALUE)
 	})
 
-	it('[HB1] ignores undefined diffs', () => {
+	it('[HB1] treats an undefined diff like RESET_VALUE: it clears rather than leaving a gap', () => {
 		const buf = new HistoryBuffer<string>(3)
 		buf.pushEntry(0, 1, 'a')
 		buf.pushEntry(1, 2, undefined as any)
+		buf.pushEntry(2, 3, 'c')
 
-		expect(buf.getChangesSince(0)).toEqual(['a'])
-		expect(buf.getChangesSince(1)).toEqual([])
+		// if the undefined entry had been skipped, this would be ['a', 'c'] with the 1 -> 2 change missing
+		expect(buf.getChangesSince(0)).toEqual(RESET_VALUE)
+		expect(buf.getChangesSince(1)).toEqual(RESET_VALUE)
+		expect(buf.getChangesSince(2)).toEqual(['c'])
 	})
 
 	it('[HB1] will clear if you push RESET_VALUE', () => {

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

@@ -333,4 +333,79 @@ describe('the computed decorator (C8, C9, C10)', () => {
 
 		warn.mockRestore()
 	})
+
+	it('[C8] can be applied as a factory with no options', () => {
+		// the options argument is optional, so `@computed()` must work like `@computed`
+		class Foo {
+			a = atom('a', 1)
+			@computed()
+			getB() {
+				return this.a.get() * 2
+			}
+		}
+
+		const foo = new Foo()
+		expect(foo.getB()).toBe(2)
+		foo.a.set(2)
+		expect(foo.getB()).toBe(4)
+	})
+
+	it('[C8] a subclass override can call the superclass computed via super', () => {
+		// each decoration stores its computed under its own key; keying by method name made the
+		// super call re-enter the subclass's own computed and overflow the stack
+		class Base {
+			a = atom('a', 1)
+			@computed
+			getB() {
+				return this.a.get() * 2
+			}
+		}
+		class Sub extends Base {
+			@computed
+			override getB() {
+				return super.getB() + 1
+			}
+		}
+
+		const sub = new Sub()
+		expect(sub.getB()).toBe(3)
+		sub.a.set(2)
+		expect(sub.getB()).toBe(5)
+		expect(new Base().getB()).toBe(2)
+	})
+
+	it('[C9] getComputedInstance resolves the nearest decorated method on the prototype chain', () => {
+		class Base {
+			a = atom('a', 1)
+			@computed
+			getB() {
+				return this.a.get() * 2
+			}
+		}
+		class Sub extends Base {
+			@computed
+			override getB() {
+				return super.getB() + 1
+			}
+		}
+		class PlainSub extends Base {
+			override getB() {
+				return super.getB() + 100
+			}
+		}
+
+		const sub = new Sub()
+		const subInst = getComputedInstance(sub, 'getB')
+		expect(subInst.get()).toBe(3)
+		sub.a.set(2)
+		expect(subInst.get()).toBe(5)
+
+		// a plain (undecorated) override still exposes the superclass's computed
+		const plain = new PlainSub()
+		expect(getComputedInstance(plain, 'getB').get()).toBe(2)
+
+		// the returned type unwraps the method's return type
+		const n: number = getComputedInstance(new Base(), 'getB').get()
+		expect(n).toBe(2)
+	})
 })

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

@@ -36,6 +36,30 @@ describe('computed signals that throw (CE)', () => {
 		expect(b.get()).toBe(3)
 	})
 
+	it('[CE1] cache a throw from the very first computation too', () => {
+		let numComputations = 0
+		const a = atom('', 1)
+		const b = computed('', () => {
+			numComputations++
+			if (a.get() === 1) throw new Error('test')
+			return a.get()
+		})
+
+		expect(() => b.get()).toThrowErrorMatchingInlineSnapshot(`[Error: test]`)
+		expect(() => b.get()).toThrowErrorMatchingInlineSnapshot(`[Error: test]`)
+		expect(() => b.get()).toThrowErrorMatchingInlineSnapshot(`[Error: test]`)
+		expect(numComputations).toBe(1)
+
+		// an unrelated change doesn't re-run it either
+		atom('', 0).set(1)
+		expect(() => b.get()).toThrowErrorMatchingInlineSnapshot(`[Error: test]`)
+		expect(numComputations).toBe(1)
+
+		a.set(2)
+		expect(b.get()).toBe(2)
+		expect(numComputations).toBe(2)
+	})
+
 	it('[CE2] entering the error state notifies effects, but consecutive errors do not', () => {
 		const a = atom('', 1)
 		let numComputations = 0

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

@@ -2,7 +2,7 @@ import { describe, expect, it, vi } from 'vitest'
 import { ArraySet } from '../ArraySet'
 import { atom } from '../Atom'
 import { reactor } from '../EffectScheduler'
-import { attach, detach, equals, hasReactors, haveParentsChanged, singleton } from '../helpers'
+import { attach, detach, equals, haveParentsChanged, singleton } from '../helpers'
 import { Child } from '../types'
 
 // Unit tests for the internal helpers behind SPEC.md rules EQ1/EQ2 (equals),
@@ -132,25 +132,21 @@ describe('helpers', () => {
 		})
 	})
 
-	describe('hasReactors', () => {
-		it('returns false when signal has no actively listening children', () => {
-			const signal = atom('test', 1)
-			expect(hasReactors(signal)).toBe(false)
-		})
-
-		it('integrates correctly with real reactive signals', () => {
+	// CAP7: a signal's children set is non-empty exactly while something downstream is listening
+	describe('children', () => {
+		it('is empty unless something is actively listening', () => {
 			const baseAtom = atom('base', 1)
-			expect(hasReactors(baseAtom)).toBe(false)
+			expect(baseAtom.children.isEmpty).toBe(true)
 
 			const reactorInstance = reactor('test-reactor', () => {
 				baseAtom.get()
 			})
 
 			reactorInstance.start()
-			expect(hasReactors(baseAtom)).toBe(true)
+			expect(baseAtom.children.isEmpty).toBe(false)
 
 			reactorInstance.stop()
-			expect(hasReactors(baseAtom)).toBe(false)
+			expect(baseAtom.children.isEmpty).toBe(true)
 		})
 	})
 })