mutts 1.0.6 → 1.0.7

package/src/reactive/interface.ts

@@ -1,11 +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 } from './tracking'
 import { markWithRoot } from './registry'
+import { dependant } from './tracking'
 import {
 	type DependencyAccess,
 	nonReactiveMark,
@@ -87,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(
-		function watchObjectEffect() {
-			dependant(value)
-			if (immediate) withEffect(myParentEffect, () => changed(value))
-			immediate = true
-		}
-	)
+	return effect(function watchObjectEffect() {
+		dependant(value)
+		if (immediate) changed(value)
+		immediate = true
+	})
 }
 
 function watchCallBack<T>(
@@ -103,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,
-					() => {
-						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)
-							)
-						}
-					}
-				)
+				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 () => {
@@ -154,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
 }
@@ -214,11 +202,9 @@ export function derived<T>(compute: (dep: DependencyAccess) => T): {
 	return cleanedBy(
 		rv,
 		untracked(() =>
-			effect(
-				function derivedEffect(access) {
-					rv.value = compute(access)
-				}
-			)
+			effect(function derivedEffect(access) {
+				rv.value = compute(access)
+			})
 		)
 	)
 }

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

@@ -2,8 +2,8 @@ import { decorator } from '../decorator'
 import { deepCompare, renamed } from '../utils'
 import { touched1 } from './change'
 import { effect, root, untracked } from './effects'
-import { dependant } from './tracking'
 import { getRoot, markWithRoot } from './registry'
+import { dependant } from './tracking'
 import { options, rootFunction } from './types'
 
 export type Memoizable = object | any[] | symbol | ((...args: any[]) => any)
@@ -114,13 +114,18 @@ export const memoize = decorator({
 			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)}`),
+					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] } : {}),
+						...((original as any)[rootFunction]
+							? { [rootFunction]: (original as any)[rootFunction] }
+							: {}),
 					}
 				)
 				wrapperRegistry.set(original, wrapper)
@@ -134,13 +139,18 @@ export const memoize = decorator({
 			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)}`),
+					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] } : {}),
+						...((original as any)[rootFunction]
+							? { [rootFunction]: (original as any)[rootFunction] }
+							: {}),
 					}
 				)
 				wrapperRegistry.set(original, wrapper)

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
@@ -130,9 +114,9 @@ const reactiveHandlers = {
 			// 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, receiver))
+				oldVal = untracked(() => Reflect.get(unwrappedObj, prop, receiver))
 			} else {
-				oldVal = withEffect(undefined, () => Reflect.get(unwrappedObj, prop, receiver))
+				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,

package/src/reactive/register.ts

@@ -1,8 +1,9 @@
+import { FunctionWrapper } from '../zone'
 import { ArrayReadForward, forwardArray, getAt, Indexable, setAt } from '../indexable'
 import { effect } from './effects'
 import { unreactive } from './interface'
 import { reactive } from './proxy'
-import { type DependencyFunction, prototypeForwarding, type ScopedCallback } from './types'
+import { type ScopedCallback } from './types'
 
 // TODO: use register in a real-world crud situation, have "events" for add, delete, update
 
@@ -36,7 +37,7 @@ function getRegisterBase<T>() {
 interface RegisterInstance<T> extends ArrayReadForward<T> {
 	[index: number]: T
 }
-
+// TODO: What to do with prototype forwarding ?
 @unreactive
 class RegisterClass<T, K extends PropertyKey = PropertyKey>
 	extends getRegisterBase<any>()
@@ -51,12 +52,12 @@ class RegisterClass<T, K extends PropertyKey = PropertyKey>
 	readonly #usage = new Map<K, number>()
 	readonly #valueInfo = new Map<T, { key: K; stop?: ScopedCallback }>()
 	readonly #keyEffects = new Set<ScopedCallback>()
-	readonly #ascend: DependencyFunction
+	readonly #ascend: FunctionWrapper
 
 	constructor(keyFn: KeyFunction<T, K>, initial?: Iterable<T>) {
 		super()
 		/* Moved below initialization */
-		let ascendGet: DependencyFunction | undefined
+		let ascendGet: FunctionWrapper | undefined
 		effect(({ ascend }) => {
 			ascendGet = ascend
 		})
@@ -65,9 +66,6 @@ class RegisterClass<T, K extends PropertyKey = PropertyKey>
 		this.#keyFn = keyFn
 		this.#keys = reactive([] as K[])
 		this.#values = reactive(new Map<K, T>())
-		Object.defineProperties(this, {
-			[prototypeForwarding]: { value: this.#keys },
-		})
 		if (initial) this.push(...initial)
 	}