@slimlib/store 1.6.2 → 2.0.0

package/src/debug.ts

@@ -0,0 +1,115 @@
+import { DEV } from 'esm-env';
+
+import { currentComputing } from './core';
+import { Flag } from './flags';
+import type { Scope } from './types';
+
+/**
+ * Debug configuration flag: Warn when writing to signals/state inside a computed
+ */
+export const WARN_ON_WRITE_IN_COMPUTED = 1 << 0;
+
+/**
+ * Debug configuration flag: Suppress warning when effects are disposed by GC instead of explicitly
+ */
+export const SUPPRESS_EFFECT_GC_WARNING = 1 << 1;
+
+/**
+ * Debug configuration flag: Warn when effects are created without an active scope
+ * This is an allowed pattern, but teams may choose to enforce scope usage for better effect lifecycle management
+ */
+export const WARN_ON_UNTRACKED_EFFECT = 1 << 2;
+
+/**
+ * Current debug configuration bitfield
+ */
+let debugConfigFlags = 0;
+
+/**
+ * Configure debug behavior using a bitfield of flags
+ */
+export const debugConfig = (flags: number): void => {
+    debugConfigFlags = flags | 0;
+};
+
+/**
+ * Safely call each function in an iterable, logging any errors to console
+ */
+export const safeForEach = (fns: Array<() => void>): void => {
+    for (let i = 0, len = fns.length; i < len; ++i) {
+        const fn = fns[i] as () => void;
+        try {
+            fn?.();
+        } catch (e) {
+            console.error(e);
+        }
+    }
+};
+
+/**
+ * Warn if writing inside a computed (not an effect)
+ * Only runs in DEV mode and when configured
+ */
+export const warnIfWriteInComputed = (context: string): void => {
+    if (DEV && (debugConfigFlags & WARN_ON_WRITE_IN_COMPUTED) !== 0 && currentComputing && (currentComputing.$_flags & Flag.EFFECT) === 0) {
+        console.warn(
+            `[@slimlib/store] Writing to ${context} inside a computed is not recommended. The computed will not automatically re-run when this value changes, which may lead to stale values.`
+        );
+    }
+};
+
+/**
+ * FinalizationRegistry for detecting effects that are GC'd without being properly disposed.
+ * Only created in DEV mode.
+ */
+const effectRegistry: FinalizationRegistry<string> | null = DEV
+    ? new FinalizationRegistry((stackTrace: string) => {
+          if ((debugConfigFlags & SUPPRESS_EFFECT_GC_WARNING) === 0) {
+              console.warn(
+                  `[@slimlib/store] Effect was garbage collected without being disposed. This may indicate a memory leak. Effects should be disposed by calling the returned dispose function or by using a scope that is properly disposed.\n\nEffect was created at:\n${stackTrace}`
+              );
+          }
+      })
+    : null;
+
+/**
+ * Register an effect for GC tracking.
+ * Returns a token that must be passed to unregisterEffect when the effect is properly disposed.
+ * Only active in DEV mode; returns undefined in production.
+ */
+export const registerEffect: () => object | undefined = DEV
+    ? () => {
+          const token = {};
+          // Capture stack trace at effect creation for better debugging
+          // Remove the first few lines (Error + registerEffect call) to get to the actual effect() call
+          const relevantStack = String(new Error().stack).split('\n').slice(3).join('\n');
+          (effectRegistry as FinalizationRegistry<string>).register(token, relevantStack, token);
+          return token;
+      }
+    : () => undefined;
+
+/**
+ * Unregister an effect from GC tracking (called when effect is properly disposed).
+ * Only active in DEV mode.
+ */
+export const unregisterEffect: (token: object | undefined) => void = DEV
+    ? (token: object | undefined) => {
+          effectRegistry?.unregister(token as WeakKey);
+      }
+    : () => {};
+
+/**
+ * Warn if an effect is created without an active scope.
+ * Only runs in DEV mode and when WARN_ON_UNTRACKED_EFFECT is enabled.
+ */
+export const warnIfNoActiveScope: (activeScope: Scope | undefined) => void = DEV
+    ? (activeScope: Scope | undefined) => {
+          if ((debugConfigFlags & WARN_ON_UNTRACKED_EFFECT) !== 0 && !activeScope) {
+              console.warn(
+                  `[@slimlib/store] Effect created without an active scope. Consider using scope() or setActiveScope() to track effects for proper lifecycle management.`
+              );
+          }
+      }
+    : () => {};
+
+export const cycleMessage = 'Detected cycle in computations.';

