mutts 1.0.6 → 1.0.7

package/src/reactive/change.ts

@@ -46,7 +46,7 @@ export function collectEffects(
 				for (const effect of deps) {
 					const runningChain = isRunning(effect)
 					if (runningChain) {
-						options.skipRunningEffect(effect, runningChain as any)
+						options.skipRunningEffect(effect)
 						continue
 					}
 					if (!effects.has(effect)) {
@@ -118,7 +118,7 @@ export function touchedOpaque(obj: any, evolution: Evolution, prop: any) {
 
 		const runningChain = isRunning(effect)
 		if (runningChain) {
-			options.skipRunningEffect(effect, runningChain as any)
+			options.skipRunningEffect(effect)
 			continue
 		}
 		effects.add(effect)

package/src/reactive/effect-context.ts

@@ -1,94 +1,18 @@
-import { effectParent, getRoot } from './registry'
-import { ReactiveError, type ScopedCallback } from './types'
-
-/**
- * Effect context stack for nested tracking (front = active, next = parent)
- */
-const stack: (ScopedCallback | undefined)[] = []
-export const effectStack = stack
-
-export function captureEffectStack() {
-	return stack.slice()
-}
-export function isRunning(effect: ScopedCallback): (ScopedCallback | undefined)[] | false {
-	const rootEffect = getRoot(effect)
-
-	// Check if the effect is directly in the stack
-	const rootIndex = stack.indexOf(rootEffect)
-	if (rootIndex !== -1) {
-		return stack.slice(0, rootIndex + 1).reverse()
-	}
-
-	// Check if any effect in the stack is a descendant of this effect
-	// (i.e., walk up the parent chain from each stack effect to see if we reach this effect)
-	for (let i = 0; i < stack.length; i++) {
-		const stackEffect = stack[i]
-		let current: ScopedCallback | undefined = stackEffect
-		const visited = new WeakSet<ScopedCallback>()
-		const ancestorChain: ScopedCallback[] = []
-		// TODO: That's perhaps a lot of computations for an `assert`
-		// Walk up the parent chain to find if this effect is an ancestor
-		while (current && !visited.has(current)) {
-			visited.add(current)
-			const currentRoot = getRoot(current)
-			ancestorChain.push(currentRoot)
-			if (currentRoot === rootEffect) {
-				// Found a descendant - build the full chain from ancestor to active
-				// The ancestorChain contains [descendant, parent, ..., ancestor] (walking up)
-				// We need [ancestor (effect), ..., parent, descendant, ...stack from descendant to active]
-				const chainFromAncestor = ancestorChain.reverse() // [ancestor, ..., descendant]
-				// Prepend the actual effect we're checking (in case current is a wrapper)
-				if (chainFromAncestor[0] !== rootEffect) {
-					chainFromAncestor.unshift(rootEffect)
-				}
-				// Append the rest of the stack from the descendant to the active effect
-				const stackFromDescendant = stack.slice(0, i + 1).reverse() // [descendant, ..., active]
-				// Remove duplicate descendant (it's both at end of chainFromAncestor and start of stackFromDescendant)
-				if (chainFromAncestor.length > 0 && stackFromDescendant.length > 0) {
-					stackFromDescendant.shift() // Remove duplicate descendant
-				}
-				return [...chainFromAncestor, ...stackFromDescendant]
-			}
-			current = effectParent.get(current)
-		}
-	}
-
-	return false
-}
-export function withEffectStack<T>(snapshot: (ScopedCallback | undefined)[], fn: () => T): T {
-	const previousStack = stack.slice()
-	assignStack(snapshot)
-	try {
-		return fn()
-	} finally {
-		assignStack(previousStack)
-	}
+import { tag } from '../utils'
+import { asyncZone, ZoneAggregator, ZoneHistory } from '../zone'
+import { getRoot } from './registry'
+import { type ScopedCallback } from './types'
+
+export const effectHistory = tag(new ZoneHistory<ScopedCallback>(), 'effectHistory')
+tag(effectHistory.present, 'effectHistory.present')
+asyncZone.add(effectHistory)
+export const effectAggregator = tag(new ZoneAggregator(effectHistory.present), 'effectAggregator')
+
+export function isRunning(effect: ScopedCallback): boolean {
+	const root = getRoot(effect)
+	return effectHistory.some((e) => getRoot(e) === root)
 }
 
 export function getActiveEffect() {
-	return stack[0]
-}
-
-/**
- * Executes a function with a specific effect context
- * @param effect - The effect to use as context
- * @param fn - The function to execute
- * @param keepParent - Whether to keep the parent effect context
- * @returns The result of the function
- */
-export function withEffect<T>(effect: ScopedCallback | undefined, fn: () => T): T {
-
-	if (getRoot(effect) === getRoot(getActiveEffect())) return fn()
-	stack.unshift(effect)
-	try {
-		return fn()
-	} finally {
-		const recoveredEffect = stack.shift()
-		if (recoveredEffect !== effect) throw new ReactiveError('[reactive] Effect stack mismatch')
-	}
-}
-
-function assignStack(values: (ScopedCallback | undefined)[]) {
-	stack.length = 0
-	stack.push(...values)
-}
+	return effectHistory.present.active
+}

package/src/reactive/effects.ts

@@ -2,16 +2,10 @@ 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 {
-	getTrackingDisabled,
-	setTrackingDisabled,
-} from './tracking'
 import {
 	effectChildren,
 	effectParent,
@@ -21,6 +15,7 @@ import {
 	watchers,
 } from './registry'
 import {
+	cleanup as cleanupSymbol,
 	type DependencyAccess,
 	type EffectOptions,
 	type Evolution,
@@ -29,10 +24,11 @@ import {
 	ReactiveErrorCode,
 	// type AsyncExecutionMode,
 	type ScopedCallback,
-	cleanup as cleanupSymbol,
 	stopped,
 } from './types'
 
+import { unwrap } from './proxy-state'
+
 /**
  * Finds a cycle in a sequence of functions by looking for the first repetition
  */
@@ -59,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
@@ -211,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)) {
@@ -336,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)
@@ -458,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
 
@@ -597,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
@@ -626,8 +626,7 @@ 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) {
-	const cleanupFn = (effect as any)[cleanupSymbol]
-	if (cleanupFn) cleanupFn()
+	(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
 
@@ -636,11 +635,16 @@ function addToBatch(effect: ScopedCallback, caller?: ScopedCallback, immediate?:
 	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
@@ -807,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
+			}
 		}
 	}
 
@@ -907,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)
@@ -935,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)
@@ -998,98 +1009,35 @@ 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
  */
@@ -1130,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'
@@ -1146,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 = <T>(cb: () => T) => withEffect(runEffect, cb)
-	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
@@ -1160,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
@@ -1184,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' &&
@@ -1260,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) {
@@ -1272,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
@@ -1292,23 +1264,6 @@ export function effect(
 		cleanupEffectFromGraph(runEffect)
 		fr.unregister(stopEffect)
 	}
-	function augmentedRv(rv: ScopedCallback): ScopedCallback {
-		Object.defineProperty(rv, stopped, {
-			get() {
-				return effectStopped
-			},
-		})
-		Object.defineProperty(rv, cleanupSymbol, {
-			value: () => {
-				if (cleanup) {
-					const prevCleanup = cleanup
-					cleanup = null
-					withEffect(undefined, () => prevCleanup())
-				}
-			},
-		})
-		return rv
-	}
 	if (isRootEffect) {
 		const callIfCollected = augmentedRv(() => stopEffect())
 		fr.register(
@@ -1346,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)
 }
 
 /**
@@ -1365,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 }
@@ -1425,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 { ReactiveSet, ReactiveWeakSet } from './set'
+import { nonReactiveObjects } from './non-reactive-state'
+import { metaProtos, objectToProxy, proxyToObject } from './proxy'
 import { effectToReactiveObjects, watchers } from './registry'
+import { ReactiveSet, ReactiveWeakSet } from './set'
 
 // 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