mutts 1.0.7 → 1.0.9

package/src/reactive/index.ts

@@ -1,15 +1,7 @@
+export { attend, lift, type ScanResult, scan } from './buffer'
 export { getState, touched, touched1 } from './change'
-export type { ReactivityGraph } from './debug'
-export {
-	buildReactivityGraph,
-	enableDevTools,
-	isDevtoolsEnabled,
-	registerEffectForDebug,
-	registerObjectForDebug,
-	setEffectName,
-	setObjectName,
-} from './debug'
 export { deepWatch } from './deep-watch'
+export { cleanedBy, derived, effectAggregator, getActiveEffect } from './effect-context'
 export {
 	addBatchCleanup,
 	atomic,
@@ -17,26 +9,32 @@ export {
 	defer,
 	effect,
 	getActivationLog,
+	onEffectThrow,
+	onEffectTrigger,
+	reset,
 	root,
-	trackEffect,
 	untracked,
 } from './effects'
-export { cleanedBy, cleanup, derived, unreactive, watch } from './interface'
 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,
+	cleanup,
+	type EffectAccess as DependencyAccess,
+	type EffectCleanup,
+	type EffectOptions,
+	type EffectTrigger,
 	type Evolution,
 	options as reactiveOptions,
 	ReactiveError,
 	ReactiveErrorCode,
 	type ScopedCallback,
 } from './types'