package/src/effect.ts

@@ -0,0 +1,125 @@
+import { batchedAddNew, checkComputedSources, clearSources, DepsSet, noopGetter, runWithTracking, scheduleFlush } from './core';
+import { cycleMessage, registerEffect, unregisterEffect, warnIfNoActiveScope } from './debug';
+import { Flag } from './flags';
+import { activeScope } from './globals';
+import { trackSymbol } from './symbols';
+import type { ReactiveNode } from './internal-types';
+import type { EffectCleanup } from './types';
+
+/**
+ * Effect creation counter - increments on every effect creation
+ * Used to maintain effect execution order by creation time
+ */
+let effectCreationCounter = 0;
+
+/**
+ * Creates a reactive effect that runs when dependencies change
+ */
+// biome-ignore lint/suspicious/noConfusingVoidType: void is semantically correct here - callback may return nothing or a cleanup function
+export const effect = (callback: () => void | EffectCleanup): (() => void) => {
+    let disposed = false;
+
+    // Register effect for GC tracking (only in DEV mode)
+    const gcToken = registerEffect();
+
+    // Warn if effect is created without an active scope (only in DEV mode when enabled)
+    warnIfNoActiveScope(activeScope);
+
+    // Declare node first so the runner closure can capture it.
+    // The variable will be assigned before the runner is ever called.
+    let node: ReactiveNode;
+
+    // Define the runner function BEFORE creating the node so that $_fn
+    // is a function from the start (Fix #1: avoids hidden class transition
+    // from undefined → function on the $_fn field).
+    const runner = () => {
+        // Skip if effect was disposed (may still be in batched queue from before disposal)
+        if (disposed) {
+            return;
+        }
+
+        // Cycle detection: if this node is already being computed, we have a cycle
+        const flags = node.$_flags;
+        if ((flags & Flag.COMPUTING) !== 0) {
+            throw new Error(cycleMessage);
+        }
+
+        // ----------------------------------------------------------------
+        // PULL PHASE: Verify if sources actually changed before running
+        // ----------------------------------------------------------------
+        // Bail-out optimization: if only CHECK flag is set (not DIRTY),
+        // verify that computed sources actually changed before running
+        if ((flags & (Flag.DIRTY | Flag.CHECK | Flag.HAS_STATE_SOURCE)) === Flag.CHECK) {
+            // PULL: Read computed sources to check if they changed
+            // If false, sources didn't change - clear CHECK flag and skip
+            // If true, sources changed or errored - proceed to run
+            if (!checkComputedSources(node.$_sources)) {
+                node.$_flags = flags & ~Flag.CHECK;
+                return;
+            }
+        }
+
+        // ----------------------------------------------------------------
+        // PULL PHASE: Execute effect and track dependencies
+        // ----------------------------------------------------------------
+        runWithTracking(node, () => {
+            // Run previous cleanup if it exists (stored in $_value)
+            if (typeof node.$_value === 'function') {
+                (node.$_value as EffectCleanup)();
+            }
+            // Run the callback and store new cleanup in $_value
+            // (callback will PULL values from signals/state/computed)
+            node.$_value = callback();
+        });
+    };
+
+    // Create effect node as a plain object with IDENTICAL initial field types
+    // as computed nodes to ensure V8 hidden class monomorphism (Fix #2):
+    //   $_deps:   new DepsSet() (Set object, same as computed — never used for effects)
+    //   $_fn:     runner (function, same as computed's getter)
+    //   $_equals: Object.is (function, same as computed's equality comparator)
+    //
+    // $_value: stores cleanup function returned by the effect callback
+    // $_stamp: creation order counter for effect scheduling
+    node = {
+        $_sources: [],
+        $_deps: new DepsSet<ReactiveNode>(noopGetter),
+        $_flags: Flag.DIRTY | Flag.EFFECT,
+        $_skipped: 0,
+        $_version: 0,
+        $_value: undefined as unknown,
+        $_stamp: ++effectCreationCounter,
+        $_fn: runner,
+        $_equals: Object.is,
+    } as unknown as ReactiveNode;
+
+    const effectId = node.$_stamp;
+
+    const dispose = (): void => {
+        // Mark as disposed to prevent running if still in batched queue
+        disposed = true;
+        // Unregister from GC tracking (only in DEV mode)
+        unregisterEffect(gcToken);
+        // Run cleanup if it exists (stored in $_value)
+        if (typeof node.$_value === 'function') {
+            (node.$_value as EffectCleanup)();
+        }
+        clearSources(node);
+    };
+
+    // Track to appropriate scope
+    if (activeScope) {
+        (activeScope[trackSymbol] as (dispose: () => void) => void)(dispose);
+    }
+
+    // ----------------------------------------------------------------
+    // Initial scheduling (triggers first PULL when flush runs)
+    // ----------------------------------------------------------------
+    // Trigger first run via batched queue
+    // node is already dirty
+    // and effect is for sure with the latest id so we directly adding without the sort
+    batchedAddNew(node, effectId);
+    scheduleFlush();
+
+    return dispose;
+};

