aoye 0.0.22 → 0.0.24

package/dist/aoye.cjs.js

@@ -2,996 +2,654 @@
 
 var bobeShared = require('bobe-shared');
 
-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 = {
@@ -1012,12 +670,12 @@ const deepSignal = (target, scope, deep = true) => {
         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;
@@ -1027,26 +685,22 @@ const deepSignal = (target, scope, deep = true) => {
       }
       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);
@@ -1056,13 +710,12 @@ const deepSignal = (target, scope, deep = true) => {
       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) {
@@ -1079,8 +732,8 @@ const deepSignal = (target, scope, deep = true) => {
 };
 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,
@@ -1094,13 +747,13 @@ const shareSignal = (from, fromPath, to, toPath) => {
       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];
@@ -1114,27 +767,23 @@ function getTargetAndKey(obj, paths) {
   };
 }
 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);
@@ -1142,11 +791,11 @@ function handleArraySet(arr, prop, value, receiver) {
 }
 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];
@@ -1156,13 +805,13 @@ const arrayMethodReWrites = {};
     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);
@@ -1177,8 +826,8 @@ const arrayMethodReWrites = {};
     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);
@@ -1236,7 +885,7 @@ arrayMethodReWrites.slice = function (start, end) {
   } 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 {
@@ -1364,42 +1013,42 @@ arrayMethodReWrites.concat = function (...items) {
 };
 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,
@@ -1421,17 +1070,17 @@ const GetMethodConf = {
   };
 });
 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);
@@ -1440,38 +1089,30 @@ arrayMethodReWrites.toSorted = function (...args) {
     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) {
@@ -1484,7 +1125,7 @@ const _Store = class _Store {
       child[key] = value;
     }
     child.parent = () => parentStore;
-    _Store.Current = parentStore;
+    Store.Current = parentStore;
     return child;
   }
   map(keyMap = {}) {
@@ -1497,56 +1138,44 @@ const _Store = class _Store {
     }
     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;
@@ -1557,84 +1186,94 @@ const effect = (customPull, depOrOpt, opt) => {
     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;