@slimlib/store 1.6.2 → 2.0.1

package/dist/index.mjs

@@ -1 +1,1067 @@
-export { createStoreFactory, unwrapValue } from './core.mjs';
+import { DEV } from 'esm-env';
+
+/**
+ * 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
+ */
+let activeScope;
+/**
+ * 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
+ */
+const setActiveScope = (scope) => {
+    activeScope = scope;
+};
+/**
+ * Scheduler function used to schedule effect execution
+ * Defaults to queueMicrotask, can be replaced with setScheduler
+ */
+let scheduler = queueMicrotask;
+/**
+ * Set a custom scheduler function for effect execution
+ */
+const setScheduler = (newScheduler) => {
+    scheduler = newScheduler;
+};
+
+// Symbols for objects that ARE exposed to users
+// These must remain symbols to avoid leaking internal implementation details
+const [unwrap, propertyDepsSymbol, trackSymbol, childrenSymbol,
+// biome-ignore lint/suspicious/noSparseArray: fine
+] = Array.from([, , , ,], Symbol);
+
+/**
+ * Core reactive system implementation using push/pull algorithm:
+ *
+ * PUSH PHASE: When a source value changes (signal/state write):
+ *   - Increment globalVersion
+ *   - Eagerly propagate CHECK flags to all dependents
+ *   - Schedule effects for execution
+ *
+ * PULL PHASE: When a computed/effect is read:
+ *   - Check if recomputation is needed (via flags and source versions)
+ *   - Lazily recompute by pulling values from sources
+ *   - Update cached value and version
+ */
+/**
+ * No-op getter used as default for DepsSet.$_getter to ensure all DepsSet
+ * instances have the same field representation (function, never undefined).
+ * This avoids V8 field representation deopts when some DepsSets have a getter
+ * and others don't.
+ */
+/* v8 ignore next -- @preserve */
+const noopGetter = () => undefined;
+/**
+ * DepsSet extends Set with $_version and $_getter properties for dependency
+ * tracking. Using a class ensures all instances share the same V8 hidden class,
+ * avoiding hidden class transitions and field constness changes.
+ *
+ * IMPORTANT: $_getter always defaults to a no-op function (never undefined)
+ * so that all DepsSet instances share the same V8 field representation.
+ * This prevents "dependent field representation changed" deopts.
+ */
+class DepsSet extends Set {
+    a = 0;
+    b;
+    constructor(getter) {
+        super();
+        this.b = getter;
+    }
+}
+/**
+ * Factory for creating source entries (unified allocation site).
+ *
+ * Both state and computed source entries MUST be created through this single
+ * factory to ensure they share the same V8 hidden class. Using separate
+ * object literals in different functions creates different allocation sites,
+ * causing V8 to assign different hidden classes and making all property
+ * accesses on source entries polymorphic.
+ *
+ * @param dependents - The DepsSet tracking dependents of this source
+ * @param node - The source ReactiveNode (undefined for state/signal sources)
+ * @param version - Initial version number
+ * @param getter - Value getter (undefined for computed sources)
+ * @param storedValue - Cached value (undefined for computed sources)
+ */
+const createSourceEntry = (dependents, node, version, getter, storedValue) => ({
+    c: dependents,
+    d: node,
+    a: version,
+    b: getter,
+    e: storedValue,
+});
+let flushScheduled = false;
+/**
+ * Global version counter - increments on every signal/state write
+ * Used for fast-path: if globalVersion hasn't changed since last read, skip all checks
+ */
+let globalVersion = 1;
+const batched = [];
+let lastAddedId = 0;
+let needsSort = false;
+// Computation tracking state
+let currentComputing;
+let tracked = true;
+/**
+ * Set the tracked state for dependency tracking (internal use only)
+ */
+const setTracked = (value) => {
+    tracked = value;
+};
+/**
+ * Add an effect to the batched set
+ * PUSH PHASE: Part of effect scheduling during dirty propagation
+ * Caller must check Flag.NEEDS_WORK before calling to avoid duplicates
+ */
+const batchedAdd = (node) => {
+    const nodeId = node.f;
+    // Track if we're adding out of order
+    if (nodeId < lastAddedId) {
+        needsSort = true;
+    }
+    lastAddedId = nodeId;
+    batched.push(node);
+};
+/**
+ * Add a newly created effect to the batched set
+ * Used during effect creation - new effects always have the highest ID
+ * so we unconditionally update lastAddedId without checking order
+ */
+const batchedAddNew = (node, effectId) => {
+    lastAddedId = effectId;
+    batched.push(node);
+};
+/**
+ * Unwraps a proxied value to get the underlying object
+ * (Utility - not specific to push/pull phases)
+ */
+const unwrapValue = (value) => (value !== null &&
+    (typeof value === 'object' || typeof value === 'function') &&
+    value[unwrap]) ||
+    value;
+/**
+ * Make a computed live - register it with all its sources
+ * Called when a live consumer starts reading this computed
+ * PUSH PHASE: Enables push notifications to flow through this node
+ */
+const makeLive = (node) => {
+    node.g |= 64 /* Flag.LIVE */;
+    const nodeSources = node.h;
+    for (let i = 0, len = nodeSources.length; i < len; ++i) {
+        const { c: c, d: sourceNode } = nodeSources[i];
+        c.add(node);
+        if (sourceNode !== undefined && (sourceNode.g & (8 /* Flag.EFFECT */ | 64 /* Flag.LIVE */)) === 0) {
+            makeLive(sourceNode);
+        }
+    }
+};
+/**
+ * Make a computed non-live - unregister it from all its sources
+ * Called when all live consumers stop depending on this computed
+ * PUSH PHASE: Disables push notifications through this node
+ */
+const makeNonLive = (node) => {
+    node.g &= -65 /* Flag.LIVE */;
+    const nodeSources = node.h;
+    for (let i = 0, len = nodeSources.length; i < len; ++i) {
+        const { c: c, d: sourceNode } = nodeSources[i];
+        c.delete(node);
+        // Check: has Flag.LIVE but not Flag.EFFECT (effects never become non-live)
+        if (sourceNode !== undefined &&
+            (sourceNode.g & (8 /* Flag.EFFECT */ | 64 /* Flag.LIVE */)) === 64 /* Flag.LIVE */ &&
+            sourceNode.i.size === 0) {
+            makeNonLive(sourceNode);
+        }
+    }
+};
+/**
+ * Clear sources for a node starting from a specific index
+ * PULL PHASE: Cleanup during dependency tracking when sources change
+ */
+const clearSources = (node, fromIndex = 0) => {
+    const isLive = (node.g & (8 /* Flag.EFFECT */ | 64 /* Flag.LIVE */)) !== 0;
+    const nodeSources = node.h;
+    for (let i = fromIndex, len = nodeSources.length; i < len; ++i) {
+        const { c: c, d: sourceNode } = nodeSources[i];
+        // Check if this deps is retained (exists in kept portion) - avoid removing shared deps
+        let retained = false;
+        for (let j = 0; j < fromIndex && !retained; ++j) {
+            retained = nodeSources[j].c === c;
+        }
+        if (!retained) {
+            // Always remove from deps to prevent stale notifications
+            c.delete(node);
+            // If source is a computed and we're live, check if it became non-live
+            if (isLive &&
+                sourceNode !== undefined &&
+                (sourceNode.g & (8 /* Flag.EFFECT */ | 64 /* Flag.LIVE */)) === 64 /* Flag.LIVE */ &&
+                sourceNode.i.size === 0) {
+                makeNonLive(sourceNode);
+            }
+        }
+    }
+    nodeSources.length = fromIndex;
+};
+/**
+ * Execute all pending effects immediately
+ * This function can be called to manually trigger all scheduled effects
+ * before the next microtask
+ * PULL PHASE: Executes batched effects, each effect pulls its dependencies
+ */
+const flushEffects = () => {
+    flushScheduled = false;
+    // Collect nodes, only sort if effects were added out of order
+    // Use a copy of the array for execution to allow re-scheduling
+    const nodes = batched.slice();
+    batched.length = 0;
+    if (needsSort) {
+        nodes.sort((a, b) => a.f - b.f);
+    }
+    lastAddedId = 0;
+    needsSort = false;
+    // Call $_fn on each node instead of calling nodes directly as functions
+    // This enables effect nodes to be plain objects (same hidden class as computed)
+    for (let i = 0, len = nodes.length; i < len; ++i) {
+        const node = nodes[i];
+        try {
+            node.j?.();
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }
+};
+/**
+ * Schedule flush via scheduler (default: microtask)
+ * PUSH PHASE: Schedules the transition from push to pull phase
+ */
+const scheduleFlush = () => {
+    if (!flushScheduled) {
+        flushScheduled = true;
+        scheduler(flushEffects);
+    }
+};
+/**
+ * Track a state/signal dependency between currentComputing and a deps Set
+ * Uses liveness tracking - only live consumers register with sources
+ * PULL PHASE: Records dependencies during computation for future invalidation
+ */
+const trackStateDependency = (deps, valueGetter, cachedValue) => {
+    // Callers guarantee tracked && currentComputing are true
+    const sourcesArray = currentComputing.h;
+    const skipIndex = currentComputing.k;
+    const existing = sourcesArray[skipIndex];
+    const noSource = existing === undefined;
+    if (noSource || existing.c !== deps) {
+        // Different dependency - clear old ones from this point and rebuild
+        if (!noSource) {
+            clearSources(currentComputing, skipIndex);
+        }
+        // Track deps version, value getter, and last seen value for polling
+        // Uses shared createSourceEntry factory for V8 hidden class monomorphism
+        sourcesArray.push(createSourceEntry(deps, undefined, deps.a, valueGetter, cachedValue));
+        // Mark that this node has state/signal sources (for polling optimization)
+        currentComputing.g |= 128 /* Flag.HAS_STATE_SOURCE */;
+        // Only register with source if we're live
+        if ((currentComputing.g & (8 /* Flag.EFFECT */ | 64 /* Flag.LIVE */)) !== 0) {
+            deps.add(currentComputing);
+        }
+    }
+    else {
+        // Same state source - update depsVersion, getter, and storedValue for accurate polling
+        const entry = sourcesArray[skipIndex];
+        entry.a = deps.a;
+        entry.b = valueGetter;
+        entry.e = cachedValue;
+        // Re-set Flag.HAS_STATE_SOURCE (may have been cleared by runWithTracking)
+        currentComputing.g |= 128 /* Flag.HAS_STATE_SOURCE */;
+    }
+    ++currentComputing.k;
+};
+/**
+ * Mark a node as needing check (eager propagation with equality cutoff)
+ * PUSH PHASE: Eagerly propagates CHECK flag up the dependency graph
+ */
+const markNeedsCheck = (node) => {
+    const flags = node.g;
+    // Fast path: skip if already computing, dirty, or marked CHECK
+    // (COMPUTING | DIRTY | CHECK) (bits 0, 1, 2)
+    if ((flags & (4 /* Flag.COMPUTING */ | 1 /* Flag.DIRTY */ | 2 /* Flag.CHECK */)) !== 0) {
+        // Exception: computing effect that's not dirty yet needs to be marked dirty
+        // Uses combined mask: (flags & 13) === 12 means COMPUTING + EFFECT set, DIRTY not set
+        if ((flags & (4 /* Flag.COMPUTING */ | 8 /* Flag.EFFECT */ | 1 /* Flag.DIRTY */)) === (4 /* Flag.COMPUTING */ | 8 /* Flag.EFFECT */)) {
+            node.g = flags | 1 /* Flag.DIRTY */;
+            batchedAdd(node);
+            scheduleFlush();
+        }
+        return;
+    }
+    // Not skipped: set CHECK and propagate to dependents
+    node.g = flags | 2 /* Flag.CHECK */;
+    if ((flags & 8 /* Flag.EFFECT */) !== 0) {
+        batchedAdd(node);
+        scheduleFlush();
+    }
+    for (const dep of node.i) {
+        markNeedsCheck(dep);
+    }
+};
+/**
+ * Mark all dependents in a Set as needing check
+ * PUSH PHASE: Entry point for push propagation when a source value changes
+ */
+const markDependents = (deps) => {
+    ++globalVersion;
+    // Increment deps version for non-live computed polling
+    ++deps.a;
+    for (const dep of deps) {
+        markNeedsCheck(dep);
+    }
+};
+/**
+ * Run a getter function with dependency tracking
+ * Handles cycle detection, context setup, and source cleanup
+ * PULL PHASE: Core of pull - executes computation while tracking dependencies
+ */
+const runWithTracking = (node, getter) => {
+    // Clear (DIRTY | CHECK) and source flags (will be recalculated during tracking)
+    // Note: Even when called from checkComputedSources (which sets tracked=false), this works
+    // because runWithTracking sets tracked=true, so trackDependency will re-set the flag
+    node.g = (node.g & -388) | 4 /* Flag.COMPUTING */;
+    node.k = 0;
+    const prev = currentComputing;
+    const prevTracked = tracked;
+    currentComputing = node;
+    tracked = true;
+    try {
+        return getter();
+    }
+    finally {
+        currentComputing = prev;
+        tracked = prevTracked;
+        // biome-ignore lint/suspicious/noAssignInExpressions: optimization
+        const flags = (node.g &= -5 /* Flag.COMPUTING */);
+        const nodeSources = node.h;
+        const skipped = node.k;
+        const nodeSourcesLength = nodeSources.length;
+        // Only update versions if there are computed sources (state sources update inline)
+        if ((flags & 256 /* Flag.HAS_COMPUTED_SOURCE */) !== 0) {
+            const updateLen = Math.min(skipped, nodeSourcesLength);
+            for (let i = 0; i < updateLen; ++i) {
+                const entry = nodeSources[i];
+                const entryNode = entry.d;
+                if (entryNode !== undefined) {
+                    entry.a = entryNode.a;
+                }
+            }
+        }
+        // Clean up any excess sources that weren't reused
+        if (nodeSourcesLength > skipped) {
+            clearSources(node, skipped);
+        }
+    }
+};
+/**
+ * Execute a callback without tracking any reactive dependencies
+ * Useful when reading signals/state without creating a dependency relationship
+ * PULL PHASE: Temporarily disables dependency tracking during pull
+ */
+const untracked = (callback) => {
+    const prevTracked = tracked;
+    tracked = false;
+    try {
+        return callback();
+    }
+    finally {
+        tracked = prevTracked;
+    }
+};
+/**
+ * Check if any computed sources have changed or errored.
+ * Used by CHECK path optimization in computed and effect.
+ * PULL PHASE: Verifies if sources actually changed before recomputing (equality cutoff)
+ *
+ * Note: Callers must check HAS_STATE_SOURCE flag before calling this function.
+ * This function assumes all sources are computed (have $_node).
+ *
+ * @param sourcesArray - The sources to check (must all be computed sources)
+ * @returns true if sources changed, false if unchanged
+ */
+const checkComputedSources = (sourcesArray) => {
+    const prevTracked = tracked;
+    tracked = false;
+    const len = sourcesArray.length;
+    for (let i = 0; i < len; ++i) {
+        const sourceEntry = sourcesArray[i];
+        const sourceNode = sourceEntry.d;
+        // Access source to trigger its recomputation if needed
+        try {
+            computedRead(sourceNode);
+        }
+        catch {
+            // Error counts as changed - caller will recompute and may handle differently
+            tracked = prevTracked;
+            return true;
+        }
+        // Check if source version changed (meaning its value changed)
+        // Early exit - runWithTracking will update all versions during recomputation
+        if (sourceEntry.a !== sourceNode.a) {
+            tracked = prevTracked;
+            return true;
+        }
+    }
+    tracked = prevTracked;
+    return false;
+};
+
+/**
+ * Debug configuration flag: Warn when writing to signals/state inside a computed
+ */
+const WARN_ON_WRITE_IN_COMPUTED = 1 << 0;
+/**
+ * Debug configuration flag: Suppress warning when effects are disposed by GC instead of explicitly
+ */
+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
+ */
+const WARN_ON_UNTRACKED_EFFECT = 1 << 2;
+/**
+ * Current debug configuration bitfield
+ */
+let debugConfigFlags = 0;
+/**
+ * Configure debug behavior using a bitfield of flags
+ */
+const debugConfig = (flags) => {
+    debugConfigFlags = flags | 0;
+};
+/**
+ * Safely call each function in an iterable, logging any errors to console
+ */
+const safeForEach = (fns) => {
+    for (let i = 0, len = fns.length; i < len; ++i) {
+        const fn = fns[i];
+        try {
+            fn?.();
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }
+};
+/**
+ * Warn if writing inside a computed (not an effect)
+ * Only runs in DEV mode and when configured
+ */
+const warnIfWriteInComputed = (context) => {
+    if (DEV && (debugConfigFlags & WARN_ON_WRITE_IN_COMPUTED) !== 0 && currentComputing && (currentComputing.g & 8 /* 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 = DEV
+    ? new FinalizationRegistry((stackTrace) => {
+        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.
+ */
+const registerEffect = 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.register(token, relevantStack, token);
+        return token;
+    }
+    : () => undefined;
+/**
+ * Unregister an effect from GC tracking (called when effect is properly disposed).
+ * Only active in DEV mode.
+ */
+const unregisterEffect = DEV
+    ? (token) => {
+        effectRegistry?.unregister(token);
+    }
+    : () => { };
+/**
+ * Warn if an effect is created without an active scope.
+ * Only runs in DEV mode and when WARN_ON_UNTRACKED_EFFECT is enabled.
+ */
+const warnIfNoActiveScope = DEV
+    ? (activeScope) => {
+        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.`);
+        }
+    }
+    : () => { };
+const cycleMessage = 'Detected cycle in computations.';
+
+/**
+ * Read function for computed nodes
+ */
+function computedRead(self) {
+    // ===== PULL PHASE: Register this computed as a dependency of the current consumer =====
+    // Track if someone is reading us
+    if (tracked && currentComputing !== undefined) {
+        // Inline tracking for computed dependencies
+        const consumerSources = currentComputing.h;
+        const skipIndex = currentComputing.k;
+        const deps = self.i;
+        const existing = consumerSources[skipIndex];
+        const noSource = existing === undefined;
+        if (noSource || existing.c !== deps) {
+            // Different dependency - clear old ones from this point and rebuild
+            if (!noSource) {
+                clearSources(currentComputing, skipIndex);
+            }
+            // Push source entry - version will be updated after source computes
+            // Uses shared createSourceEntry factory for V8 hidden class monomorphism
+            consumerSources.push(createSourceEntry(deps, self, 0, undefined, undefined));
+            // Only register with source if we're live
+            if ((currentComputing.g & (8 /* Flag.EFFECT */ | 64 /* Flag.LIVE */)) !== 0) {
+                deps.add(currentComputing);
+                // If source computed is not live, make it live
+                if ((self.g & 64 /* Flag.LIVE */) === 0) {
+                    makeLive(self);
+                }
+            }
+        }
+        // Mark that this node has computed sources (for version update loop optimization)
+        currentComputing.g |= 256 /* Flag.HAS_COMPUTED_SOURCE */;
+        ++currentComputing.k;
+    }
+    let flags = self.g;
+    const sourcesArray = self.h;
+    // Cycle detection: if this computed is already being computed, we have a cycle
+    // This matches TC39 Signals proposal behavior: throw an error on cyclic reads
+    if ((flags & 4 /* Flag.COMPUTING */) !== 0) {
+        throw new Error(cycleMessage);
+    }
+    // ===== PULL PHASE: Check if cached value can be returned =====
+    // Combined check: node has cached result and doesn't need work
+    const hasCached = (flags & (16 /* Flag.HAS_VALUE */ | 32 /* Flag.HAS_ERROR */)) !== 0;
+    // biome-ignore lint/suspicious/noConfusingLabels: expected
+    checkCache: if ((flags & (1 /* Flag.DIRTY */ | 2 /* Flag.CHECK */)) === 0 && hasCached) {
+        // Fast-path: nothing has changed globally since last read
+        if (self.f === globalVersion) {
+            if ((flags & 32 /* Flag.HAS_ERROR */) !== 0) {
+                throw self.l;
+            }
+            return self.l;
+        }
+        // ===== PULL PHASE: Poll sources for non-live computeds =====
+        // Non-live nodes poll instead of receiving push notifications
+        if ((flags & 64 /* Flag.LIVE */) === 0) {
+            let sourceChanged = false;
+            // Disable tracking while polling sources to avoid unnecessary dependency tracking
+            const prevTracked = tracked;
+            // TODO: inline after it combined to a single scope?
+            setTracked(false);
+            for (let i = 0, len = sourcesArray.length; i < len; ++i) {
+                const source = sourcesArray[i];
+                const sourceNode = source.d; // Extract once at loop start
+                if (sourceNode === undefined) {
+                    // State source - check if deps version changed
+                    const currentDepsVersion = source.c.a;
+                    if (source.a !== currentDepsVersion) {
+                        // Deps version changed, check if actual value reverted (primitives only)
+                        const storedValue = source.e;
+                        const storedType = typeof storedValue;
+                        if (storedValue === null || (storedType !== 'object' && storedType !== 'function')) {
+                            const currentValue = source.b();
+                            if (Object.is(currentValue, storedValue)) {
+                                // Value reverted - update depsVersion and continue checking
+                                source.a = currentDepsVersion;
+                                continue;
+                            }
+                        }
+                        // Value actually changed - mark DIRTY and skip remaining
+                        sourceChanged = true;
+                        break;
+                    }
+                }
+                else {
+                    // Computed source - use sourceNode directly (already extracted above)
+                    try {
+                        computedRead(sourceNode);
+                    }
+                    catch {
+                        // Error counts as changed
+                        sourceChanged = true;
+                        break;
+                    }
+                    if (source.a !== sourceNode.a) {
+                        sourceChanged = true;
+                        break; // EXIT EARLY - don't process remaining sources
+                    }
+                }
+            }
+            setTracked(prevTracked);
+            if (sourceChanged) {
+                // Source changed or threw - mark DIRTY and proceed to recompute
+                self.g = flags |= 1 /* Flag.DIRTY */;
+                break checkCache;
+            }
+            // No sources changed - return cached value
+            self.f = globalVersion;
+            if ((flags & 32 /* Flag.HAS_ERROR */) !== 0) {
+                throw self.l;
+            }
+            return self.l;
+        }
+    }
+    // ===== PULL PHASE: Verify CHECK state for live computeds =====
+    // Live computeds receive CHECK via push - verify sources before recomputing
+    // Non-live computeds already verified above during polling
+    // Note: Check for Flag.HAS_VALUE OR Flag.HAS_ERROR since cached errors should also use this path
+    if ((flags & (1 /* Flag.DIRTY */ | 2 /* Flag.CHECK */ | 128 /* Flag.HAS_STATE_SOURCE */)) === 2 /* Flag.CHECK */ && hasCached) {
+        if (checkComputedSources(sourcesArray)) {
+            // Sources changed or errored - mark DIRTY and let getter run
+            flags = (flags & -3 /* Flag.CHECK */) | 1 /* Flag.DIRTY */;
+        }
+        else {
+            // Sources unchanged, clear CHECK flag and return cached value
+            self.g = flags & -3 /* Flag.CHECK */;
+            // No sources changed - return cached value
+            self.f = globalVersion;
+            if ((flags & 32 /* Flag.HAS_ERROR */) !== 0) {
+                throw self.l;
+            }
+            return self.l;
+        }
+    }
+    // ===== PULL PHASE: Recompute value by pulling from sources =====
+    // Recompute if dirty or check (sources actually changed)
+    if ((flags & (1 /* Flag.DIRTY */ | 2 /* Flag.CHECK */)) !== 0) {
+        const wasDirty = (flags & 1 /* Flag.DIRTY */) !== 0;
+        runWithTracking(self, () => {
+            try {
+                const newValue = self.j();
+                // Check if value actually changed (common path: no error recovery)
+                const changed = (flags & 16 /* Flag.HAS_VALUE */) === 0 || !self.m(self.l, newValue);
+                if (changed) {
+                    self.l = newValue;
+                    // Increment version to indicate value changed (for polling)
+                    ++self.a;
+                    self.g = (self.g | 16 /* Flag.HAS_VALUE */) & ~32 /* Flag.HAS_ERROR */;
+                    // ===== PUSH PHASE (during pull): Mark CHECK-only dependents as DIRTY =====
+                    // When value changes during recomputation, upgrade dependent CHECK flags to DIRTY
+                    for (const dep of self.i) {
+                        const depFlags = dep.g;
+                        if ((depFlags & (4 /* Flag.COMPUTING */ | 1 /* Flag.DIRTY */ | 2 /* Flag.CHECK */)) === 2 /* Flag.CHECK */) {
+                            dep.g = depFlags | 1 /* Flag.DIRTY */;
+                        }
+                    }
+                }
+                else if (wasDirty) {
+                    self.g |= 16 /* Flag.HAS_VALUE */;
+                }
+                // Update last seen global version
+                self.f = globalVersion;
+            }
+            catch (e) {
+                // Per TC39 Signals proposal: cache the error and mark as clean with error flag
+                // The error will be rethrown on subsequent reads until a dependency changes
+                // Reuse valueSymbol for error storage since a computed can't have both value and error
+                // Increment version since the result changed (to error)
+                ++self.a;
+                self.l = e;
+                self.g = (self.g & ~16 /* Flag.HAS_VALUE */) | 32 /* Flag.HAS_ERROR */;
+                self.f = globalVersion;
+            }
+        });
+    }
+    // Check if we have a cached error to rethrow (stored in valueSymbol)
+    if ((self.g & 32 /* Flag.HAS_ERROR */) !== 0) {
+        throw self.l;
+    }
+    return self.l;
+}
+/**
+ * Creates a computed value that automatically tracks dependencies and caches results
+ */
+const computed = (getter, equals = Object.is) => {
+    const node = {
+        h: [],
+        i: new DepsSet(noopGetter),
+        g: 1 /* Flag.DIRTY */,
+        k: 0,
+        a: 0,
+        l: undefined,
+        f: 0,
+        j: getter,
+        m: equals,
+    };
+    return () => computedRead(node);
+};
+
+/**
+ * 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
+const effect = (callback) => {
+    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;
+    // 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.g;
+        if ((flags & 4 /* 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 & (1 /* Flag.DIRTY */ | 2 /* Flag.CHECK */ | 128 /* Flag.HAS_STATE_SOURCE */)) === 2 /* 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.h)) {
+                node.g = flags & -3 /* Flag.CHECK */;
+                return;
+            }
+        }
+        // ----------------------------------------------------------------
+        // PULL PHASE: Execute effect and track dependencies
+        // ----------------------------------------------------------------
+        runWithTracking(node, () => {
+            // Run previous cleanup if it exists (stored in $_value)
+            if (typeof node.l === 'function') {
+                node.l();
+            }
+            // Run the callback and store new cleanup in $_value
+            // (callback will PULL values from signals/state/computed)
+            node.l = 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 = {
+        h: [],
+        i: new DepsSet(noopGetter),
+        g: 1 /* Flag.DIRTY */ | 8 /* Flag.EFFECT */,
+        k: 0,
+        a: 0,
+        l: undefined,
+        f: ++effectCreationCounter,
+        j: runner,
+        m: Object.is,
+    };
+    const effectId = node.f;
+    const dispose = () => {
+        // 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.l === 'function') {
+            node.l();
+        }
+        clearSources(node);
+    };
+    // Track to appropriate scope
+    if (activeScope) {
+        activeScope[trackSymbol](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;
+};
+
+/**
+ * Creates a reactive scope for tracking effects
+ * Effects created within a scope callback are automatically tracked and disposed together
+ */
+const scope = (callback, parent = activeScope) => {
+    const effects = [];
+    const children = [];
+    const cleanups = [];
+    let disposed = false;
+    let myIndex = -1;
+    /**
+     * Register a cleanup function to run when scope is disposed
+     */
+    const onDispose = cleanup => {
+        if (disposed) {
+            return;
+        }
+        cleanups.push(cleanup);
+    };
+    const ctx = ((cb) => {
+        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][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;
+    });
+    // Internal symbols for effect tracking and child management
+    ctx[trackSymbol] = (dispose) => effects.push(dispose);
+    ctx[childrenSymbol] = children;
+    // Register with parent
+    if (parent) {
+        myIndex = parent[childrenSymbol].push(ctx) - 1;
+    }
+    // Run initial callback if provided
+    if (callback) {
+        ctx(callback);
+    }
+    return ctx;
+};
+
+/**
+ * Create a simple signal
+ */
+function signal(initialValue) {
+    let value = initialValue;
+    let deps;
+    /**
+     * Read the signal value and track dependency
+     */
+    const read = () => {
+        // === 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(read)), read, value);
+        }
+        return value;
+        // === END PULL PHASE ===
+    };
+    /**
+     * Set a new value and notify dependents
+     */
+    read.set = (newValue) => {
+        // === 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;
+}
+
+/**
+ * Creates a reactive state object
+ */
+function state(object = {}) {
+    // 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, property) => {
+        const propsMap = target[propertyDepsSymbol];
+        if (!propsMap)
+            return;
+        const deps = propsMap.get(property);
+        if (deps !== undefined) {
+            markDependents(deps);
+        }
+    };
+    const createProxy = (object) => {
+        if (proxiesCache.has(object)) {
+            return proxiesCache.get(object);
+        }
+        let methodCache;
+        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[p], realValue)) {
+                    target[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[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[propertyDepsSymbol];
+                    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[p];
+                        // biome-ignore lint/suspicious/noAssignInExpressions: optimization
+                        propsMap.set(p, (deps = new DepsSet(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, deps.b, 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();
+                    }
+                    let cached = methodCache.get(p);
+                    if (cached === undefined) {
+                        // Capture method reference at cache time to avoid re-reading on each call
+                        const method = propValue;
+                        cached = (...args) => {
+                            // 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[propertyDepsSymbol];
+                                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);
+            },
+            // 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;
+    };
+    return createProxy(object);
+}
+
+export { SUPPRESS_EFFECT_GC_WARNING, WARN_ON_UNTRACKED_EFFECT, WARN_ON_WRITE_IN_COMPUTED, activeScope, computed, debugConfig, effect, flushEffects, scope, setActiveScope, setScheduler, signal, state, untracked, unwrapValue };
+//# sourceMappingURL=index.mjs.map