package/src/flags.ts

@@ -0,0 +1,38 @@
+// ============================================================================
+// BIT FLAGS FOR NODE STATE
+// ============================================================================
+// These flags are central to the push/pull reactive algorithm:
+// - PUSH PHASE sets: Flag.CHECK, Flag.DIRTY (propagated eagerly on source change)
+// - PULL PHASE checks: Flag.NEEDS_WORK to decide if recomputation is needed
+// - PULL PHASE clears: Flag.DIRTY, Flag.CHECK after recomputation
+// ============================================================================
+
+// biome-ignore lint/suspicious/noConstEnum: optimization
+export const enum Flag {
+    // PUSH PHASE: Set when a source definitely changed - forces recomputation
+    DIRTY = 1 << 0, // 1 - definitely needs recomputation
+
+    // PUSH PHASE: Set when a source might have changed - needs verification
+    CHECK = 1 << 1, // 2 - might need recomputation, check sources first
+
+    // PULL PHASE: Set while executing getter to detect cycles
+    COMPUTING = 1 << 2, // 4 - currently executing
+
+    // Determines if node receives PUSH notifications (effects always do)
+    EFFECT = 1 << 3, // 8 - is an effect (eager execution, always live)
+
+    // PULL PHASE: Indicates cached value is available
+    HAS_VALUE = 1 << 4, // 16 - has a cached value
+
+    // PULL PHASE: Indicates cached error is available
+    HAS_ERROR = 1 << 5, // 32 - has a cached error (per TC39 Signals proposal)
+
+    // PUSH PHASE: When set, node receives push notifications from sources
+    LIVE = 1 << 6, // 64 - computed is live (has live dependents)
+
+    // PULL PHASE: Has at least one state/signal source (requires polling, can't skip loop)
+    HAS_STATE_SOURCE = 1 << 7, // 128 - has state/signal dependency
+
+    // PULL PHASE: Has at least one computed source (requires version update loop)
+    HAS_COMPUTED_SOURCE = 1 << 8, // 256 - has computed dependency
+}

package/src/globals.ts

@@ -0,0 +1,30 @@
+import type { Scope } from './types';
+
+/**
+ * Active scope for effect tracking
+ * When set, effects created will be tracked to this scope
+ * Can be set via setActiveScope() or automatically during scope() callbacks
+ */
+export let activeScope: Scope | undefined;
+
+/**
+ * Set the active scope for effect tracking
+ * Effects created outside of a scope() callback will be tracked to this scope
+ * Pass undefined to clear the active scope
+ */
+export const setActiveScope = (scope: Scope | undefined): void => {
+    activeScope = scope;
+};
+
+/**
+ * Scheduler function used to schedule effect execution
+ * Defaults to queueMicrotask, can be replaced with setScheduler
+ */
+export let scheduler: (callback: () => void) => void = queueMicrotask;
+
+/**
+ * Set a custom scheduler function for effect execution
+ */
+export const setScheduler = (newScheduler: (callback: () => void) => void): void => {
+    scheduler = newScheduler;
+};

package/src/index.ts

@@ -0,0 +1,9 @@
+export { computed } from './computed';
+export { flushEffects, untracked, unwrapValue } from './core';
+export { debugConfig, SUPPRESS_EFFECT_GC_WARNING, WARN_ON_UNTRACKED_EFFECT, WARN_ON_WRITE_IN_COMPUTED } from './debug';
+export { effect } from './effect';
+export { activeScope, setActiveScope, setScheduler } from './globals';
+export { scope } from './scope';
+export { signal } from './signal';
+export { state } from './state';
+export type { Computed, Effect, EffectCleanup, OnDisposeCallback, Scope, ScopeCallback, ScopeFunction, Signal } from './types';

