mutts 1.0.5 → 1.0.7

package/src/reactive/map.ts

@@ -1,56 +1,47 @@
+import { contentRef } from '../utils'
 import { touched, touched1 } from './change'
 import { notifyPropertyChange } from './deep-touch'
 import { makeReactiveEntriesIterator, makeReactiveIterator } from './non-reactive'
 import { reactive } from './proxy'
 import { dependant } from './tracking'
-import { prototypeForwarding } from './types'
-
-const native = Symbol('native')
 
 /**
  * Reactive wrapper around JavaScript's WeakMap class
  * Only tracks individual key operations, no size tracking (WeakMap limitation)
  */
-export class ReactiveWeakMap<K extends object, V> {
-	readonly [native]!: WeakMap<K, V>
-	readonly content!: symbol
-	constructor(original: WeakMap<K, V>) {
-		Object.defineProperties(this, {
-			[native]: { value: original },
-			[prototypeForwarding]: { value: original },
-			content: { value: Symbol('WeakMapContent') },
-			[Symbol.toStringTag]: { value: 'ReactiveWeakMap' },
-		})
+export abstract class ReactiveWeakMap<K extends object, V> extends WeakMap<K, V> {
+	get [Symbol.toStringTag]() {
+		return 'ReactiveWeakMap'
 	}
 
 	// Implement WeakMap interface methods with reactivity
 	delete(key: K): boolean {
-		const hadKey = this[native].has(key)
-		const result = this[native].delete(key)
+		const hadKey = this.has(key)
+		const result = this.delete(key)
 
-		if (hadKey) touched1(this.content, { type: 'del', prop: key }, key)
+		if (hadKey) touched1(contentRef(this), { type: 'del', prop: key }, key)
 
 		return result
 	}
 
 	get(key: K): V | undefined {
-		dependant(this.content, key)
-		return reactive(this[native].get(key))
+		dependant(contentRef(this), key)
+		return reactive(this.get(key))
 	}
 
 	has(key: K): boolean {
-		dependant(this.content, key)
-		return this[native].has(key)
+		dependant(contentRef(this), key)
+		return this.has(key)
 	}
 
 	set(key: K, value: V): this {
-		const hadKey = this[native].has(key)
-		const oldValue = this[native].get(key)
+		const hadKey = this.has(key)
+		const oldValue = this.get(key)
 		const reactiveValue = reactive(value)
-		this[native].set(key, reactiveValue)
+		this.set(key, reactiveValue)
 
 		if (!hadKey || oldValue !== reactiveValue) {
-			notifyPropertyChange(this.content, key, oldValue, reactiveValue, hadKey)
+			notifyPropertyChange(contentRef(this), key, oldValue, reactiveValue, hadKey)
 		}
 
 		return this
@@ -61,60 +52,52 @@ export class ReactiveWeakMap<K extends object, V> {
  * Reactive wrapper around JavaScript's Map class
  * Tracks size changes, individual key operations, and collection-wide operations
  */
-export class ReactiveMap<K, V> {
-	readonly [native]!: Map<K, V>
-	readonly content!: symbol
-
-	constructor(original: Map<K, V>) {
-		Object.defineProperties(this, {
-			[native]: { value: original },
-			[prototypeForwarding]: { value: original },
-			content: { value: Symbol('MapContent') },
-			[Symbol.toStringTag]: { value: 'ReactiveMap' },
-		})
+export abstract class ReactiveMap<K, V> extends Map<K, V> {
+	get [Symbol.toStringTag]() {
+		return 'ReactiveMap'
 	}
 
 	// Implement Map interface methods with reactivity
 	get size(): number {
 		dependant(this, 'size') // The ReactiveMap instance still goes through proxy
-		return this[native].size
+		return this.size
 	}
 
 	clear(): void {
-		const hadEntries = this[native].size > 0
-		this[native].clear()
+		const hadEntries = this.size > 0
+		this.clear()
 
 		if (hadEntries) {
 			const evolution = { type: 'bunch', method: 'clear' } as const
 			// Clear triggers all effects since all keys are affected
 			touched1(this, evolution, 'size')
-			touched(this.content, evolution)
+			touched(contentRef(this), evolution)
 		}
 	}
 
 	entries(): Generator<[K, V]> {
-		dependant(this.content)
-		return makeReactiveEntriesIterator(this[native].entries())
+		dependant(contentRef(this))
+		return makeReactiveEntriesIterator(this.entries())
 	}
 
 	forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void {
-		dependant(this.content)
-		this[native].forEach(callbackfn, thisArg)
+		dependant(contentRef(this))
+		this.forEach(callbackfn, thisArg)
 	}
 
 	keys(): MapIterator<K> {
-		dependant(this.content)
-		return this[native].keys()
+		dependant(contentRef(this))
+		return this.keys()
 	}
 
 	values(): Generator<V> {
-		dependant(this.content)
-		return makeReactiveIterator(this[native].values())
+		dependant(contentRef(this))
+		return makeReactiveIterator(this.values())
 	}
 
-	[Symbol.iterator](): Iterator<[K, V]> {
-		dependant(this.content)
-		const nativeIterator = this[native][Symbol.iterator]()
+	[Symbol.iterator](): MapIterator<[K, V]> {
+		dependant(contentRef(this))
+		const nativeIterator = this[Symbol.iterator]()
 		return {
 			next() {
 				const result = nativeIterator.next()
@@ -126,17 +109,21 @@ export class ReactiveMap<K, V> {
 					done: false,
 				}
 			},
+			[Symbol.iterator]() {
+				return this
+			},
+			[Symbol.dispose]() {},
 		}
 	}
 
 	// Implement Map methods with reactivity
 	delete(key: K): boolean {
-		const hadKey = this[native].has(key)
-		const result = this[native].delete(key)
+		const hadKey = this.has(key)
+		const result = this.delete(key)
 
 		if (hadKey) {
 			const evolution = { type: 'del', prop: key } as const
-			touched1(this.content, evolution, key)
+			touched1(contentRef(this), evolution, key)
 			touched1(this, evolution, 'size')
 		}
 
@@ -144,23 +131,23 @@ export class ReactiveMap<K, V> {
 	}
 
 	get(key: K): V | undefined {
-		dependant(this.content, key)
-		return reactive(this[native].get(key))
+		dependant(contentRef(this), key)
+		return reactive(this.get(key))
 	}
 
 	has(key: K): boolean {
-		dependant(this.content, key)
-		return this[native].has(key)
+		dependant(contentRef(this), key)
+		return this.has(key)
 	}
 
 	set(key: K, value: V): this {
-		const hadKey = this[native].has(key)
-		const oldValue = this[native].get(key)
+		const hadKey = this.has(key)
+		const oldValue = this.get(key)
 		const reactiveValue = reactive(value)
-		this[native].set(key, reactiveValue)
+		this.set(key, reactiveValue)
 
 		if (!hadKey || oldValue !== reactiveValue) {
-			notifyPropertyChange(this.content, key, oldValue, reactiveValue, hadKey)
+			notifyPropertyChange(contentRef(this), key, oldValue, reactiveValue, hadKey)
 			// Also notify size change for Map (WeakMap doesn't track size)
 			const evolution = { type: hadKey ? 'set' : 'add', prop: key } as const
 			touched1(this, evolution, 'size')

package/src/reactive/memoize.ts

@@ -1,8 +1,10 @@
 import { decorator } from '../decorator'
-import { renamed } from '../utils'
+import { deepCompare, renamed } from '../utils'
 import { touched1 } from './change'
-import { effect, root } from './effects'
-import { dependant, getRoot, markWithRoot } from './tracking'
+import { effect, root, untracked } from './effects'
+import { getRoot, markWithRoot } from './registry'
+import { dependant } from './tracking'
+import { options, rootFunction } from './types'
 
 export type Memoizable = object | any[] | symbol | ((...args: any[]) => any)
 
@@ -12,7 +14,8 @@ type MemoCacheTree<Result> = {
 	branches?: WeakMap<Memoizable, MemoCacheTree<Result>>
 }
 
-const memoizedRegistry = new WeakMap<Function, Function>()
+const memoizedRegistry = new WeakMap<any, Function>()
+const wrapperRegistry = new WeakMap<Function, Function>()
 
 function getBranch<Result>(tree: MemoCacheTree<Result>, key: Memoizable): MemoCacheTree<Result> {
 	tree.branches ??= new WeakMap()
@@ -38,18 +41,33 @@ function memoizeFunction<Result, Args extends Memoizable[]>(
 			throw new Error('memoize expects non-null object arguments')
 
 		let node: MemoCacheTree<Result> = cacheRoot
+		// Note: decorators add `this` as first argument
 		for (const arg of localArgs) {
 			node = getBranch(node, arg)
 		}
 
 		dependant(node, 'memoize')
-		if ('result' in node) return node.result!
+		if ('result' in node) {
+			if (options.onMemoizationDiscrepancy) {
+				const wasVerification = options.isVerificationRun
+				options.isVerificationRun = true
+				try {
+					const fresh = untracked(() => fn(...localArgs))
+					if (!deepCompare(node.result, fresh)) {
+						options.onMemoizationDiscrepancy(node.result, fresh, fn, localArgs, 'calculation')
+					}
+				} finally {
+					options.isVerificationRun = wasVerification
+				}
+			}
+			return node.result!
+		}
 
 		// Create memoize internal effect to track dependencies and invalidate cache
 		// Use untracked to prevent the effect creation from being affected by parent effects
 		node.cleanup = root(() =>
 			effect(
-				markWithRoot(() => {
+				() => {
 					// Execute the function and track its dependencies
 					// The function execution will automatically track dependencies on reactive objects
 					node.result = fn(...localArgs)
@@ -57,11 +75,31 @@ function memoizeFunction<Result, Args extends Memoizable[]>(
 						// When dependencies change, clear the cache and notify consumers
 						delete node.result
 						touched1(node, { type: 'invalidate', prop: localArgs }, 'memoize')
+						// Lazy memoization: stop the effect so it doesn't re-run immediately.
+						// It will be re-created on next access.
+						if (node.cleanup) {
+							node.cleanup()
+							node.cleanup = undefined
+						}
 					}
-				}, fnRoot),
+				},
 				{ opaque: true }
 			)
 		)
+
+		if (options.onMemoizationDiscrepancy) {
+			const wasVerification = options.isVerificationRun
+			options.isVerificationRun = true
+			try {
+				const fresh = untracked(() => fn(...localArgs))
+				if (!deepCompare(node.result, fresh)) {
+					options.onMemoizationDiscrepancy(node.result, fresh, fn, localArgs, 'comparison')
+				}
+			} finally {
+				options.isVerificationRun = wasVerification
+			}
+		}
+
 		return node.result!
 	}, fn)
 
@@ -71,35 +109,53 @@ function memoizeFunction<Result, Args extends Memoizable[]>(
 }
 
 export const memoize = decorator({
-	getter(original, propertyKey) {
-		const memoized = memoizeFunction(
-			markWithRoot(
-				renamed(
-					(that: object) => {
-						return original.call(that)
-					},
-					`${String(this.constructor.name)}.${String(propertyKey)}`
-				),
-				original
-			)
-		)
+	getter(original, target, propertyKey) {
 		return function (this: any) {
+			let wrapper = wrapperRegistry.get(original)
+			if (!wrapper) {
+				wrapper = markWithRoot(
+					renamed(
+						(that: object) => {
+							return original.call(that)
+						},
+						`${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(propertyKey)}`
+					),
+					{
+						method: original,
+						propertyKey,
+						...((original as any)[rootFunction]
+							? { [rootFunction]: (original as any)[rootFunction] }
+							: {}),
+					}
+				)
+				wrapperRegistry.set(original, wrapper)
+			}
+			const memoized = memoizeFunction(wrapper as any)
 			return memoized(this)
 		}
 	},
-	method(original, name) {
-		const memoized = memoizeFunction(
-			markWithRoot(
-				renamed(
-					(that: object, ...args: object[]) => {
-						return original.call(that, ...args)
-					},
-					`${String(this.constructor.name)}.${String(name)}`
-				),
-				original
-			)
-		) as (...args: object[]) => unknown
+	method(original, target, name) {
 		return function (this: any, ...args: object[]) {
+			let wrapper = wrapperRegistry.get(original)
+			if (!wrapper) {
+				wrapper = markWithRoot(
+					renamed(
+						(that: object, ...args: object[]) => {
+							return original.call(that, ...args)
+						},
+						`${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(name)}`
+					),
+					{
+						method: original,
+						propertyKey: name,
+						...((original as any)[rootFunction]
+							? { [rootFunction]: (original as any)[rootFunction] }
+							: {}),
+					}
+				)
+				wrapperRegistry.set(original, wrapper)
+			}
+			const memoized = memoizeFunction(wrapper as any) as (...args: object[]) => unknown
 			return memoized(this, ...args)
 		}
 	},

package/src/reactive/project.ts

@@ -1,4 +1,4 @@
-import { ReflectGet, ReflectSet } from '../utils'
+import { FoolProof } from '../utils'
 import { setEffectName } from './debug'
 import { getActiveEffect } from './effect-context'
 import { effect, untracked } from './effects'
@@ -42,17 +42,10 @@ export type ProjectAccess<SourceValue, Key, SourceType, Target> = {
 	value: SourceValue
 }
 
-type BivariantProjectCallback<Args extends any[], Return> = {
-	bivarianceHack(...args: Args): Return
-}['bivarianceHack']
-
-export type ProjectCallback<
-	SourceValue,
-	Key,
-	Target extends object,
-	SourceType,
-	Result,
-> = BivariantProjectCallback<[ProjectAccess<SourceValue, Key, SourceType, Target>, Target], Result>
+export type ProjectCallback<SourceValue, Key, Target extends object, SourceType, Result> = (
+	access: ProjectAccess<SourceValue, Key, SourceType, Target>,
+	target: Target
+) => Result
 
 export type ProjectResult<Target extends object> = Target & { [cleanup]: ScopedCallback }
 
@@ -92,12 +85,12 @@ function projectArray<SourceValue, ResultValue>(
 	source: readonly SourceValue[],
 	apply: ProjectCallback<SourceValue, number, ResultValue[], readonly SourceValue[], ResultValue>
 ): ProjectResult<ResultValue[]> {
-	const observedSource = reactive(source) as readonly SourceValue[]
+	source = reactive(source)
 	const target = reactive([] as ResultValue[])
 	const indexEffects = new Map<number, ScopedCallback>()
 
 	function normalizeTargetLength(length: number) {
-		ReflectSet(target as unknown as object, 'length', length, target)
+		FoolProof.set(target as unknown as object, 'length', length, target)
 	}
 
 	function disposeIndex(index: number) {
@@ -113,7 +106,7 @@ function projectArray<SourceValue, ResultValue>(
 	const depth = parent ? parent.depth + 1 : 0
 
 	const cleanupLength = effect(function projectArrayLengthEffect({ ascend }) {
-		const length = observedSource.length
+		const length = source.length
 		normalizeTargetLength(length)
 		const existing = Array.from(indexEffects.keys())
 		for (let i = 0; i < length; i++) {
@@ -124,10 +117,10 @@ function projectArray<SourceValue, ResultValue>(
 					const previous = untracked(() => target[index])
 					const accessBase = {
 						key: index,
-						source: observedSource,
-						get: () => ReflectGet(observedSource as any, index, observedSource),
+						source,
+						get: () => FoolProof.get(source as any, index, source),
 						set: (value: SourceValue) =>
-							ReflectSet(observedSource as any, index, value, observedSource),
+							FoolProof.set(source as any, index, value, source),
 						old: previous,
 					} as ProjectAccess<SourceValue, number, readonly SourceValue[], ResultValue[]>
 					defineAccessValue(accessBase)
@@ -136,7 +129,7 @@ function projectArray<SourceValue, ResultValue>(
 				})
 				setEffectName(stop, `project[${depth}]:${index}`)
 				effectProjectionMetadata.set(stop, {
-					source: observedSource,
+					source,
 					key: index,
 					target,
 					depth,
@@ -149,7 +142,7 @@ function projectArray<SourceValue, ResultValue>(
 	})
 
 	return makeCleanup(target, indexEffects, () => cleanupLength(), {
-		source: observedSource,
+		source,
 		target,
 		apply,
 		depth,
@@ -274,9 +267,9 @@ function projectRecord<Source extends Record<PropertyKey, any>, ResultValue>(
 					const accessBase = {
 						key: sourceKey,
 						source: observedSource,
-						get: () => ReflectGet(observedSource, sourceKey, observedSource),
+						get: () => FoolProof.get(observedSource, sourceKey, observedSource),
 						set: (value: Source[typeof sourceKey]) =>
-							ReflectSet(observedSource, sourceKey, value, observedSource),
+							FoolProof.set(observedSource, sourceKey, value, observedSource),
 						old: previous,
 					} as ProjectAccess<
 						Source[typeof sourceKey],
@@ -415,6 +408,34 @@ type ProjectOverload = {
 	map: typeof projectMap
 }
 
+function projectCore<SourceValue, ResultValue>(
+	source: readonly SourceValue[],
+	apply: ProjectCallback<SourceValue, number, ResultValue[], readonly SourceValue[], ResultValue>
+): ProjectResult<ResultValue[]>
+function projectCore<Key extends PropertyKey, SourceValue, ResultValue>(
+	source: Register<SourceValue, Key>,
+	apply: ProjectCallback<
+		SourceValue,
+		Key,
+		Map<Key, ResultValue>,
+		Register<SourceValue, Key>,
+		ResultValue
+	>
+): ProjectResult<Map<Key, ResultValue>>
+function projectCore<Source extends Record<PropertyKey, any>, ResultValue>(
+	source: Source,
+	apply: ProjectCallback<
+		Source[keyof Source],
+		keyof Source,
+		Record<keyof Source, ResultValue>,
+		Source,
+		ResultValue
+	>
+): ProjectResult<Record<keyof Source, ResultValue>>
+function projectCore<Key, Value, ResultValue>(
+	source: Map<Key, Value>,
+	apply: ProjectCallback<Value, Key, Map<Key, ResultValue>, Map<Key, Value>, ResultValue>
+): ProjectResult<Map<Key, ResultValue>>
 function projectCore(source: any, apply: any): ProjectResult<any> {
 	if (Array.isArray(source)) return projectArray(source, apply)
 	if (source instanceof Map) return projectMap(source, apply)

package/src/reactive/proxy.ts

@@ -1,6 +1,6 @@
 import { decorator } from '../decorator'
 import { mixin } from '../mixins'
-import { isOwnAccessor, ReflectGet, ReflectSet } from '../utils'
+import { FoolProof, isOwnAccessor } from '../utils'
 import { touched1 } from './change'
 import { notifyPropertyChange } from './deep-touch'
 import {
@@ -10,7 +10,7 @@ import {
 	objectsWithDeepWatchers,
 	removeBackReference,
 } from './deep-watch-state'
-import { withEffect } from './effect-context'
+import { untracked } from './effects'
 import { absent, isNonReactive } from './non-reactive-state'
 import {
 	getExistingProxy,
@@ -25,34 +25,29 @@ import {
 	nativeReactive,
 	nonReactiveMark,
 	options,
-	prototypeForwarding,
 	ReactiveError,
 	ReactiveErrorCode,
 	unreactiveProperties,
 } from './types'
+export const metaProtos = new WeakMap()
 
 const hasReentry: any[] = []
 const reactiveHandlers = {
 	[Symbol.toStringTag]: 'MutTs Reactive',
 	get(obj: any, prop: PropertyKey, receiver: any) {
+		if (obj && typeof obj === 'object' && !Object.hasOwn(obj, prop)) {
+			const metaProto = metaProtos.get(obj.constructor)
+			if (metaProto && prop in metaProto) {
+				const desc = Object.getOwnPropertyDescriptor(metaProto, prop)!
+				return desc.get ? desc.get.call(obj) : (...args) => desc.value.apply(obj, args)
+			}
+		}
 		if (prop === nonReactiveMark) return false
 		const unwrappedObj = unwrap(obj)
 		// Check if this property is marked as unreactive
 		if (unwrappedObj[unreactiveProperties]?.has(prop) || typeof prop === 'symbol')
-			return ReflectGet(obj, prop, receiver)
+			return FoolProof.get(obj, prop, receiver)
 
-		// Special-case: array wrappers use prototype forwarding + numeric accessors.
-		// With options.instanceMembers=true, inherited reads are normally not tracked, which breaks
-		// reactivity for array indices/length (they appear inherited on the proxy).
-		const isArrayCase =
-			prototypeForwarding in obj &&
-			// biome-ignore lint/suspicious/useIsArray: This is the whole point here
-			obj[prototypeForwarding] instanceof Array &&
-			typeof prop === 'string' &&
-			(prop === 'length' || !Number.isNaN(Number(prop)))
-		if (isArrayCase) {
-			dependant(obj, prop === 'length' ? 'length' : Number(prop))
-		}
 		// Check if property exists and if it's an own property (cached for later use)
 		const hasProp = Reflect.has(receiver, prop)
 		const isOwnProp = hasProp && Object.hasOwn(receiver, prop)
@@ -86,7 +81,7 @@ const reactiveHandlers = {
 				current = next
 			}
 		}
-		const value = ReflectGet(obj, prop, receiver)
+		const value = FoolProof.get(obj, prop, receiver)
 		if (typeof value === 'object' && value !== null) {
 			const reactiveValue = reactiveObject(value)
 
@@ -106,19 +101,8 @@ const reactiveHandlers = {
 
 		// Check if this property is marked as unreactive
 		if (unwrappedObj[unreactiveProperties]?.has(prop) || unwrappedObj !== unwrappedReceiver)
-			return ReflectSet(obj, prop, value, receiver)
-		// Really specific case for when Array is forwarder, in order to let it manage the reactivity
-		const isArrayCase =
-			prototypeForwarding in obj &&
-			// biome-ignore lint/suspicious/useIsArray: This is the whole point here
-			obj[prototypeForwarding] instanceof Array &&
-			(!Number.isNaN(Number(prop)) || prop === 'length')
+			return FoolProof.set(obj, prop, value, receiver)
 		const newValue = unwrap(value)
-
-		if (isArrayCase) {
-			;(obj as any)[prop] = newValue
-			return true
-		}
 		// Read old value, using withEffect(undefined, ...) for getter-only accessors to avoid
 		// breaking memoization dependency tracking during SET operations
 		let oldVal = absent
@@ -127,12 +111,12 @@ const reactiveHandlers = {
 			const receiverDesc = Object.getOwnPropertyDescriptor(unwrappedReceiver, prop)
 			const targetDesc = Object.getOwnPropertyDescriptor(unwrappedObj, prop)
 			const desc = receiverDesc || targetDesc
-			// If it's a getter-only accessor (has getter but no setter), read without tracking
-			// to avoid breaking memoization invalidation when the getter calls memoized functions
+			// We *need* to use `receiver` and not `unwrappedObj` here, otherwise we break
+			// the dependency tracking for memoized getters
 			if (desc?.get && !desc?.set) {
-				oldVal = withEffect(undefined, () => Reflect.get(unwrappedObj, prop, unwrappedReceiver))
+				oldVal = untracked(() => Reflect.get(unwrappedObj, prop, receiver))
 			} else {
-				oldVal = Reflect.get(unwrappedObj, prop, unwrappedReceiver)
+				oldVal = untracked(() => Reflect.get(unwrappedObj, prop, receiver))
 			}
 		}
 		if (objectsWithDeepWatchers.has(obj)) {
@@ -148,7 +132,7 @@ const reactiveHandlers = {
 		if (oldVal !== newValue) {
 			// For getter-only accessors, Reflect.set() may fail, but we still return true
 			// to avoid throwing errors. Only proceed with change notifications if set succeeded.
-			if (ReflectSet(obj, prop, newValue, receiver)) {
+			if (FoolProof.set(obj, prop, newValue, receiver)) {
 				notifyPropertyChange(obj, prop, oldVal, newValue, oldVal !== absent)
 			}
 		}
@@ -189,15 +173,6 @@ const reactiveHandlers = {
 
 		return true
 	},
-	getPrototypeOf(obj: any): object | null {
-		if (prototypeForwarding in obj) return obj[prototypeForwarding]
-		return Object.getPrototypeOf(obj)
-	},
-	setPrototypeOf(obj: any, proto: object | null): boolean {
-		if (prototypeForwarding in obj) return false
-		Object.setPrototypeOf(obj, proto)
-		return true
-	},
 	ownKeys(obj: any): (string | symbol)[] {
 		dependant(obj, allProps)
 		return Reflect.ownKeys(obj)

package/src/reactive/record.ts

@@ -1,4 +1,4 @@
-import { ReflectGet, ReflectSet } from '../utils'
+import { FoolProof } from '../utils'
 import { touched1 } from './change'
 import { effect } from './effects'
 import { cleanedBy, cleanup } from './interface'
@@ -147,9 +147,9 @@ export function organized<
 					const sourceKey = key as keyof Source
 					const accessBase = {
 						key: sourceKey,
-						get: () => ReflectGet(observedSource, sourceKey, observedSource),
+						get: () => FoolProof.get(observedSource, sourceKey, observedSource),
 						set: (value: Source[typeof sourceKey]) =>
-							ReflectSet(observedSource, sourceKey, value, observedSource),
+							FoolProof.set(observedSource, sourceKey, value, observedSource),
 					}
 					Object.defineProperty(accessBase, 'value', {
 						get: accessBase.get,