@the-w1zard/the-cloud 1.0.2 → 1.0.4

package/dist/the-cloud.js

@@ -1,1386 +0,0 @@
-//                                                                                               IMPORTS
-// #region ══════════════════════════════════════════════════════════════════════════════════════════════════════
-import store from "#STR";
-import { BYTE_ID } from "#HPR";
-import { TIERED_QUEUE } from "#SS";
-const __sid = new BYTE_ID();
-export function _sidi() {
-    return __sid.b();
-}
-// #endregion 
-//                                                                                                SAURON
-// #region ══════════════════════════════════════════════════════════════════════════════════════════════════════
-const queues = {
-    immediate: new Map(), 'user-blocking': new Map(), normal: new Map(), background: new Map(), idle: new Map()
-};
-class SAURON {
-    root;
-    constructor(root = null) {
-        this.root = root;
-        this.r = root.r;
-        this.s = root.s;
-        this.m = root.m;
-        this.k = root.k;
-    }
-    online = false;
-    r = 'THE_WIZARD_ROOT_REG';
-    m = 'SAURON_MASTER_REG';
-    s = "__SAURON__";
-    k = "__SAURON__";
-    u = undefined;
-    uuuu = [this.u, this.u, this.u, this.u];
-    UUUU = [this.s, this.m, this.r];
-    uuu = [this.u, this.u, this.u];
-    UUU = [this.s, this.m, this.r];
-    uu = [this.u, this.u];
-    UU = [this.m, this.r];
-    _localChange = false;
-    _channel = null;
-    init_hooks_context = false;
-    batchDepth = 0;
-    openScopes = new Set();
-    dirty = new Set();
-    _flushScheduled = false;
-    _adapter = null;
-    _currentHookState = null;
-    _currentComponent = null;
-    PRIORITY_ORDER = ["immediate", "user-blocking", "normal", "background", "idle"];
-    GLOBAL_SCOPE = Symbol("global-scope");
-    scopeCursors = { immediate: 0, "user-blocking": 0, normal: 0, background: 0, idle: 0 };
-    currentScope = this.GLOBAL_SCOPE;
-    loopScheduled = false;
-    _subscribers = new Map();
-    __subscribers = new Map();
-    _externalSubscribers = new Map();
-    _components = new Map();
-    _pendingNotifications = new Set();
-    externalSubscribers = new Set();
-    instanceId = `instance_${Date.now()}_${Math.random().toString(36).slice(2)}`;
-    _root = {
-        id: store.get('THE_WIZARD_ROOT_REG') ?? 'THE_WIZARD_ROOT_REG',
-        hooks: new Map(),
-        unmount: new Set(),
-        contextProviders: new Map()
-    };
-    FULFIL_THIS_SAURON_DEPOT(r) {
-        this.root = r;
-    }
-    getNestedMap(s = this.s, m = this.m, r = this.r) {
-        let root = globalThis[r]; //  STATE_CONTEXT === "sauron" ? : null;
-        if (!root) {
-            root = new Map();
-            globalThis[r] = root;
-        }
-        let masterMap = root.get(m);
-        if (!masterMap) {
-            masterMap = new Map();
-            root.set(m, masterMap);
-        }
-        let slaveMap = masterMap.get(s);
-        if (!slaveMap) {
-            slaveMap = new Map();
-            masterMap.set(s, slaveMap);
-        }
-        return slaveMap;
-    }
-    getMetadata(s = this.s, m = this.m, r = this.r) {
-        let root = globalThis[r]; // STATE_CONTEXT === "sauron" ?  : null;
-        if (!root) {
-            root = new Map();
-            globalThis[r] = root;
-        }
-        let masterMap = root.get(m);
-        if (!masterMap) {
-            masterMap = new Map();
-            root.set(m, masterMap);
-        }
-        let metaMap = masterMap.get(s);
-        if (!metaMap) {
-            metaMap = {
-                _batches: new Set(),
-                _batchQueue: new Map(),
-                _batchOpts: new Map(),
-                _history: new Map(),
-                _timeTravel: new Map(),
-                _globalListeners: new Set(),
-                _global_subscribers: new Map(),
-                _waiters: new Map(),
-                _sys: new Map(),
-                _sealed: new Set(),
-                _frozen: new Set(),
-                _keyContracts: new Map(),
-                _conflicts: new Map(),
-                _conflictStrategies: new Map(),
-                _causal: new Map(),
-                _scopes: new Map(),
-                _msgHandlers: new Map(),
-                _lastWriteSource: new Map(),
-                _mainMap: new Map(),
-                _tupleCache: new Map(),
-                _weakMap: new WeakMap(),
-                _boundaries: new WeakMap(),
-            };
-            masterMap.set(s, metaMap);
-        }
-        return metaMap;
-    }
-    onFlush(cb) {
-        this.dirty.add(cb);
-        this.scheduleDrain();
-    }
-    scheduleDrain() {
-        if (this._flushScheduled)
-            return;
-        this._flushScheduled = true;
-        queueMicrotask(this.drain);
-    }
-    drain() {
-        this._flushScheduled = false;
-        if (this.dirty.size === 0)
-            return;
-        // An explicit openBatch() scope is still open (deliberately spanning an await) —
-        // don't drop the pending callbacks, just wait for closeBatch() to let them through.
-        if (this.openScopes.size > 0) {
-            this.scheduleDrain();
-            return;
-        }
-        const callbacks = this.dirty;
-        this.dirty = new Set();
-        for (const cb of callbacks)
-            cb();
-    }
-    microtask(fn) {
-        queueMicrotask(fn);
-    }
-    batch(fn) {
-        this.batchDepth++;
-        try {
-            return fn();
-        }
-        finally {
-            this.batchDepth--;
-            if (this.batchDepth === 0) {
-                this.flush();
-            }
-        }
-    }
-    openBatch() {
-        const scope = Symbol("batch-scope");
-        this.openScopes.add(scope);
-        return scope;
-    }
-    closeBatch(scope) {
-        this.openScopes.delete(scope);
-        if (this.openScopes.size === 0 && this.dirty.size > 0) {
-            this.scheduleDrain();
-        }
-    }
-    isBatching() {
-        return this.batchDepth > 0 || this.openScopes.size > 0;
-    }
-    flushSync() {
-        if (this.openScopes.size > 0)
-            return;
-        this._flushScheduled = false;
-        if (this.dirty.size === 0)
-            return;
-        const callbacks = this.dirty;
-        this.dirty = new Set();
-        for (const cb of callbacks)
-            cb();
-    }
-    flush(fn) {
-        if (!fn) {
-            this.flushSync();
-            return;
-        }
-        this.batchDepth++;
-        let result;
-        try {
-            result = fn();
-        }
-        finally {
-            this.batchDepth--;
-        }
-        this.flushSync();
-        return result;
-    }
-    enqueue(task) {
-        if (task.priority === "immediate") {
-            this.microtask(() => this.runOne(task));
-            return;
-        }
-        const tier = queues[task.priority];
-        if (!tier.has(task.scope))
-            tier.set(task.scope, []);
-        tier.get(task.scope).push(task);
-        this.scheduleLoop();
-    }
-    scheduleLoop() {
-        if (this.loopScheduled)
-            return;
-        this.loopScheduled = true;
-        setImmediate(this.drainOne);
-    }
-    pickNext() {
-        for (const p of this.PRIORITY_ORDER) {
-            if (p === "immediate")
-                continue;
-            const tier = queues[p];
-            if (tier.size === 0)
-                continue;
-            const scopes = Array.from(tier.keys());
-            const idx = this.scopeCursors[p] % scopes.length;
-            const scope = scopes[idx];
-            const list = tier.get(scope);
-            const task = list.shift();
-            if (list.length === 0)
-                tier.delete(scope);
-            this.scopeCursors[p] = idx + 1;
-            return MaybePromise(task);
-        }
-        return undefined;
-    }
-    runOne(task) {
-        if (task.cancelled || task.signal?.aborted)
-            return;
-        const prev = this.currentScope;
-        this.currentScope = task.scope;
-        try {
-            task.fn();
-        }
-        finally {
-            this.currentScope = prev;
-        }
-    }
-    drainOne() {
-        this.loopScheduled = false;
-        const task = this.pickNext();
-        if (task)
-            this.runOne(task);
-        if (Object.values(queues).some((m) => m.size > 0))
-            this.scheduleLoop();
-    }
-    schedule(fn, opts = {}) {
-        const task = { priority: opts.priority ?? "normal", scope: opts.scope ?? this.currentScope, fn, signal: opts.signal, cancelled: false };
-        // signals.chains().sc.addEventListener('abort', () => { task.cancelled = true })
-        this.enqueue(task);
-        const self = this;
-        return {
-            cancel() {
-                task.cancelled = true;
-            },
-            reprioritize(next) {
-                if (task.cancelled || next === task.priority)
-                    return;
-                const old = queues[task.priority].get(task.scope);
-                if (old) {
-                    const i = old.indexOf(task);
-                    if (i !== -1)
-                        old.splice(i, 1);
-                    if (old.length === 0)
-                        queues[task.priority].delete(task.scope);
-                }
-                task.priority = next;
-                self.enqueue(task);
-            },
-        };
-    }
-    withRequestScope(requestId, fn) {
-        const prev = this.currentScope;
-        this.currentScope = requestId;
-        try {
-            return fn();
-        }
-        finally {
-            this.currentScope = prev;
-        }
-    }
-    yieldToScheduler() {
-        return new Promise((resolve) => {
-            this.schedule(() => resolve(), { priority: "normal", scope: this.currentScope });
-        });
-    }
-    scheduleChunked(work, opts = {}) {
-        const iterator = Symbol.iterator in work ? work[Symbol.iterator]() : work;
-        const chunkBudgetMs = opts.chunkBudgetMs ?? 5;
-        const scope = opts.scope ?? this.currentScope;
-        let cancelled = false;
-        let priority = opts.priority ?? "normal";
-        const self = this;
-        function runChunk() {
-            if (cancelled)
-                return;
-            const start = performance.now();
-            while (true) {
-                const { value: step, done } = iterator.next();
-                if (done)
-                    return;
-                step();
-                const elapsed = performance.now() - start;
-                if (elapsed >= chunkBudgetMs)
-                    break;
-            }
-            if (!cancelled)
-                self.schedule(runChunk, { priority, scope });
-        }
-        this.schedule(runChunk, { priority, scope });
-        return {
-            cancel() {
-                cancelled = true;
-            },
-            reprioritize(next) {
-                priority = next;
-            },
-        };
-    }
-    // SAURON
-    _globalNotifyCache = new WeakMap();
-    _notifyCache = new WeakMap();
-    scheduleGlobalNotify(key, meta, opts) {
-        let cache = this._globalNotifyCache.get(meta);
-        if (!cache) {
-            cache = new Map();
-            this._globalNotifyCache.set(meta, cache);
-        }
-        let fn = cache.get(key);
-        if (!fn) {
-            fn = () => {
-                cache.delete(key);
-                const finalVal = this.store.get(key, opts);
-                const waiters = meta._waiters.get(key);
-                if (waiters) {
-                    for (const resolveFn of waiters) {
-                        try {
-                            resolveFn(finalVal);
-                        }
-                        catch (err) {
-                            console.error(`[Sauron Waiter Error]:`, err);
-                        }
-                    }
-                    meta._waiters.delete(key);
-                }
-                for (const listener of meta._globalListeners) {
-                    try {
-                        listener(key, finalVal);
-                    }
-                    catch (err) {
-                        console.error(`[Sauron Global Listener Error]:`, err);
-                    }
-                }
-            };
-            cache.set(key, fn);
-        }
-        this.onFlush(fn);
-    }
-    scheduleNotify(key, _listeners, _state) {
-        let cache = this._notifyCache.get(_listeners);
-        if (!cache) {
-            cache = new Map();
-            this._notifyCache.set(_listeners, cache);
-        }
-        let fn = cache.get(key);
-        if (!fn) {
-            fn = () => {
-                cache.delete(key);
-                const val = _state.get(key);
-                _listeners.get(key)?.forEach((l) => l(val));
-            };
-            cache.set(key, fn);
-        }
-        this.onFlush(fn);
-    }
-    store = {
-        get: (key, opts = { sl_reg: this.s, ms_reg: this.m, globalKey: this.r }) => {
-            const { sl_reg, ms_reg, globalKey } = opts;
-            const _state = this.getNestedMap(sl_reg, ms_reg, globalKey);
-            const _persistent = this.getNestedMap(`${sl_reg}_PERSISTENT`, ms_reg, globalKey);
-            const _persistKeys = this.getNestedMap(`${sl_reg}_PERSIST_KEYS`, ms_reg, globalKey);
-            // recordDependency(key)
-            if (_state.has(key))
-                return MaybePromise(_state.get(key));
-            if (_persistKeys.has(key) && _persistent.has(key)) {
-                const v = _persistent.get(key);
-                _state.set(key, v);
-                return MaybePromise(v);
-            }
-            return undefined;
-        },
-        set: (key, value, opts = { sl_reg: this.s, ms_reg: this.m, globalKey: this.r, triggerRender: true, cap: 200 }) => {
-            const { triggerRender = true, sl_reg, ms_reg, globalKey, cap } = opts;
-            const _state = this.getNestedMap(sl_reg, ms_reg, globalKey);
-            const _persistent = this.getNestedMap(`${sl_reg}_PERSISTENT`, ms_reg, globalKey);
-            const _persistKeys = this.getNestedMap(`${sl_reg}_PERSIST_KEYS`, ms_reg, globalKey);
-            const _listeners = this.getNestedMap(`${sl_reg}_LISTENERS`, ms_reg, globalKey);
-            const prev = _state.get(key);
-            const next = typeof value === "function" ? value(prev) : value;
-            if (Object.is(prev, next))
-                return;
-            // TIME TRAVEL
-            if (!this.root.TIME_TRAVEL._time_travel_reverting) {
-                const meta = this.getMetadata(sl_reg, ms_reg, globalKey);
-                let hist = meta._history.get(key);
-                if (!hist) {
-                    hist = [];
-                    meta._history.set(key, hist);
-                }
-                const lastActive = hist.findLastIndex((e) => !e.undone) ?? -1;
-                if (lastActive < hist.length - 1)
-                    hist.length = lastActive + 1; // truncate redo tail
-                hist.push({ k: (hist[hist.length - 1]?.k ?? 0) + 1, prev, next, ts: Date.now(), undone: false });
-                const cap_val = cap ?? 200;
-                while (hist.length > cap_val)
-                    hist.shift();
-            }
-            _state.set(key, next);
-            if (_persistKeys.has(key))
-                _persistent.set(key, next);
-            if (triggerRender)
-                this.scheduleGlobalNotify(key, this.getMetadata(sl_reg, ms_reg, globalKey), opts);
-            if (triggerRender)
-                this.scheduleNotify(key, _listeners, _state);
-            return MaybePromise(next);
-        },
-        subscribe: (key, listener, opts = { sl_reg: this.s, ms_reg: this.m, globalKey: this.r }) => {
-            const { sl_reg, ms_reg, globalKey } = opts;
-            const _listeners = this.getNestedMap(`${sl_reg}_LISTENERS`, ms_reg, globalKey);
-            if (!_listeners.has(key))
-                _listeners.set(key, new Set());
-            _listeners.get(key).add(listener);
-            return () => {
-                _listeners.get(key)?.delete(listener);
-                if (_listeners.get(key)?.size === 0)
-                    _listeners.delete(key);
-            };
-        },
-        delete: (key, opts = { sl_reg: this.s, ms_reg: this.m, globalKey: this.r }) => {
-            const { sl_reg, ms_reg, globalKey } = opts;
-            const _state = this.getNestedMap(sl_reg, ms_reg, globalKey);
-            const _persistent = this.getNestedMap(`${sl_reg}_PERSISTENT`, ms_reg, globalKey);
-            const _persistKeys = this.getNestedMap(`${sl_reg}_PERSIST_KEYS`, ms_reg, globalKey);
-            const _listeners = this.getNestedMap(`${sl_reg}_LISTENERS`, ms_reg, globalKey);
-            const existed = _state.delete(key);
-            if (_persistKeys.has(key)) {
-                _persistKeys.delete(key);
-                _persistent.delete(key);
-            }
-            _listeners.get(key)?.forEach((l) => l(undefined));
-            _listeners.delete(key);
-            return MaybePromise(existed);
-        },
-        entries: (opts = { sl_reg: this.s, ms_reg: this.m, globalKey: this.r }) => {
-            const { sl_reg, ms_reg, globalKey } = opts;
-            const _state = this.getNestedMap(sl_reg, ms_reg, globalKey);
-            return MaybePromise(Array.from(_state.entries()));
-        },
-        persist: (key, opts = { sl_reg: this.s, ms_reg: this.m, globalKey: this.r }) => {
-            const { sl_reg, ms_reg, globalKey } = opts;
-            const _persistKeys = this.getNestedMap(`${sl_reg}_PERSIST_KEYS`, ms_reg, globalKey);
-            _persistKeys.set(key, true);
-        },
-        unpersist: (key, opts = { sl_reg: this.s, ms_reg: this.m, globalKey: this.r }) => {
-            const { sl_reg, ms_reg, globalKey } = opts;
-            const _persistent = this.getNestedMap(`${sl_reg}_PERSISTENT`, ms_reg, globalKey);
-            const _persistKeys = this.getNestedMap(`${sl_reg}_PERSIST_KEYS`, ms_reg, globalKey);
-            _persistKeys.delete(key);
-            _persistent.delete(key);
-        },
-        has: (key, opts = { sl_reg: this.s, ms_reg: this.m, globalKey: this.r }) => {
-            const { sl_reg, ms_reg, globalKey } = opts;
-            const _state = this.getNestedMap(sl_reg, ms_reg, globalKey);
-            const _persistent = this.getNestedMap(`${sl_reg}_PERSISTENT`, ms_reg, globalKey);
-            const _persistKeys = this.getNestedMap(`${sl_reg}_PERSIST_KEYS`, ms_reg, globalKey);
-            return _state.has(key) || (_persistKeys.has(key) && _persistent.has(key));
-        },
-        clear: (opts = { sl_reg: this.s, ms_reg: this.m, globalKey: this.r }) => {
-            const { sl_reg, ms_reg, globalKey } = opts;
-            const _state = this.getNestedMap(sl_reg, ms_reg, globalKey);
-            const _listeners = this.getNestedMap(`${sl_reg}_LISTENERS`, ms_reg, globalKey);
-            _state.clear();
-            _listeners.clear();
-        },
-        clearPersistent: (opts = { sl_reg: this.s, ms_reg: this.m, globalKey: this.r }) => {
-            const { sl_reg, ms_reg, globalKey } = opts;
-            const _persistent = this.getNestedMap(`${sl_reg}_PERSISTENT`, ms_reg, globalKey);
-            const _persistKeys = this.getNestedMap(`${sl_reg}_PERSIST_KEYS`, ms_reg, globalKey);
-            _persistent.clear();
-            _persistKeys.clear();
-        },
-        _emit: (key, sl_reg = this.s, ms_reg = this.m, globalKey = this.r) => {
-            const opts = { sl_reg, ms_reg, globalKey };
-            const _state = this.getNestedMap(sl_reg, ms_reg, globalKey);
-            const _listeners = this.getNestedMap(`${sl_reg}_LISTENERS`, ms_reg, globalKey);
-            const meta = this.getMetadata(sl_reg, ms_reg, globalKey);
-            this.scheduleNotify(key, _listeners, _state);
-            this.scheduleGlobalNotify(key, meta, opts);
-        },
-    };
-    state = {
-        get: (key, opts = { sl_reg: this.s, ms_reg: this.m, globalKey: this.r }) => {
-            return MaybePromise(this.store.get(key, opts));
-        },
-        set: (key, value, opts = { sl_reg: this.s, ms_reg: this.m, globalKey: this.r }) => {
-            const { sl_reg, ms_reg, globalKey, triggerRender = true } = opts;
-            this.store.set(key, value, { triggerRender, sl_reg, ms_reg, globalKey });
-            return MaybePromise(value);
-        },
-        delete: (key, opts = { sl_reg: this.s, ms_reg: this.m, globalKey: this.r }) => {
-            const { sl_reg, ms_reg, globalKey } = opts;
-            const meta = this.getMetadata(sl_reg, ms_reg, globalKey);
-            const deleted = this.store.delete(key, opts);
-            if (deleted) {
-                for (const listener of meta._globalListeners) {
-                    try {
-                        listener(key, undefined);
-                    }
-                    catch (err) {
-                        console.error(`[Sauron Global Listener Error]:`, err);
-                    }
-                }
-            }
-            return deleted;
-        },
-        getByPrefix: (prefix, opts = { sl_reg: this.s, ms_reg: this.m, globalKey: this.r }) => {
-            return this.store
-                .entries(opts)
-                .filter(([key]) => typeof key === "string" && key.startsWith(prefix))
-                .map(([key, value]) => ({ key: key, value }));
-        },
-        getAll: (opts = { sl_reg: this.s, ms_reg: this.m, globalKey: this.r }) => {
-            const result = {};
-            for (const [key, value] of this.store.entries(opts)) {
-                result[key] = value;
-            }
-            return result;
-        },
-        subscribe: (key, listener, opts = { sl_reg: this.s, ms_reg: this.m, globalKey: this.r }) => {
-            return this.store.subscribe(key, listener, opts);
-        },
-        subscribeAll: (listener, opts = { sl_reg: this.s, ms_reg: this.m, globalKey: this.r }) => {
-            const { sl_reg, ms_reg, globalKey } = opts;
-            const meta = this.getMetadata(sl_reg, ms_reg, globalKey);
-            meta._globalListeners.add(listener);
-            return () => {
-                meta._globalListeners.delete(listener);
-            };
-        },
-        clear: (opts = { sl_reg: this.s, ms_reg: this.m, globalKey: this.r }) => {
-            const { sl_reg, ms_reg, globalKey } = opts;
-            const meta = this.getMetadata(sl_reg, ms_reg, globalKey);
-            this.store.clear(opts);
-            meta._waiters.clear();
-            meta._globalListeners.clear();
-        },
-        waitFor: (key, opts = { sl_reg: this.s, ms_reg: this.m, globalKey: this.r }) => {
-            const { sl_reg, ms_reg, globalKey } = opts;
-            const meta = this.getMetadata(sl_reg, ms_reg, globalKey);
-            // If it already exists, resolve immediately
-            const existing = this.state.get(key, opts);
-            if (existing !== undefined)
-                return Promise.resolve(existing);
-            return new Promise((resolve) => {
-                if (!meta._waiters.has(key))
-                    meta._waiters.set(key, new Set());
-                meta._waiters.get(key).add(resolve);
-            });
-        },
-    };
-    /**  public store2 = (() => {
-        const sa = {
-            get: <T = A>(key: SignalKey, opts: ScopeOptions = { s: this.s, m: this.m, r: this.r, },) => {
-                const { s, m, r, } = opts;
-                const atom = this.root.SIGNALS.create<T>(key, undefined, undefined, s, m, r,) as SIGNAL_CELL;
-                return atom ? atom.node : undefined;
-            },
-            set: <T = A>(key: SignalKey, value: A, opts: { triggerRender?: boolean; cap?: number; source?: string; } & ScopeOptions = { s: this.s, m: this.m, r: this.r, triggerRender: true, cap: 200, },): T | undefined => {
-                const { triggerRender = true, cap = 200, source = "state.set", s, m, r, } = opts;
-                const atom = this.root.SIGNALS.create(key, typeof value === "function" ? value() : value, opts, s, m, r,);
-                atom.historyMax = cap;
-                const next = atom.write((previous: A) => typeof value === "function" ? (value as (prev: T | undefined) => T)(previous) : value, { source, triggerRender },);
-                const listeners = this.__subscribers.get(r)?.get(m)?.get(s)?.get(key);
-                if (listeners) {
-                    for (const listener of listeners) {
-                        try { listener(next); }
-                        catch (error) { console.error(`[Sauron:state.subscribeAll] listener failed for "${String(atom.key)}":`, error,); }
-                    }
-                }
-                return MaybePromise(next);
-            },
-
-            subscribe: <T = A>(key: SignalKey, listener: (value: T) => void, opts: ScopeOptions = { s: this.s, m: this.m, r: this.r, },): Unsubscribe => {
-                let msMap = this.__subscribers.get(opts.r);
-
-                if (!msMap) { msMap = new Map(); this.__subscribers.set(opts.r, msMap); }
-                let slMap = msMap.get(opts.m);
-                if (!slMap) { slMap = new Map(); msMap.set(opts.m, slMap); }
-                let keyMap = slMap.get(opts.s);
-                if (!keyMap) { keyMap = new Map(); slMap.set(opts.s, keyMap); }
-                let listeners = keyMap.get(key);
-                if (!listeners) { listeners = new Set(); keyMap.set(key, listeners); }
-
-                listeners.add(listener);
-
-                return () => {
-                    listeners!.delete(listener);
-                    if (listeners!.size === 0) { keyMap!.delete(key); }
-                    if (keyMap!.size === 0) { slMap!.delete(opts.s); }
-                    if (slMap!.size === 0) { msMap!.delete(opts.m); }
-                    if (msMap!.size === 0) { this.__subscribers.delete(opts.r); }
-                };
-            },
-
-            delete: (key: SignalKey, opts: ScopeOptions = { s: this.s, m: this.m, r: this.r, }): boolean => {
-                const { s, m, r } = opts;
-                const registry = this.root.SIGNALS.atom_reg(s, m, r);
-                const atom = this.root.SIGNALS.get(key, s, m, r);
-                if (!atom) return false;
-                const previous = atom.peek();
-                const resolvedKey = this.root.SIGNALS.resolveKey(key, s, m, r);
-                const listeners = this.__subscribers.get(r)?.get(m)?.get(s)?.get(key);
-                if (listeners) for (const listener of listeners) {
-                    try { listener({ key: atom.key, previous, current: undefined, version: atom.version + 1, timestamp: Date.now(), source: "state.delete" }); }
-                    catch (error) { console.error(`[Sauron:state.delete] listener failed for "${String(key)}":`, error); }
-                }
-                const subscribers = this._externalSubscribers.get(r)?.get(m)?.get(s)?.get(key);
-                if (subscribers) for (const notify of subscribers) {
-                    try { notify(undefined); }
-                    catch (error) { console.error(`[Sauron:state.delete] external subscriber failed for "${String(key)}":`, error); }
-                }
-                registry.delete(resolvedKey);
-                return MaybePromise(true);
-            },
-            entries: <T = A>(opts: ScopeOptions = { s: this.s, m: this.m, r: this.r, },): [SignalKey, T][] => {
-                const { s, m, r, } = opts;
-                const registry = this.root.SIGNALS.atom_reg(s, m, r,);
-                return MaybePromise([...registry.entries()].map(([key, atom]) => [key, atom.read() as T,]),
-                );
-            },
-            persist: (key: SignalKey, opts: ScopeOptions = { s: this.s, m: this.m, r: this.r, },): void => {
-                const atom = this.root.SIGNALS.atom_reg(opts.s, opts.m, opts.r,).get(key);
-                if (!atom) return;
-                atom.persisted = true;
-                setSS(String(atom.key), atom.peek(),);
-            },
-            unpersist: (key: SignalKey, opts: ScopeOptions = { s: this.s, m: this.m, r: this.r, },): void => {
-                const atom = this.root.SIGNALS.get(key, opts.s, opts.m, opts.r,);
-                if (!atom) return;
-                atom.persisted = false;
-                deleteSS(String(atom.key));
-            },
-            has: (key: SignalKey, opts: ScopeOptions = { s: this.s, m: this.m, r: this.r, },): boolean => {
-                const registry = this.root.SIGNALS.atom_reg(opts.s, opts.m, opts.r,);
-                const resolvedKey = this.root.SIGNALS.resolveKey(key, opts.s, opts.m, opts.r,);
-                return registry.has(resolvedKey);
-            },
-            clear: (opts: ScopeOptions = { s: this.s, m: this.m, r: this.r, },): void => {
-                const registry = this.root.SIGNALS.atom_reg(opts.s, opts.m, opts.r,);
-                for (const atom of registry.values()) {
-                    for (const notify of atom.externalSubscribers) {
-                        try {
-                            notify();
-                        } catch (error) {
-                            console.error(
-                                `[Sauron:state.clear] external subscriber failed:`,
-                                error,
-                            );
-                        }
-                    }
-
-                    atom.listeners.clear();
-                    atom.externalSubscribers.clear();
-                    atom.waiters.clear();
-                }
-
-                registry.clear();
-            },
-            clearPersistent: (opts: ScopeOptions = { s: this.s, m: this.m, r: this.r, },): void => {
-                const registry = this.root.SIGNALS.atom_reg(opts.s, opts.m, opts.r,);
-
-                for (const atom of registry.values()) {
-                    if (!atom.persisted) continue;
-
-                    atom.persisted = false;
-                    deleteSS(String(atom.key));
-                }
-            },
-            _emit: (key: SignalKey, s = this.s, m = this.m, r = this.r,): void => {
-                const atom = this.root.SIGNALS.atom_reg(s, m, r,).get('_LISTENERS').get(key);
-                if (!atom) return;
-                const value = atom.peek();
-                for (const listener of atom.listeners) {
-                    listener({ key: atom.key, previous: value, current: value, version: atom.version, timestamp: Date.now(), source: "state.emit", });
-                }
-
-                for (const notify of atom.externalSubscribers) { notify(); }
-            },
-        };
-        return sa
-    })();
-    public state2 = (() => {
-        const sa = {
-            get: <T = A>(key: SignalKey, opts: ScopeOptions = { s: this.s, m: this.m, r: this.r, },): T | undefined => {
-                return MaybePromise(this.store.get<T>(key, opts) as T);
-            },
-            set: <T = A>(key: SignalKey, value: T | ((prev: T | undefined) => T), opts: { triggerRender?: boolean; } & ScopeOptions = { s: this.s, m: this.m, r: this.r, },) => {
-                this.store.set(key, value, { triggerRender: opts.triggerRender ?? true, s: opts.s, m: opts.m, r: opts.r, source: "state.set", });
-                return MaybePromise(value as T);
-            },
-            delete: (key: SignalKey, opts: ScopeOptions = { s: this.s, m: this.m, r: this.r, },): boolean => {
-                return this.store.delete(key, opts);
-            },
-            getByPrefix: <T = A>(prefix: string, opts: ScopeOptions = { s: this.s, m: this.m, r: this.r, },) => {
-                return this.store.entries<T>(opts).filter(([key]) => { return typeof key === "string" && key.startsWith(prefix); }).map(([key, value]) => ({ key: key as string, value, }));
-            },
-            getAll: <T = A>(opts: ScopeOptions = { s: this.s, m: this.m, r: this.r, },): Record<string | symbol, T> => {
-                const result: Record<string | symbol, T> = {};
-                for (const [key, value] of this.store.entries<T>(opts)) { result[key] = value; }
-                return result;
-            },
-            subscribe: <T = A>(key: SignalKey, listener: (value: T) => void, opts: ScopeOptions = { s: this.s, m: this.m, r: this.r, },): Unsubscribe => {
-                return this.store.subscribe<T>(key, listener, opts);
-            },
-            subscribeAll: (listener: (key: SignalKey, value: unknown) => void, opts: ScopeOptions = { s: this.s, m: this.m, r: this.r, },): Unsubscribe => {
-                const scope = this.root.SIGNALS.get(opts.s, opts.m, opts.r,);
-                return () => { scope.listeners.delete(listener); };
-            },
-            clear: (opts: ScopeOptions = { s: this.s, m: this.m, r: this.r, },): void => {
-                this.store.clear(opts);
-            },
-            waitFor: <T = A>(key: SignalKey, opts: ScopeOptions = { s: this.s, m: this.m, r: this.r, },): Promise<T> => {
-                const atom = this.root.SIGNALS.get(opts.s, opts.m, opts.r,);
-                if (!atom) { return new Promise<T>(() => { }); }
-
-                if (atom.hasWritten) {
-                    return Promise.resolve(atom.read());
-                }
-
-                return atom.waitForNext();
-            },
-        };
-        return sa
-    })(); */
-    _devRecord = null;
-    devRecord(componentId, hookName, sauronId, key, value) {
-        return this._devRecord?.(componentId, hookName, sauronId, key, value);
-    }
-    registerDevRecorder(fn) {
-        this._devRecord = fn;
-    }
-    rerender = (key) => {
-        if (key !== undefined) {
-            //   const hs = graphHookStates.get(key);
-            // if (hs) notifyHook(`${GRAPH_BRIDGE_COMPONENT_ID}:${key}`);
-            this.notifyHook(key);
-        }
-        else {
-            this.flushSync();
-        }
-    };
-    flushHookKey = (key) => {
-        const [componentId] = key.split(":");
-        /**
-         * Store/global synthetic hook keys do not map to a component hook state.
-         * They simply notify subscribers.
-         */
-        if (componentId === "store") {
-            this._subscribers.get(key)?.forEach((callback) => {
-                if (typeof callback !== "function")
-                    return;
-                callback();
-                this.onFlush(callback);
-            });
-            return;
-        }
-        const component = this._components.get(componentId) ?? this._root;
-        const hook = component?.hooks.get(key);
-        /**
-         * Prefer direct DOM binding updates where bindings exist.
-         */
-        if (hook?.bindings && hook.bindings.size > 0) {
-            for (const binding of hook.bindings) {
-                if (!binding.active)
-                    continue;
-                binding.update(binding.node, hook.value);
-            }
-            return;
-        }
-        this._subscribers.get(key)?.forEach((callback) => {
-            if (typeof callback !== "function")
-                return;
-            callback();
-            this.onFlush(callback);
-        });
-    };
-    _flushHookNotifications = () => {
-        this._flushScheduled = false;
-        const keys = Array.from(this._pendingNotifications);
-        this._pendingNotifications.clear();
-        for (const key of keys) {
-            this.flushHookKey(key);
-        }
-    };
-    getCurrentComponent = () => {
-        if (this.root.isReact === true && this.root.IS_THE_WIZARD === false) {
-            if (this._currentComponent)
-                return this._currentComponent;
-            return this._root;
-        }
-        else {
-            if (!this.init_hooks_context) {
-                this.set("_root", this._root, true, this.s, this.m, this.r);
-                this.init_hooks_context = true;
-            }
-            const updated_ctx = this.get("_root", this.s, this.m, this.r);
-            if (updated_ctx && updated_ctx.id === this.r)
-                return updated_ctx;
-            else
-                return this._root;
-        }
-    };
-    unmountComponent(id) {
-        const instance = this._components.get(id);
-        if (!instance)
-            return;
-        for (const dispose of instance.unmount) {
-            try {
-                dispose();
-            }
-            catch (error) {
-                console.error(`[THE_CLOUD][UNMOUNT] cleanup failed for "${id}":`, error);
-            }
-        }
-        instance.unmount.clear();
-        for (const hook of instance.hooks.values()) {
-            try {
-                hook.cleanup?.();
-            }
-            catch (error) {
-                console.error(`[THE_CLOUD][UNMOUNT] hook cleanup failed for "${id}":`, error);
-            }
-        }
-        instance.hooks.clear();
-        this._components.delete(id);
-    }
-    mountComponent(id, renderFn) {
-        const instance = {
-            id,
-            hooks: new Map(),
-            unmount: new Set(),
-            render: renderFn,
-        };
-        this._components.set(id, instance);
-        return instance;
-    }
-    hmrPreserve() {
-        const snapshot = new Map();
-        this._components.forEach((instance, id) => {
-            const hooks = new Map();
-            instance.hooks.forEach((state, key) => {
-                hooks.set(key, state.value);
-            });
-            snapshot.set(id, hooks);
-        });
-        return snapshot;
-    }
-    hmrRestore(snapshot) {
-        snapshot.forEach((hooks, id) => {
-            const instance = this._components.get(id);
-            if (!instance)
-                return;
-            hooks.forEach((value, key) => {
-                const state = instance.hooks.get(key);
-                if (state)
-                    state.value = value;
-            });
-        });
-    }
-    subscribeToHook(key, cb) {
-        if (!this._subscribers.has(key))
-            this._subscribers.set(key, new Set());
-        this._subscribers.get(key).add(cb);
-        return () => {
-            this._subscribers.get(key)?.delete(cb);
-            if (this._subscribers.get(key)?.size === 0)
-                this._subscribers.delete(key);
-        };
-    }
-    notifyHook(key) {
-        this._pendingNotifications.add(key);
-        if (!this._flushScheduled) {
-            this._flushScheduled = true;
-            queueMicrotask(this._flushHookNotifications);
-        }
-    }
-    endHookDependencyCapture() {
-        this._currentHookState = null;
-    }
-    beginHookDependencyCapture(hook) {
-        this._currentHookState = hook;
-    }
-    registerDOMBinding(node, update) {
-        const hook = this._currentHookState;
-        if (!hook)
-            return;
-        const binding = { node, update, active: true };
-        if (!hook.bindings) {
-            hook.bindings = new Set();
-        }
-        hook.bindings.add(binding);
-        const anyNode = node;
-        if (!anyNode.__sauron_bindings__) {
-            anyNode.__sauron_bindings__ = new Set();
-        }
-        anyNode.__sauron_bindings__.add(hook);
-        return () => {
-            if (!binding.active)
-                return;
-            binding.active = false;
-            hook.bindings?.delete(binding);
-            anyNode.__sauron_bindings__?.delete(hook);
-        };
-    }
-    setCurrentComponent(instance) {
-        this._currentComponent = instance;
-    }
-    registerDOMRef(name, node) {
-        if (!this._currentHookState)
-            return;
-        if (!this._currentHookState.domRefs)
-            this._currentHookState.domRefs = new Map();
-        this._currentHookState.domRefs.set(name, node);
-    }
-    getDOMRef(name) {
-        if (!this._currentHookState || !this._currentHookState.domRefs)
-            return undefined;
-        return this._currentHookState.domRefs.get(name);
-    }
-    registerAdapter(adapter) {
-        this._adapter = adapter;
-    }
-    _reactHookCursor = 0;
-    _currentRenderInstanceCheck = null;
-    _isReactRenderContext() {
-        const _react = this.root.isReact;
-        if (!_react)
-            return false;
-        if (this.root.IS_THE_WIZARD)
-            return false;
-        try {
-            _react.useState;
-            // If useState is callable without throwing, we're in a React render context
-            // We probe by checking if the dispatcher is active via a known internal
-            const internals = _react.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
-            const dispatcher = internals?.ReactCurrentDispatcher?.current ?? internals?.H;
-            return !!dispatcher;
-        }
-        catch (e) {
-            // log(`[THE_CLOUD][_IS_REACT_RENDER_CONTEXT]`, { error: e, }, t.error)
-            return false;
-        }
-    }
-    createHook(hookName, sauronId, initializer, updater, triggerRender = true) {
-        if (this.root.isReact === true && this.root.IS_THE_WIZARD === false) {
-            try {
-                const isReact = this._isReactRenderContext();
-                const { instance, forceUpdate } = isReact && this._adapter ? this._adapter.getComponentInstance() : { instance: this.getCurrentComponent(), forceUpdate: undefined };
-                const component = instance;
-                // ─── THE TARGETED FIX ───────────────────────────────────────────────────────
-                // Use sequential indexing when in React so it matches React's rendering slots.
-                // Otherwise, use Sauron's default compilation ID string.
-                const stableSlotId = isReact ? `seq-${this._reactHookCursor++}` : sauronId;
-                const key = `${component.id}:${hookName}:${stableSlotId}`;
-                // ────────────────────────────────────────────────────────────────────────────
-                if (!this._components.has(component.id)) {
-                    this._components.set(component.id, component);
-                }
-                if (!component.hooks.has(key)) {
-                    const state = initializer();
-                    component.hooks.set(key, state);
-                    if (component.render) {
-                        const unsub = this.subscribeToHook(key, () => component.render?.());
-                        component.unmount.add(unsub);
-                    }
-                }
-                if (isReact && this._adapter && forceUpdate) {
-                    this._adapter.onHookSubscribe(key, forceUpdate);
-                }
-                const notify = (k) => {
-                    if (typeof process !== "undefined" && process.env?.NODE_ENV !== "production") {
-                        const state = component.hooks.get(k);
-                        this.devRecord(component.id, hookName, stableSlotId, k, state?.value);
-                    }
-                    this.notifyHook(k);
-                };
-                const hookState = component.hooks.get(key);
-                this.beginHookDependencyCapture(hookState);
-                try {
-                    return updater(hookState, key, notify);
-                }
-                finally {
-                    this.endHookDependencyCapture();
-                }
-            }
-            catch (e) {
-                //  log(`[THE_CLOUD][CREATE_HOOK]`, { error: e, }, t.error)
-                return e.error;
-            }
-        }
-        else {
-            try {
-                const component = this.getCurrentComponent();
-                const key = `${component.id}:${hookName}:${sauronId}`;
-                if (!this._components.has(component.id)) {
-                    this._components.set(component.id, component);
-                }
-                if (!component.hooks.has(key)) {
-                    const state = initializer();
-                    component.hooks.set(key, state);
-                    if (triggerRender && component.render) {
-                        const unsub = this.subscribeToHook(key, () => component.render?.());
-                        component.unmount.add(unsub);
-                    }
-                }
-                const notify = (k) => {
-                    if (typeof process !== "undefined" && process.env?.NODE_ENV !== "production") {
-                        const state = component.hooks.get(k);
-                        this.devRecord(component.id, hookName, sauronId, k, state?.value);
-                    }
-                    if (triggerRender)
-                        this.notifyHook(k);
-                };
-                const hookState = component.hooks.get(key);
-                this.beginHookDependencyCapture(hookState);
-                try {
-                    return updater(hookState, key, notify);
-                }
-                finally {
-                    this.endHookDependencyCapture();
-                }
-            }
-            catch (e) {
-                // log(`[THE_CLOUD][CREATE_HOOK]`, { error: e, }, t.error)
-                return e.error;
-            }
-        }
-    }
-    _broadcastSS(key, value, storageType, fn, path, domain, options) {
-        this._localChange = true;
-        this._channel?.postMessage({ key, value, storageType, fn, path, domain, options });
-    }
-    getChain(key, s, m, r, chain) {
-        return MaybePromise(this.state.get(key, { s, m, r }));
-    }
-    getReChain(key, s, m, r) {
-        return MaybePromise(this.state.get(key, { s, m, r }));
-    }
-    get(key, s, m, r) {
-        return MaybePromise(this.state.get(key, { s, m, r }));
-    }
-    getSauron(key, s, m, r) {
-        return MaybePromise(this.state.get(key, { s, m, r }));
-    }
-    getAll(opts) {
-        return this.state.getAll(opts);
-    }
-    getAllSauron(opts) {
-        return this.state.getAll(opts);
-    }
-    async getMany(keys, s, m, r) {
-        if (!Array.isArray(keys) || keys.length === 0) {
-            return {};
-        }
-        const result = {};
-        const promises = keys.map(async (key) => {
-            const value = await this.get(key, s, m, r);
-            return { key, value };
-        });
-        const results = await Promise.all(promises);
-        for (const { key, value } of results) {
-            result[key] = value;
-        }
-        return result;
-    }
-    setChain(label, value, triggerRender = true, s, m, r) {
-        return MaybePromise(this.state.set(label, value, { triggerRender, s, m, r }));
-    }
-    set(label, value, triggerRender = true, s, m, r) {
-        this._broadcastSS(label, value, "sauron", "set");
-        return MaybePromise(this.state.set(label, value, { triggerRender, s, m, r }));
-    }
-    setSauron(label, value, triggerRender = true, s, m, r) {
-        this._broadcastSS(label, value, "sauron", "set");
-        return MaybePromise(this.state.set(label, value, { triggerRender, s, m, r }));
-    }
-    async setMany(entries) {
-        if (!entries || typeof entries !== "object") {
-            return;
-        }
-        // Batch all sets without triggering renders until the end
-        const entriesArray = Object.entries(entries);
-        for (let i = 0; i < entriesArray.length; i++) {
-            const [key, value] = entriesArray[i];
-            // Only trigger render on the last item to avoid multiple renders
-            const triggerRender = i === entriesArray.length - 1;
-            this.set(key, value, triggerRender);
-        }
-    }
-    subChain(label, fn, s, m, r) {
-        return MaybePromise(this.state.subscribe(label, fn, { s, m, r }));
-    }
-    sub(label, fn, s, m, r) {
-        if (!label || !fn)
-            return () => { };
-        return MaybePromise(this.state.subscribe(label, fn, { s, m, r }));
-    }
-    /**
- * subSauronInfinity<MyType>('myKey', (value) => {
-    console.log(value) // every value
-})
- */
-    subSauron(k, fn, s, m, r) {
-        if (!k || !fn)
-            return () => { };
-        return MaybePromise(this.state.subscribe(k, fn, { s, m, r }));
-    }
-    subAll(fn, s, m, r) {
-        if (!fn)
-            return () => { };
-        return this.state.subscribeAll(fn, { s, m, r });
-    }
-    subAllSauron(fn, s, m, r) {
-        if (!fn)
-            return () => { };
-        return this.state.subscribeAll(fn, { s, m, r });
-    }
-    delSauron(label, s, m, r) {
-        if (!label)
-            return false;
-        const v = this.state.delete(label, { s, m, r });
-        this._broadcastSS(label, undefined, "sauron", "delete");
-        return v;
-    }
-    deleteSauron(label, s, m, r) {
-        if (!label)
-            return false;
-        const v = this.state.delete(label, { s, m, r });
-        this._broadcastSS(label, undefined, "sauron", "delete");
-        return v;
-    }
-    deleteChain(label, s, m, r) {
-        return MaybePromise(this.state.delete(label, { s, m, r }));
-    }
-    async deleteMany(keys, s, m, r) {
-        if (!Array.isArray(keys) || keys.length === 0) {
-            return false;
-        }
-        let allDeleted = true;
-        // Batch all deletes without triggering renders until the end
-        for (let i = 0; i < keys.length; i++) {
-            const deleted = this.delSauron(keys[i], s, m, r);
-            if (!deleted) {
-                allDeleted = false;
-            }
-        }
-        return allDeleted;
-    }
-    waitFor(label, s, m, r) {
-        return this.state.waitFor(label, { s, m, r });
-    }
-    waitForSauron(label, s, m, r) {
-        return this.state.waitFor(label, { s, m, r });
-    }
-}
-// #endregion 
-//                                                                                           TIME TRAVEL
-// #region ══════════════════════════════════════════════════════════════════════════════════════════════════════
-class DRSTimeTravel {
-    root;
-    _time_travel_reverting = false;
-    constructor(root) {
-        this.root = root;
-    }
-    get sauron() {
-        return this.root.SAURON;
-    }
-    defaultChannels = () => ({
-        r: this.sauron.r,
-        m: this.sauron.m,
-        s: '_TC_TIME_TRAVEL_',
-    });
-    resolveChannels = (channels = this.defaultChannels()) => ({
-        ...this.defaultChannels(),
-        ...channels,
-    });
-    resolveHistory = (key, channels = this.defaultChannels()) => {
-        const { s, m, r } = this.resolveChannels(channels);
-        const meta = this.root.SAURON.getMetadata(s, m, r);
-        return meta._history.get(key);
-    };
-    history = (key, channels = this.defaultChannels()) => {
-        return this.resolveHistory(key, channels) ?? [];
-    };
-    replay = (key, value, channels, source) => {
-        const { s, m, r } = this.resolveChannels(channels);
-        this._time_travel_reverting = true;
-        try {
-            this.sauron.store.set(key, value, {
-                sl_reg: s,
-                ms_reg: m,
-                globalKey: r,
-                triggerRender: true,
-            });
-            return value;
-        }
-        finally {
-            this._time_travel_reverting = false;
-        }
-    };
-    graft = (drs) => {
-        drs.time_travel = {
-            back: this.back,
-            forward: this.forward,
-            goto: this.goto,
-            history: this.history,
-        };
-        return drs.time_travel;
-    };
-    back = (key, steps = 1, channels = this.defaultChannels()) => {
-        const history = this.resolveHistory(key, channels);
-        if (!history?.length || steps <= 0)
-            return undefined;
-        const { s, m, r } = this.resolveChannels(channels);
-        const meta = this.root.SAURON.getMetadata(s, m, r);
-        const index = meta._timeTravel.get(key) ?? history.length - 1;
-        const targetIndex = Math.max(0, index - steps);
-        if (targetIndex === index)
-            return undefined;
-        meta._timeTravel.set(key, targetIndex);
-        for (let i = 0; i < history.length; i++) {
-            history[i].undone = i > targetIndex;
-        }
-        return this.replay(key, history[targetIndex].next, channels, "time-travel.back");
-    };
-    forward = (key, steps = 1, channels = this.defaultChannels()) => {
-        const history = this.resolveHistory(key, channels);
-        if (!history?.length || steps <= 0)
-            return undefined;
-        const { s, m, r } = this.resolveChannels(channels);
-        const meta = this.root.SAURON.getMetadata(s, m, r);
-        const index = meta._timeTravel.get(key) ?? history.length - 1;
-        const targetIndex = Math.min(history.length - 1, index + steps);
-        if (targetIndex === index)
-            return undefined;
-        meta._timeTravel.set(key, targetIndex);
-        for (let i = 0; i < history.length; i++) {
-            history[i].undone = i > targetIndex;
-        }
-        return this.replay(key, history[targetIndex].next, channels, "time-travel.forward");
-    };
-    goto = (key, sequence, channels = this.defaultChannels()) => {
-        const history = this.resolveHistory(key, channels);
-        if (!history?.length)
-            return undefined;
-        const { s, m, r } = this.resolveChannels(channels);
-        const meta = this.root.SAURON.getMetadata(s, m, r);
-        const targetIndex = history.findIndex((entry) => entry.k === sequence);
-        const index = meta._timeTravel.get(key) ?? history.length - 1;
-        if (targetIndex < 0 || targetIndex === index)
-            return undefined;
-        meta._timeTravel.set(key, targetIndex);
-        for (let i = 0; i < history.length; i++) {
-            history[i].undone = i > targetIndex;
-        }
-        return this.replay(key, history[targetIndex].next, channels, "time-travel.goto");
-    };
-}
-// #endregion 
-//                                                                                                  ROOT
-// #region ══════════════════════════════════════════════════════════════════════════════════════════════════════
-export class ROOT {
-    SAURON;
-    TIME_TRAVEL;
-    SIGNALS;
-    r = 'TW_ROOT_REG';
-    m = 'TW_MASTER_REG';
-    s = '_TC_ROOT_';
-    isReact = false;
-    IS_THE_WIZARD = true;
-    constructor() {
-        this.SAURON = new SAURON(this);
-        this.TIME_TRAVEL = new DRSTimeTravel(this);
-        // this.SIGNALS  = new SIGNALS(this)
-        this.s = store.get('SAURON_SLAVE_REG') ?? '_TC_ROOT_';
-        this.m = store.get('SAURON_MASTER_REG') ?? 'TW_MASTER_REG';
-        this.r = store.get('THE_WIZARD_ROOT_REG') ?? 'TW_ROOT_REG';
-        this.SIGNALS.r = this.r;
-        this.SIGNALS.m = this.m;
-        this.SIGNALS.r = this.r;
-        this.SIGNALS.m = this.m;
-        this.SIGNALS.hub.STATE_CONTEXT = store.get('STATE_CONTEXT') ?? 'sauron';
-        this.SAURON.root = this;
-        this.TIME_TRAVEL.root = this;
-    }
-}
-export const root = new ROOT();
-// #endregion 
-//                                         [SIGNALS]
-// #region ══════════════════════════════════════════════════════════════════════════════════════════════════════
-// #endregion 
-export const signals = root.SIGNALS;
-export const _root = root.SAURON._root;
-export const getNestedMap = root.SAURON.getNestedMap;
-export const getMetadata = root.SAURON.getMetadata;
-export const scheduleGlobalNotify = root.SAURON.scheduleGlobalNotify;
-export const scheduleNotify = root.SAURON.scheduleNotify;
-//export const store = root.SAURON.store
-export const state = root.SAURON.state;
-export const _devRecord = root.SAURON._devRecord;
-export const devRecord = root.SAURON.devRecord;
-export const registerDevRecorder = root.SAURON.registerDevRecorder;
-export const rerender = root.SAURON.rerender;
-export const flushHookKey = root.SAURON.flushHookKey;
-export const _flushHookNotifications = root.SAURON._flushHookNotifications;
-export const getCurrentComponent = root.SAURON.getCurrentComponent;
-export const unmountComponent = root.SAURON.unmountComponent;
-export const mountComponent = root.SAURON.mountComponent;
-export const hmrPreserve = root.SAURON.hmrPreserve;
-export const hmrRestore = root.SAURON.hmrRestore;
-export const subscribeToHook = root.SAURON.subscribeToHook;
-export const notifyHook = root.SAURON.notifyHook;
-export const endHookDependencyCapture = root.SAURON.endHookDependencyCapture;
-export const beginHookDependencyCapture = root.SAURON.beginHookDependencyCapture;
-export const registerDOMBinding = root.SAURON.registerDOMBinding;
-export const setCurrentComponent = root.SAURON.setCurrentComponent;
-export const registerDOMRef = root.SAURON.registerDOMRef;
-export const getDOMRef = root.SAURON.getDOMRef;
-export const registerAdapter = root.SAURON.registerAdapter;
-export const _reactHookCursor = root.SAURON._reactHookCursor;
-export const _currentRenderInstanceCheck = root.SAURON._currentRenderInstanceCheck;
-export const _isReactRenderContext = root.SAURON._isReactRenderContext;
-export const createHook = root.SAURON.createHook;
-export const _broadcastSS = root.SAURON._broadcastSS;
-export const getChain = root.SAURON.getChain;
-export const getReChain = root.SAURON.getReChain;
-export const get = root.SAURON.get;
-export const getSauron = root.SAURON.getSauron;
-export const getAll = root.SAURON.getAll;
-export const getAllSauron = root.SAURON.getAllSauron;
-export const getMany = root.SAURON.getMany;
-export const setChain = root.SAURON.setChain;
-export const set = root.SAURON.set;
-export const setSauron = root.SAURON.setSauron;
-export const setMany = root.SAURON.setMany;
-export const subChain = root.SAURON.subChain;
-export const sub = root.SAURON.sub;
-export const subSauron = root.SAURON.subSauron;
-export const subAll = root.SAURON.subAll;
-export const subAllSauron = root.SAURON.subAllSauron;
-export const delSauron = root.SAURON.delSauron;
-export const deleteSauron = root.SAURON.deleteSauron;
-export const deleteChain = root.SAURON.deleteChain;
-export const deleteMany = root.SAURON.deleteMany;
-export const waitFor = root.SAURON.waitFor;
-export const waitForSauron = root.SAURON.waitForSauron;
-const chh = root.SAURON.createHook;
-globalThis.createHook = chh;
-globalThis._sid = _sidi;