package/src/internal-types.ts

@@ -0,0 +1,45 @@
+/**
+ * Internal types used for implementation - not part of public API
+ */
+
+/**
+ * Source entry for dependencies (unified for monomorphism).
+ * Properties are initialized for both types to ensure consistent hidden class.
+ */
+export type SourceEntry = {
+    $_dependents: Set<ReactiveNode>;
+    $_node: ReactiveNode | undefined;
+    $_version: number;
+    $_getter: undefined | (() => unknown);
+    $_storedValue: unknown;
+};
+
+/**
+ * Base type for reactive nodes (computed and effect).
+ * Uses $_ prefixed properties for minification.
+ *
+ * Both computed and effect nodes are plain objects and MUST initialize ALL
+ * of these properties in the same order to ensure V8 hidden class monomorphism.
+ * Property initialization order:
+ *   $_sources, $_deps, $_flags, $_skipped, $_version,
+ *   $_value, $_stamp, $_fn, $_equals
+ *
+ * Several fields serve different purposes depending on node type:
+ *   $_value  — Computed: cached value or thrown error. Effect: cleanup function.
+ *   $_stamp  — Computed: last seen globalVersion (fast-path cache). Effect: creation order (scheduling).
+ *   $_fn     — Computed: getter function. Effect: runner function.
+ *   $_equals — Computed: equality comparator. Effect: Object.is (unused, for hidden class monomorphism).
+ *   $_deps   — Computed: set of dependent consumers. Effect: empty DepsSet (unused, for hidden class monomorphism).
+ *   $_version — Computed: value change counter. Effect: 0 (unused).
+ */
+export type ReactiveNode = {
+    $_sources: SourceEntry[];
+    $_deps: Set<ReactiveNode>;
+    $_flags: number;
+    $_skipped: number;
+    $_version: number;
+    $_value: unknown;
+    $_stamp: number;
+    $_fn: (() => unknown) | undefined;
+    $_equals: ((a: unknown, b: unknown) => boolean) | undefined;
+};

package/src/scope.ts

@@ -0,0 +1,85 @@
+import { safeForEach } from './debug';
+import { activeScope, setActiveScope } from './globals';
+import { childrenSymbol, trackSymbol } from './symbols';
+import type { OnDisposeCallback, Scope, ScopeCallback } from './types';
+
+/**
+ * Creates a reactive scope for tracking effects
+ * Effects created within a scope callback are automatically tracked and disposed together
+ */
+export const scope = (callback?: ScopeCallback, parent: Scope | undefined | null = activeScope): Scope => {
+    const effects: (() => void)[] = [];
+    const children: Scope[] = [];
+    const cleanups: Array<() => void> = [];
+    let disposed = false;
+    let myIndex = -1;
+
+    /**
+     * Register a cleanup function to run when scope is disposed
+     */
+    const onDispose: OnDisposeCallback = cleanup => {
+        if (disposed) {
+            return;
+        }
+        cleanups.push(cleanup);
+    };
+
+    const ctx = ((cb?: ScopeCallback) => {
+        if (!cb) {
+            // Dispose - return early if already disposed (idempotent)
+            if (disposed) {
+                return;
+            }
+            // Dispose
+            disposed = true;
+
+            // Dispose children first (depth-first)
+            safeForEach(children);
+
+            // Stop all effects
+            safeForEach(effects);
+            effects.length = 0;
+
+            // Run cleanup handlers
+            safeForEach(cleanups);
+
+            // Remove from parent
+            if (parent) {
+                (parent[childrenSymbol] as (Scope | undefined)[])[myIndex] = undefined;
+            }
+
+            return;
+        }
+
+        // Extend scope - silently ignore if disposed
+        if (disposed) {
+            return ctx;
+        }
+
+        // Run callback in this scope's context
+        const prev = activeScope;
+        setActiveScope(ctx);
+        try {
+            cb(onDispose);
+        } finally {
+            setActiveScope(prev);
+        }
+        return ctx;
+    }) as Scope;
+
+    // Internal symbols for effect tracking and child management
+    ctx[trackSymbol] = (dispose: () => void) => effects.push(dispose);
+    ctx[childrenSymbol] = children;
+
+    // Register with parent
+    if (parent) {
+        myIndex = (parent[childrenSymbol] as Scope[]).push(ctx) - 1;
+    }
+
+    // Run initial callback if provided
+    if (callback) {
+        ctx(callback);
+    }
+
+    return ctx;
+};

