mutts 1.0.5 → 1.0.7

package/src/reactive/effects.ts

@@ -2,23 +2,20 @@ import { decorator } from '../decorator'
 import { IterableWeakSet } from '../iterableWeak'
 import { getTriggerChain, isDevtoolsEnabled, registerEffectForDebug } from './debug'
 import {
-	captureEffectStack,
-	effectStack,
+	effectAggregator,
+	effectHistory,
 	getActiveEffect,
-	withEffect,
-	withEffectStack,
 } from './effect-context'
 import {
 	effectChildren,
 	effectParent,
 	effectToReactiveObjects,
 	getRoot,
-	getTrackingDisabled,
 	markWithRoot,
-	setTrackingDisabled,
 	watchers,
-} from './tracking'
+} from './registry'
 import {
+	cleanup as cleanupSymbol,
 	type DependencyAccess,
 	type EffectOptions,
 	type Evolution,
@@ -27,8 +24,11 @@ import {
 	ReactiveErrorCode,
 	// type AsyncExecutionMode,
 	type ScopedCallback,
+	stopped,
 } from './types'
 
+import { unwrap } from './proxy-state'
+
 /**
  * Finds a cycle in a sequence of functions by looking for the first repetition
  */
@@ -55,11 +55,8 @@ function formatRoots(roots: Function[], limit = 20): string {
 	return `${start.join(' → ')} ... (${names.length - 15} more) ... ${end.join(' → ')}`
 }
 
-import { ensureZoneHooked } from './zone'
-
 type EffectTracking = (obj: any, evolution: Evolution, prop: any) => void
 
-export { captureEffectStack, withEffectStack, getActiveEffect, effectStack }
 export interface ActivationRecord {
 	effect: ScopedCallback
 	obj: any
@@ -207,6 +204,7 @@ function getOrCreateClosure(
  * @param targetRoot - Root function of the effect being triggered
  */
 function addGraphEdge(callerRoot: Function, targetRoot: Function) {
+	if (options.cycleHandling === 'none') return
 	// Skip if edge already exists
 	const triggers = effectTriggers.get(callerRoot)
 	if (triggers?.has(targetRoot)) {
@@ -297,6 +295,7 @@ function addGraphEdge(callerRoot: Function, targetRoot: Function) {
  * @param end - Target node
  * @param exclude - Node to exclude from the path
  * @returns true if a path exists without going through the excluded node
+ * @todo Can be REALLY costly - optimise or make optional or ...
  */
 function hasPathExcluding(start: Function, end: Function, exclude: Function): boolean {
 	if (start === end) return true
@@ -331,6 +330,7 @@ function hasPathExcluding(start: Function, end: Function, exclude: Function): bo
  * @param effect - The effect being cleaned up
  */
 function cleanupEffectFromGraph(effect: ScopedCallback) {
+	if (options.cycleHandling === 'none') return
 	const root = getRoot(effect)
 
 	// Get closures before removing direct edges (needed for propagation)
@@ -453,6 +453,7 @@ const batchCleanups = new Set<ScopedCallback>()
  * Called once when batch starts or when new effects are added
  */
 function computeAllInDegrees(batch: BatchQueue): void {
+	if (options.cycleHandling === 'none') return
 	const activeEffect = getActiveEffect()
 	const activeRoot = activeEffect ? getRoot(activeEffect) : null
 
@@ -592,6 +593,10 @@ function getCyclePathForEdge(callerRoot: Function, targetRoot: Function): Functi
  * Checks if adding an edge would create a cycle
  * Uses causesClosure to check if callerRoot is already a cause of targetRoot
  * Self-loops (callerRoot === targetRoot) are explicitly ignored and return false
+ *
+ * **Note**: This is the primary optimization benefit of the transitive closure system.
+ * It allows detecting cycles in O(1) time before they are executed.
+ *
  * @param callerRoot - Root of the effect that triggers
  * @param targetRoot - Root of the effect being triggered
  * @returns true if adding this edge would create a cycle
@@ -621,16 +626,25 @@ function wouldCreateCycle(callerRoot: Function, targetRoot: Function): boolean {
  * @param immediate - If true, don't create edges in the dependency graph
  */
 function addToBatch(effect: ScopedCallback, caller?: ScopedCallback, immediate?: boolean) {
+	(effect as any)[cleanupSymbol]?.()
+	// If the effect was stopped during cleanup (e.g. lazy memoization), don't add it to the batch
+	if ((effect as any)[stopped]) return
+
 	if (!batchQueue) return
 
 	const root = getRoot(effect)
 
 	// 1. Add to batch first (needed for cycle detection)
+	if (options.cycleHandling === 'none' && batchQueue.all.has(root)) {
+		// If already present in flat mode, remove it so that the next set puts it at the end
+		batchQueue.all.delete(root)
+	}
+
 	batchQueue.all.set(root, effect)
 
 	// 2. Add to global graph (if caller exists and not immediate) - USE ROOTS ONLY
 	// When immediate is true, don't create edges - the effect is not considered as a consequence
-	if (caller && !immediate) {
+	if (caller && !immediate && options.cycleHandling !== 'none') {
 		const callerRoot = getRoot(caller)
 
 		// Check for cycle BEFORE adding edge
@@ -797,14 +811,22 @@ function executeNext(effectuatedRoots: Function[]): any {
 	let nextEffect: ScopedCallback | null = null
 	let nextRoot: Function | null = null
 
-	// Find an effect with in-degree 0 (no dependencies in batch that still need execution)
-	// Using cached in-degrees for O(n) lookup instead of O(n²)
-	for (const [root, effect] of batchQueue!.all) {
-		const inDegree = batchQueue!.inDegrees.get(root) ?? 0
-		if (inDegree === 0) {
-			nextEffect = effect
-			nextRoot = root
-			break
+	if (options.cycleHandling === 'none') {
+		// In flat mode, we just take the first effect in the queue (FIFO)
+		const first = batchQueue!.all.entries().next().value
+		if (first) {
+			;[nextRoot, nextEffect] = first
+		}
+	} else {
+		// Find an effect with in-degree 0 (no dependencies in batch that still need execution)
+		// Using cached in-degrees for O(n) lookup instead of O(n²)
+		for (const [root, effect] of batchQueue!.all) {
+			const inDegree = batchQueue!.inDegrees.get(root) ?? 0
+			if (inDegree === 0) {
+				nextEffect = effect
+				nextRoot = root
+				break
+			}
 		}
 	}
 
@@ -897,9 +919,8 @@ export function batch(effect: ScopedCallback | ScopedCallback[], immediate?: 'im
 		// Nested batch - add to existing
 		options?.chain(roots, getRoot(getActiveEffect()))
 		const caller = getActiveEffect()
-		for (let i = 0; i < effect.length; i++) {
+		for (let i = 0; i < effect.length; i++)
 			addToBatch(effect[i], caller, immediate === 'immediate')
-		}
 		if (immediate) {
 			const firstReturn: { value?: any } = {}
 			// Execute immediately (before batch returns)
@@ -925,30 +946,30 @@ export function batch(effect: ScopedCallback | ScopedCallback[], immediate?: 'im
 			inDegrees: new Map(),
 		}
 
-		// Add initial effects
 		const caller = getActiveEffect()
-		for (let i = 0; i < effect.length; i++) {
-			addToBatch(effect[i], caller, immediate === 'immediate')
-		}
-
 		const effectuatedRoots: ScopedCallback[] = []
-		computeAllInDegrees(batchQueue)
-		if (immediate) {
-			// Execute immediately (before batch returns)
-			const firstReturn: { value?: any } = {}
-			try {
+		const firstReturn: { value?: any } = {}
+
+		try {
+			if (immediate) {
+				// Execute initial effects in providing order
 				for (let i = 0; i < effect.length; i++) {
 					try {
 						const rv = effect[i]()
 						if (rv !== undefined && !('value' in firstReturn)) firstReturn.value = rv
 					} finally {
-						const root = getRoot(effect[i])
-						batchQueue.all.delete(root)
+						batchQueue.all.delete(getRoot(effect[i]))
 					}
 				}
-				// After immediate execution, execute any effects that were triggered during execution
-				// This is important for @atomic decorator - effects triggered inside should still run
-				while (batchQueue.all.size > 0) {
+			} else {
+				// Add initial effects to batch and compute dependencies
+				for (let i = 0; i < effect.length; i++) addToBatch(effect[i], caller, false)
+				computeAllInDegrees(batchQueue)
+			}
+
+			// Processing loop for all triggered effects and cleanups
+			while (batchQueue.all.size > 0 || batchCleanups.size > 0) {
+				if (batchQueue.all.size > 0) {
 					if (effectuatedRoots.length > options.maxEffectChain) {
 						const cycle = findCycleInChain(effectuatedRoots as any)
 						const trace = formatRoots(effectuatedRoots as any)
@@ -988,118 +1009,55 @@ export function batch(effect: ScopedCallback | ScopedCallback[], immediate?: 'im
 								break
 						}
 					}
-					if (!batchQueue || batchQueue.all.size === 0) break
 					const rv = executeNext(effectuatedRoots)
-					// If executeNext() returned null but batch is not empty, it means a cycle was detected
-					// and an error was thrown, so we won't reach here
 					if (rv !== undefined && !('value' in firstReturn)) firstReturn.value = rv
+				} else {
+					// Process cleanups. If they trigger more effects, they will be caught in the next iteration.
+					const cleanups = Array.from(batchCleanups)
+					batchCleanups.clear()
+					for (const cleanup of cleanups) cleanup()
+
+					// In immediate mode, we traditionally don't process recursive effects from cleanups.
+					// If we want to keep that behavior: if (immediate) break
 				}
-				const cleanups = Array.from(batchCleanups)
-				batchCleanups.clear()
-				for (const cleanup of cleanups) cleanup()
-				return firstReturn.value
-			} finally {
-				activationRegistry = undefined
-				batchQueue = undefined
-				options.endChain()
-			}
-		} else {
-			// Execute in dependency order
-			const firstReturn: { value?: any } = {}
-			try {
-				// Outer loop: continue while there are effects OR cleanups pending.
-				// This ensures effects triggered by cleanups are not lost.
-				while (batchQueue.all.size > 0 || batchCleanups.size > 0) {
-					// Inner loop: execute all pending effects
-					while (batchQueue.all.size > 0) {
-						if (effectuatedRoots.length > options.maxEffectChain) {
-							const cycle = findCycleInChain(effectuatedRoots as any)
-							const trace = formatRoots(effectuatedRoots as any)
-							const message = cycle
-								? `Max effect chain reached (cycle detected: ${formatRoots(cycle)})`
-								: `Max effect chain reached (trace: ${trace})`
-
-							const queuedRoots = batchQueue ? Array.from(batchQueue.all.keys()) : []
-							const queued = queuedRoots.map((r) => r.name || '<anonymous>')
-							const debugInfo = {
-								code: ReactiveErrorCode.MaxDepthExceeded,
-								effectuatedRoots,
-								cycle,
-								trace,
-								maxEffectChain: options.maxEffectChain,
-								queued: queued.slice(0, 50),
-								queuedCount: queued.length,
-								// Try to get causation for the last effect
-								causalChain:
-									effectuatedRoots.length > 0
-										? getTriggerChain(
-												batchQueue.all.get(effectuatedRoots[effectuatedRoots.length - 1])!
-											)
-										: [],
-							}
-							switch (options.maxEffectReaction) {
-								case 'throw':
-									throw new ReactiveError(`[reactive] ${message}`, debugInfo)
-								case 'debug':
-									// biome-ignore lint/suspicious/noDebugger: This is the whole point here
-									debugger
-									throw new ReactiveError(`[reactive] ${message}`, debugInfo)
-								case 'warn':
-									options.warn(
-										`[reactive] ${message} (queued: ${queued.slice(0, 10).join(', ')}${queued.length > 10 ? ', …' : ''})`
-									)
-									break
-							}
-						}
-						const rv = executeNext(effectuatedRoots)
-						// executeNext() returns null when batch is complete or cycle detected (throws error)
-						// But functions can legitimately return null, so we check batchQueue.all.size instead
-						if (batchQueue.all.size === 0) {
-							// Batch complete
-							break
-						}
-						// If executeNext() returned null but batch is not empty, it means a cycle was detected
-						// and an error was thrown, so we won't reach here
-						if (rv !== undefined && !('value' in firstReturn)) firstReturn.value = rv
-						// Note: executeNext() already removed it from batchQueue, so we track by count
-					}
-					// Process cleanups. If they trigger new effects, the outer loop will catch them.
-					if (batchCleanups.size > 0) {
-						const cleanups = Array.from(batchCleanups)
-						batchCleanups.clear()
-						for (const cleanup of cleanups) cleanup()
-					}
-				}
-				return firstReturn.value
-			} finally {
-				activationRegistry = undefined
-				batchQueue = undefined
-				options.endChain()
 			}
+			return firstReturn.value
+		} catch (error) {
+			throw error instanceof ReactiveError
+				? error
+				: new ReactiveError('Effects are broken', { code: ReactiveErrorCode.BrokenEffects, cause: error })
+		} finally {
+			activationRegistry = undefined
+			batchQueue = undefined
+			options.endChain()
 		}
 	}
 }
 
+// Inject batch function to allow atomic game loops in requestAnimationFrame/setTimeout/...
+// TODO: perhaps introduce somewhere a way to wrap async functions - find out if it's necessary
+// wrapAsync(fn=> batch(fn, 'immediate'))
+
 /**
  * Decorator that makes methods atomic - batches all effects triggered within the method
  */
 export const atomic = decorator({
 	method(original) {
-		return function (...args: any[]) {
-			return batch(
-				markWithRoot(() => original.apply(this, args), original),
-				'immediate'
-			)
+		return function (this: any, ...args: any[]) {
+			const atomicEffect = () => original.apply(this, args)
+			// Debug: helpful to have a name
+			Object.defineProperty(atomicEffect, 'name', { value: `atomic(${original.name})` })
+			return batch(atomicEffect, 'immediate')
 		}
 	},
 	default<Args extends any[], Return>(
 		original: (...args: Args) => Return
 	): (...args: Args) => Return {
 		return function (this: any, ...args: Args) {
-			return batch(
-				markWithRoot(() => original.apply(this, args), original),
-				'immediate'
-			)
+			const atomicEffect = () => original.apply(this, args)
+			// Debug: helpful to have a name
+			Object.defineProperty(atomicEffect, 'name', { value: `atomic(${original.name})` })
+			return batch(atomicEffect, 'immediate')
 		}
 	},
 })
@@ -1120,10 +1078,10 @@ export function effect(
 	//biome-ignore lint/suspicious/noConfusingVoidType: We have to
 	fn: (access: DependencyAccess) => ScopedCallback | undefined | void | Promise<any>,
 	effectOptions?: EffectOptions
-): ScopedCallback {
-	// Ensure zone is hooked if asyncZone option is enabled (lazy initialization)
-	// Inject batch function to allow atomic game loops in requestAnimationFrame
-	ensureZoneHooked(batch)
+): ScopedCallback & {
+	[stopped]: boolean
+	[cleanupSymbol]: () => void
+} {
 
 	// Use per-effect asyncMode or fall back to global option
 	const asyncMode = effectOptions?.asyncMode ?? options.asyncMode ?? 'cancel'
@@ -1136,10 +1094,13 @@ export function effect(
 		}
 	}
 	let cleanup: (() => void) | null = null
-	// capture the parent effect at creation time for ascend
-	const parentsForAscend = captureEffectStack()
-	const tracked = markWithRoot(<T>(cb: () => T) => withEffect(runEffect, cb), fn)
-	const ascend = <T>(cb: () => T) => withEffectStack(parentsForAscend, cb)
+	const tracked = effectHistory.present.with(runEffect, ()=> effectAggregator.zoned)
+	const ascend = effectHistory.zoned
+	//const parent = effectHistory.present.active // TODO: Double-check parenting (untracked -> stop children) - use case or untracked(effect)
+	let parent = effectHistory.present.active
+	/*if (!parent) {
+		for (const h of effectHistory.active.history) parent = h
+	}*/
 	let effectStopped = false
 	let hasReacted = false
 	let runningPromise: Promise<any> | null = null
@@ -1150,7 +1111,7 @@ export function effect(
 		if (cleanup) {
 			const prevCleanup = cleanup
 			cleanup = null
-			withEffect(undefined, () => prevCleanup())
+			untracked(() => prevCleanup())
 		}
 
 		// Handle async modes when effect is retriggered
@@ -1174,7 +1135,7 @@ export function effect(
 		let reactionCleanup: ScopedCallback | undefined
 		let result: any
 		try {
-			result = withEffect(runEffect, () => fn({ tracked, ascend, reaction: hasReacted }))
+			result = tracked(() => fn({ tracked, ascend, reaction: hasReacted }))
 			if (
 				result &&
 				typeof result !== 'function' &&
@@ -1250,6 +1211,28 @@ export function effect(
 	}
 	// Mark the runEffect callback with the original function as its root
 	markWithRoot(runEffect, fn)
+	function augmentedRv(rv: ScopedCallback) {
+		return Object.defineProperties(rv, {
+			[stopped]: {
+				get() {
+					return effectStopped
+				},
+			},
+			[cleanupSymbol]: {
+				value: () => {
+					if (cleanup) {
+						const prevCleanup = cleanup
+						cleanup = null
+						untracked(() => prevCleanup())
+					}
+				},
+			},
+		}) as ScopedCallback & {
+			[stopped]: boolean
+			[cleanupSymbol]: () => void
+		}
+	}
+	augmentedRv(runEffect)
 
 	// Register strict mode if enabled
 	if (effectOptions?.opaque) {
@@ -1262,7 +1245,6 @@ export function effect(
 
 	batch(runEffect, 'immediate')
 
-	const parent = parentsForAscend[0]
 	// Store parent relationship for hierarchy traversal
 	effectParent.set(runEffect, parent)
 	// Only ROOT effects are registered for GC cleanup and zone tracking
@@ -1283,7 +1265,7 @@ export function effect(
 		fr.unregister(stopEffect)
 	}
 	if (isRootEffect) {
-		const callIfCollected = () => stopEffect()
+		const callIfCollected = augmentedRv(() => stopEffect())
 		fr.register(
 			callIfCollected,
 			() => {
@@ -1300,15 +1282,16 @@ export function effect(
 		children = new Set()
 		effectChildren.set(parent, children)
 	}
-	const subEffectCleanup = (): void => {
+	const subEffectCleanup = augmentedRv(() => {
 		children.delete(subEffectCleanup)
 		if (children.size === 0) {
 			effectChildren.delete(parent)
 		}
 		// Execute this child effect cleanup (which triggers its own mainCleanup)
 		stopEffect()
-	}
+	})
 	children.add(subEffectCleanup)
+
 	return subEffectCleanup
 }
 
@@ -1318,17 +1301,7 @@ export function effect(
  * @param fn - The function to execute
  */
 export function untracked<T>(fn: () => T): T {
-	// Store current tracking state and temporarily disable it
-	// This prevents the parent effect from tracking dependencies during fn execution
-	const wasTrackingDisabled = getTrackingDisabled()
-	setTrackingDisabled(true)
-
-	try {
-		return fn()
-	} finally {
-		// Restore tracking state
-		setTrackingDisabled(wasTrackingDisabled)
-	}
+	return effectHistory.present.root(fn)
 }
 
 /**
@@ -1337,11 +1310,7 @@ export function untracked<T>(fn: () => T): T {
  * @param fn - The function to execute
  */
 export function root<T>(fn: () => T): T {
-	let rv!: T
-	withEffect(undefined, () => {
-		rv = fn()
-	})
-	return rv
+	return effectHistory.root(fn)
 }
 
 export { effectTrackers }
@@ -1397,18 +1366,17 @@ export function biDi<T>(
 		set = get.set
 		get = get.get
 	}
-	const root = getRoot(received)
+	let programatticallySetValue: any = Symbol()
 	effect(
 		markWithRoot(() => {
-			received(get())
-		}, root)
+			const newValue = get()
+			if (unwrap(newValue) !== programatticallySetValue) received(newValue)
+		}, received)
 	)
-	return atomic((value: T) => {
-		set!(value)
-		if (batchQueue?.all.has(root)) {
-			// Remove the effect from the batch queue so it doesn't execute
-			// This prevents circular updates in bidirectional bindings
-			batchQueue.all.delete(root)
-		}
-	})
+	return set
+		? atomic((value: T) => {
+				programatticallySetValue = unwrap(value)
+				set(value)
+			})
+		: () => {}
 }

package/src/reactive/index.ts

@@ -13,33 +13,30 @@ export { deepWatch } from './deep-watch'
 export {
 	addBatchCleanup,
 	atomic,
-	batch, // TODO: Batch is now exported for testing purposes, though it shouldn't be - modify the tests to go through `atomic`
 	biDi,
 	defer,
 	effect,
 	getActivationLog,
-	getActiveEffect,
 	root,
 	trackEffect,
 	untracked,
 } from './effects'
 export { cleanedBy, cleanup, derived, unreactive, watch } from './interface'
-export { mapped, ReadOnlyError, reduced } from './mapped'
 export { type Memoizable, memoize } from './memoize'
 export { immutables, isNonReactive, registerNativeReactivity } from './non-reactive'
 export { getActiveProjection, project } from './project'
 export { isReactive, ReactiveBase, reactive, unwrap } from './proxy'
 export { organize, organized } from './record'
+export { scan, type ScanResult } from './buffer'
 export { Register, register } from './register'
 export {
 	type DependencyAccess,
-	type DependencyFunction,
 	type Evolution,
 	options as reactiveOptions,
 	ReactiveError,
+	ReactiveErrorCode,
 	type ScopedCallback,
 } from './types'
-export { isZoneEnabled, setZoneEnabled } from './zone'
 
 import { ReactiveArray } from './array'
 import {
@@ -49,17 +46,17 @@ import {
 	objectsWithDeepWatchers,
 } from './deep-watch'
 import { ReactiveMap, ReactiveWeakMap } from './map'
-import { nonReactiveObjects, registerNativeReactivity } from './non-reactive-state'
-import { objectToProxy, proxyToObject } from './proxy'
+import { nonReactiveObjects } from './non-reactive-state'
+import { metaProtos, objectToProxy, proxyToObject } from './proxy'
+import { effectToReactiveObjects, watchers } from './registry'
 import { ReactiveSet, ReactiveWeakSet } from './set'
-import { effectToReactiveObjects, watchers } from './tracking'
 
 // Register native collection types to use specialized reactive wrappers
-registerNativeReactivity(WeakMap, ReactiveWeakMap)
-registerNativeReactivity(Map, ReactiveMap)
-registerNativeReactivity(WeakSet, ReactiveWeakSet)
-registerNativeReactivity(Set, ReactiveSet)
-registerNativeReactivity(Array, ReactiveArray)
+metaProtos.set(Array, ReactiveArray.prototype)
+metaProtos.set(Set, ReactiveSet.prototype)
+metaProtos.set(WeakSet, ReactiveWeakSet.prototype)
+metaProtos.set(Map, ReactiveMap.prototype)
+metaProtos.set(WeakMap, ReactiveWeakMap.prototype)
 
 /**
  * Object containing internal reactive system state for debugging and profiling

package/src/reactive/interface.ts

@@ -1,10 +1,10 @@
 import { decorator, type GenericClassDecorator } from '../decorator'
 import { deepWatch } from './deep-watch'
-import { withEffect } from './effect-context'
-import { effect, getActiveEffect, untracked } from './effects'
+import { effect, untracked } from './effects'
 import { isNonReactive, nonReactiveClass, nonReactiveObjects } from './non-reactive-state'
 import { unwrap } from './proxy-state'
-import { dependant, markWithRoot } from './tracking'
+import { markWithRoot } from './registry'
+import { dependant } from './tracking'
 import {
 	type DependencyAccess,
 	nonReactiveMark,
@@ -86,15 +86,12 @@ function watchObject(
 	changed: (value: object) => void,
 	{ immediate = false, deep = false } = {}
 ): ScopedCallback {
-	const myParentEffect = getActiveEffect()
 	if (deep) return deepWatch(value, changed, { immediate })!
-	return effect(
-		markWithRoot(function watchObjectEffect() {
-			dependant(value)
-			if (immediate) withEffect(myParentEffect, () => changed(value))
-			immediate = true
-		}, changed)
-	)
+	return effect(function watchObjectEffect() {
+		dependant(value)
+		if (immediate) changed(value)
+		immediate = true
+	})
 }
 
 function watchCallBack<T>(
@@ -102,29 +99,20 @@ function watchCallBack<T>(
 	changed: (value: T, oldValue?: T) => void,
 	{ immediate = false, deep = false } = {}
 ): ScopedCallback {
-	const myParentEffect = getActiveEffect()
 	let oldValue: T | typeof unsetYet = unsetYet
 	let deepCleanup: ScopedCallback | undefined
 	const cbCleanup = effect(
 		markWithRoot(function watchCallBackEffect(access) {
 			const newValue = value(access)
 			if (oldValue !== newValue)
-				withEffect(
-					myParentEffect,
-					markWithRoot(() => {
-						if (oldValue === unsetYet) {
-							if (immediate) changed(newValue)
-						} else changed(newValue, oldValue)
-						oldValue = newValue
-						if (deep) {
-							if (deepCleanup) deepCleanup()
-							deepCleanup = deepWatch(
-								newValue as object,
-								markWithRoot((value) => changed(value as T, value as T), changed)
-							)
-						}
-					}, changed)
-				)
+				if (oldValue === unsetYet) {
+					if (immediate) changed(newValue)
+				} else changed(newValue, oldValue)
+				oldValue = newValue
+				if (deep) {
+					if (deepCleanup) deepCleanup()
+					deepCleanup = deepWatch(newValue as object, (value) => changed(value as T, value as T))
+				}
 		}, value)
 	)
 	return () => {
@@ -153,6 +141,7 @@ function deepNonReactive<T>(obj: T): T {
 		})
 	} catch {}
 	if (!(nonReactiveMark in (obj as object))) nonReactiveObjects.add(obj as object)
+	// Finally, not deep
 	//for (const key in obj) deepNonReactive(obj[key])
 	return obj
 }
@@ -213,11 +202,9 @@ export function derived<T>(compute: (dep: DependencyAccess) => T): {
 	return cleanedBy(
 		rv,
 		untracked(() =>
-			effect(
-				markWithRoot(function derivedEffect(access) {
-					rv.value = compute(access)
-				}, compute)
-			)
+			effect(function derivedEffect(access) {
+				rv.value = compute(access)
+			})
 		)
 	)
 }