@fluixi/reactive 1.0.0-alpha.100

package/dist/lib/signal/signal.js

@@ -0,0 +1,1233 @@
+/**
+ * @fileoverview Fine-grained reactive signal system
+ * @description Reactive primitives for signals, effects, memos, resources,
+ * scheduling, ownership, and dependency tracking.
+ *
+ * Inspired by:
+ * - S.js by Adam Haile (https://github.com/adamhaile/S)
+ * - SolidJS by Ryan Carniato (https://github.com/solidjs/solid)
+ *
+ * This implementation was independently designed and written by
+ * Ibrahima Touré.
+ *
+ * Copyright (c) 2026 Ibrahima Touré
+ * Licensed under MIT.
+ */
+import { isPromise } from '../predicates.js';
+import { Observable } from '../observable/observable.js';
+// Detection guards + helpers now live in the TC39-owned ./graph/detect.js
+// (graph-agnostic). Imported for internal use, re-exported below for the surface.
+import { __DEV__, isSignal, isMemo, isResource, isComponent, isSuspense, isProvider, makeArrayFlat, } from './graph/detect.js';
+export { __DEV__, isSignal, isMemo, isResource, isComponent, isSuspense, isProvider, makeArrayFlat, };
+// Derived utilities ported onto the TC39 graph: live in ./graph/derived.js.
+import { createSelector, createDeferred, createDebounce } from './graph/derived.js';
+export { createSelector, createDeferred, createDebounce };
+// Reactive children resolver (was the mis-named `childrens`): ./graph/children.js.
+import { readChildren } from './graph/children.js';
+export { readChildren };
+export const $SIGNAL = Symbol.for('signal');
+export const $MEMO = Symbol.for('memo');
+export const $RESOURCE = Symbol.for('resource');
+export const $PROXY = Symbol('fluixi-proxy');
+const $NODE = Symbol.for('signal-node');
+const CLEAN = 0;
+const STALE = 1;
+const DIRTY = 2;
+// RUNNING is a sentinel state set on a computation just before its fn executes.
+// Any propagateDirty() call that fires DURING the fn (e.g. a signal write inside
+// a route component's setup code) will override it with DIRTY.  After the fn,
+// RUNNING -> CLEAN (nothing re-dirtied it) or DIRTY -> stay DIRTY (needs re-run).
+// This correctly distinguishes "was dirty going in" from "re-dirtied during fn."
+const RUNNING = 3;
+let Owner = null;
+let Listener = null;
+let Updates = null;
+let Effects = null;
+let ExecCount = 0;
+// When true, a signal write eagerly schedules a stale effect reached through a
+// Legacy propagateDirty flag. Never enabled anymore. SSR runs on the TC39 graph,
+// which schedules its own re-runs, so this is always off (dead branch below).
+const _eagerStaleEffects = false;
+let Pending = false;
+/** Depth of user-initiated batch() calls. Incremented on batch entry, decremented on exit. */
+let BatchDepth = 0;
+const MAX_ITERATIONS = 1000000;
+const signalObservers = new WeakMap();
+/** Active transition: non-null while startTransition's fn is running or effects are deferred. */
+let Transition = null;
+const errorHandlers = [];
+let Scheduler = null;
+const nodeRegistry = new Map();
+let nodeIdCounter = 0;
+export const sharedConfig = {
+    context: null,
+    owner: null,
+    routeData: new Map(),
+    matchedRoute: new Map(),
+};
+/**
+ * Set current reactive owner (for internal use)
+ * @internal
+ */
+export function setOwner(owner) {
+    Owner = owner;
+    sharedConfig.owner = owner;
+    sharedConfig.context = owner;
+}
+/**
+ * Get shared config (for compatibility)
+ * @internal
+ */
+export function getSharedConfig() {
+    return sharedConfig;
+}
+// SSR resource injectables moved to the TC39-owned ./graph/ssr-hooks.js
+// (graph-agnostic). Imported for the legacy createResource below, re-exported for
+// the public surface.
+import { setResourceTracker, trackResourcePromise, setServerDataGetter, getServerData, setResourceIdSource, nextResourceId, setResourceDataSink, reportResourceData, } from './graph/ssr-hooks.js';
+export { setResourceTracker, trackResourcePromise, setServerDataGetter, getServerData, setResourceIdSource, nextResourceId, setResourceDataSink, reportResourceData, };
+function createNodeId() {
+    return `node_${++nodeIdCounter}_${Date.now()}`;
+}
+function registerNode(node) {
+    if (__DEV__)
+        nodeRegistry.set(node.id, new WeakRef(node));
+}
+function unregisterNode(node) {
+    if (__DEV__)
+        nodeRegistry.delete(node.id);
+}
+function createReactiveNode(type, initialValue, options) {
+    const node = {
+        id: createNodeId(),
+        type,
+        value: initialValue,
+        version: 0,
+        equals: options?.equals,
+        name: options?.name,
+        created: Date.now(),
+        updated: Date.now(),
+    };
+    registerNode(node);
+    return node;
+}
+function defaultEquals(a, b) {
+    return a === b;
+}
+function handleError(err) {
+    if (typeof console !== 'undefined')
+        console.error('Reactive error:', err);
+    throw err;
+}
+// Initialized lazily so it doesn't run before createSignal is defined.
+let _transPending = null;
+let _setTransPending = null;
+function ensureTransPending() {
+    if (!_transPending) {
+        const [get, set] = createSignal(false);
+        _transPending = get;
+        _setTransPending = set;
+    }
+}
+/**
+ * Central computation scheduling that respects batch mode and active transitions.
+ *
+ *  - In batch -> always queue in Updates (flushed by flushUpdates).
+ *  - In transition (non-pure) -> defer to Transition.effects (flush async).
+ *  - Computed (pure=true, computed=true) -> run eagerly.
+ *  - Effect (pure=false) -> run eagerly (unless deferred by transition).
+ *  - Memo (pure=true, computed=false) -> skip here; lazy, runs on next read.
+ */
+function scheduleComputation(c) {
+    if (Updates) {
+        if (Updates.indexOf(c) === -1)
+            Updates.push(c);
+    }
+    else if (Transition && Transition.running && !c.pure) {
+        if (Transition.effects.indexOf(c) === -1)
+            Transition.effects.push(c);
+    }
+    else if (!c.pure || c.computed) {
+        updateComputation(c);
+    }
+    else if (c.pure && !c.computed && c.accessor) {
+        // Pure memo outside batch: evaluate now so its equality check gates whether
+        // downstream effects are scheduled. If value unchanged, observers not notified.
+        // Set Updates=[] so any signal writes during the memo's fn (e.g. setOutlet
+        // inside routeStates.fn) are deferred instead of running effects immediately
+        // before the DOM structure is ready. Process them via runCascadeAndEffects
+        // afterwards, same cascade that batch uses.
+        const prevListener = Listener;
+        const prevUpdatesM = Updates;
+        Listener = null;
+        Updates = [];
+        c.accessor();
+        Listener = prevListener;
+        const memoDeferred = Updates;
+        Updates = prevUpdatesM;
+        if (memoDeferred.length > 0) {
+            const savedU = Updates;
+            runCascadeAndEffects(memoDeferred);
+            Updates = savedU;
+        }
+    }
+}
+function propagate(observerList, propagator) {
+    for (let i = 0; i < observerList.length; i++)
+        propagator(observerList[i]);
+}
+export function createSignal(_value, options) {
+    let value = _value;
+    if (typeof value === 'object' && value && $PROXY in value)
+        delete value[$PROXY];
+    const node = createReactiveNode('signal', value, {
+        equals: options?.equals === false ? undefined : options?.equals,
+        name: options?.name,
+    });
+    const s = [read, write];
+    signalObservers.set(s, new Set());
+    let lastObs;
+    function read() {
+        let observer = Listener;
+        if (observer) {
+            if (!observer.sources)
+                observer.sources = [s];
+            else if (observer.sources.indexOf(s) === -1)
+                observer.sources.push(s);
+            const observers = signalObservers.get(s);
+            if (observers && !observers.has(observer))
+                observers.add(observer);
+        }
+        return value;
+    }
+    function write(nextValue) {
+        const v = typeof nextValue === 'function'
+            ? nextValue(value)
+            : nextValue;
+        const equals = node.equals || defaultEquals;
+        if (options?.equals === false || !equals(value, v)) {
+            value = v;
+            node.value = v;
+            node.version++;
+            node.updated = Date.now();
+            const observers = signalObservers.get(s);
+            if (observers && observers.size > 0) {
+                const observerList = Array.from(observers);
+                const toUpdate = [];
+                const visited = new Set();
+                function propagateDirty(comp, viaPureMemo = false) {
+                    const prevState = comp.state;
+                    if (prevState === RUNNING && comp === Listener)
+                        return;
+                    if (viaPureMemo && !comp.pure) {
+                        if (prevState === CLEAN) {
+                            comp.state = STALE;
+                            // Eagerly SCHEDULE the stale effect, but only when enabled (server SSR
+                            // drain). There is no scheduler/read loop on the server to re-run a
+                            // stranded STALE effect, so the <Suspense> output insert effect wouldn't
+                            // re-render on the inFallback flip and the resolved children never
+                            // replaced the fallback in the serialized tree. On the CLIENT this stays
+                            // OFF: eager scheduling here removes a loop-breaker and can spin a
+                            // memo and effect cycling off each other forever (froze the storefront after hydration). The
+                            // client keeps the lazy behavior, the effect re-runs when next read.
+                            if (_eagerStaleEffects) {
+                                if (Updates !== null && Updates.indexOf(comp) === -1)
+                                    Updates.push(comp);
+                                else
+                                    toUpdate.push(comp);
+                            }
+                        }
+                        return;
+                    }
+                    if (visited.has(comp))
+                        return;
+                    visited.add(comp);
+                    comp.state = DIRTY;
+                    if (prevState === CLEAN || prevState === STALE)
+                        toUpdate.push(comp);
+                    else if (!comp.pure &&
+                        Updates !== null &&
+                        Updates.indexOf(comp) === -1)
+                        Updates.push(comp);
+                    if (comp.pure && comp.accessor) {
+                        const memoObservers = signalObservers.get(comp.accessor);
+                        if (memoObservers)
+                            propagate(Array.from(memoObservers), (c) => propagateDirty(c, true));
+                    }
+                }
+                propagate(observerList, propagateDirty);
+                for (const comp of toUpdate)
+                    scheduleComputation(comp);
+            }
+        }
+    }
+    read.toObservable = () => new Observable((observer) => {
+        let first = true;
+        const dispose = createEffect(() => {
+            const val = read();
+            if (first)
+                first = false;
+            else
+                observer.next(val);
+        });
+        return dispose;
+    });
+    Object.defineProperty(read, $SIGNAL, { value: true, enumerable: true });
+    Object.defineProperty(read, $NODE, { value: node, enumerable: false });
+    return s;
+}
+export function createEffect(fn, value, options) {
+    const c = {
+        fn,
+        state: DIRTY,
+        sources: null,
+        sourceSlots: null,
+        owned: null,
+        cleanups: null,
+        owner: Owner,
+        contexts: null,
+        pure: false,
+        updatedAt: null,
+    };
+    if (Owner) {
+        if (!Owner.owned)
+            Owner.owned = [c];
+        else
+            Owner.owned.push(c);
+    }
+    const SC = _SuspenseContext && useContext(_SuspenseContext);
+    if (SC)
+        c.suspense = SC;
+    runComputation(c, value);
+    return () => dispose(c);
+}
+function runComputation(c, value) {
+    if (c.sources) {
+        for (const source of c.sources) {
+            const observers = signalObservers.get(source);
+            if (observers)
+                observers.delete(c);
+        }
+        c.sources = null;
+        c.sourceSlots = null;
+    }
+    if (c.owned) {
+        for (let i = 0; i < c.owned.length; i++)
+            dispose(c.owned[i]);
+        c.owned = null;
+    }
+    const prevListener = Listener;
+    const prevOwner = Owner;
+    Listener = c;
+    Owner = c;
+    ExecCount++;
+    if (ExecCount > MAX_ITERATIONS) {
+        ExecCount = 0;
+        Listener = prevListener;
+        Owner = prevOwner;
+        throw new Error('Potential infinite loop detected. Exceeded maximum iterations.');
+    }
+    try {
+        c.state = RUNNING;
+        const result = c.fn(value);
+        if (typeof result === 'function') {
+            if (!c.cleanups)
+                c.cleanups = [result];
+            else
+                c.cleanups.push(result);
+        }
+        if (c.state === RUNNING)
+            c.state = CLEAN;
+    }
+    catch (err) {
+        if (isPromise(err)) {
+            const ctx = _SuspenseContext && useContext(_SuspenseContext);
+            if (ctx) {
+                ctx.increment();
+                err.finally(() => ctx.decrement());
+                if (c.suspense)
+                    ctx.effects.push(c);
+            }
+            return;
+        }
+        handleError(err);
+    }
+    finally {
+        Listener = prevListener;
+        Owner = prevOwner;
+    }
+}
+function updateComputation(c) {
+    if (c.disposed || !c.fn || c.state === CLEAN)
+        return;
+    if (c.state === DIRTY || c.state === STALE || c.state === RUNNING) {
+        if (c.cleanups) {
+            for (let i = 0; i < c.cleanups.length; i++)
+                c.cleanups[i]();
+            c.cleanups = null;
+        }
+        if (c.owned) {
+            for (let i = 0; i < c.owned.length; i++)
+                dispose(c.owned[i]);
+            c.owned = null;
+        }
+        if (c.renderEffect)
+            runRenderComputation(c);
+        else
+            runComputation(c, c.value);
+    }
+}
+function dispose(c) {
+    // Mark first so a resume triggered during teardown (e.g. a Suspense boundary
+    // decrementing as a now-resolved promise settles) can't re-run this node.
+    c.disposed = true;
+    if (c.sources) {
+        for (const source of c.sources) {
+            const observers = signalObservers.get(source);
+            if (observers)
+                observers.delete(c);
+        }
+    }
+    if (c.cleanups)
+        for (let i = 0; i < c.cleanups.length; i++)
+            c.cleanups[i]();
+    if (c.owned)
+        for (let i = 0; i < c.owned.length; i++)
+            dispose(c.owned[i]);
+    if (c.owner && c.owner.owned) {
+        const index = c.owner.owned.indexOf(c);
+        if (index !== -1)
+            c.owner.owned.splice(index, 1);
+    }
+}
+export function createMemo(fn, value, options) {
+    const node = createReactiveNode('memo', value, {
+        equals: options?.equals === false ? undefined : options?.equals,
+        name: options?.name,
+    });
+    const c = {
+        fn,
+        state: DIRTY,
+        sources: null,
+        sourceSlots: null,
+        value,
+        owned: null,
+        cleanups: null,
+        owner: Owner,
+        contexts: null,
+        pure: true,
+        updatedAt: null,
+        node,
+        accessor: undefined,
+    };
+    if (Owner) {
+        if (!Owner.owned)
+            Owner.owned = [c];
+        else
+            Owner.owned.push(c);
+    }
+    const read = () => {
+        if (Listener && Listener !== c) {
+            if (!Listener.sources)
+                Listener.sources = [read];
+            else if (Listener.sources.indexOf(read) === -1)
+                Listener.sources.push(read);
+            const memoAsSignal = read;
+            if (!signalObservers.has(memoAsSignal))
+                signalObservers.set(memoAsSignal, new Set());
+            const observers = signalObservers.get(memoAsSignal);
+            if (observers)
+                observers.add(Listener);
+        }
+        if (c.state !== CLEAN) {
+            if (c.sources) {
+                for (const source of c.sources) {
+                    const observers = signalObservers.get(source);
+                    if (observers)
+                        observers.delete(c);
+                }
+                c.sources = null;
+                c.sourceSlots = null;
+            }
+            if (c.cleanups) {
+                for (let i = 0; i < c.cleanups.length; i++)
+                    c.cleanups[i]();
+                c.cleanups = null;
+            }
+            if (c.owned) {
+                for (let i = 0; i < c.owned.length; i++)
+                    dispose(c.owned[i]);
+                c.owned = null;
+            }
+            const prevListener = Listener;
+            const prevOwner = Owner;
+            Listener = c;
+            Owner = c;
+            c.state = RUNNING;
+            try {
+                const nextValue = c.fn(c.value);
+                const equals = node.equals || defaultEquals;
+                const hasChanged = options?.equals === false || !equals(c.value, nextValue);
+                if (hasChanged) {
+                    c.value = nextValue;
+                    node.value = nextValue;
+                    node.version++;
+                    node.updated = Date.now();
+                    const memoAsSignal = read;
+                    const observers = signalObservers.get(memoAsSignal);
+                    if (observers && observers.size > 0) {
+                        const observerList = Array.from(observers);
+                        const toUpdate = [];
+                        const visited = new Set();
+                        // Mirror the signal-write propagateDirty (see createSignal.write), when an
+                        // observer is itself a pure memo, recurse through it to its observers so
+                        // they are marked stale too. Without this, a memo M observed by another
+                        // memo N (e.g. a child route content/outlet memo gating on a parent content
+                        // memo) updates M but never notifies N's downstream effects, so a deferred
+                        // <Outlet/> deep in a nested layout never re-renders after its parent
+                        // settles. viaPureMemo marks downstream non-pure (effects) STALE.
+                        function propagateDirty(comp, viaPureMemo = false) {
+                            if (comp === c)
+                                return;
+                            const prevState = comp.state;
+                            if (prevState === RUNNING)
+                                return;
+                            if (viaPureMemo && !comp.pure) {
+                                if (prevState === CLEAN) {
+                                    comp.state = STALE;
+                                    if (Updates !== null && Updates.indexOf(comp) === -1)
+                                        Updates.push(comp);
+                                    else
+                                        toUpdate.push(comp);
+                                }
+                                return;
+                            }
+                            if (visited.has(comp))
+                                return;
+                            visited.add(comp);
+                            comp.state = DIRTY;
+                            if (prevState === CLEAN || prevState === STALE)
+                                toUpdate.push(comp);
+                            else if (!comp.pure &&
+                                Updates !== null &&
+                                Updates.indexOf(comp) === -1)
+                                Updates.push(comp);
+                            if (comp.pure && comp.accessor) {
+                                const memoObservers = signalObservers.get(comp.accessor);
+                                if (memoObservers && memoObservers.size > 0)
+                                    for (const o of Array.from(memoObservers))
+                                        propagateDirty(o, true);
+                            }
+                        }
+                        for (let i = 0; i < observerList.length; i++)
+                            propagateDirty(observerList[i]);
+                        for (const comp of toUpdate)
+                            scheduleComputation(comp);
+                    }
+                }
+                if (c.state === RUNNING)
+                    c.state = CLEAN;
+            }
+            catch (err) {
+                if (isPromise(err)) {
+                    let ctx = _SuspenseContext && useContext(_SuspenseContext);
+                    if (!ctx && _SuspenseContext) {
+                        let owner = prevOwner;
+                        while (owner) {
+                            if (owner.contexts?.has(_SuspenseContext.id)) {
+                                ctx = owner.contexts.get(_SuspenseContext.id);
+                                break;
+                            }
+                            owner = owner.owner;
+                        }
+                    }
+                    if (ctx) {
+                        ctx.increment();
+                        err.finally(() => ctx.decrement());
+                    }
+                    return c.value;
+                }
+                handleError(err);
+            }
+            finally {
+                Listener = prevListener;
+                Owner = prevOwner;
+            }
+        }
+        return c.value;
+    };
+    c.accessor = read;
+    signalObservers.set(read, new Set());
+    read.toObservable = () => new Observable((observer) => {
+        let first = true;
+        const dispose = createEffect(() => {
+            const val = read();
+            if (first)
+                first = false;
+            else
+                observer.next(val);
+        });
+        return dispose;
+    });
+    Object.defineProperty(read, $SIGNAL, { value: true, enumerable: true });
+    Object.defineProperty(read, $MEMO, { value: true, enumerable: true });
+    Object.defineProperty(read, $NODE, { value: node, enumerable: false });
+    return read;
+}
+/**
+ * Cascade-evaluates pure memos from `initial`, transitively following any
+ * newly-triggered pure memos, then runs all collected non-pure effects.
+ *
+ * Pure memos with no downstream observers are skipped (lazy, they'll
+ * re-evaluate on next read without side effects).
+ */
+function runCascadeAndEffects(initial) {
+    const cascadeQueue = [];
+    const effectsToRun = [];
+    for (const comp of initial) {
+        if (comp.pure && !comp.computed && comp.accessor) {
+            if (cascadeQueue.indexOf(comp) === -1)
+                cascadeQueue.push(comp);
+        }
+        else if ((comp.computed || !comp.pure) &&
+            effectsToRun.indexOf(comp) === -1)
+            effectsToRun.push(comp);
+    }
+    Updates = [];
+    let ci = 0;
+    while (ci < cascadeQueue.length) {
+        const comp = cascadeQueue[ci++];
+        const observers = signalObservers.get(comp.accessor);
+        if (observers && observers.size > 0) {
+            const prevListener = Listener;
+            Listener = null;
+            comp.accessor();
+            Listener = prevListener;
+        }
+        const fresh = Updates.splice(0);
+        for (const c of fresh) {
+            if (c.pure && !c.computed && c.accessor) {
+                if (cascadeQueue.indexOf(c) === -1)
+                    cascadeQueue.push(c);
+            }
+            else if ((c.computed || !c.pure) && effectsToRun.indexOf(c) === -1)
+                effectsToRun.push(c);
+        }
+    }
+    Updates = null;
+    for (const comp of effectsToRun)
+        if (comp.computed || !comp.pure)
+            updateComputation(comp);
+}
+export function batch(fn) {
+    if (Updates && BatchDepth > 0)
+        return fn();
+    if (Updates && BatchDepth === 0) {
+        const prev = Updates;
+        const nested = [];
+        Updates = nested;
+        BatchDepth++;
+        let result;
+        try {
+            result = fn();
+        }
+        finally {
+            BatchDepth--;
+            Updates = prev;
+        }
+        const savedUpdates = Updates;
+        runCascadeAndEffects(nested);
+        Updates = savedUpdates;
+        return result;
+    }
+    BatchDepth++;
+    Updates = [];
+    Effects = [];
+    try {
+        return fn();
+    }
+    finally {
+        BatchDepth--;
+        flushUpdates();
+    }
+}
+function flushUpdates() {
+    if (Pending)
+        return;
+    Pending = true;
+    ExecCount = 0;
+    try {
+        while (Updates && Updates.length > 0) {
+            const updates = Updates;
+            Updates = null;
+            runCascadeAndEffects(updates);
+        }
+        Updates = null;
+        if (Effects) {
+            const effects = Effects;
+            Effects = null;
+            for (let i = 0; i < effects.length; i++)
+                updateComputation(effects[i]);
+        }
+    }
+    finally {
+        Pending = false;
+    }
+}
+export function createRoot(fn) {
+    const owner = {
+        owned: null,
+        cleanups: null,
+        contexts: null,
+        owner: Owner,
+    };
+    const prevListener = Listener;
+    Listener = null;
+    const prevOwner = Owner;
+    Owner = owner;
+    try {
+        return fn(() => {
+            if (owner.owned)
+                for (let i = 0; i < owner.owned.length; i++)
+                    dispose(owner.owned[i]);
+            if (owner.cleanups)
+                for (let i = 0; i < owner.cleanups.length; i++)
+                    owner.cleanups[i]();
+        });
+    }
+    finally {
+        Owner = prevOwner;
+        Listener = prevListener;
+    }
+}
+export function untrack(fn) {
+    const prevListener = Listener;
+    Listener = null;
+    try {
+        return fn();
+    }
+    finally {
+        Listener = prevListener;
+    }
+}
+export function onCleanup(fn) {
+    if (Owner) {
+        if (!Owner.cleanups)
+            Owner.cleanups = [fn];
+        else
+            Owner.cleanups.push(fn);
+    }
+}
+const cache = new Map();
+function fetchCached(key) {
+    if (!cache.has(key))
+        cache.set(key, fetch(key));
+    return cache.get(key);
+}
+export function createResource(source, fetcherFn, options = {}) {
+    let s;
+    let fetcher;
+    if (typeof fetcherFn === 'function') {
+        s = typeof source === 'function' ? source : () => source;
+        fetcher = fetcherFn;
+    }
+    else {
+        s = () => true;
+        fetcher = source;
+        if (fetcherFn && typeof fetcherFn === 'object')
+            options = fetcherFn;
+    }
+    const { initialValue, name } = options;
+    // SSR data transport: a stable per-render id; on the client, seed from the
+    // server-serialized value so hydration doesn't refetch (and doesn't flash).
+    const __ssrId = options.transport === false ? undefined : nextResourceId();
+    const __seed = __ssrId !== undefined ? getServerData(__ssrId) : undefined;
+    let skipFirstFetch = __seed !== undefined;
+    const [value, setValue] = createSignal(__seed !== undefined ? __seed.value : options.initialValue, { equals: false });
+    const [error, setError] = createSignal(undefined, { equals: false });
+    const [state, setState] = createSignal(__seed !== undefined || options.initialValue !== undefined ? 'ready' : 'unresolved', { equals: false });
+    const [promise, setPromise] = createSignal(undefined, { equals: false });
+    const [track, trigger] = createSignal(undefined, { equals: false });
+    const UNSET = Symbol();
+    let prevKey = UNSET;
+    let manualRefetch = false;
+    const saveToCache = (data) => {
+        // No localStorage on the server (SSR): skip silently.
+        if (typeof localStorage === 'undefined')
+            return;
+        try {
+            if (data)
+                localStorage.setItem('storage', JSON.stringify({ data, timestamp: Date.now() }));
+        }
+        catch (error) {
+            console.error(`Failed to save resource to cache (${name}):`, error);
+        }
+    };
+    const dispose = createEffect(() => {
+        const val = s ? s() : source;
+        track();
+        if (val === false || val === null || val === undefined) {
+            prevKey = UNSET;
+            batch(() => {
+                setState('unresolved');
+                setPromise(undefined);
+                setError(undefined);
+            });
+            return;
+        }
+        const isManual = manualRefetch;
+        manualRefetch = false;
+        if (prevKey !== UNSET && val === prevKey && !isManual)
+            return;
+        prevKey = val;
+        // Seeded from server data during hydration: value is already set, skip the
+        // first fetch (still tracked the source above, so later refetches work).
+        if (skipFirstFetch) {
+            skipFirstFetch = false;
+            return;
+        }
+        let cancelled = false;
+        onCleanup(() => (cancelled = true));
+        const currentState = untrack(state);
+        const currentValue = untrack(value);
+        const isRefreshing = currentState === 'ready' || currentState === 'refreshing';
+        batch(() => {
+            setState(isRefreshing ? 'refreshing' : 'pending');
+            setError(undefined);
+        });
+        try {
+            const res = fetcher(val, {
+                value: currentValue,
+                refetching: isRefreshing,
+            });
+            if (isPromise(res)) {
+                setPromise(res);
+                trackResourcePromise(res); // server async SSR: collect & await
+                res
+                    .then((v) => {
+                    if (cancelled)
+                        return;
+                    if (__ssrId !== undefined)
+                        reportResourceData(__ssrId, v); // server: collect for serialization
+                    batch(() => {
+                        setValue(() => v);
+                        saveToCache(v);
+                        setState('ready');
+                        setPromise(undefined);
+                    });
+                }, (e) => {
+                    if (cancelled)
+                        return;
+                    batch(() => {
+                        setError(e);
+                        setState('errored');
+                        setPromise(undefined);
+                    });
+                })
+                    .catch((e) => {
+                    if (cancelled)
+                        return;
+                    batch(() => {
+                        setError(e);
+                        setState('errored');
+                        setPromise(undefined);
+                    });
+                });
+                const suspenseCtx = _SuspenseContext && useContext(_SuspenseContext);
+                if (suspenseCtx) {
+                    suspenseCtx.increment();
+                    res.finally(() => suspenseCtx.decrement());
+                }
+            }
+            else {
+                if (cancelled)
+                    return;
+                batch(() => {
+                    setValue(() => res);
+                    setState('ready');
+                    setPromise(undefined);
+                });
+            }
+        }
+        catch (e) {
+            if (cancelled)
+                return;
+            batch(() => {
+                setError(e);
+                setState('errored');
+                setPromise(undefined);
+            });
+        }
+    });
+    onCleanup(dispose);
+    const loading = () => {
+        const s = state();
+        return s === 'pending' || s === 'refreshing';
+    };
+    const resource = (() => {
+        const e = error();
+        if (e)
+            throw e;
+        if (loading()) {
+            const p = promise();
+            if (p)
+                throw p;
+        }
+        return value();
+    });
+    Object.defineProperty(resource, $RESOURCE, { value: true, enumerable: true });
+    Object.defineProperty(resource, $SIGNAL, { value: true, enumerable: true });
+    Object.defineProperties(resource, {
+        state: { get: state },
+        loading: { get: () => loading() },
+        error: { get: error },
+        latest: { get: value },
+    });
+    return [
+        resource,
+        {
+            mutate: setValue,
+            refetch: () => {
+                manualRefetch = true;
+                trigger(undefined);
+            },
+        },
+    ];
+}
+export function getOwner() {
+    return Owner;
+}
+export function runWithOwner(owner, fn) {
+    const prevOwner = Owner;
+    const prevListener = Listener;
+    Owner = owner;
+    Listener = null;
+    try {
+        return fn();
+    }
+    finally {
+        Owner = prevOwner;
+        Listener = prevListener;
+    }
+}
+export function createContext(defaultValue) {
+    const id = Symbol('context');
+    const Provider = createProvider(id);
+    return { id, Provider, defaultValue };
+}
+export function createProvider(id) {
+    return (props) => {
+        let _node = Owner;
+        while (_node) {
+            if (!_node.contexts)
+                _node.contexts = new Map();
+            if (!_node.contexts.has(id))
+                _node.contexts.set(id, props.value);
+            _node = _node.owner;
+        }
+        let provider;
+        createRenderEffect(() => {
+            provider = untrack(() => {
+                const owner = Owner;
+                if (owner) {
+                    if (!owner.contexts)
+                        owner.contexts = new Map();
+                    owner.contexts.set(id, props.value);
+                }
+                return readChildren(() => props.children);
+            });
+        });
+        return provider;
+    };
+}
+export function useContext(context) {
+    let owner = Owner;
+    while (owner) {
+        if (owner.contexts && owner.contexts.has(context.id))
+            return owner.contexts.get(context.id);
+        owner = owner.owner;
+    }
+    if (!context)
+        return;
+    return context.defaultValue;
+}
+export function flush() {
+    return new Promise((resolve) => {
+        queueMicrotask(() => {
+            flushUpdates();
+            resolve();
+        });
+    });
+}
+/**
+ * startTransition: defer non-critical effect updates.
+ *
+ * Runs `fn` synchronously, capturing all non-pure effects that would fire as
+ * a result into a deferred queue. Pure computations (memos, createComputed)
+ * update immediately so signal values are consistent. The deferred effects are
+ * then flushed asynchronously (next microtask), keeping the current UI
+ * responsive while the new state is prepared.
+ */
+export function startTransition(fn) {
+    if (Transition && Transition.running) {
+        fn();
+        return Transition.done;
+    }
+    ensureTransPending();
+    let resolve;
+    const done = new Promise((res) => (resolve = res));
+    const t = { running: true, effects: [], resolve, done };
+    Transition = t;
+    try {
+        fn();
+    }
+    finally {
+        t.running = false;
+    }
+    if (!t.effects.length) {
+        Transition = null;
+        resolve();
+        return done;
+    }
+    _setTransPending(true);
+    Promise.resolve().then(() => {
+        const effects = t.effects.splice(0);
+        Transition = null;
+        _setTransPending(false);
+        if (effects.length)
+            batch(() => {
+                for (const e of effects) {
+                    e.state = DIRTY;
+                    updateComputation(e);
+                }
+            });
+        resolve();
+    });
+    return done;
+}
+/**
+ * useTransition: reactive hook version of startTransition.
+ * Returns `[isPending, start]`
+ */
+export function useTransition() {
+    ensureTransPending();
+    return [_transPending, startTransition];
+}
+export function on(deps, fn, options) {
+    const defer = options?.defer ?? false;
+    let isFirst = true;
+    return (prev) => {
+        const values = deps();
+        if (defer && isFirst) {
+            isFirst = false;
+            return prev;
+        }
+        return untrack(() => fn(values, prev));
+    };
+}
+/**
+ * createRenderEffect - runs synchronously during rendering.
+ */
+export function createRenderEffect(fn, value, options) {
+    const c = {
+        fn: fn,
+        state: DIRTY,
+        sources: null,
+        sourceSlots: null,
+        value,
+        owned: null,
+        cleanups: null,
+        owner: Owner,
+        contexts: null,
+        pure: false,
+        updatedAt: null,
+        renderEffect: true,
+    };
+    if (Owner) {
+        if (!Owner.owned)
+            Owner.owned = [c];
+        else
+            Owner.owned.push(c);
+    }
+    const SC = _SuspenseContext && useContext(_SuspenseContext);
+    if (SC)
+        c.suspense = SC;
+    runRenderComputation(c);
+    return () => dispose(c);
+}
+function runRenderComputation(c) {
+    if (c.sources) {
+        for (const source of c.sources) {
+            const observers = signalObservers.get(source);
+            if (observers)
+                observers.delete(c);
+        }
+        c.sources = null;
+        c.sourceSlots = null;
+    }
+    if (c.cleanups) {
+        for (let i = 0; i < c.cleanups.length; i++)
+            c.cleanups[i]();
+        c.cleanups = null;
+    }
+    if (c.owned) {
+        for (let i = 0; i < c.owned.length; i++)
+            dispose(c.owned[i]);
+        c.owned = null;
+    }
+    const prevListener = Listener;
+    const prevOwner = Owner;
+    const prevUpdates = Updates;
+    Listener = c;
+    Owner = c;
+    if (Updates === null)
+        Updates = [];
+    c.state = RUNNING;
+    try {
+        const result = c.fn(c.value);
+        if (typeof result === 'function') {
+            if (!c.cleanups)
+                c.cleanups = [];
+            c.cleanups.push(result);
+        }
+        c.value = result;
+        if (c.state === RUNNING)
+            c.state = CLEAN;
+    }
+    catch (err) {
+        if (isPromise(err)) {
+            const ctx = _SuspenseContext && useContext(_SuspenseContext);
+            if (ctx) {
+                ctx.increment();
+                err.finally(() => ctx.decrement());
+                if (c.suspense)
+                    ctx.effects.push(c);
+            }
+            return;
+        }
+        handleError(err);
+    }
+    finally {
+        Listener = prevListener;
+        Owner = prevOwner;
+        const deferred = Updates;
+        Updates = prevUpdates;
+        // Flush computations scheduled during this render effect via the full cascade,
+        // which re-evaluates PURE MEMOS (and propagates to their observers) as well as
+        // running effects. The old loop processed only effects, so a pure memo scheduled
+        // here was left dirty and never notified its own downstream effects: e.g. a
+        // child route content/outlet memo that settled while a parent layout rendered
+        // would never re-render the child (deeply nested <Outlet/> stayed empty).
+        if (deferred !== prevUpdates && deferred && deferred.length > 0) {
+            const saved = Updates;
+            runCascadeAndEffects(deferred);
+            Updates = saved;
+        }
+    }
+}
+/**
+ * createComputed: synchronous pre-render computation.
+ */
+export function createComputed(fn, value, options) {
+    const c = {
+        fn,
+        state: DIRTY,
+        sources: null,
+        sourceSlots: null,
+        value,
+        owned: null,
+        cleanups: null,
+        owner: Owner,
+        contexts: null,
+        pure: true,
+        computed: true,
+        updatedAt: null,
+    };
+    if (Owner) {
+        if (!Owner.owned)
+            Owner.owned = [c];
+        else
+            Owner.owned.push(c);
+    }
+    if (Transition && Transition.running) {
+        if (!Updates)
+            Updates = [];
+        if (Updates.indexOf(c) === -1)
+            Updates.push(c);
+    }
+    else if (Updates) {
+        if (Updates.indexOf(c) === -1)
+            Updates.push(c);
+    }
+    else
+        runComputation(c, value);
+}
+let _SuspenseContext;
+export function getSuspenseContext() {
+    return (_SuspenseContext ||
+        (_SuspenseContext = createContext()));
+}
+let _SuspenseListContext;
+export function getSuspenseListContext() {
+    return (_SuspenseListContext ||
+        (_SuspenseListContext = createContext()));
+}
+export function resumeEffects(effects) {
+    if (!effects.length)
+        return;
+    const queued = effects.slice();
+    effects.length = 0;
+    for (const c of queued) {
+        c.state = DIRTY;
+        updateComputation(c);
+    }
+}
+export function onResolve(fn) {
+    const ctx = _SuspenseContext && useContext(_SuspenseContext);
+    if (ctx && ctx.inFallback())
+        createEffect(() => {
+            if (!ctx.inFallback())
+                fn();
+        });
+    else
+        fn();
+}
+export function setScheduler(scheduler) {
+    Scheduler = scheduler;
+}
+export function trackPromise(promise) {
+    const ctx = _SuspenseContext && useContext(_SuspenseContext);
+    if (!ctx)
+        return promise;
+    ctx.increment();
+    promise.finally(() => ctx.decrement());
+    return promise;
+}
+export default {
+    createSignal,
+    createEffect,
+    createMemo,
+    createComputed,
+    createRoot,
+    createSelector,
+    createResource,
+    batch,
+    untrack,
+    onCleanup,
+    getOwner,
+    runWithOwner,
+    createContext,
+    useContext,
+    flush,
+    startTransition,
+    useTransition,
+    isSignal,
+    on,
+    createRenderEffect,
+    getSuspenseContext,
+    getSuspenseListContext,
+    resumeEffects,
+    onResolve,
+    setScheduler,
+    trackPromise,
+};