package/src/signal.ts

@@ -0,0 +1,55 @@
+import { currentComputing, DepsSet, markDependents, tracked, trackStateDependency } from './core';
+import { warnIfWriteInComputed } from './debug';
+import type { ReactiveNode } from './internal-types';
+import type { Signal } from './types';
+
+/**
+ * Create a simple signal without an initial value
+ */
+export function signal<T>(): Signal<T | undefined>;
+/**
+ * Create a simple signal with an initial value
+ */
+export function signal<T>(initialValue: T): Signal<T>;
+/**
+ * Create a simple signal
+ */
+export function signal<T>(initialValue?: T): Signal<T> {
+    let value = initialValue as T;
+    let deps: DepsSet<ReactiveNode> | undefined;
+
+    /**
+     * Read the signal value and track dependency
+     */
+    const read = (): T => {
+        // === PULL PHASE ===
+        // When a computed/effect reads this signal, we register the dependency
+        // Fast path: if not tracked or no current computing, skip tracking
+        if (tracked && currentComputing !== undefined) {
+            // Pass value getter for polling optimization (value revert detection)
+            // biome-ignore lint/suspicious/noAssignInExpressions: optimization
+            trackStateDependency((deps ??= new DepsSet<ReactiveNode>(read)), read, value);
+        }
+        return value;
+        // === END PULL PHASE ===
+    };
+
+    /**
+     * Set a new value and notify dependents
+     */
+    read.set = (newValue: T): void => {
+        // === PUSH PHASE ===
+        // When the signal value changes, we eagerly propagate dirty/check flags
+        // to all dependents via markDependents
+        warnIfWriteInComputed('signal');
+        if (!Object.is(value, newValue)) {
+            value = newValue;
+            if (deps !== undefined) {
+                markDependents(deps); // Push: notify all dependents
+            }
+        }
+        // === END PUSH PHASE ===
+    };
+
+    return read;
+}

package/src/state.ts

