aoye 0.0.22 → 0.0.24

package/dist/index.umd.js

@@ -4,996 +4,654 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Aoye = {}, global.BobeShared));
 })(this, (function (exports, bobeShared) { 'use strict';
 
-  const rawToProxy = /* @__PURE__ */new WeakMap();
-  new bobeShared.BaseEvent();
-  const G = {
-    /** 原子 signal 更新次数 */
-    version: 0,
-    id: 0,
-    /** scope 销毁任务序号 */
-    scopeDisposeI: 0,
-    PullingSignal: null,
-    /** 表示当前处于 pull 递归中 */
-    PullingRecurseDeep: 0
-  };
-  var State = /* @__PURE__ */(State2 => {
-    State2[State2["Clean"] = 0] = "Clean";
-    State2[State2["LinkScopeOnly"] = 256] = "LinkScopeOnly";
-    State2[State2["ScopeAbort"] = 128] = "ScopeAbort";
-    State2[State2["ScopeReady"] = 64] = "ScopeReady";
-    State2[State2["IsScope"] = 32] = "IsScope";
-    State2[State2["PullingDirty"] = 16] = "PullingDirty";
-    State2[State2["PullingUnknown"] = 8] = "PullingUnknown";
-    State2[State2["Unknown"] = 4] = "Unknown";
-    State2[State2["Dirty"] = 2] = "Dirty";
-    State2[State2["Pulling"] = 1] = "Pulling";
-    return State2;
-  })(State || {});
-  const DirtyState = 4 /* Unknown */ | 2 /* Dirty */;
-  const ScopeExecuted = 64 /* ScopeReady */ | 128 /* ScopeAbort */;
-  const ScopeAbort = 128 /* ScopeAbort */;
+  let _execId = 0;
+  let currentExecId = 0;
+  const execIdInc = () => ++_execId;
+  const execId = () => currentExecId;
+  const setExecId = v => currentExecId = v;
+  let pulling = null;
+  const setPulling = v => pulling = v;
+  const getPulling = () => pulling;
+  function runWithPulling(fn, scope) {
+    const oldPulling = pulling;
+    pulling = scope;
+    const ret = fn();
+    pulling = oldPulling;
+    return ret;
+  }
 
-  const leakI = (y, max) => y < 0 || y >= max ? null : y;
-  const getLeft = (x, max) => leakI(x * 2 + 1, max);
-  const getRight = (x, max) => leakI(x * 2 + 2, max);
-  const getParent = (x, max) => leakI(x - 1 >>> 1, max);
-  const exchange = (arr, i, j) => {
-    var _ref = [arr[j], arr[i]];
-    arr[i] = _ref[0];
-    arr[j] = _ref[1];
-    return _ref;
-  };
-  class PriorityQueue {
-    // 构造函数接受一个compare函数
-    // compare返回的-1, 0, 1决定元素是否优先被去除
-    constructor(aIsUrgent) {
-      this.aIsUrgent = aIsUrgent;
-      this.arr = [];
-      this.goUp = (arr, current, len) => {
-        let i = len - 1;
-        while (i > 0) {
-          const item = arr[i];
-          const pI = getParent(i, len);
-          const parent = arr[pI];
-          if (this.aIsUrgent(item, parent)) {
-            exchange(arr, i, pI);
-            i = pI;
-          } else {
-            break;
+  function mark(signal) {
+    let line = signal.emitHead;
+    while (line) {
+      const _line = line,
+        down = _line.down;
+        _line.up;
+      const scope = down.scope,
+        emitHead = down.emitHead,
+        state = down.state;
+      if (scope && scope.state & 128) ; else {
+        const notLocked = (state & 1) === 0;
+        down.state |= notLocked ? 2 : 16;
+        if (state & 32) {
+          if (notLocked && state & 512) {
+            addEffect(down);
           }
+        } else if (emitHead) {
+          markUnknownDeep(emitHead);
         }
-      };
-      this.goDown = (arr, i) => {
-        const len = this.size();
-        const half = len >>> 1;
-        while (i < half) {
-          const lI = getLeft(i, len);
-          const rI = getRight(i, len);
-          let point = i;
-          if (lI != null && this.aIsUrgent(arr[lI], arr[point])) {
-            point = lI;
-          }
-          if (rI != null && this.aIsUrgent(arr[rI], arr[point])) {
-            point = rI;
-          }
-          if (point === i) {
-            break;
+      }
+      line = line.nextEmitLine;
+    }
+  }
+  function markUnknownDeep(initialLine) {
+    const noPulling = !getPulling();
+    const stack = [initialLine];
+    let len = 1;
+    while (len > 0) {
+      let line = stack[--len];
+      stack[len] = null;
+      while (line) {
+        const _line2 = line,
+          down = _line2.down;
+          _line2.up;
+        const state = down.state,
+          scope = down.scope;
+        if (scope && scope.state & 128 || noPulling && state & 6) ; else {
+          const notLocked = (state & 1) === 0;
+          down.state |= notLocked ? 4 : 8;
+          if (state & 32) {
+            if (notLocked && state & 512) {
+              addEffect(down);
+            }
+          } else if (down.emitHead) {
+            stack[len++] = down.emitHead;
           }
-          exchange(arr, i, point);
-          i = point;
         }
-      };
-    }
-    // 添加一个元素
-    _add(current) {
-      this.arr.push(current);
-      const len = this.size();
-      if (len === 1) {
-        return;
+        line = line.nextEmitLine;
       }
-      this.goUp(this.arr, current, len);
     }
-    add(...items) {
-      items.forEach(it => this._add(it));
-    }
-    // 去除头元素并返回
-    poll() {
-      const arr = this.arr;
-      const len = this.size();
-      if (len <= 2) {
-        return arr.shift();
+  }
+  function pullDeep(root) {
+    let node = root,
+      top = null,
+      i = -1;
+    const lineStack = [];
+    do {
+      const _node = node,
+        state = _node.state,
+        scope = _node.scope;
+      let noSkipSelf = !(state & 193 || (state & 6) === 0 || scope && scope.state & 128);
+      const firstLine = node.recHead;
+      if (noSkipSelf) {
+        node.state |= 1;
+        if ((state & 2) === 0 && firstLine) {
+          node = firstLine.up;
+          lineStack[++i] = top;
+          top = firstLine;
+          continue;
+        }
       }
-      const last = arr.pop();
-      const first = arr[0];
-      arr[0] = last;
-      this.goDown(this.arr, 0);
-      return first;
-    }
-    // 取得头元素
-    peek() {
-      return this.arr[0];
-    }
-    // 取得元素数量
-    size() {
-      return this.arr.length;
-    }
-    logTree() {
-      const arr = this.arr;
-      let i = 0;
-      let j = 1;
-      let level = 0;
-      const matrix = [];
       do {
-        matrix.push(arr.slice(i, j));
-        i = i * 2 + 1;
-        j = i + Math.pow(2, level) + 1;
-        level++;
-      } while (i < arr.length);
-      const last = Math.pow(2, matrix.length - 1);
-      const arrStr = JSON.stringify(last);
-      const halfLen = arrStr.length >>> 1;
-      matrix.forEach(it => {
-        const str = JSON.stringify(it);
-        const halfIt = str.length >>> 1;
-        console.log(str.padStart(halfLen + halfIt, " "));
-      });
-      console.log("\n");
-    }
+        const _node2 = node,
+          state = _node2.state;
+        let noGoSibling = false;
+        if (noSkipSelf) {
+          if (state & 2) {
+            const prevValue = node.value;
+            const prevPulling = getPulling();
+            setPulling(node);
+            const value = node.get(false, false);
+            setPulling(prevPulling);
+            if (noGoSibling = value !== prevValue) {
+              let line = node.emitHead;
+              while (line) {
+                const _line3 = line,
+                  down = _line3.down;
+                down.state &= -5;
+                down.state |= 2;
+                line = line.nextEmitLine;
+              }
+            }
+          } else {
+            transferDirtyState(node, state);
+          }
+          node.state &= -2;
+        }
+        if (node === root) {
+          return node.value;
+        }
+        if (!noGoSibling && top.nextRecLine) {
+          top = top.nextRecLine;
+          node = top.up;
+          break;
+        }
+        noSkipSelf = true;
+        node = top.down;
+        top = lineStack[i];
+        lineStack[i--] = null;
+      } while (true);
+    } while (true);
   }
-
-  const DefaultTaskControlReturn = {
-    finished: true,
-    startNewCallbackAble: true
-  };
-  class TaskQueue {
-    constructor(callbackAble, aIsUrgent) {
-      this.callbackAble = callbackAble;
-      this.aIsUrgent = aIsUrgent;
-      this.isScheduling = false;
-    }
-    static create({
-      callbackAble,
-      aIsUrgent
-    }) {
-      const queue = new TaskQueue(callbackAble, aIsUrgent);
-      queue.taskQueue = new PriorityQueue(aIsUrgent);
-      return queue;
-    }
-    pushTask(task) {
-      const taskQueue = this.taskQueue,
-        isScheduling = this.isScheduling;
-      taskQueue._add(task);
-      if (!isScheduling) {
-        this.callbackAble(this.scheduleTask.bind(this));
-        this.isScheduling = true;
-      }
+  function transferDirtyState(node, state) {
+    if (state & 8) {
+      node.state = state & -9 | 4;
+    } else {
+      node.state &= -5;
     }
-    scheduleTask() {
-      const taskQueue = this.taskQueue;
-      const fn = taskQueue.peek();
-      if (!fn) return this.isScheduling = false;
-      let info = fn() || {};
-      info = {
-        ...DefaultTaskControlReturn,
-        ...info
-      };
-      if (info.finished) {
-        taskQueue.poll();
-        if (taskQueue.size() === 0) {
-          return this.isScheduling = false;
-        }
-      }
-      if (info.startNewCallbackAble) {
-        this.callbackAble(this.scheduleTask.bind(this));
-      } else {
-        this.scheduleTask();
-      }
+    if (state & 16) {
+      node.state = state & -17 | 2;
+    } else {
+      node.state &= -3;
     }
   }
-
-  var Keys = /* @__PURE__ */(Keys2 => {
-    Keys2["Iterator"] = "__AOYE_ITERATOR";
-    Keys2["Raw"] = "__AOYE_RAW";
-    Keys2["Meta"] = "__AOYE_META";
-    return Keys2;
-  })(Keys || {});
-  const IsStore = /* @__PURE__ */Symbol("__AOYE_IS_STORE"),
-    StoreIgnoreKeys = /* @__PURE__ */Symbol("__AOYE_IGNORE_KEYS");
-
-  let channel = globalThis.MessageChannel ? new MessageChannel() : null;
-  if (globalThis.MessageChannel) {
-    channel = new MessageChannel();
+  const effectQueue = [];
+  let consumeI = -1,
+    produceI = -1;
+  function addEffect(effect) {
+    effectQueue[++produceI] = effect;
   }
-  let msgId = 0;
-  const macro = fn => {
-    if (!channel) {
-      setTimeout(fn);
+  function flushEffect() {
+    if (consumeI !== -1) {
+      return;
     }
-    const memoId = msgId;
-    function onMessage(e) {
-      if (memoId === e.data) {
-        fn();
-        channel.port2.removeEventListener("message", onMessage);
+    while (++consumeI <= produceI) {
+      const effect = effectQueue[consumeI];
+      if (effect.state | 6) {
+        effect.get();
       }
+      effectQueue[consumeI] = null;
     }
-    channel.port2.addEventListener("message", onMessage);
-    channel.port1.postMessage(msgId++);
-  };
-  const p = Promise.resolve();
-  const micro = cb => {
-    p.then(cb);
-  };
-  const toRaw = a => {
-    if (typeof a === "object" && a !== null && a[Keys.Raw]) {
-      return toRaw(a[Keys.Raw]);
+    consumeI = -1;
+    produceI = -1;
+  }
+  let _batchDeep = 0;
+  const batchStart = () => _batchDeep++;
+  const batchEnd = () => {
+    _batchDeep--;
+    if (_batchDeep === 0) {
+      flushEffect();
     }
-    return a;
   };
-
-  class Scheduler {
-    constructor() {
-      this.effectQueue = new bobeShared.Queue();
-      /** 每当 Set 或 BatchSet 开始时标记 */
-      this.firstEffectItem = null;
-      /** 记录 Set 或 BatchSet 产生的最后一个 Effect */
-      this.lastEffectItem = null;
-    }
-    static {
-      this.Sync = "__Sync_";
-    }
-    static {
-      this.Layout = "__Layout_";
-    }
-    static {
-      this.Micro = "__Micro_";
-    }
-    static {
-      this.Macro = "__Macro_";
+  const batchDeep = () => _batchDeep;
+  function unlink(line, deep) {
+    const nextEmitLine = line.nextEmitLine,
+      prevEmitLine = line.prevEmitLine,
+      nextRecLine = line.nextRecLine,
+      prevRecLine = line.prevRecLine,
+      up = line.up,
+      down = line.down,
+      prevOutLink = line.prevOutLink,
+      nextOutLink = line.nextOutLink;
+    const scope = down.scope;
+    if (prevEmitLine) {
+      prevEmitLine.nextEmitLine = nextEmitLine;
+    } else {
+      up.emitHead = nextEmitLine;
     }
-    endSet() {
-      if (!this.firstEffectItem) return;
-      const subQueue = this.effectQueue.subRef(this.firstEffectItem, this.lastEffectItem);
-      this.firstEffectItem = null;
-      this.lastEffectItem = null;
-      this.onOneSetEffectsAdded?.(subQueue, this.effectQueue);
+    if (nextEmitLine) {
+      nextEmitLine.prevEmitLine = prevEmitLine;
+    } else {
+      up.emitTail = prevEmitLine;
     }
-    addEffect(effect) {
-      const item = this.effectQueue.push(effect);
-      this.onEffectAdded?.(effect, item, this.effectQueue);
-      return item;
+    if (prevRecLine) {
+      prevRecLine.nextRecLine = nextRecLine;
+    } else {
+      down.recHead = nextRecLine;
     }
-  }
-  class SyncScheduler extends Scheduler {
-    onOneSetEffectsAdded(subQueue, queue) {
-      subQueue.forEach((effect, item) => {
-        queue.delete(item);
-        effect.runIfDirty();
-      });
+    if (nextRecLine) {
+      nextRecLine.prevRecLine = prevRecLine;
+    } else {
+      down.recTail = prevRecLine;
+    }
+    if (prevOutLink) {
+      prevOutLink.nextOutLink = nextOutLink;
+    }
+    if (nextOutLink) {
+      nextOutLink.prevOutLink = prevOutLink;
+    }
+    if (scope && scope.outLink === line) {
+      scope.outLink = nextOutLink;
+    }
+    if (up.state & 32) {
+      up.dispose();
+    } else if (deep && !prevEmitLine && !nextEmitLine) {
+      let _ref = up,
+        line = _ref.recHead;
+      while (line) {
+        const next = line.nextRecLine;
+        unlink(line, true);
+        line = next;
+      }
     }
   }
-  class MicroScheduler extends Scheduler {
-    constructor() {
-      super(...arguments);
-      this.taskQueue = TaskQueue.create({
-        callbackAble: micro,
-        aIsUrgent: (a, b) => a.time < b.time
-      });
-    }
-    onOneSetEffectsAdded(subQueue, queue) {
-      const task = () => {
-        subQueue.forEach((effect, item) => {
-          queue.delete(item);
-          effect.runIfDirty();
-        });
-        return {
-          finished: true,
-          startNewCallbackAble: false
-        };
-      };
-      task.time = Date.now();
-      this.taskQueue.pushTask(task);
+  function dispose() {
+    let toDel = this.recHead,
+      emitHead = this.emitHead;
+    while (toDel) {
+      const _toDel = toDel,
+        up = _toDel.up,
+        nextRecLine = _toDel.nextRecLine;
+      if ((up.state & 32) === 0) {
+        unlink(toDel, true);
+        toDel = nextRecLine;
+        continue;
+      }
+      let node = up,
+        top = null,
+        i = -1;
+      const lineStack = [];
+      outer: do {
+        let noSkipSelf = node.state & 32 && (node.state & 128) === 0;
+        const firstLine = node.recHead;
+        if (noSkipSelf && firstLine) {
+          node = firstLine.up;
+          lineStack[++i] = top;
+          top = firstLine;
+          continue;
+        }
+        do {
+          if (noSkipSelf) {
+            releaseScope(node);
+          }
+          if (node === up) {
+            break outer;
+          }
+          if (top.nextRecLine) {
+            top = top.nextRecLine;
+            node = top.up;
+            break;
+          }
+          noSkipSelf = true;
+          node = top.down;
+          top = lineStack[i];
+          lineStack[i--] = null;
+        } while (true);
+      } while (true);
+      toDel = nextRecLine;
     }
+    releaseScope(this);
+    if (emitHead) unlink(emitHead, false);
   }
-  class MacroScheduler extends Scheduler {
-    constructor() {
-      super(...arguments);
-      this.taskQueue = TaskQueue.create({
-        callbackAble: macro,
-        aIsUrgent: (a, b) => a.time < b.time
-      });
-    }
-    onOneSetEffectsAdded(subQueue, queue) {
-      const task = () => {
-        subQueue.forEach((effect, item) => {
-          queue.delete(item);
-          effect.runIfDirty();
-        });
-      };
-      task.time = Date.now();
-      this.taskQueue.pushTask(task);
-    }
+  function clean(onClean) {
+    const current = getPulling();
+    current.clean = onClean;
   }
-  class LayoutScheduler extends Scheduler {
-    constructor() {
-      super(...arguments);
-      this.taskQueue = TaskQueue.create({
-        callbackAble: macro,
-        aIsUrgent: (a, b) => a.time < b.time
-      });
-    }
-    onOneSetEffectsAdded(subQueue, queue) {
-      const task = () => {
-        subQueue.forEach((effect, item) => {
-          queue.delete(item);
-          effect.runIfDirty();
-        });
-      };
-      task.time = Date.now();
-      this.taskQueue.pushTask(task);
+  function releaseScope(scope) {
+    let outLink = scope.outLink;
+    while (outLink) {
+      const next = outLink.nextOutLink;
+      unlink(outLink, true);
+      outLink = next;
     }
+    scope.state |= 128;
+    scope.clean?.();
+    scope.clean = null;
   }
-  const _scheduler = {
-    [Scheduler.Sync]: new SyncScheduler(),
-    [Scheduler.Micro]: new MicroScheduler(),
-    [Scheduler.Macro]: new MacroScheduler(),
-    [Scheduler.Layout]: new LayoutScheduler()
-  };
-  globalThis["sche"] = _scheduler[Scheduler.Sync];
-  const registerScheduler = (key, Ctor) => _scheduler[key] = new Ctor();
 
-  const DefaultDFSOpt = {
-    isUp: false,
-    begin: null,
-    complete: null,
-    breakStack: [],
-    breakLine: null,
-    breakNode: null
-  };
-  function dfs(root, opt = {}) {
-    const _DefaultDFSOpt$opt = {
-        ...DefaultDFSOpt,
-        ...opt
-      },
-      isUp = _DefaultDFSOpt$opt.isUp,
-      begin = _DefaultDFSOpt$opt.begin,
-      complete = _DefaultDFSOpt$opt.complete,
-      lineStack = _DefaultDFSOpt$opt.breakStack,
-      breakLine = _DefaultDFSOpt$opt.breakLine;
-    let node = opt.breakNode || root;
-    let line = breakLine;
-    const listKey = isUp ? "recStart" : "emitStart";
-    const nodeKey = isUp ? "upstream" : "downstream";
-    const nextLineKey = isUp ? "nextRecLine" : "nextEmitLine";
-    const reverseNodeKey = isUp ? "downstream" : "upstream";
-    while (true) {
-      let notGoDeep = begin?.({
-        node,
-        lineFromUp: line,
-        walkedLine: lineStack
-      });
-      lineStack.push(line);
-      line = node[listKey];
-      if (line && !notGoDeep) {
-        const firstChild = line[nodeKey];
-        node = firstChild;
-        continue;
-      }
-      while (true) {
-        const noGoSibling = complete?.({
-          node,
-          lineToDeep: line,
-          walkedLine: lineStack,
-          notGoDeep
-        });
-        line = lineStack.pop();
-        if (node === root) {
-          return;
-        }
-        notGoDeep = false;
-        const nextLine = line[nextLineKey];
-        if (!noGoSibling && nextLine) {
-          line = nextLine;
-          node = nextLine[nodeKey];
-          break;
-        }
-        node = line[reverseNodeKey];
-      }
+  function link(up = null, down = null) {
+    const prevEmitLine = up.emitTail,
+      scopeUp = up.scope;
+    let recHead = down.recHead,
+      recTail = down.recTail,
+      scopeDown = down.scope;
+    if (scopeDown && scopeDown !== scopeUp && (up.state & 32) === 0) {
+      outLink(up, down);
+      return;
     }
-  }
-
-  class Line {
-    constructor() {
-      /** 上游顶点 */
-      this.upstream = null;
-      /** 上游节点 发出的上一条线 */
-      this.prevEmitLine = null;
-      /** 上游节点 发出的下一条线 */
-      this.nextEmitLine = null;
-      /** 下游顶点 */
-      this.downstream = null;
-      /** 下游节点 接收的上一条线 */
-      this.prevRecLine = null;
-      /** 下游节点 接收的下一条线 */
-      this.nextRecLine = null;
-      /** 表示 scope 当前存在的 外部 link  */
-      this.prevOutLink = null;
-      this.nextOutLink = null;
-    }
-    static link(v1, v2) {
-      let emitEnd = v1.emitEnd,
-        recEnd = v2.recEnd,
-        recStart = v2.recStart,
-        noRecEnd = !recEnd,
-        head = {
-          nextRecLine: recStart
-        },
-        line;
-      recEnd = recEnd || head;
-      const _ref = recEnd || {},
-        nextRecLine = _ref.nextRecLine;
-      if (!nextRecLine) {
-        line = new Line();
-        Line.emit_line(v1, line);
-        Line.rec_line(v2, line);
-        emitEnd && Line.line_line_emit(emitEnd, line);
-        !noRecEnd && Line.line_line_rec(recEnd, line);
-      } else if (nextRecLine.upstream === v1) {
-        v2.recEnd = nextRecLine;
-      } else {
-        line = new Line();
-        Line.emit_line(v1, line);
-        Line.rec_line(v2, line);
-        emitEnd && Line.line_line_emit(emitEnd, line);
-        Line.insert_line_rec(recEnd, nextRecLine, line);
-      }
-      for (const key in head) {
-        head[key] = null;
-      }
-      if (line && v2.scope && v1.scope !== v2.scope && (v1.state & State.IsScope) === 0) {
-        const first = v2.scope.outLink;
-        if (!first) {
-          v2.scope.outLink = line;
-        } else {
-          first.prevOutLink = line;
-          line.nextOutLink = first;
-          v2.scope.outLink = line;
-        }
-      }
+    const nextRec = recTail ? recTail.nextRecLine : recHead;
+    const eid = execId();
+    if (prevEmitLine && prevEmitLine.down === down && prevEmitLine.execId === eid) {
+      return;
     }
-    static unlink(line) {
-      let prevEmitLine = line.prevEmitLine,
-        nextEmitLine = line.nextEmitLine,
-        prevRecLine = line.prevRecLine,
-        nextRecLine = line.nextRecLine,
-        upstream = line.upstream,
-        downstream = line.downstream,
-        nextOutLink = line.nextOutLink,
-        prevOutLink = line.prevOutLink;
-      line.prevEmitLine = null;
-      line.nextEmitLine = null;
-      line.prevRecLine = null;
-      line.nextRecLine = null;
-      line.upstream = null;
-      line.downstream = null;
-      line.prevOutLink = null;
-      line.nextOutLink = null;
-      const downNode = downstream;
-      if (prevOutLink) {
-        prevOutLink.nextOutLink = nextOutLink;
-      }
-      if (nextOutLink) {
-        nextOutLink.prevOutLink = prevOutLink;
-      }
-      if (downNode.scope && downNode.scope.outLink === line) {
-        downNode.scope.outLink = nextOutLink;
-      }
+    if (!nextRec) {
+      const line = {
+        execId: eid,
+        up,
+        down,
+        prevEmitLine,
+        nextEmitLine: null,
+        prevRecLine: recTail,
+        nextRecLine: null
+      };
       if (prevEmitLine) {
-        prevEmitLine.nextEmitLine = nextEmitLine;
+        prevEmitLine.nextEmitLine = line;
       } else {
-        upstream.emitStart = nextEmitLine;
+        up.emitHead = line;
       }
-      if (nextEmitLine) {
-        nextEmitLine.prevEmitLine = prevEmitLine;
+      up.emitTail = line;
+      if (recTail) {
+        recTail.nextRecLine = line;
       } else {
-        upstream.emitEnd = prevEmitLine;
-      }
-      if (prevRecLine) {
-        prevRecLine.nextRecLine = nextRecLine;
-      } else {
-        downstream.recStart = nextRecLine;
-      }
-      if (nextRecLine) {
-        nextRecLine.prevRecLine = prevRecLine;
-      } else {
-        downstream.recEnd = prevRecLine;
-      }
-    }
-    static unlinkRec(line) {
-      let toDel = line;
-      while (toDel) {
-        const memoNext = toDel.nextRecLine;
-        Line.unlink(toDel);
-        toDel = memoNext;
+        down.recHead = line;
       }
+      down.recTail = line;
+      return;
     }
-    static unlinkEmit(line) {
-      let toDel = line;
-      while (toDel) {
-        const memoNext = toDel.nextEmitLine;
-        Line.unlink(toDel);
-        toDel = memoNext;
-      }
+    if (nextRec.up === up) {
+      nextRec.execId = eid;
+      down.recTail = nextRec;
+      return;
     }
-    /** 上游节点 连 link */
-    static emit_line(upstream, line) {
-      if (!upstream.emitStart) {
-        upstream.emitStart = line;
-      }
-      upstream.emitEnd = line;
-      line.upstream = upstream;
+    const line = {
+      execId: eid,
+      up,
+      down,
+      prevEmitLine,
+      nextEmitLine: null,
+      prevRecLine: recTail,
+      nextRecLine: nextRec
+    };
+    if (prevEmitLine) {
+      prevEmitLine.nextEmitLine = line;
+    } else {
+      up.emitHead = line;
     }
-    /** 下游节点 连 link */
-    static rec_line(downstream, line) {
-      if (!downstream.recStart) {
-        downstream.recStart = line;
-      }
-      downstream.recEnd = line;
-      line.downstream = downstream;
-    }
-    /** 同一节点发出的 两个条线 相连 */
-    static line_line_emit(l1, l2) {
-      if (!l1 || !l2) return;
-      l1.nextEmitLine = l2;
-      l2.prevEmitLine = l1;
-    }
-    /** 同一节点接收的 两个条线 相连 */
-    static line_line_rec(l1, l2) {
-      if (!l1 || !l2) return;
-      l1.nextRecLine = l2;
-      l2.prevRecLine = l1;
-    }
-    static insert_line_emit(l1, l2, ins) {
-      l1.nextEmitLine = ins;
-      ins.prevEmitLine = l1;
-      l2.prevEmitLine = ins;
-      ins.nextEmitLine = l2;
-    }
-    static insert_line_rec(l1, l2, ins) {
-      l1.nextRecLine = ins;
-      ins.prevRecLine = l1;
-      l2.prevRecLine = ins;
-      ins.nextRecLine = l2;
+    up.emitTail = line;
+    if (recHead) {
+      recTail.nextRecLine = line;
+    } else {
+      down.recHead = line;
     }
+    down.recTail = line;
+    if (recTail) recTail.nextRecLine = line;
+    nextRec.prevRecLine = line;
   }
-
-  function unlinkRecWithScope(line) {
-    let toDel = line;
-    while (toDel) {
-      const memoNext = toDel.nextRecLine;
-      const upstream = toDel.upstream;
-      if (upstream.state & State.IsScope) {
-        dispose.call(upstream);
+  function outLink(up = null, down = null) {
+    const prevEmitLine = up.emitTail;
+    let recHead = down.recHead,
+      recTail = down.recTail,
+      scopeDown = down.scope;
+    const nextRec = recTail ? recTail.nextRecLine : recHead;
+    if (!nextRec) {
+      const line = {
+        execId: execId(),
+        up,
+        down,
+        prevEmitLine,
+        nextEmitLine: null,
+        prevRecLine: recTail,
+        nextRecLine: null,
+        nextOutLink: null,
+        prevOutLink: null
+      };
+      if (prevEmitLine) {
+        prevEmitLine.nextEmitLine = line;
       } else {
-        unlinkSingleLine(toDel);
+        up.emitHead = line;
       }
-      toDel = memoNext;
-    }
-  }
-  function unlinkSingleLine(line) {
-    const upstream = line.upstream;
-    if (upstream.emitStart === upstream.emitEnd) {
-      unlinkSingleRefedNode(upstream);
-    } else {
-      Line.unlink(line);
-    }
-  }
-  function unlinkSingleRefedNode(delRoot) {
-    let toUnlink;
-    dfs(delRoot, {
-      isUp: true,
-      begin: ({
-        node
-      }) => {
-        doUnlink(toUnlink);
-        toUnlink = null;
-        if (node.emitStart !== node.emitEnd) {
-          return true;
-        }
-      },
-      complete: ({
-        node,
-        notGoDeep
-      }) => {
-        doUnlink(toUnlink);
-        toUnlink = null;
-        const isSingleRefed = !notGoDeep;
-        if (isSingleRefed) {
-          toUnlink = node.emitStart;
-        }
+      up.emitTail = line;
+      if (recTail) {
+        recTail.nextRecLine = line;
+      } else {
+        down.recHead = line;
       }
-    });
-    doUnlink(toUnlink);
-  }
-  function doUnlink(line) {
-    if (!line) {
+      down.recTail = line;
+      makeOutLink(scopeDown, line);
       return;
     }
-    Line.unlink(line);
-  }
-  function dispose() {
-    let toDel = this.recStart;
-    while (toDel) {
-      const memoNext = toDel.nextRecLine;
-      const upstream = toDel.upstream;
-      if (upstream.state & State.IsScope) {
-        dfs(upstream, {
-          isUp: true,
-          begin: ({
-            node
-          }) => {
-            if ((node.state & State.IsScope) === 0 || node.state & ScopeAbort) return true;
-          },
-          complete: ({
-            node: scope,
-            notGoDeep
-          }) => {
-            const shouldAbort = !notGoDeep;
-            if (shouldAbort) {
-              releaseScope(scope);
-            }
-          }
-        });
-      } else {
-        unlinkSingleLine(toDel);
-      }
-      toDel = memoNext;
+    if (nextRec.up === up) {
+      down.recTail = nextRec;
+      return;
     }
-    releaseScope(this);
-    doUnlink(this.emitStart);
-  }
-  function releaseScope(scope) {
-    let outLink = scope.outLink;
-    while (outLink) {
-      const memoNext = outLink.nextOutLink;
-      unlinkSingleLine(outLink);
-      outLink = memoNext;
+    const line = {
+      execId: execId(),
+      up,
+      down,
+      prevEmitLine,
+      nextEmitLine: null,
+      prevRecLine: recTail,
+      nextRecLine: nextRec,
+      nextOutLink: null,
+      prevOutLink: null
+    };
+    if (prevEmitLine) {
+      prevEmitLine.nextEmitLine = line;
+    } else {
+      up.emitHead = line;
     }
-    scope.state |= State.ScopeAbort;
-    scope.clean?.();
-    scope.clean = null;
-  }
-  function clean(cb) {
-    G.PullingSignal.clean = () => runWithPulling(cb, null);
-  }
-  function runWithPulling(fn, signal) {
-    const prevPulling = G.PullingSignal;
-    G.PullingSignal = signal;
-    const res = fn();
-    G.PullingSignal = prevPulling;
-    return res;
-  }
-  function getPulling() {
-    return G.PullingSignal;
+    up.emitTail = line;
+    if (recHead) {
+      recTail.nextRecLine = line;
+    } else {
+      down.recHead = line;
+    }
+    down.recTail = line;
+    if (recTail) recTail.nextRecLine = line;
+    nextRec.prevRecLine = line;
+    makeOutLink(scopeDown, line);
   }
-  function setPulling(pulling) {
-    G.PullingSignal = pulling;
+  function makeOutLink(scopeDown, line) {
+    const first = scopeDown.outLink;
+    if (first) {
+      first.prevOutLink = line;
+      line.nextOutLink = first;
+    }
+    scopeDown.outLink = line;
   }
 
-  const markDeep = root => {
-    let node = root,
-      i = -1,
-      parent;
-    const stack = [];
-    outer: do {
-      let noGoDeep = false;
-      const state = node.state,
-        emitStart = node.emitStart,
-        scheduler = node.scheduler;
-      if (node.scope && node.scope.state & State.ScopeAbort ||
-      // 是 scope 节点，且处于 ready 状态，不需要重复执行
-      node.state & ScopeExecuted) {
-        noGoDeep = true;
-      } else {
-        const inPullingArea = state & State.Pulling;
-        const isEffect = parent !== void 0;
-        const isLeaf = !emitStart || emitStart.downstream === node.scope;
-        if (isEffect) {
-          node.state |= inPullingArea ? State.PullingUnknown : State.Unknown;
-        } else if (!isLeaf) {
-          node.state |= State.Dirty;
+  class Computed {
+    emitHead = null;
+    emitTail = null;
+    recHead = null;
+    recTail = null;
+    state = 0;
+    scope = getPulling();
+    value = null;
+    constructor(callback) {
+      this.callback = callback;
+    }
+    get(shouldLink = true, notForceUpdate = true) {
+      const scope = this.scope;
+      if (scope && scope.state & 128) return this.value;
+      const down = getPulling();
+      if (this.recHead && notForceUpdate) {
+        if (this.state & 6) {
+          this.value = pullDeep(this);
         }
-        if (isLeaf) {
-          noGoDeep = true;
-          if (isEffect && !inPullingArea) {
-            const instance = _scheduler[scheduler];
-            const item = instance.addEffect(node);
-            instance.firstEffectItem ??= item;
-            instance.lastEffectItem = item;
-          }
+      } else {
+        this.state |= 1;
+        const nextId = execIdInc();
+        const prevId = execId();
+        setExecId(nextId);
+        setPulling(this);
+        this.recTail = null;
+        this.value = this.callback(this);
+        this.state &= -2;
+        setPulling(down);
+        setExecId(prevId);
+        transferDirtyState(this, this.state);
+        let line = this.recTail?.nextRecLine;
+        while (line) {
+          const nextLine = line.nextRecLine;
+          unlink(line, true);
+          line = nextLine;
         }
       }
-      if (emitStart && !noGoDeep) {
-        stack[++i] = emitStart;
-        parent = node;
-        node = emitStart.downstream;
-        noGoDeep = false;
-        continue;
+      if (shouldLink && down && (down.state & 256) === 0) {
+        link(this, down);
       }
-      while (true) {
-        if (i === -1) {
-          break outer;
-        }
-        const backLine = stack[i];
-        const nextLine = backLine.nextEmitLine;
-        if (nextLine) {
-          node = nextLine.downstream;
-          stack[i] = nextLine;
-          break;
-        }
-        node = parent;
-        if (--i !== -1) {
-          parent = stack[i].upstream;
-        }
-      }
-    } while (true);
-  };
-  const pullingPostprocess = node => {
-    let s = node.state;
-    s &= ~State.Pulling;
-    if (s & State.PullingUnknown) {
-      s = s & ~State.PullingUnknown | State.Unknown;
+      return this.value;
     }
-    node.state = s;
-  };
+  }
+
   class Signal {
-    constructor(nextValue, customPull) {
-      this.nextValue = nextValue;
-      this.customPull = customPull;
-      this.version = -1;
-      this.id = G.id++;
-      this.state = State.Clean;
-      /** 当前节点创建时处于的 effect 就是 scope */
-      this.scope = G.PullingSignal;
-      this.recEnd = null;
-      this.recStart = null;
-      this.emitStart = null;
-      this.emitEnd = null;
-      this.scheduler = null;
-      this.value = null;
-      this.outLink = null;
-      this.pull = null;
-      /** 记录当前 effect 中 clean */
-      this.clean = null;
-    }
-    static {
-      this.Pulling = null;
-    }
-    static create(nextValue, {
-      customPull,
-      isScope,
-      scope,
-      immediate,
-      ...rest
-    }) {
-      const s = new Signal(nextValue, customPull);
-      s.pull = s.customPull || s.DEFAULT_PULL;
-      Object.assign(s, rest);
-      if (isScope) {
-        s.state |= State.IsScope;
-      }
-      if (scope !== void 0) {
-        s.scope = scope;
-      }
-      return s;
-    }
-    DEFAULT_PULL() {
-      return this.nextValue;
-    }
-    /**
-     * 递归拉取负责建立以来链
-     */
-    pullRecurse(shouldLink = true) {
-      G.PullingRecurseDeep++;
-      const downstream = G.PullingSignal;
-      this.linkWhenPull(downstream, shouldLink);
-      try {
-        if (this.version === G.version) {
-          return this.value;
-        }
-        if (this.pull !== this.DEFAULT_PULL) this.recEnd = null;
-        this.state |= State.Pulling;
-        G.PullingSignal = this;
-        this.clean?.();
-        this.clean = null;
-        let v = this.pull();
-        if (this.state & State.IsScope && typeof v === "function") {
-          const fn = v;
-          this.clean = () => runWithPulling(fn, null);
-          v = this.value;
+    scope = getPulling();
+    emitHead = null;
+    emitTail = null;
+    state = 0;
+    constructor(value) {
+      this.value = value;
+    }
+    get(shouldLink = true) {
+      if (shouldLink) {
+        const down = getPulling();
+        if (down && (down.state & 256) === 0) {
+          link(this, down);
         }
-        this.value = v;
-        this.version = G.version;
-        return this.value;
-      } catch (error) {
-        console.error("\u8BA1\u7B97\u5C5E\u6027\u62A5\u9519\u8FD9\u6B21\u4E0D\u89E6\u53D1\uFF0C\u540E\u7EED\u72B6\u6001\u53EF\u80FD\u51FA\u9519", error);
-        return this.value;
-      } finally {
-        this.pull = this.customPull || this.DEFAULT_PULL;
-        pullingPostprocess(this);
-        const toDel = this.recEnd?.nextRecLine;
-        unlinkRecWithScope(toDel);
-        G.PullingSignal = downstream;
-        G.PullingRecurseDeep--;
       }
-    }
-    linkWhenPull(downstream, shouldLink) {
-      const isScope = this.state & State.IsScope;
-      if (
-      // 2. 有下游
-      downstream && shouldLink && (
-      // 3. 下游是 watcher 不是 watch，或 是watcher 但 当前是 scope
-      (downstream.state & State.LinkScopeOnly) === 0 || isScope) && (
-      /**4. scope 只能被一个下游节点管理，就是初始化它的那个下游节点
-      * 发生在 outEffect(() => scope(() => innerEffect(), null))
-      * 虽然通过 scope 让 innerEffect 被管理，
-      * 如果 innerEffect 在 outEffect 中被再次触发，就导致其被 outEffect 管理，
-      * 若 outEffect 后续重新触发， 则导致 innerEffect 被销毁
-      */
-      !isScope || !this.emitStart)) {
-        Line.link(this, downstream);
-      }
-    }
-    pullDeep() {
-      const signal = this;
-      if (signal.state & DirtyState) {
-        let node = signal,
-          i = -1,
-          parent;
-        const stack = [];
-        outer: do {
-          let noGoDeep = false;
-          if (node.state & (State.Pulling | State.Dirty) || (node.state & DirtyState) === 0 || node.isDisabled()) {
-            noGoDeep = true;
-          } else {
-            node.state |= State.Pulling;
-          }
-          const recStart = node.recStart;
-          if (recStart && !noGoDeep) {
-            stack[++i] = recStart;
-            parent = node;
-            node = recStart.upstream;
-            continue;
-          }
-          while (true) {
-            const isDirty = node.state & State.Dirty;
-            let currentClean = noGoDeep && !isDirty;
-            if (noGoDeep && node.state & State.Pulling) {
-              currentClean = true;
-            }
-            let noGoSibling = false;
-            const downstream2 = parent;
-            const isEmitter = node.pull === node.DEFAULT_PULL;
-            if (currentClean) ; else if (isDirty) {
-              if (isEmitter && node.value !== node.nextValue) {
-                node.markDownStreamsDirty();
-                node.state &= ~State.Dirty;
-              } else {
-                const prevPulling = G.PullingSignal;
-                G.PullingSignal = downstream2;
-                const prevValue = node.value;
-                node.pullRecurse(false);
-                if (prevValue !== node.value) {
-                  node.markDownStreamsDirty();
-                }
-                node.state &= ~State.Dirty;
-                G.PullingSignal = prevPulling;
-                noGoSibling = true;
-              }
-            } else if (node.state & State.Unknown) {
-              node.state &= ~State.Unknown;
-            }
-            if (!isEmitter) {
-              node.version = G.version;
-            }
-            pullingPostprocess(node);
-            noGoDeep = false;
-            if (i === -1) {
-              break outer;
-            }
-            const backLine = stack[i];
-            const nextLine = backLine.nextRecLine;
-            if (!noGoSibling && nextLine) {
-              node = nextLine.upstream;
-              stack[i] = nextLine;
-              break;
-            } else {
-              node = parent;
-              if (--i !== -1) {
-                parent = stack[i].downstream;
-              }
-            }
-          }
-        } while (true);
-      }
-      const downstream = G.PullingSignal;
-      this.linkWhenPull(downstream, true);
       return this.value;
     }
-    get v() {
-      if (this.isDisabled()) {
-        return this.value;
-      }
-      if (!this.recStart || this.pull === this.DEFAULT_PULL) {
-        return this.pullRecurse(true);
-      }
-      return this.pullDeep();
-    }
-    // pause() {
-    //   this.state |= State.SelfPaused;
-    // }
-    // resume() {
-    //   this.state &= ~State.SelfPaused;
-    // }
-    markDownStreamsDirty() {
-      let point = this.emitStart;
-      while (point != null) {
-        const downstream = point.downstream;
-        downstream.state |= State.Dirty;
-        downstream.state &= ~State.Unknown;
-        point = point.nextEmitLine;
+    set(v) {
+      if (this.value === v) return;
+      this.value = v;
+      if (this.emitHead) {
+        mark(this);
+        if (batchDeep() === 0) {
+          flushEffect();
+        }
       }
     }
-    set v(v) {
-      if (this.isDisabled() || this.nextValue === v) {
-        return;
-      }
-      this.nextValue = v;
-      this.pull = this.DEFAULT_PULL;
-      G.version++;
-      if (this.emitStart) {
-        markDeep(this);
-        if (batchDeep === 0) {
-          this.scheduleEffect();
+  }
+
+  const EffectState = 512 | 32;
+  class Effect {
+    emitHead = null;
+    emitTail = null;
+    recHead = null;
+    recTail = null;
+    state = EffectState;
+    scope = getPulling();
+    outLink = null;
+    clean = null;
+    constructor(callback) {
+      this.callback = callback;
+      this.get();
+    }
+    get(shouldLink = true, notForceUpdate = true) {
+      if (this.state & 128) return;
+      const down = getPulling();
+      if (this.recHead && notForceUpdate) {
+        pullDeep(this);
+      } else {
+        this.state |= 1;
+        setPulling(null);
+        this.clean?.();
+        this.clean = null;
+        const nextId = execIdInc();
+        const prevId = execId();
+        setExecId(nextId);
+        setPulling(this);
+        this.recTail = null;
+        const res = this.callback(this);
+        typeof res === 'function' && (this.clean = res);
+        this.state &= -2;
+        setPulling(down);
+        setExecId(prevId);
+        transferDirtyState(this, this.state);
+        let line = this.recTail?.nextRecLine;
+        while (line) {
+          const nextLine = line.nextRecLine;
+          unlink(line, true);
+          line = nextLine;
         }
       }
-    }
-    scheduleEffect() {
-      for (const key in _scheduler) {
-        const instance = _scheduler[key];
-        instance.endSet();
+      if (!this.emitHead && shouldLink && down) {
+        link(this, down);
       }
     }
-    /** 返回值为 true 表示已处理 */
-    runIfDirty() {
-      this.state & (State.Unknown | State.Dirty) && this.v;
-    }
-    isDisabled() {
-      return (
-        // scope 被取消
-        this.scope && this.scope.state & State.ScopeAbort ||
-        // 是 scope 节点，且处于 ready 状态，不需要重复执行
-        this.state & ScopeExecuted
-      );
+  }
+  Effect.prototype.dispose = dispose;
+
+  const ScopeAndLinkScopeOnly = 32 | 256;
+  class Scope {
+    emitHead = null;
+    emitTail = null;
+    recHead = null;
+    recTail = null;
+    state = ScopeAndLinkScopeOnly;
+    scope = getPulling();
+    outLink = null;
+    constructor(callback) {
+      this.callback = callback;
+    }
+    get(shouldLink = true) {
+      const scope = this.scope;
+      this.state |= 1;
+      setPulling(this);
+      this.recTail = null;
+      const res = this.callback();
+      typeof res === 'function' && (this.clean = res);
+      this.state &= -2;
+      setPulling(scope);
+      if (!this.emitHead && shouldLink && scope) {
+        link(this, scope);
+      }
     }
   }
-  let batchDeep = 0;
-  function batchStart() {
-    batchDeep++;
+  Scope.prototype.dispose = dispose;
+
+  const rawToProxy = new WeakMap();
+  let State = function (State) {
+    State[State["Clean"] = 0] = "Clean";
+    State[State["LinkScopeOnly"] = 256] = "LinkScopeOnly";
+    State[State["ScopeAbort"] = 128] = "ScopeAbort";
+    State[State["ScopeReady"] = 64] = "ScopeReady";
+    State[State["IsScope"] = 32] = "IsScope";
+    State[State["PullingDirty"] = 16] = "PullingDirty";
+    State[State["PullingUnknown"] = 8] = "PullingUnknown";
+    State[State["Unknown"] = 4] = "Unknown";
+    State[State["Dirty"] = 2] = "Dirty";
+    State[State["Pulling"] = 1] = "Pulling";
+    return State;
+  }({});
+  State.Unknown | State.Dirty;
+  State.ScopeReady | State.ScopeAbort;
+  State.ScopeAbort;
+
+  let Keys = function (Keys) {
+    Keys["Iterator"] = "__AOYE_ITERATOR";
+    Keys["Raw"] = "__AOYE_RAW";
+    Keys["Meta"] = "__AOYE_META";
+    return Keys;
+  }({});
+  const IsStore = Symbol('__AOYE_IS_STORE'),
+    StoreIgnoreKeys = Symbol('__AOYE_IGNORE_KEYS');
+
+  const ide = globalThis.requestIdleCallback || (globalThis.requestAnimationFrame ? fn => globalThis.requestAnimationFrame(() => {
+    setTimeout(() => {
+      fn();
+    });
+  }) : globalThis.setTimeout);
+  const now = () => {
+    const timer = globalThis.performance || globalThis.Date;
+    return timer.now();
+  };
+  let channel = globalThis.MessageChannel ? new MessageChannel() : null;
+  if (globalThis.MessageChannel) {
+    channel = new MessageChannel();
   }
-  function batchEnd() {
-    if (--batchDeep) return;
-    for (const key in _scheduler) {
-      const instance = _scheduler[key];
-      instance.endSet();
+  let msgId = 0;
+  const macro = fn => {
+    if (!channel) {
+      setTimeout(fn);
     }
-  }
+    const memoId = msgId;
+    function onMessage(e) {
+      if (memoId === e.data) {
+        fn();
+        channel.port2.removeEventListener('message', onMessage);
+      }
+    }
+    channel.port2.addEventListener('message', onMessage);
+    channel.port1.postMessage(msgId++);
+  };
+  const p = Promise.resolve();
+  const micro = cb => {
+    p.then(cb);
+  };
+  const toRaw = a => {
+    if (typeof a === 'object' && a !== null && a[Keys.Raw]) {
+      return toRaw(a[Keys.Raw]);
+    }
+    return a;
+  };
 
   const deepSignal = (target, scope, deep = true) => {
-    const isObj = typeof target === "object" && target !== null;
+    const isObj = typeof target === 'object' && target !== null;
     if (!isObj || target[Keys.Raw]) return target;
     const p = rawToProxy.get(target);
     if (p) return p;
-    const cells = /* @__PURE__ */new Map();
+    const cells = new Map();
     const targetIsArray = Array.isArray(target);
     const targetIsStore = Boolean(target.constructor?.[IsStore]);
     const meta = {
@@ -1014,12 +672,12 @@
           return Reflect.get(obj, prop, receiver);
         }
         const desc = Reflect.getOwnPropertyDescriptor(obj, prop);
-        const isGetter = desc && typeof desc.get === "function";
+        const isGetter = desc && typeof desc.get === 'function';
         if (isGetter) {
           return handleGetterAsComputed(obj, prop, receiver, cells, scope);
         }
         const value = Reflect.get(obj, prop, receiver);
-        const valueIsFn = typeof value === "function";
+        const valueIsFn = typeof value === 'function';
         if (valueIsFn) {
           if (targetIsArray) {
             return arrayMethodReWrites[prop] || value;
@@ -1029,26 +687,22 @@
         }
         let s = cells.get(prop);
         if (s) {
-          return s.v;
+          return s.get();
         }
         const wrappedValue = deep ? deepSignal(value, scope) : value;
-        s = Signal.create(wrappedValue, {
-          scheduler: Scheduler.Sync,
-          isScope: false,
-          scope
-        });
+        s = new Signal(wrappedValue);
         cells.set(prop, s);
-        return s.v;
+        return s.get();
       },
       set(obj, prop, value, receiver) {
-        if (targetIsStore && isIgnoreKey(obj.constructor[StoreIgnoreKeys], prop) || typeof value === "function") {
+        if (targetIsStore && isIgnoreKey(obj.constructor[StoreIgnoreKeys], prop) || typeof value === 'function') {
           return Reflect.set(obj, prop, value, receiver);
         }
         batchStart();
         const success = Reflect.set(obj, prop, value, receiver);
         const cell = cells.get(prop);
         if (cell) {
-          cell.v = deep ? deepSignal(value, scope) : value;
+          cell.set(deep ? deepSignal(value, scope) : value);
         }
         if (targetIsArray) {
           handleArraySet(obj, prop, value, receiver);
@@ -1058,13 +712,12 @@
         batchEnd();
         return success;
       },
-      // 【核心修改】拦截 delete 操作
       deleteProperty(obj, prop) {
-        if (targetIsStore && isIgnoreKey(obj.constructor[StoreIgnoreKeys], prop) || typeof obj[prop] === "function") {
+        if (targetIsStore && isIgnoreKey(obj.constructor[StoreIgnoreKeys], prop) || typeof obj[prop] === 'function') {
           return Reflect.deleteProperty(obj, prop);
         }
         cells.delete(prop);
-        triggerIter(obj, prop, void 0, proxy);
+        triggerIter(obj, prop, undefined, proxy);
         return Reflect.deleteProperty(obj, prop);
       },
       ownKeys(obj) {
@@ -1081,8 +734,8 @@
   };
   const shareSignal = (from, fromPath, to, toPath) => {
     try {
-      const toPaths = toPath.split(".");
-      const formPaths = Array.isArray(fromPath) ? fromPath : fromPath.split(".");
+      const toPaths = toPath.split('.');
+      const formPaths = Array.isArray(fromPath) ? fromPath : fromPath.split('.');
       runWithPulling(() => {
         const _getTargetAndKey = getTargetAndKey(from, formPaths),
           fromTarget = _getTargetAndKey.target,
@@ -1096,13 +749,13 @@
         toTarget[Keys.Raw][toKey] = val;
       }, null);
     } catch (error) {
-      console.error("\u6620\u5C04\u4E86\u4E0D\u5B58\u5728\u7684Key\uFF01");
+      console.error('映射了不存在的Key！');
       throw error;
     }
   };
   function getTargetAndKey(obj, paths) {
     let target = obj;
-    let key = "";
+    let key = '';
     const len = paths.length;
     for (let i = 0; i < len; i++) {
       key = paths[i];
@@ -1116,27 +769,23 @@
     };
   }
   function isIgnoreKey(ignores, key) {
-    if (typeof key !== "string") {
+    if (typeof key !== 'string') {
       return ignores.includes(key);
     }
-    return ignores.some(it => typeof it === "string" && key.startsWith(it));
+    return ignores.some(it => typeof it === 'string' && key.startsWith(it));
   }
   function handleGetterAsComputed(obj, prop, receiver, cells, scope) {
     let s = cells.get(prop);
     if (s) {
-      return s.v;
+      return s.get();
     }
-    s = Signal.create(null, {
-      customPull: () => Reflect.get(obj, prop, receiver),
-      scheduler: Scheduler.Sync,
-      isScope: false,
-      scope
-    });
+    s = new Computed(() => Reflect.get(obj, prop, receiver));
+    s.scope = scope;
     cells.set(prop, s);
-    return s.v;
+    return s.get();
   }
   function handleArraySet(arr, prop, value, receiver) {
-    if (prop === "length") ; else if (bobeShared.isNatureNumStr(prop)) {
+    if (prop === 'length') ; else if (bobeShared.isNatureNumStr(prop)) {
       receiver[Keys.Iterator] = (arr[Keys.Iterator] || 0) + 1;
     } else {
       triggerIter(arr, prop, value, receiver);
@@ -1144,11 +793,11 @@
   }
   function triggerIter(obj, prop, value, receiver) {
     if (!Reflect.has(obj, prop)) {
-      receiver[Keys.Iterator] = receiver[Keys.Raw][Keys.Iterator] + 1;
+      receiver[Keys.Iterator] = (receiver[Keys.Raw][Keys.Iterator] || 0) + 1;
     }
   }
   const arrayMethodReWrites = {};
-  ["pop", "push", "shift", "splice", "unshift", "copyWithin", "reverse", "fill"].forEach(key => {
+  ['pop', 'push', 'shift', 'splice', 'unshift', 'copyWithin', 'reverse', 'fill'].forEach(key => {
     arrayMethodReWrites[key] = function (...args) {
       batchStart();
       const fn = Array.prototype[key];
@@ -1158,13 +807,13 @@
       return res;
     };
   });
-  ["includes", "indexOf", "lastIndexOf"].forEach(key => {
+  ['includes', 'indexOf', 'lastIndexOf'].forEach(key => {
     arrayMethodReWrites[key] = function (...args) {
       const fn = Array.prototype[key];
       const that = toRaw(this);
       let result = fn.call(that, ...args);
       const value = args[0];
-      if ((result === false || result === -1) && typeof value === "object" && value !== null) {
+      if ((result === false || result === -1) && typeof value === 'object' && value !== null) {
         if (value[Keys.Raw]) {
           args[0] = value[Keys.Raw];
           result = fn.call(that, ...args);
@@ -1179,8 +828,8 @@
       return result;
     };
   });
-  [Symbol.iterator, "values", "entries"].forEach(key => {
-    const isEntries = key === "entries";
+  [Symbol.iterator, 'values', 'entries'].forEach(key => {
+    const isEntries = key === 'entries';
     arrayMethodReWrites[key] = function (...args) {
       const fn = Array.prototype[key];
       const rawArray = toRaw(this);
@@ -1238,7 +887,7 @@
     } else {
       k = Math.min(k, len);
     }
-    let final = end === void 0 ? len : end;
+    let final = end === undefined ? len : end;
     if (final < 0) {
       final = Math.max(len + final, 0);
     } else {
@@ -1366,42 +1015,42 @@
   };
   const GetMethodConf = {
     wrapReturn: false,
-    wrapArgs: 1
+    wrapArgs: 0b01
   };
   [{
-    key: "every",
+    key: 'every',
     ...GetMethodConf
   }, {
-    key: "find",
+    key: 'find',
     wrapReturn: true,
     ...GetMethodConf
   }, {
-    key: "findLast",
+    key: 'findLast',
     ...GetMethodConf,
     wrapReturn: true
   }, {
-    key: "findIndex",
+    key: 'findIndex',
     ...GetMethodConf
   }, {
-    key: "findLastIndex",
+    key: 'findLastIndex',
     ...GetMethodConf
   }, {
-    key: "forEach",
+    key: 'forEach',
     ...GetMethodConf
   }, {
-    key: "map",
+    key: 'map',
     ...GetMethodConf
   }, {
-    key: "some",
+    key: 'some',
     ...GetMethodConf
   }, {
-    key: "reduce",
+    key: 'reduce',
     ...GetMethodConf,
-    wrapArgs: 2
+    wrapArgs: 0b10
   }, {
-    key: "reduceRight",
+    key: 'reduceRight',
     ...GetMethodConf,
-    wrapArgs: 2
+    wrapArgs: 0b10
   }].forEach(({
     key,
     wrapReturn,
@@ -1423,17 +1072,17 @@
     };
   });
   arrayMethodReWrites.toSorted = function (...args) {
-    const fn = Array.prototype["toSorted"];
+    const fn = Array.prototype['toSorted'];
     const meta = this[Keys.Meta];
     const isDeep = meta.deep,
       scope = meta.scope;
     const that = toRaw(this);
-    warpCallbackArgs(isDeep, args, scope, 3);
+    warpCallbackArgs(isDeep, args, scope, 0b11);
     let result = fn.call(that, ...args);
     this[Keys.Iterator];
     return isDeep ? result.map(it => deepSignal(it, scope)) : result;
   };
-  ["join", "toString", "toLocaleString"].forEach(key => {
+  ['join', 'toString', 'toLocaleString'].forEach(key => {
     arrayMethodReWrites[key] = function (...args) {
       const fn = Array.prototype[key];
       const that = toRaw(this);
@@ -1442,38 +1091,30 @@
       return result;
     };
   });
-  function warpCallbackArgs(isDeep, args, scope, wrapArgs = 1) {
+  function warpCallbackArgs(isDeep, args, scope, wrapArgs = 0b01) {
     const callback = args[0];
     const wrapCb = function (...cbArgs) {
       if (isDeep) {
-        if (wrapArgs & 1) cbArgs[0] = deepSignal(cbArgs[0], scope);
-        if (wrapArgs & 2) cbArgs[1] = deepSignal(cbArgs[1], scope);
+        if (wrapArgs & 0b01) cbArgs[0] = deepSignal(cbArgs[0], scope);
+        if (wrapArgs & 0b10) cbArgs[1] = deepSignal(cbArgs[1], scope);
       }
       return callback.call(this, ...cbArgs);
     };
     args[0] = wrapCb;
   }
 
-  var _a, _b;
-  _b = IsStore, _a = StoreIgnoreKeys;
-  const _Store = class _Store {
+  class Store {
+    static [IsStore] = true;
+    static [StoreIgnoreKeys] = ['ui', 'raw'];
+    static Current = null;
     constructor() {
-      this.parent = () => null;
-      const proxy = deepSignal(this, G.PullingSignal, true);
-      _Store.Current = proxy;
+      const proxy = deepSignal(this, getPulling(), true);
+      Store.Current = proxy;
       return proxy;
     }
-    static {
-      this[_b] = true;
-    }
-    static {
-      this[_a] = ["ui", "raw"];
-    }
-    static {
-      this.Current = null;
-    }
+    parent = () => null;
     static new(keyMap = {}, staticMap = {}) {
-      const parentStore = _Store.Current;
+      const parentStore = Store.Current;
       const child = new this();
       if (parentStore) {
         for (const childKey in keyMap) {
@@ -1486,7 +1127,7 @@
         child[key] = value;
       }
       child.parent = () => parentStore;
-      _Store.Current = parentStore;
+      Store.Current = parentStore;
       return child;
     }
     map(keyMap = {}) {
@@ -1499,56 +1140,44 @@
       }
       this.parent = null;
     }
-  };
-  let Store = _Store;
+  }
 
-  const DefaultCustomSignalOpt = {
-    /** 三种模式
-     * 1. auto:   根据值类型自动判断 默认
-     * 2. ref:    对任何值使用 {v: xxx} 进行包装
-     * 3. proxy:  使用 proxy 进行包装
-     */
-    mode: "auto",
-    /** 是否深度响应式 */
-    deep: true
-  };
-  ({
-    scheduler: Scheduler.Sync});
-  const $ = (init, opt = {}) => {
-    opt = {
-      ...DefaultCustomSignalOpt,
-      ...opt
-    };
-    let intiValue, customPull;
-    if (typeof init === "function") {
-      intiValue = null;
-      customPull = init;
-    } else if (opt.mode !== "ref" && typeof init === "object" && init !== null) {
-      return deepSignal(init, G.PullingSignal, opt.deep);
+  function $(data) {
+    if (typeof data === 'object' && data !== null) {
+      return deepSignal(data, getPulling());
+    }
+    if (typeof data === 'function') {
+      const s = new Computed(data),
+        get = s.get.bind(s);
+      return {
+        ins: s,
+        get v() {
+          return get();
+        }
+      };
     } else {
-      intiValue = init;
+      const s = new Signal(data),
+        set = s.set.bind(s),
+        get = s.get.bind(s);
+      return {
+        ins: s,
+        get v() {
+          return get();
+        },
+        set v(v) {
+          set(v);
+        }
+      };
     }
-    const s = Signal.create(intiValue, {
-      scheduler: Scheduler.Sync,
-      isScope: false,
-      customPull
-    });
-    return s;
-  };
-  const effect = (customPull, depOrOpt, opt) => {
+  }
+  function effectUt(callback, depOrOpt, opt) {
     const hasDep = Array.isArray(depOrOpt);
     opt = hasDep ? opt || {} : depOrOpt || {};
     if (!hasDep) {
-      const s2 = Signal.create(null, {
-        customPull,
-        scheduler: Scheduler.Sync,
-        isScope: true,
-        ...opt
-      });
-      s2.v;
-      const bound2 = dispose.bind(s2);
-      bound2.ins = s2;
-      return bound2;
+      const ef = new Effect(callback);
+      const run = ef.dispose.bind(ef);
+      run.ins = ef;
+      return run;
     }
     let mounted = false;
     const deps = depOrOpt;
@@ -1559,84 +1188,94 @@
       old: null,
       val: null
     }));
-    const s = Signal.create(null, {
-      customPull() {
-        for (let i = 0; i < deps.length; i++) {
-          const value = deps[i].v;
-          vs[i].old = vs[i].val;
-          vs[i].val = value;
-        }
-        if (mounted || immediate) {
-          s.state |= State.LinkScopeOnly;
-          customPull(...vs);
-          s.state &= ~State.LinkScopeOnly;
-        }
-        mounted = true;
-      },
-      scheduler: Scheduler.Sync,
-      isScope: true,
-      ...opt
-    });
-    s.v;
-    const bound = dispose.bind(s);
-    bound.ins = s;
-    return bound;
-  };
-  const scope = (...args) => {
-    const hasScope = args.length > 1;
-    const s = Signal.create(null, {
-      customPull: args[0],
-      scheduler: Scheduler.Sync,
-      isScope: true,
-      scope: hasScope ? args[1] : G.PullingSignal
+    const ef = new Effect(() => {
+      for (let i = 0; i < deps.length; i++) {
+        const value = deps[i].v;
+        vs[i].old = vs[i].val;
+        vs[i].val = value;
+      }
+      if (mounted || immediate) {
+        ef.state |= 256;
+        callback(...vs);
+        ef.state &= -257;
+      }
+      mounted = true;
     });
-    if (hasScope) {
-      runWithPulling(() => {
-        s.v;
-      }, args[1]);
-    } else {
-      s.v;
+    const run = ef.dispose.bind(ef);
+    run.ins = ef;
+    return run;
+  }
+  function effect(callback, depOrOpt, opt) {
+    const hasDep = Array.isArray(depOrOpt);
+    opt = hasDep ? opt || {} : depOrOpt || {};
+    if (!hasDep) {
+      const ef = new Effect(callback);
+      const run = ef.dispose.bind(ef);
+      run.ins = ef;
+      return run;
     }
-    s.state |= State.ScopeReady;
-    const bound = dispose.bind(s);
-    bound.ins = s;
-    return bound;
-  };
-  const customEffect = opt => {
-    return (init, innerOpt = {}) => {
-      return effect(init, {
-        ...opt,
-        ...innerOpt
-      });
-    };
-  };
-  const isSignal = value => {
-    return value instanceof Signal;
-  };
-  const isScope = value => {
-    return value instanceof Signal;
-  };
+    let mounted = false;
+    const deps = depOrOpt;
+    const immediate = deps.length === 0 ? true : opt.immediate ?? true;
+    const vs = Array.from({
+      length: deps.length
+    }, () => ({
+      old: null,
+      val: null
+    }));
+    const ef = new Effect(eff => {
+      for (let i = 0; i < deps.length; i++) {
+        const value = deps[i].get();
+        vs[i].old = vs[i].val;
+        vs[i].val = value;
+      }
+      if (mounted || immediate) {
+        eff.state |= 256;
+        callback(...vs);
+        eff.state &= -257;
+      }
+      mounted = true;
+    });
+    const run = ef.dispose.bind(ef);
+    run.ins = ef;
+    return run;
+  }
+  function scope(...args) {
+    const ins = new Scope(args[0]);
+    if (args.length === 2) {
+      ins.scope = args[1];
+    }
+    ins.get();
+    const run = ins.dispose.bind(ins);
+    run.ins = ins;
+    return run;
+  }
 
   exports.$ = $;
+  exports.Computed = Computed;
+  exports.Effect = Effect;
   exports.IsStore = IsStore;
   exports.Keys = Keys;
-  exports.Scheduler = Scheduler;
+  exports.Scope = Scope;
   exports.Signal = Signal;
   exports.Store = Store;
   exports.StoreIgnoreKeys = StoreIgnoreKeys;
-  exports.TaskQueue = TaskQueue;
   exports.batchEnd = batchEnd;
   exports.batchStart = batchStart;
   exports.clean = clean;
-  exports.customEffect = customEffect;
   exports.deepSignal = deepSignal;
   exports.effect = effect;
+  exports.effectUt = effectUt;
+  exports.execId = execId;
+  exports.execIdInc = execIdInc;
   exports.getPulling = getPulling;
-  exports.isScope = isScope;
-  exports.isSignal = isSignal;
-  exports.registerScheduler = registerScheduler;
+  exports.ide = ide;
+  exports.macro = macro;
+  exports.micro = micro;
+  exports.now = now;
   exports.runWithPulling = runWithPulling;
   exports.scope = scope;
+  exports.setExecId = setExecId;
   exports.setPulling = setPulling;
   exports.shareSignal = shareSignal;
   exports.toRaw = toRaw;