+export { unreactive, watch } from './watch'
+export { describe } from './describe'
 
 import { ReactiveArray } from './array'
 import {

package/src/reactive/map.ts

@@ -10,10 +10,6 @@ import { dependant } from './tracking'
  * Only tracks individual key operations, no size tracking (WeakMap limitation)
  */
 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.has(key)
@@ -53,10 +49,6 @@ export abstract class ReactiveWeakMap<K extends object, V> extends WeakMap<K, V>
  * Tracks size changes, individual key operations, and collection-wide operations
  */
 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
@@ -97,23 +89,15 @@ export abstract class ReactiveMap<K, V> extends Map<K, V> {
 
 	[Symbol.iterator](): MapIterator<[K, V]> {
 		dependant(contentRef(this))
-		const nativeIterator = this[Symbol.iterator]()
-		return {
-			next() {
-				const result = nativeIterator.next()
-				if (result.done) {
-					return result
-				}
-				return {
-					value: [result.value[0], reactive(result.value[1])],
-					done: false,
-				}
-			},
-			[Symbol.iterator]() {
-				return this
-			},
-			[Symbol.dispose]() {},
+		const it: MapIterator<[K, V]> = Map.prototype[Symbol.iterator].call(this)
+		const nativeNext = it.next.bind(it)
+		it.next = () => {
+			const result = nativeNext()
+			if (result.done) return result
+			const [key, value] = result.value
+			return { value: [reactive(key), reactive(value)], done: false }
 		}
+		return it
 	}
 
 	// Implement Map methods with reactivity

package/src/reactive/memoize.ts

@@ -4,7 +4,7 @@ import { touched1 } from './change'
 import { effect, root, untracked } from './effects'
 import { getRoot, markWithRoot } from './registry'
 import { dependant } from './tracking'
-import { options, rootFunction } from './types'
+import { optionCall, options, rootFunction } from './types'
 
 export type Memoizable = object | any[] | symbol | ((...args: any[]) => any)
 
@@ -54,7 +54,7 @@ function memoizeFunction<Result, Args extends Memoizable[]>(
 				try {
 					const fresh = untracked(() => fn(...localArgs))
 					if (!deepCompare(node.result, fresh)) {
-						options.onMemoizationDiscrepancy(node.result, fresh, fn, localArgs, 'calculation')
+						optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, localArgs, 'calculation')
 					}
 				} finally {
 					options.isVerificationRun = wasVerification
@@ -93,7 +93,7 @@ function memoizeFunction<Result, Args extends Memoizable[]>(
 			try {
 				const fresh = untracked(() => fn(...localArgs))
 				if (!deepCompare(node.result, fresh)) {
-					options.onMemoizationDiscrepancy(node.result, fresh, fn, localArgs, 'comparison')
+					optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, localArgs, 'comparison')
 				}
 			} finally {
 				options.isVerificationRun = wasVerification
@@ -108,6 +108,29 @@ function memoizeFunction<Result, Args extends Memoizable[]>(
 	return memoized as (...args: Args) => Result
 }
 
+/**
+ * Decorator and function wrapper for memoizing computed values based on reactive dependencies.
+ *
+ * When used as a decorator on getters or methods, it caches the result and automatically
+ * invalidates the cache when reactive dependencies change.
+ *
+ * When used as a function wrapper, it memoizes based on object arguments (WeakMap-based cache).
+ *
+ * @example
+ * ```typescript
+ * class User {
+ *   @memoize
+ *   get fullName() {
+ *     return `${this.firstName} ${this.lastName}`
+ *   }
+ * }
+ *
+ * // Or as a function wrapper
+ * const expensive = memoize((obj: SomeObject) => {
+ *   return heavyComputation(obj)
+ * })
+ * ```
+ */
 export const memoize = decorator({
 	getter(original, target, propertyKey) {
 		return function (this: any) {

package/src/reactive/project.md

@@ -0,0 +1,107 @@
+# project
+
+This document explains how `project(...)` composes reactive effects, and why it uses `ascend(...)` when creating per-item/per-key effects.
+
+## What `project` builds
+
+`project` is a reactive “mapping” primitive.
+
+- A **source** collection (`Array`, `Map`, `Register`, plain record)
+- A **target** collection of the same shape
+- A set of effects that keep target in sync with source:
+  - **structure effect** (length/keys watcher)
+  - **item effect** per key/index (computes the projected value)
+
+The important property is **stability**: changing one source entry should only re-run the effect that owns that entry.
+
+## Effects involved
+
+For `project.array(source, apply)` the implementation creates:
+
+- **Length effect**: watches the set of valid indexes by reading `source.length`.
+- **Index effects**: created lazily (when an index appears), one effect per index.
+
+The other variants (`project.map`, `project.record`, `project.register`) follow the same pattern:
+
+- a *keys effect* (watches which keys exist)
+- a *key effect* per key
+
+## Cleanup and “garbage collection”
+
+`effect(...)` has two cleanup pathways:
+
+- **explicit**: you keep the returned stop function and call it.
+- **GC-driven** (Node with `--expose-gc`): for **root effects only**, a `FinalizationRegistry` calls `stopEffect()` when the stop function itself becomes unreachable.
+
+Parenting matters because only root effects are eligible for automatic GC cleanup.
+
+### Parent-child relationship
+
+When an effect is created while another effect is active, it becomes a **child**:
+
+- the parent keeps a reference to a child-cleanup function
+- when the parent is cleaned up, it calls child-cleanups
+
+This guarantees that **unstored** children do not leak and do not rely on GC.
+
+## Why `project` uses `ascend(...)`
+
+In `project.ts`, per-item effects are created inside the structure effect.
+
+If we created item effects “normally” inside the structure effect body, they would be parented to the structure effect.
+
+That is *not* what we want:
+
+- The structure effect re-runs whenever the set of keys/indexes changes.
+- On each re-run, `effect(...)` executes the previous cleanup first.
+- If item effects were children of the structure effect, that cleanup would stop all item effects on every structural update.
+
+That would break stability:
+
+- pushing a new element would unnecessarily dispose and recreate existing item effects
+- nested projections would be especially unstable
+
+### What `ascend` does here
+
+`ascend` is a wrapper around `effectHistory.zoned`.
+
+It executes a function in the **parent effect context** (the effect that was active when the structure effect itself was created).
+
+So the parent chain becomes:
+
+- owning effect (the effect that called `project(...)`)
+  - structure effect (length/keys)
+  - item effects (per index/key)
+
+All of them share the same owner.
+
+This gives the intended semantics:
+
+- structure effect may re-run many times without killing item effects
+- when the owning effect stops (explicitly or by GC), it will stop:
+  - the structure effect
+  - all item effects
+  - all nested projections under those item effects
+
+## Projection context
+
+During an item effect’s first run, `project` calls:
+
+- `setActiveProjection({ source, key, target, depth, parent })`
+
+This attaches a `ProjectionContext` to the currently running effect via `effectProjectionMetadata`.
+
+`getActiveProjection()` is how nested projections discover their parent projection.
+
+The goal is to allow:
+
+- a nested projection to compute its own `depth`
+- a nested projection to know its parent projection (for debugging/introspection)
+
+## Testing expectations
+
+The behavior that matters (and that tests should lock down) is:
+
+- item effects are not disposed on structural updates of the same projection
+- disposing an outer item stops all nested projection effects under that item
+- disposing the owning effect (or letting it be GC’ed) stops all projection effects created under it

package/src/reactive/project.ts

@@ -1,16 +1,20 @@
-import { FoolProof } from '../utils'
-import { setEffectName } from './debug'
-import { getActiveEffect } from './effect-context'
+import { setEffectName } from '../../debug/debug'
+import { FoolProof, named } from '../utils'
+import { cleanedBy, getActiveEffect } from './effect-context'
 import { effect, untracked } from './effects'
-import { cleanedBy, cleanup } from './interface'
 import { reactive } from './proxy'
 import { Register } from './register'
-import { type ProjectionContext, projectionInfo, type ScopedCallback } from './types'
-
+import {
+	cleanup,
+	type EffectTrigger,
+	type ProjectionContext,
+	projectionInfo,
+	type ScopedCallback,
+} from './types'
 /**
  * Maps projection effects (item effects) to their projection context
  */
-export const effectProjectionMetadata = new WeakMap<ScopedCallback, ProjectionContext>()
+export const effectProjectionMetadata = new WeakMap<EffectTrigger, ProjectionContext>()
 
 /**
  * Returns the projection context of the currently running effect, if any.
@@ -19,11 +23,10 @@ export function getActiveProjection(): ProjectionContext | undefined {
 	const active = getActiveEffect()
 	return active ? effectProjectionMetadata.get(active) : undefined
 }
-
-/* TODO
-It seems to work and I feel like it's correct but I couldn't validate theoretically that `ascend`
-is the correct way to deal with nested effects.
-*/
+function setActiveProjection(projection: ProjectionContext | undefined) {
+	const active = getActiveEffect()
+	if (active) effectProjectionMetadata.set(active, projection)
+}
 
 type ProjectOldValue<Target> = Target extends readonly (infer Item)[]
 	? Item
@@ -105,41 +108,33 @@ function projectArray<SourceValue, ResultValue>(
 	const parent = getActiveProjection()
 	const depth = parent ? parent.depth + 1 : 0
 
-	const cleanupLength = effect(function projectArrayLengthEffect({ ascend }) {
+	const cleanupLength = effect(named(`project:${source[Symbol.toStringTag]}.length`, ({ ascend }) => {
 		const length = source.length
 		normalizeTargetLength(length)
 		const existing = Array.from(indexEffects.keys())
 		for (let i = 0; i < length; i++) {
 			if (indexEffects.has(i)) continue
-			ascend(() => {
+			ascend(function projectArrayIndexAscend() {
 				const index = i
-				const stop = effect(function projectArrayIndexEffect() {
+				const stop = effect(named(`project:${source[Symbol.toStringTag]}[${index}]`, ({ reaction }) => {
+					if (!reaction) setActiveProjection({ source, key: index, target, depth, parent })
 					const previous = untracked(() => target[index])
 					const accessBase = {
 						key: index,
 						source,
 						get: () => FoolProof.get(source as any, index, source),
-						set: (value: SourceValue) =>
-							FoolProof.set(source as any, index, value, source),
+						set: (value: SourceValue) => FoolProof.set(source as any, index, value, source),
 						old: previous,
 					} as ProjectAccess<SourceValue, number, readonly SourceValue[], ResultValue[]>
 					defineAccessValue(accessBase)
-					const produced = apply(accessBase, target)
-					target[index] = produced
-				})
+					target[index] = apply(accessBase, target)
+				}))
 				setEffectName(stop, `project[${depth}]:${index}`)
-				effectProjectionMetadata.set(stop, {
-					source,
-					key: index,
-					target,
-					depth,
-					parent,
-				})
 				indexEffects.set(i, stop)
 			})
 		}
 		for (const index of existing) if (index >= length) disposeIndex(index)
-	})
+	}))
 
 	return makeCleanup(target, indexEffects, () => cleanupLength(), {
 		source,
@@ -160,7 +155,7 @@ function projectRegister<Key extends PropertyKey, SourceValue, ResultValue>(
 		ResultValue
 	>
 ): ProjectResult<Map<Key, ResultValue>> {
-	const observedSource = reactive(source) as Register<SourceValue, Key>
+	source = reactive(source) as Register<SourceValue, Key>
 	const rawTarget = new Map<Key, ResultValue>()
 	const target = reactive(rawTarget) as Map<Key, ResultValue>
 	const keyEffects = new Map<Key, ScopedCallback>()
@@ -179,19 +174,20 @@ function projectRegister<Key extends PropertyKey, SourceValue, ResultValue>(
 
 	const cleanupKeys = effect(function projectRegisterEffect({ ascend }) {
 		const keys = new Set<Key>()
-		for (const key of observedSource.mapKeys()) keys.add(key)
+		for (const key of source.mapKeys()) keys.add(key)
 
 		for (const key of keys) {
 			if (keyEffects.has(key)) continue
 			ascend(() => {
-				const stop = effect(function projectRegisterKeyEffect() {
+				const stop = effect(function projectRegisterKeyEffect({ reaction }) {
+					if (!reaction) setActiveProjection({ source, key, target, depth, parent })
 					const previous = untracked(() => target.get(key))
 					const accessBase = {
 						key,
-						source: observedSource,
-						get: () => observedSource.get(key) as SourceValue,
+						source: source,
+						get: () => source.get(key) as SourceValue,
 						set: (value: SourceValue) => {
-							observedSource.set(key, value)
+							source.set(key, value)
 							return true
 						},
 						old: previous,
@@ -201,13 +197,6 @@ function projectRegister<Key extends PropertyKey, SourceValue, ResultValue>(
 					target.set(key, produced)
 				})
 				setEffectName(stop, `project[${depth}]:${String(key)}`)
-				effectProjectionMetadata.set(stop, {
-					source: observedSource,
-					key,
-					target,
-					depth,
-					parent,
-				})
 				keyEffects.set(key, stop)
 			})
 		}
@@ -216,7 +205,7 @@ function projectRegister<Key extends PropertyKey, SourceValue, ResultValue>(
 	})
 
 	return makeCleanup(target, keyEffects, () => cleanupKeys(), {
-		source: observedSource,
+		source: source,
 		target,
 		apply,
 		depth,
@@ -234,7 +223,7 @@ function projectRecord<Source extends Record<PropertyKey, any>, ResultValue>(
 		ResultValue
 	>
 ): ProjectResult<Record<keyof Source, ResultValue>> {
-	const observedSource = reactive(source) as Source
+	source = reactive(source) as Source
 	const target = reactive({} as Record<keyof Source, ResultValue>)
 	const keyEffects = new Map<PropertyKey, ScopedCallback>()
 
@@ -252,24 +241,25 @@ function projectRecord<Source extends Record<PropertyKey, any>, ResultValue>(
 
 	const cleanupKeys = effect(function projectRecordEffect({ ascend }) {
 		const keys = new Set<PropertyKey>()
-		for (const key in observedSource) keys.add(key)
-		const observed = Reflect.ownKeys(observedSource)
+		for (const key in source) keys.add(key)
+		const observed = Reflect.ownKeys(source)
 		for (const key of observed) keys.add(key)
 
 		for (const key of keys) {
 			if (keyEffects.has(key)) continue
 			ascend(() => {
-				const stop = effect(function projectRecordKeyEffect() {
+				const stop = effect(function projectRecordKeyEffect({ reaction }) {
+					if (!reaction) setActiveProjection({ source, key, target, depth, parent })
 					const sourceKey = key as keyof Source
 					const previous = untracked(
 						() => (target as Record<PropertyKey, ResultValue | undefined>)[key]
 					)
 					const accessBase = {
 						key: sourceKey,
-						source: observedSource,
-						get: () => FoolProof.get(observedSource, sourceKey, observedSource),
+						source: source,
+						get: () => FoolProof.get(source, sourceKey, source),
 						set: (value: Source[typeof sourceKey]) =>
-							FoolProof.set(observedSource, sourceKey, value, observedSource),
+							FoolProof.set(source, sourceKey, value, source),
 						old: previous,
 					} as ProjectAccess<
 						Source[typeof sourceKey],
@@ -282,13 +272,6 @@ function projectRecord<Source extends Record<PropertyKey, any>, ResultValue>(
 					;(target as any)[sourceKey] = produced
 				})
 				setEffectName(stop, `project[${depth}]:${String(key)}`)
-				effectProjectionMetadata.set(stop, {
-					source: observedSource,
-					key,
-					target,
-					depth,
-					parent,
-				})
 				keyEffects.set(key, stop)
 			})
 		}
@@ -297,7 +280,7 @@ function projectRecord<Source extends Record<PropertyKey, any>, ResultValue>(
 	})
 
 	return makeCleanup(target, keyEffects, () => cleanupKeys(), {
-		source: observedSource,
+		source: source,
 		target,
 		apply,
 		depth,
@@ -309,7 +292,7 @@ function projectMap<Key, Value, ResultValue>(
 	source: Map<Key, Value>,
 	apply: ProjectCallback<Value, Key, Map<Key, ResultValue>, Map<Key, Value>, ResultValue>
 ): ProjectResult<Map<Key, ResultValue>> {
-	const observedSource = reactive(source) as Map<Key, Value>
+	source = reactive(source) as Map<Key, Value>
 	const rawTarget = new Map<Key, ResultValue>()
 	const target = reactive(rawTarget) as Map<Key, ResultValue>
 	const keyEffects = new Map<Key, ScopedCallback>()
@@ -328,19 +311,20 @@ function projectMap<Key, Value, ResultValue>(
 
 	const cleanupKeys = effect(function projectMapEffect({ ascend }) {
 		const keys = new Set<Key>()
-		for (const key of observedSource.keys()) keys.add(key)
+		for (const key of source.keys()) keys.add(key)
 
 		for (const key of keys) {
 			if (keyEffects.has(key)) continue
 			ascend(() => {
-				const stop = effect(function projectMapKeyEffect() {
+				const stop = effect(function projectMapKeyEffect({ reaction }) {
+					if (!reaction) setActiveProjection({ source, key, target, depth, parent })
 					const previous = untracked(() => target.get(key))
 					const accessBase = {
 						key,
-						source: observedSource,
-						get: () => observedSource.get(key) as Value,
+						source: source,
+						get: () => source.get(key) as Value,
 						set: (value: Value) => {
-							observedSource.set(key, value)
+							source.set(key, value)
 							return true
 						},
 						old: previous,
@@ -350,13 +334,6 @@ function projectMap<Key, Value, ResultValue>(
 					target.set(key, produced)
 				})
 				setEffectName(stop, `project[${depth}]:${String(key)}`)
-				effectProjectionMetadata.set(stop, {
-					source: observedSource,
-					key,
-					target,
-					depth,
-					parent,
-				})
 				keyEffects.set(key, stop)
 			})
 		}
@@ -365,7 +342,7 @@ function projectMap<Key, Value, ResultValue>(
 	})
 
 	return makeCleanup(target, keyEffects, () => cleanupKeys(), {
-		source: observedSource,
+		source: source,
 		target,
 		apply,
 		depth,

package/src/reactive/proxy.ts

@@ -35,11 +35,18 @@ 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)) {
+		if (obj && typeof obj === 'object' && prop !== Symbol.toStringTag) {
 			const metaProto = metaProtos.get(obj.constructor)
-			if (metaProto && prop in metaProto) {
+			if (metaProto && Object.hasOwn(metaProto, prop)) {
 				const desc = Object.getOwnPropertyDescriptor(metaProto, prop)!
-				return desc.get ? desc.get.call(obj) : (...args) => desc.value.apply(obj, args)
+				if (desc.get) {
+					if (!Object.hasOwn(obj, prop)) return desc.get.call(obj)
+					// For own properties (e.g., array length): only override if writable/configurable
+					const ownDesc = Object.getOwnPropertyDescriptor(obj, prop)!
+					if (ownDesc.configurable || ownDesc.writable || ownDesc.get)
+						return desc.get.call(obj)
+				} else if (!Object.hasOwn(obj, prop))
+					return (...args: any[]) => desc.value.apply(obj, args)
 			}
 		}
 		if (prop === nonReactiveMark) return false
@@ -103,6 +110,17 @@ const reactiveHandlers = {
 		if (unwrappedObj[unreactiveProperties]?.has(prop) || unwrappedObj !== unwrappedReceiver)
 			return FoolProof.set(obj, prop, value, receiver)
 		const newValue = unwrap(value)
+		// metaProto setter dispatch (e.g., reactive array length)
+		if (obj && typeof obj === 'object' && prop !== Symbol.toStringTag) {
+			const metaProto = obj.constructor && metaProtos.get(obj.constructor)
+			if (metaProto && Object.hasOwn(metaProto, prop)) {
+				const desc = Object.getOwnPropertyDescriptor(metaProto, prop)!
+				if (desc.set) {
+					desc.set.call(obj, 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

package/src/reactive/record.ts

@@ -1,9 +1,13 @@
 import { FoolProof } from '../utils'
+import { attend } from './buffer'
 import { touched1 } from './change'
-import { effect } from './effects'
-import { cleanedBy, cleanup } from './interface'
+import { cleanedBy } from './effect-context'
 import { reactive } from './proxy'
-import { type ScopedCallback } from './types'
+import {
+	cleanup,
+	type EffectCloser,
+	type ScopedCallback,
+} from './types'
 
 /**
  * Provides type-safe access to a source object's property within the organized callback.
@@ -50,7 +54,7 @@ export type OrganizedCallback<Source extends Record<PropertyKey, any>, Target ex
 	 * The target object where organized data will be stored
 	 */
 	target: Target
-) => ScopedCallback | undefined
+) => EffectCloser | undefined
 
 /**
  * The result type of the organized function, combining the target object with cleanup capability.
@@ -125,51 +129,32 @@ export function organized<
 ): OrganizedResult<Target> {
 	const observedSource = reactive(source) as Source
 	const target = reactive(baseTarget) as Target
-	const keyEffects = new Map<PropertyKey, ScopedCallback>()
 
-	function disposeKey(key: PropertyKey) {
-		const stopEffect = keyEffects.get(key)
-		if (stopEffect) {
-			keyEffects.delete(key)
-			stopEffect()
-		}
-	}
-
-	const cleanupKeys = effect(function organizedKeysEffect({ ascend }) {
-		//const keys = Reflect.ownKeys(observedSource) as PropertyKey[]
-		const keys = new Set<PropertyKey>()
-		for (const key in observedSource) keys.add(key)
-
-		for (const key of keys) {
-			if (keyEffects.has(key)) continue
-			ascend(() => {
-				const stop = effect(function organizedKeyEffect() {
-					const sourceKey = key as keyof Source
-					const accessBase = {
-						key: sourceKey,
-						get: () => FoolProof.get(observedSource, sourceKey, observedSource),
-						set: (value: Source[typeof sourceKey]) =>
-							FoolProof.set(observedSource, sourceKey, value, observedSource),
-					}
-					Object.defineProperty(accessBase, 'value', {
-						get: accessBase.get,
-						set: accessBase.set,
-						configurable: true,
-						enumerable: true,
-					})
-					return apply(accessBase as OrganizedAccess<Source, typeof sourceKey>, target)
-				})
-				keyEffects.set(key, stop)
+	const stop = attend(
+		() => {
+			const keys: PropertyKey[] = []
+			for (const key in observedSource) keys.push(key)
+			return keys
+		},
+		(key) => {
+			const sourceKey = key as keyof Source
+			const accessBase = {
+				key: sourceKey,
+				get: () => FoolProof.get(observedSource, sourceKey, observedSource),
+				set: (value: Source[typeof sourceKey]) =>
+					FoolProof.set(observedSource, sourceKey, value, observedSource),
+			}
+			Object.defineProperty(accessBase, 'value', {
+				get: accessBase.get,
+				set: accessBase.set,
+				configurable: true,
+				enumerable: true,
 			})
+			return apply(accessBase as OrganizedAccess<Source, typeof sourceKey>, target)
 		}
+	)
 
-		for (const key of Array.from(keyEffects.keys())) if (!keys.has(key)) disposeKey(key)
-	})
-
-	return cleanedBy(target, () => {
-		cleanupKeys()
-		for (const key of Array.from(keyEffects.keys())) disposeKey(key)
-	}) as OrganizedResult<Target>
+	return cleanedBy(target, stop) as OrganizedResult<Target>
 }
 
 /**