@@ -0,0 +1,170 @@
+import { currentComputing, DepsSet, markDependents, tracked, trackStateDependency, unwrapValue } from './core';
+import { warnIfWriteInComputed } from './debug';
+import { propertyDepsSymbol, unwrap } from './symbols';
+import type { ReactiveNode } from './internal-types';
+
+/**
+ * Creates a store without an initial object
+ */
+export function state(): object;
+/**
+ * Creates a store with an initial object
+ */
+export function state<T extends object>(object: T): T;
+/**
+ * Creates a reactive state object
+ */
+export function state<T extends object>(object: T = {} as T): T {
+    // State uses a proxy to intercept reads and writes
+    // - Reads trigger PULL phase (trackDependency registers the consumer)
+    // - Writes trigger PUSH phase (markDependents propagates dirty flags)
+    const proxiesCache = new WeakMap();
+
+    /**
+     * PUSH PHASE: Notify all dependents that a property changed
+     * This propagates dirty/check flags to all live consumers
+     */
+    const notifyPropertyDependents = (target: object, property: string | symbol): void => {
+        const propsMap = (target as Record<symbol, unknown>)[propertyDepsSymbol] as Map<string | symbol, DepsSet<ReactiveNode>> | undefined;
+        if (!propsMap) return;
+        const deps = propsMap.get(property);
+        if (deps !== undefined) {
+            markDependents(deps as DepsSet<ReactiveNode>);
+        }
+    };
+
+    const createProxy = <U extends object>(object: U): U => {
+        if (proxiesCache.has(object)) {
+            return proxiesCache.get(object) as U;
+        }
+
+        let methodCache: Map<string | symbol, (...args: unknown[]) => unknown> | undefined;
+
+        const proxy = new Proxy(object, {
+            // PUSH PHASE: Setting a property notifies all dependents
+            set(target, p, newValue) {
+                warnIfWriteInComputed('state');
+                const realValue = unwrapValue(newValue);
+                // Use direct property access instead of Reflect for performance
+                if (!Object.is((target as Record<string | symbol, unknown>)[p], realValue)) {
+                    (target as Record<string | symbol, unknown>)[p] = realValue;
+                    // PUSH: Propagate dirty flags to dependents
+                    notifyPropertyDependents(target, p);
+                    // Clear method cache entry if it was a method
+                    methodCache?.delete(p);
+                }
+                return true;
+            },
+            // PULL PHASE: Reading a property registers the dependency
+            get(target, p) {
+                if (p === unwrap) return target;
+                // Use direct property access instead of Reflect for performance
+                const propValue = (target as Record<string | symbol, unknown>)[p];
+
+                // PULL: Track dependency if we're inside an effect/computed
+                if (tracked && currentComputing !== undefined) {
+                    // Get or create the Map for this target (stored as non-enumerable property)
+                    let propsMap = (target as Record<symbol, unknown>)[propertyDepsSymbol] as
+                        | Map<string | symbol, DepsSet<ReactiveNode>>
+                        | undefined;
+                    if (propsMap === undefined) {
+                        propsMap = new Map();
+                        Object.defineProperty(target, propertyDepsSymbol, { value: propsMap });
+                    }
+
+                    // Get or create the Set for this property
+                    let deps = propsMap.get(p);
+
+                    if (deps === undefined) {
+                        // Create DepsSet with getter eagerly to avoid V8 field constness deopts
+                        const propertyGetter = () => (target as Record<string | symbol, unknown>)[p];
+                        // biome-ignore lint/suspicious/noAssignInExpressions: optimization
+                        propsMap.set(p, (deps = new DepsSet<ReactiveNode>(propertyGetter)));
+                    }
+
+                    // PULL: Bidirectional linking with optimization
+                    // Pass value getter for polling optimization (value revert detection)
+                    // Capture target and property for later value retrieval
+                    trackStateDependency(
+                        deps as DepsSet<ReactiveNode>,
+                        (deps as DepsSet<ReactiveNode>).$_getter as () => unknown,
+                        propValue
+                    );
+                }
+
+                // Fast path for primitives (most common case)
+                const propertyType = typeof propValue;
+                if (propValue === null || (propertyType !== 'object' && propertyType !== 'function')) {
+                    return propValue;
+                }
+
+                // Functions are wrapped to apply with correct `this` (target, not proxy)
+                // After function call, notify dependents (function may have mutated internal state)
+                // Functions are wrapped to trigger PUSH after mutation
+                if (propertyType === 'function') {
+                    // Check cache first to avoid creating new function on every access
+                    if (methodCache === undefined) {
+                        methodCache = new Map<string | symbol, (...args: unknown[]) => unknown>();
+                    }
+                    let cached = methodCache.get(p);
+                    if (cached === undefined) {
+                        // Capture method reference at cache time to avoid re-reading on each call
+                        const method = propValue as (...args: unknown[]) => unknown;
+                        cached = (...args: unknown[]) => {
+                            // Unwrap in-place - args is already a new array from rest params
+                            for (let i = 0, len = args.length; i < len; ++i) {
+                                args[i] = unwrapValue(args[i]);
+                            }
+                            const result = method.apply(target, args);
+                            // PUSH PHASE: Notify after function call (function may have mutated state)
+                            // Only notify if we're NOT currently inside an effect/computed execution
+                            // to avoid infinite loops when reading during effect
+                            if (currentComputing === undefined) {
+                                const propsMap = (target as Record<symbol, unknown>)[propertyDepsSymbol] as
+                                    | Map<string | symbol, DepsSet<ReactiveNode>>
+                                    | undefined;
+                                if (propsMap === undefined) return result;
+                                for (const deps of propsMap.values()) {
+                                    // PUSH: Propagate dirty flags to all property dependents
+                                    markDependents(deps);
+                                }
+                            }
+                            return result;
+                        };
+                        methodCache.set(p, cached);
+                    }
+                    return cached;
+                }
+
+                // Object - create nested proxy
+                return createProxy(propValue as object);
+            },
+            // PUSH PHASE: Defining a property notifies dependents
+            defineProperty(target, property, attributes) {
+                warnIfWriteInComputed('state');
+                const result = Reflect.defineProperty(target, property, attributes);
+                if (result) {
+                    // PUSH: Propagate dirty flags to dependents
+                    notifyPropertyDependents(target, property);
+                }
+                return result;
+            },
+            // PUSH PHASE: Deleting a property notifies dependents
+            deleteProperty(target, p) {
+                warnIfWriteInComputed('state');
+                const result = Reflect.deleteProperty(target, p);
+                if (result) {
+                    // PUSH: Propagate dirty flags to dependents
+                    notifyPropertyDependents(target, p);
+                    // Clear method cache entry if it was a method
+                    methodCache?.delete(p);
+                }
+                return result;
+            },
+        });
+        proxiesCache.set(object, proxy);
+        return proxy as U;
+    };
+
+    return createProxy(object);
+}