@lytjs/reactivity 5.0.1 → 6.4.0

package/dist/index.cjs

@@ -1 +1,1679 @@
-"use strict";var N=Object.defineProperty;var Ve=Object.getOwnPropertyDescriptor;var Fe=Object.getOwnPropertyNames;var Ie=Object.prototype.hasOwnProperty;var Ke=(e,t)=>{for(var n in t)N(e,n,{get:t[n],enumerable:!0})},Ae=(e,t,n,r)=>{if(t&&typeof t=="object"||typeof t=="function")for(let o of Fe(t))!Ie.call(e,o)&&o!==n&&N(e,o,{get:()=>t[o],enumerable:!(r=Ve(t,o))||r.enumerable});return e};var Me=e=>Ae(N({},"__esModule",{value:!0}),e);var Ue={};Ke(Ue,{ITERATE_KEY:()=>S,ReactiveEffect:()=>d,activeEffect:()=>c,batch:()=>we,clearQueue:()=>x.clearQueue,computed:()=>he,computedSignal:()=>Se,effect:()=>Z,enterSignalComponentContext:()=>Oe,hasPendingJob:()=>x.hasPendingJob,isReactive:()=>w,isReadonly:()=>J,isRef:()=>h,markReadOnly:()=>fe,markSkip:()=>ce,nextTick:()=>R.nextTick,onSignalCleanup:()=>We,pauseTracking:()=>K,queueJob:()=>x.queueJob,queuePostFlushCb:()=>x.queuePostFlushCb,rawSymbol:()=>T,reactive:()=>W,reactiveFlag:()=>v,readonly:()=>H,readonlyFlag:()=>y,ref:()=>le,refSymbol:()=>_,resetTracking:()=>A,shallowReactive:()=>ae,shallowRef:()=>de,shallowRefSymbol:()=>U,signal:()=>G,signalEffect:()=>ve,stop:()=>ee,toRaw:()=>m,toRef:()=>L,toRefs:()=>ye,track:()=>f,trigger:()=>u,triggerRef:()=>Te,unref:()=>be,untrack:()=>ge,useSignal:()=>je,useSignalState:()=>ke,watch:()=>me,watchEffect:()=>xe});module.exports=Me(Ue);var c=null,k=[],De=0,Y=new WeakMap,d=class{constructor(t,n={}){this.active=!0;this.deps=new Set;this.fn=t,this.scheduler=n.scheduler,this.beforeRun=n.beforeRun,this.afterRun=n.afterRun,this.lazy=n.lazy,this.id=De++}run(){var t,n;if(!this.active)return this.fn();if(k.includes(this))return this.fn();try{return(t=this.beforeRun)==null||t.call(this),k.push(this),c=this,B(this),this.fn()}finally{(n=this.afterRun)==null||n.call(this),k.pop(),c=k[k.length-1]||null}}stop(){this.active&&(B(this),this.onStop&&this.onStop(),this.active=!1)}},I=!0,X=[];function K(){X.push(I),I=!1}function A(){let e=X.pop();I=e===void 0?!0:e}function B(e){let{deps:t}=e;for(let n of t)n.delete(e);t.clear()}function f(e,t){if(!I||!c)return;let n=Y.get(e);n||(n=new Map,Y.set(e,n));let r=n.get(t);r||(r=new Set,n.set(t,r)),r.has(c)||(r.add(c),c.deps.add(r))}function u(e,t,n,r){let o=Y.get(e);if(!o)return;let i=new Set,s=a=>{if(a)for(let p of a)(p!==c||p.allowRecurse)&&i.add(p)};if(s(o.get(t)),(n==="add"||n==="delete")&&s(o.get(S)),n==="set"&&Array.isArray(e)){let a=o.get("length");a&&typeof t=="number"&&t<e.length&&s(a)}for(let a of i)a.scheduler?a.scheduler(a):a.run()}var S=Symbol("iterate");function Z(e,t={}){let n=new d(e,t);t.lazy||n.run();let r=n.run.bind(n);return r.effect=n,r.stop=()=>n.stop(),r}function ee(e){var t;(t=e==null?void 0:e.effect)==null||t.stop()}var y=Symbol("readonly"),T=Symbol("raw"),v=Symbol("reactive"),oe=Symbol("skip"),te=new WeakMap,ne=new WeakMap,re=new WeakMap;function O(e){return e!==null&&typeof e=="object"}function ie(e,t){return!Object.is(e,t)}function M(e,t){return Object.prototype.hasOwnProperty.call(e,t)}var D={};["includes","indexOf","lastIndexOf"].forEach(e=>{D[e]=function(...t){let n=m(this);for(let r=0;r<n.length;r++)f(n,String(r));return f(n,"length"),n[e](...t)}});["push","pop","shift","unshift","splice","sort","reverse"].forEach(e=>{D[e]=function(...t){K();let n=Array.prototype[e].apply(this,t);return A(),u(m(this),"length","set",m(this).length),n}});var He={get(e,t,n){if(t===T)return e;if(t===v)return!0;if(Array.isArray(e)&&D.hasOwnProperty(t))return D[t];f(e,t);let r=Reflect.get(e,t,n);return t===y?e[y]===!0:!O(r)||e[oe]?r:W(r)},set(e,t,n,r){let o=e[t],i=Array.isArray(e)&&se(t)?Number(t)<e.length:M(e,t),s=Reflect.set(e,t,n,r);return(e===(r==null?void 0:r[T])||e===m(r))&&(i?ie(n,o)&&u(e,t,"set",n):u(e,t,"add",n)),s},deleteProperty(e,t){let n=M(e,t),r=Reflect.deleteProperty(e,t);return r&&n&&u(e,t,"delete"),r},has(e,t){return f(e,t),Reflect.has(e,t)},ownKeys(e){return f(e,S),Reflect.ownKeys(e)}},ze={get(e,t,n){if(t===T)return e;if(t===v||t===y)return!0;f(e,t);let r=Reflect.get(e,t,n);return O(r)?H(r):r},set(e,t,n,r){return!1},deleteProperty(e,t){return!1},has(e,t){return f(e,t),Reflect.has(e,t)},ownKeys(e){return f(e,S),Reflect.ownKeys(e)}},Ge={get(e,t,n){return t===T?e:t===v?!0:(f(e,t),Reflect.get(e,t,n))},set(e,t,n,r){let o=e[t],i=Array.isArray(e)&&se(t)?Number(t)<e.length:M(e,t),s=Reflect.set(e,t,n,r);return(e===(r==null?void 0:r[T])||e===m(r))&&(i?ie(n,o)&&u(e,t,"set",n):u(e,t,"add",n)),s},deleteProperty(e,t){let n=M(e,t),r=Reflect.deleteProperty(e,t);return r&&n&&u(e,t,"delete"),r},has(e,t){return f(e,t),Reflect.has(e,t)},ownKeys(e){return f(e,S),Reflect.ownKeys(e)}};function se(e){return typeof e=="string"&&e!=="NaN"&&e[0]!=="-"&&""+parseInt(e,10)===e}function W(e,t={}){if(!O(e)||e[v])return e;if(e[y])return H(e);let n=te.get(e);if(n)return n;let r=new Proxy(e,He);return te.set(e,r),r}function H(e){if(!O(e))return e;let t=ne.get(e);if(t)return t;e[y]=!0;let n=new Proxy(e,ze);return ne.set(e,n),n}function ae(e){if(!O(e))return e;let t=re.get(e);if(t)return t;let n=new Proxy(e,Ge);return re.set(e,n),n}function m(e){let t=e&&e[T];return t?m(t):e}function w(e){return J(e)?w(e[T]):!!(e&&e[v])}function J(e){return!!(e&&e[y])}function fe(e){return e[y]=!0,e}function ce(e){return e[oe]=!0,e}var ue=require("@lytjs/common"),_=Symbol("ref"),U=Symbol("shallowRef"),q=new WeakMap;function Ne(e){return q.get(e)||e}function le(e){if(h(e))return e;let t={_value:pe(e),_rawValue:e,__v_isRef:!0,[_]:!0},n=new Proxy(t,Ye);return q.set(n,t),n}function pe(e){return(0,ue.isObject)(e)?W(e):e}var Ye={get(e,t,n){return t==="value"?(f(e,"value"),e._value):t===_||t==="__v_isRef"?!0:t==="_rawValue"?e._rawValue:Reflect.get(e,t,n)},set(e,t,n,r){if(t==="value"){let o=e._rawValue;return Object.is(o,n)||(e._rawValue=n,e._value=pe(n),u(e,"value","set",n)),!0}return Reflect.set(e,t,n,r)}};function de(e){if(h(e))return e;let t={_value:e,_rawValue:e,__v_isRef:!0,__v_isShallow:!0,[_]:!0,[U]:!0},n=new Proxy(t,Je);return q.set(n,t),n}var Je={get(e,t,n){return t==="value"?(f(e,"value"),e._value):t===_||t==="__v_isRef"||t==="__v_isShallow"?!0:t==="_rawValue"?e._rawValue:Reflect.get(e,t,n)},set(e,t,n,r){if(t==="value"){let o=e._rawValue;return Object.is(o,n)||(e._rawValue=n,e._value=n,u(e,"value","set",n)),!0}return Reflect.set(e,t,n,r)}};function h(e){return!!(e&&e.__v_isRef===!0)}function be(e){return h(e)?e.value:e}function L(e,t){let n=e[t];return h(n)?n:new Proxy({_obj:e,_key:t,__v_isRef:!0},{get(r,o,i){return o==="value"?r._obj[r._key]:o==="__v_isRef"?!0:Reflect.get(r,o,i)},set(r,o,i,s){return o==="value"?(r._obj[r._key]=i,!0):Reflect.set(r,o,i,s)}})}function ye(e){let t={};for(let n in e)Object.prototype.hasOwnProperty.call(e,n)&&(t[n]=L(e,n));return t}function Te(e){let t=Ne(e);u(t,"value","set",t._rawValue)}var $=class{constructor(t,n){this._dirty=!0;this.__v_isRef=!0;this.deps=new Set;this._setter=n,this._effect=new d(t,{scheduler:()=>{this._dirty||(this._dirty=!0,this.triggerDep())},lazy:!0}),this._value=void 0}get value(){return f(this,"value"),c&&!this.deps.has(c)&&(this.deps.add(c),c.deps.add(this.deps)),this._dirty&&(this._value=this._effect.run(),this._dirty=!1),this._value}set value(t){this._setter&&this._setter(t)}triggerDep(){for(let t of this.deps)t.scheduler?t.scheduler(t):t.run()}};function he(e){let t,n;return typeof e=="function"?(t=e,n=void 0):(t=e.get,n=e.set),new $(t,n)}var R=require("@lytjs/common");function P(e,t=1/0,n){if(!(0,R.isObject)(e)||t<=0||(n||(n=new Set),n.has(e)))return e;if(n.add(e),h(e))P(e.value,t-1,n);else if(Array.isArray(e))for(let r=0;r<e.length;r++)P(e[r],t-1,n);else for(let r of Object.keys(e))P(e[r],t-1,n);return e}function Re(e){return h(e)?()=>e.value:w(e)?()=>P(e):typeof e=="function"?e:()=>P(e)}function me(e,t,n={}){let r,o=!1;if(Array.isArray(e)){o=!0;let l=e.map(j=>Re(j));r=()=>l.map(j=>j())}else r=Re(e);w(e)&&n.deep!==!1&&(n.deep=!0);let i=o?[]:void 0,s,a=l=>{s=l},p=()=>{s&&(s(),s=void 0);let l=E.run();(o?l.some((j,Pe)=>!Object.is(j,i[Pe])):!Object.is(l,i)||n.deep&&(0,R.isObject)(l))&&(t(l,o?[...i]:i,a),i=o?[...l]:l)},E=new d(r,{lazy:!0,scheduler:()=>{n.flush==="sync"?p():(0,R.queueJob)(p)}});return n.immediate?p():i=E.run(),()=>{E.stop()}}function xe(e,t={}){let n,r=()=>{n&&(n(),n=void 0),e(i=>{n=i})},o=new d(r,{scheduler:()=>{t.flush==="sync"?r():(0,R.queueJob)(r)}});return o.run(),()=>{o.stop(),n&&(n(),n=void 0)}}var x=require("@lytjs/common");var z=require("@lytjs/common"),b=null,V=!1,F=0,g=new Set,Q=!1;function G(e){let t=e,n=new Set,r=function(){return b&&!V&&n.add(b),t};return r.set=function(o){Object.is(t,o)||(t=o,Ce(n))},r.update=function(o){r.set(o(t))},r._subscribe=function(o){n.add(o)},r._unsubscribe=function(o){n.delete(o)},r.dispose=function(){n.clear()},r}function Se(e){let t,n=!0,r=!1,o=new Set,i=new Set,s=function(){if(b&&!V&&i.add(b),n){if(r)throw new z.LytError(z.LytErrorCodes.LYT_REACTIVITY_CIRCULAR_DEPENDENCY,"computed \u5728\u5176\u81EA\u8EAB\u7684\u8BA1\u7B97\u56FE\u4E2D");r=!0;for(let l of o)l._unsubscribe(s);o.clear();let E=b;b=s;try{t=e()}finally{b=E,r=!1}n=!1}return t},a={_dirty:!1,notify(){n=!0,Ce(i)}};return s.notify=a.notify.bind(a),s._dirty=!1,s._subscribe=function(p){i.add(p)},s._unsubscribe=function(p){i.delete(p)},s}function ve(e){let t=null,n=!1,r=new Set,o=()=>{if(n)return;t&&(t(),t=null);for(let a of r)a._unsubscribe(i);r.clear();let s=b;b=i;try{e(a=>{t=a})}finally{b=s}},i={_dirty:!1,notify(){F>0?g.add(i):o()}};return o(),()=>{n=!0,t&&(t(),t=null);for(let s of r)s._unsubscribe(i);r.clear(),g.delete(i)}}function we(e){F++;try{e()}finally{F--,F===0&&_e()}}function _e(){if(!Q){Q=!0;try{let e=new Set(g);g.clear();for(let t of e)t.notify();g.size>0&&_e()}finally{Q=!1}}}function ge(e){let t=V;V=!0;try{return e()}finally{V=t}}function Ce(e){if(F>0)for(let t of e)g.add(t);else for(let t of e)t.notify()}var C=[];function Ee(){return C.length>0?C[C.length-1]:null}function je(e){return e()}function ke(e){let t=G(e),n=o=>t.set(o),r=Ee();return[t,n]}function Oe(){let e={_cleanupFns:[]};return C.push(e),()=>{for(let n of e._cleanupFns)n();e._cleanupFns.length=0;let t=C.indexOf(e);t!==-1&&C.splice(t,1)}}function We(e){let t=Ee();t&&t._cleanupFns.push(e)}
+'use strict';
+
+var commonIs = require('@lytjs/common-is');
+var commonError = require('@lytjs/common-error');
+var commonAssertions = require('@lytjs/common-assertions');
+var commonConstants = require('@lytjs/common-constants');
+var commonScheduler = require('@lytjs/common-scheduler');
+
+// src/reactive.ts
+var RefSymbol = /* @__PURE__ */ Symbol(void 0);
+var ShallowRefSymbol = /* @__PURE__ */ Symbol(void 0);
+var ComputedRefSymbol = /* @__PURE__ */ Symbol(void 0);
+var ReactiveSymbol = /* @__PURE__ */ Symbol(void 0);
+var ReadonlySymbol = /* @__PURE__ */ Symbol(void 0);
+var SignalSymbol = /* @__PURE__ */ Symbol(void 0);
+var ComputedSignalSymbol = /* @__PURE__ */ Symbol(void 0);
+var ReactiveFlags = {
+  IS_REACTIVE: "__v_isReactive",
+  IS_READONLY: "__v_isReadonly",
+  IS_SHALLOW: "__v_isShallow",
+  IS_REF: "__v_isRef",
+  RAW: "__v_raw",
+  SKIP: "__v_skip"
+};
+var TrackOpTypes = {
+  GET: "get",
+  HAS: "has",
+  ITERATE: "iterate"
+};
+var TriggerOpTypes = {
+  SET: "set",
+  ADD: "add",
+  DELETE: "delete",
+  CLEAR: "clear"
+};
+var ITERATE_KEY = /* @__PURE__ */ Symbol("iterate");
+var activeSubscriber = null;
+var isUntracked = false;
+var trackDependency = null;
+var batchDepth = 0;
+var MAX_BATCH_DEPTH = 100;
+var pendingNotifications = /* @__PURE__ */ new Set();
+var pendingTriggerOps = /* @__PURE__ */ new Map();
+var isNotifying = false;
+function signal(initialValue) {
+  let value = initialValue;
+  const subscribers = /* @__PURE__ */ new Set();
+  let disposed = false;
+  const store = {};
+  const SIGNAL_KEY = /* @__PURE__ */ Symbol("signal_value");
+  store[SIGNAL_KEY] = initialValue;
+  const signalFn = function signalFn2() {
+    const currentSubscriber = activeSubscriber;
+    if (currentSubscriber && !isUntracked && !disposed) {
+      if (!subscribers.has(currentSubscriber)) {
+        subscribers.add(currentSubscriber);
+        if (trackDependency) {
+          trackDependency(signalFn2, () => {
+            subscribers.delete(currentSubscriber);
+          });
+        }
+      }
+    }
+    if (!disposed) {
+      track(store, TrackOpTypes.GET, SIGNAL_KEY);
+    }
+    return value;
+  };
+  Object.defineProperty(signalFn, SignalSymbol, { value: true });
+  signalFn.set = (newValue) => {
+    if (disposed) return;
+    if (Object.is(newValue, value)) return;
+    value = newValue;
+    store[SIGNAL_KEY] = newValue;
+    notifySubscribers(subscribers, store, SIGNAL_KEY, newValue);
+  };
+  signalFn.update = (updater) => {
+    if (disposed) return;
+    const newValue = updater(value);
+    if (Object.is(newValue, value)) return;
+    value = newValue;
+    store[SIGNAL_KEY] = newValue;
+    notifySubscribers(subscribers, store, SIGNAL_KEY, newValue);
+  };
+  signalFn.dispose = () => {
+    disposed = true;
+    subscribers.clear();
+  };
+  signalFn.cleanup = () => {
+    subscribers.clear();
+    trigger(store, TriggerOpTypes.SET, SIGNAL_KEY);
+  };
+  signalFn._subscribe = (subscriber) => {
+    if (disposed) return () => {
+    };
+    subscribers.add(subscriber);
+    return () => subscribers.delete(subscriber);
+  };
+  return signalFn;
+}
+function createComputedSignalInternal(getter, typeName) {
+  let value;
+  let dirty = true;
+  let isComputing = false;
+  const dependencies = /* @__PURE__ */ new Map();
+  const subscribers = /* @__PURE__ */ new Set();
+  let disposed = false;
+  const store = {};
+  const COMPUTED_SIGNAL_KEY = /* @__PURE__ */ Symbol("computed_signal_value");
+  const invalidate = () => {
+    if (disposed) return;
+    dirty = true;
+    trigger(store, TriggerOpTypes.SET, COMPUTED_SIGNAL_KEY);
+    const subs = Array.from(subscribers);
+    for (const sub of subs) {
+      sub();
+    }
+  };
+  const computedFn = function computedFn2() {
+    if (disposed) return value;
+    track(store, TrackOpTypes.GET, COMPUTED_SIGNAL_KEY);
+    if (activeSubscriber && !isUntracked) {
+      subscribers.add(activeSubscriber);
+    }
+    if (dirty) {
+      if (isComputing) {
+        throw new Error(`[lytjs/signal] Circular dependency detected in ${typeName}.`);
+      }
+      isComputing = true;
+      try {
+        for (const unsubscribe of dependencies.values()) {
+          unsubscribe();
+        }
+        dependencies.clear();
+        const prevSubscriber = activeSubscriber;
+        const prevTrackDependency = trackDependency;
+        activeSubscriber = invalidate;
+        trackDependency = (dep, unsubscribe) => {
+          dependencies.set(dep, unsubscribe);
+        };
+        try {
+          value = getter();
+          dirty = false;
+        } finally {
+          activeSubscriber = prevSubscriber;
+          trackDependency = prevTrackDependency;
+        }
+      } finally {
+        isComputing = false;
+      }
+    }
+    return value;
+  };
+  Object.defineProperty(computedFn, ComputedSignalSymbol, { value: true });
+  const dispose = () => {
+    disposed = true;
+    for (const unsubscribe of dependencies.values()) {
+      unsubscribe();
+    }
+    dependencies.clear();
+    subscribers.clear();
+  };
+  return { computedFn, invalidate, dispose };
+}
+function computed(fn) {
+  const { computedFn, dispose } = createComputedSignalInternal(fn, "computed signal");
+  computedFn.dispose = dispose;
+  computedFn.stop = dispose;
+  return computedFn;
+}
+function writableComputedSignal(getter, setter) {
+  const { computedFn, dispose } = createComputedSignalInternal(getter, "writable computed signal");
+  computedFn.set = (newValue) => {
+    setter(newValue);
+  };
+  computedFn.dispose = dispose;
+  computedFn.stop = dispose;
+  return computedFn;
+}
+function signalBatch(fn) {
+  if (batchDepth >= MAX_BATCH_DEPTH) {
+    fn();
+    return;
+  }
+  batchDepth++;
+  try {
+    fn();
+  } finally {
+    batchDepth--;
+    if (batchDepth === 0) {
+      flushPendingNotifications();
+    }
+  }
+}
+function signalUntrack(fn) {
+  const prevIsUntracked = isUntracked;
+  isUntracked = true;
+  try {
+    return fn();
+  } finally {
+    isUntracked = prevIsUntracked;
+  }
+}
+function _isSignalUntracked() {
+  return isUntracked;
+}
+function notifySubscribers(subscribers, store, signalKey, newValue) {
+  if (batchDepth > 0 || isNotifying) {
+    const it2 = subscribers.values();
+    let next2 = it2.next();
+    while (!next2.done) {
+      pendingNotifications.add(next2.value);
+      next2 = it2.next();
+    }
+    if (store && signalKey !== void 0) {
+      pendingTriggerOps.set(signalKey, { store, signalKey, newValue });
+    }
+    return;
+  }
+  const it = subscribers.values();
+  let next = it.next();
+  while (!next.done) {
+    next.value();
+    next = it.next();
+  }
+  if (store && signalKey !== void 0) {
+    trigger(store, TriggerOpTypes.SET, signalKey, newValue);
+  }
+}
+function flushPendingNotifications() {
+  if (isNotifying) return;
+  isNotifying = true;
+  try {
+    let iterations = 0;
+    while ((pendingNotifications.size > 0 || pendingTriggerOps.size > 0) && iterations < commonConstants.REACTIVITY_MAX_TRIGGER_DEPTH) {
+      const notifications = new Set(pendingNotifications);
+      const triggers = new Set(pendingTriggerOps.values());
+      pendingNotifications.clear();
+      pendingTriggerOps.clear();
+      const notifIt = notifications.values();
+      let notifNext = notifIt.next();
+      while (!notifNext.done) {
+        notifNext.value();
+        notifNext = notifIt.next();
+      }
+      const triggerIt = triggers.values();
+      let triggerNext = triggerIt.next();
+      while (!triggerNext.done) {
+        const { store, signalKey, newValue } = triggerNext.value;
+        trigger(store, TriggerOpTypes.SET, signalKey, newValue);
+        triggerNext = triggerIt.next();
+      }
+      iterations++;
+    }
+  } finally {
+    isNotifying = false;
+  }
+}
+function computedSignal(fn) {
+  return computed(fn);
+}
+function valueOf(sig) {
+  return sig();
+}
+function set(sig, newValue) {
+  if (isWritableSignal(sig)) {
+    sig.set(newValue);
+  }
+}
+function isWritableSignal(sig) {
+  return typeof sig === "function" && "set" in sig;
+}
+function update(sig, updater) {
+  sig.update(updater);
+}
+function readonlySignal(sig) {
+  const readonlyFn = function readonlyFn2() {
+    return sig();
+  };
+  Object.defineProperty(readonlyFn, SignalSymbol, { value: true });
+  return readonlyFn;
+}
+var activeEffectScope;
+function getActiveEffectScope() {
+  return activeEffectScope;
+}
+function effectScope(options) {
+  const detached = typeof options === "boolean" ? options : options?.detached;
+  const scope = {
+    active: true,
+    effects: [],
+    cleanups: [],
+    parent: activeEffectScope,
+    detached: !!detached,
+    run(fn) {
+      if (!this.active) {
+        return;
+      }
+      const prevScope = activeEffectScope;
+      activeEffectScope = this;
+      try {
+        return fn();
+      } finally {
+        activeEffectScope = prevScope;
+      }
+    },
+    stop() {
+      if (!this.active) return;
+      this.active = false;
+      for (const effect2 of this.effects) {
+        try {
+          effect2.stop();
+        } catch (e) {
+          commonError.error(`Error stopping effect in scope: ${String(e)}`);
+        }
+      }
+      for (const cleanup of this.cleanups) {
+        try {
+          cleanup();
+        } catch (e) {
+          commonError.error(`Error running cleanup in scope: ${String(e)}`);
+        }
+      }
+      if (this.parent) {
+        const idx = this.parent.effects.indexOf(commonAssertions.unsafeCast(this));
+        if (idx !== -1) {
+          this.parent.effects.splice(idx, 1);
+        }
+      }
+      this.effects.length = 0;
+      this.cleanups.length = 0;
+      this.parent = void 0;
+    }
+  };
+  if (!scope.detached && activeEffectScope) {
+    activeEffectScope.effects.push(commonAssertions.unsafeCast(scope));
+  }
+  return scope;
+}
+function getCurrentScope() {
+  return activeEffectScope;
+}
+function onScopeDispose(fn) {
+  if (activeEffectScope) {
+    activeEffectScope.cleanups.push(fn);
+  }
+}
+var activeEffect;
+var _trackDepth = 0;
+var targetMap = /* @__PURE__ */ new WeakMap();
+var shouldTrack = true;
+var trackStack = [];
+var isFirstRenderPass = false;
+var skippedTrackingCount = 0;
+function withFirstRenderOptimization(fn) {
+  const wasFirstRender = isFirstRenderPass;
+  isFirstRenderPass = true;
+  try {
+    return fn();
+  } finally {
+    if (!wasFirstRender) {
+      isFirstRenderPass = false;
+    }
+  }
+}
+function shouldSkipTracking() {
+  return isFirstRenderPass;
+}
+function getSkippedTrackingCount() {
+  return skippedTrackingCount;
+}
+function resetSkippedTrackingCount() {
+  skippedTrackingCount = 0;
+}
+function getActiveEffect() {
+  return activeEffect;
+}
+function getShouldTrack() {
+  return shouldTrack;
+}
+var createDep = () => {
+  return /* @__PURE__ */ new Set();
+};
+var triggerDepth = 0;
+function track(target, _type, key) {
+  if (!shouldTrack || activeEffect === void 0) return;
+  if (_isSignalUntracked()) return;
+  let depsMap = targetMap.get(target);
+  if (!depsMap) {
+    targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
+  }
+  let dep = depsMap.get(key);
+  if (!dep) {
+    depsMap.set(key, dep = createDep());
+  }
+  trackEffect(dep);
+}
+function trackEffect(dep) {
+  if (shouldSkipTracking()) {
+    skippedTrackingCount++;
+    return;
+  }
+  if (activeEffect && !dep.has(activeEffect)) {
+    dep.add(activeEffect);
+    activeEffect.deps.push(dep);
+  }
+}
+function trigger(target, type, key, newValue, oldValue) {
+  const depsMap = targetMap.get(target);
+  if (!depsMap) return;
+  const deps = [];
+  if (type === "clear") {
+    deps.push(...depsMap.values());
+  } else {
+    if (key !== void 0) {
+      deps.push(depsMap.get(key));
+    }
+    if (type === "add") {
+      if (Array.isArray(target)) {
+        deps.push(depsMap.get("length"));
+      } else {
+        deps.push(depsMap.get(ITERATE_KEY));
+      }
+    } else if (type === "delete") {
+      if (!Array.isArray(target)) {
+        deps.push(depsMap.get(ITERATE_KEY));
+      }
+    } else if (type === "set") {
+      if (Array.isArray(target) && isIntegerKey(key)) {
+        deps.push(depsMap.get("length"));
+      }
+    }
+  }
+  const effects = [];
+  for (const dep of deps) {
+    if (dep) {
+      for (const effect2 of dep) {
+        effects.push(effect2);
+      }
+    }
+  }
+  triggerEffects([...new Set(effects)], target, type, key, newValue, oldValue);
+}
+function triggerEffects(effects, target, type, key, newValue, oldValue) {
+  if (triggerDepth > commonConstants.REACTIVITY_MAX_TRIGGER_DEPTH) {
+    return;
+  }
+  triggerDepth++;
+  try {
+    for (const effect2 of effects) {
+      if (effect2.computed) {
+        triggerEffect(effect2, target, type, key, newValue, oldValue);
+      }
+    }
+    for (const effect2 of effects) {
+      if (!effect2.computed) {
+        triggerEffect(effect2, target, type, key, newValue, oldValue);
+      }
+    }
+  } finally {
+    triggerDepth--;
+  }
+}
+function triggerEffect(effect2, target, type, key, newValue, oldValue) {
+  if (effect2 !== activeEffect || effect2.allowRecurse) {
+    if (effect2.scheduler) {
+      effect2.scheduler();
+    } else {
+      effect2.run();
+    }
+  }
+}
+var ReactiveEffect = class {
+  constructor(fn, scheduler) {
+    this.fn = fn;
+    this.scheduler = scheduler;
+    this.active = true;
+    this.deps = [];
+    this.parent = void 0;
+    // 运行前清理（onEffectCleanup 注册的）
+    this._cleanups = [];
+    const scope = getActiveEffectScope();
+    if (scope && scope.active) {
+      scope.effects.push(this);
+    }
+  }
+  run() {
+    if (!this.active) {
+      return void 0;
+    }
+    if (this._cleanups.length > 0) {
+      for (let i = 0; i < this._cleanups.length; i++) {
+        this._cleanups[i]();
+      }
+      this._cleanups.length = 0;
+    }
+    const prevShouldTrack = shouldTrack;
+    try {
+      this.parent = activeEffect;
+      activeEffect = this;
+      shouldTrack = true;
+      _trackDepth++;
+      return this.fn();
+    } catch (error3) {
+      if (this.onError) {
+        this.onError(error3);
+        return void 0;
+      }
+      throw error3;
+    } finally {
+      _trackDepth--;
+      activeEffect = this.parent;
+      shouldTrack = prevShouldTrack;
+      this.parent = void 0;
+    }
+  }
+  stop() {
+    if (this.active) {
+      cleanupEffect(this);
+      if (this._cleanups.length > 0) {
+        for (let i = 0; i < this._cleanups.length; i++) {
+          this._cleanups[i]();
+        }
+        this._cleanups.length = 0;
+      }
+      if (this.onStop) {
+        this.onStop();
+      }
+      this.active = false;
+      this.scheduler = void 0;
+    }
+  }
+};
+function cleanupEffect(effect2) {
+  const { deps } = effect2;
+  for (let i = 0; i < deps.length; i++) {
+    deps[i].delete(effect2);
+  }
+  deps.length = 0;
+}
+function effect(fn, options) {
+  const _effect = new ReactiveEffect(fn);
+  if (options) {
+    _effect.scheduler = options.scheduler;
+    _effect.allowRecurse = options.allowRecurse;
+    _effect.onStop = options.onStop;
+    _effect.onTrack = options.onTrack;
+    _effect.onTrigger = options.onTrigger;
+    _effect.onError = options.onError;
+  }
+  if (!options || !options.lazy) {
+    _effect.run();
+  }
+  const runner = _effect.run.bind(_effect);
+  runner.effect = _effect;
+  return runner;
+}
+function stop(runner) {
+  runner.effect.stop();
+}
+function pauseTracking() {
+  trackStack.push(shouldTrack);
+  shouldTrack = false;
+}
+function enableTracking() {
+  trackStack.push(shouldTrack);
+  shouldTrack = true;
+}
+function resetTracking() {
+  const last = trackStack.pop();
+  shouldTrack = last === void 0 ? true : last;
+}
+function batch(fn) {
+  const stackLength = trackStack.length;
+  pauseTracking();
+  try {
+    fn();
+  } finally {
+    while (trackStack.length > stackLength) {
+      trackStack.pop();
+    }
+    shouldTrack = trackStack.length > 0 ? trackStack[trackStack.length - 1] : true;
+  }
+}
+function batchAsync(fn) {
+  const stackLength = trackStack.length;
+  pauseTracking();
+  const restoreTracking = () => {
+    while (trackStack.length > stackLength) {
+      trackStack.pop();
+    }
+    shouldTrack = trackStack.length > 0 ? trackStack[trackStack.length - 1] : true;
+  };
+  try {
+    const result = fn();
+    if (result && typeof result === "object" && "then" in result) {
+      return result.finally(restoreTracking);
+    }
+    restoreTracking();
+    return Promise.resolve();
+  } catch (e) {
+    restoreTracking();
+    return Promise.reject(e);
+  }
+}
+function untrack(fn) {
+  const stackLength = trackStack.length;
+  pauseTracking();
+  try {
+    return fn();
+  } finally {
+    while (trackStack.length > stackLength) {
+      trackStack.pop();
+    }
+    shouldTrack = trackStack.length > 0 ? trackStack[trackStack.length - 1] : true;
+  }
+}
+function onEffectCleanup(fn, failSilently = false) {
+  if (activeEffect === void 0) {
+    return;
+  }
+  activeEffect._cleanups.push(fn);
+}
+function isIntegerKey(key) {
+  return typeof key === "string" && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key && Number.isSafeInteger(Number(key));
+}
+var MAX_RAW_DEPTH = 100;
+var _rawSeenSet = /* @__PURE__ */ new Set();
+var _rawDepth = 0;
+function toRaw(observed) {
+  _rawDepth++;
+  if (_rawDepth === 1) {
+    _rawSeenSet.clear();
+  }
+  try {
+    let current = observed;
+    let depth = 0;
+    while (current && current[ReactiveFlags.RAW]) {
+      if (_rawSeenSet.has(current) || depth >= MAX_RAW_DEPTH) return current;
+      _rawSeenSet.add(current);
+      current = current[ReactiveFlags.RAW];
+      depth++;
+    }
+    return current;
+  } finally {
+    _rawDepth--;
+    if (_rawDepth === 0) {
+      _rawSeenSet.clear();
+    }
+  }
+}
+function isRef(r) {
+  return !!(r && typeof r === "object" && r.__v_isRef === true);
+}
+
+// src/reactive.ts
+var MUTATING_METHODS = /* @__PURE__ */ new Set(["set", "add", "delete", "clear"]);
+var collectionMethodCache = /* @__PURE__ */ new WeakMap();
+var arrayInstrumentations = {};
+["includes", "indexOf", "lastIndexOf"].forEach((method) => {
+  const originMethod = Array.prototype[method];
+  arrayInstrumentations[method] = function(...args) {
+    const arr = toRaw(this);
+    track(arr, TrackOpTypes.HAS, "length");
+    const result = originMethod.apply(arr, args);
+    if (result === -1 || result === false) {
+      return originMethod.apply(
+        arr,
+        args.map((a) => toRaw(a))
+      );
+    }
+    return result;
+  };
+});
+["push", "pop", "shift", "unshift", "splice"].forEach((method) => {
+  const originMethod = Array.prototype[method];
+  arrayInstrumentations[method] = function(...args) {
+    pauseTracking();
+    try {
+      const result = originMethod.apply(this, args);
+      return result;
+    } finally {
+      resetTracking();
+    }
+  };
+});
+["sort", "reverse", "fill", "copyWithin"].forEach((method) => {
+  const originMethod = Array.prototype[method];
+  arrayInstrumentations[method] = function(...args) {
+    const arr = toRaw(this);
+    pauseTracking();
+    try {
+      const result = originMethod.apply(arr, args);
+      trigger(arr, TriggerOpTypes.SET, "length");
+      return result;
+    } finally {
+      resetTracking();
+    }
+  };
+});
+var builtInSymbols = new Set(
+  Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => {
+    const value = commonAssertions.unsafeCast(Symbol[key]);
+    return commonIs.isSymbol(value) ? value : void 0;
+  }).filter((sym) => sym !== void 0)
+);
+function isNonTrackableKey(key) {
+  return key === "__proto__" || key === "__v_isRef";
+}
+function toTriggerKey(value) {
+  if (typeof value === "string" || typeof value === "symbol") {
+    return value;
+  }
+  return void 0;
+}
+function createReactiveObject(target, isReadonlyFlag, _isShallow, baseHandlers, collectionHandlers, proxyMap) {
+  if (!commonIs.isObject(target)) {
+    return target;
+  }
+  if (target[ReactiveFlags.SKIP]) {
+    return target;
+  }
+  if (target[ReactiveFlags.RAW] && !(isReadonlyFlag && target[ReactiveFlags.IS_REACTIVE])) {
+    return target;
+  }
+  const existingProxy = proxyMap.get(target);
+  if (existingProxy) {
+    return existingProxy;
+  }
+  const handlers = commonIs.isMap(target) || commonIs.isSet(target) ? collectionHandlers : baseHandlers;
+  const proxy = new Proxy(target, handlers);
+  proxyMap.set(target, proxy);
+  return proxy;
+}
+function createMutableHandler(isReadonly2, isShallow) {
+  return {
+    get(target, key, _receiver) {
+      if (key === ReactiveFlags.IS_REACTIVE) return !isReadonly2;
+      if (key === ReactiveFlags.IS_READONLY) return isReadonly2;
+      if (key === ReactiveFlags.IS_SHALLOW) return isShallow;
+      if (key === ReactiveFlags.RAW) return target;
+      const targetIsArray = Array.isArray(target);
+      if (!isReadonly2 && targetIsArray && commonIs.hasOwn(arrayInstrumentations, key)) {
+        return Reflect.get(arrayInstrumentations, key, _receiver);
+      }
+      const res = Reflect.get(target, key, _receiver);
+      if (commonIs.isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKey(key)) {
+        return res;
+      }
+      if (!isReadonly2) {
+        track(target, TrackOpTypes.GET, key);
+      }
+      if (isShallow) {
+        return res;
+      }
+      if (isRef(res)) {
+        return targetIsArray && isIntegerKey(key) ? res : res.value;
+      }
+      if (commonIs.isObject(res)) {
+        return isReadonly2 ? readonly(res) : reactive(res);
+      }
+      return res;
+    },
+    set(target, key, value, receiver) {
+      if (isReadonly2) {
+        return true;
+      }
+      let oldValue = Reflect.get(target, key);
+      if (!isShallow) {
+        value = toRaw(value);
+        oldValue = toRaw(oldValue);
+        if (!Array.isArray(target) && isRef(oldValue) && !isRef(value)) {
+          oldValue.value = value;
+          return true;
+        }
+      }
+      const hadKey = Array.isArray(target) && isIntegerKey(key) ? Number(key) < target.length : commonIs.hasOwn(target, key);
+      const result = Reflect.set(target, key, value, receiver);
+      if (target === toRaw(receiver)) {
+        if (!hadKey) {
+          trigger(target, TriggerOpTypes.ADD, key, value);
+        } else if (commonIs.hasChanged(value, oldValue)) {
+          trigger(target, TriggerOpTypes.SET, key, value, oldValue);
+        }
+      }
+      return result;
+    },
+    deleteProperty(target, key) {
+      if (isReadonly2) {
+        return true;
+      }
+      const hadKey = commonIs.hasOwn(target, key);
+      const oldValue = Reflect.get(target, key);
+      const result = Reflect.deleteProperty(target, key);
+      if (result && hadKey) {
+        trigger(target, TriggerOpTypes.DELETE, key, void 0, oldValue);
+      }
+      return result;
+    },
+    has(target, key) {
+      const result = Reflect.has(target, key);
+      if (!commonIs.isSymbol(key) || !builtInSymbols.has(key)) {
+        if (!isReadonly2) {
+          track(target, TrackOpTypes.HAS, key);
+        }
+      }
+      return result;
+    },
+    // FIX: P2-08 ownKeys 属性枚举顺序一致：
+    // 返回 Reflect.ownKeys 结果，确保与原生 Object.keys() 枚举顺序一致
+    ownKeys(target) {
+      if (!isReadonly2) {
+        track(target, TrackOpTypes.ITERATE, Array.isArray(target) ? "length" : ITERATE_KEY);
+      }
+      return Reflect.ownKeys(target);
+    }
+  };
+}
+function createCollectionHandler(isReadonly2, isShallow) {
+  return {
+    get(target, key, _receiver) {
+      if (key === ReactiveFlags.IS_REACTIVE) return !isReadonly2;
+      if (key === ReactiveFlags.IS_READONLY) return isReadonly2;
+      if (key === ReactiveFlags.IS_SHALLOW) return isShallow;
+      if (key === ReactiveFlags.RAW) return target;
+      if (key === "size" || key === "has" || key === "forEach" || key === "entries" || key === "keys" || key === "values" || key === Symbol.iterator) {
+        track(target, TrackOpTypes.GET, ITERATE_KEY);
+      }
+      const res = Reflect.get(target, key, target);
+      if (typeof res === "function") {
+        if (!isReadonly2 && (key === "entries" || key === "keys" || key === "values" || key === Symbol.iterator)) {
+          let methodCache = collectionMethodCache.get(target);
+          if (!methodCache) {
+            methodCache = /* @__PURE__ */ new Map();
+            collectionMethodCache.set(target, methodCache);
+          }
+          let cachedFn = methodCache.get(key);
+          if (!cachedFn) {
+            cachedFn = (...args) => {
+              track(target, TrackOpTypes.GET, ITERATE_KEY);
+              return res.apply(target, args);
+            };
+            methodCache.set(key, cachedFn);
+          }
+          return cachedFn;
+        }
+        if (!isReadonly2) {
+          if (MUTATING_METHODS.has(key)) {
+            return (...args) => {
+              const rawTarget = toRaw(target);
+              if (key === "set") {
+                const oldValue = rawTarget.get(args[0]);
+                const hadKey = rawTarget.has(args[0]);
+                const result2 = res.apply(target, args);
+                if (!hadKey || !Object.is(toRaw(oldValue), toRaw(args[1]))) {
+                  const triggerKey = toTriggerKey(args[0]);
+                  if (triggerKey !== void 0) {
+                    trigger(target, TriggerOpTypes.SET, triggerKey, args[1], oldValue);
+                  }
+                }
+                return result2;
+              } else if (key === "add") {
+                const had = rawTarget.has(args[0]);
+                const result2 = res.apply(target, args);
+                if (!had) {
+                  const triggerKey = toTriggerKey(args[0]);
+                  if (triggerKey !== void 0) {
+                    trigger(target, TriggerOpTypes.ADD, triggerKey, args[0]);
+                  }
+                  trigger(target, TriggerOpTypes.ADD, ITERATE_KEY);
+                }
+                return result2;
+              } else if (key === "delete") {
+                const hadKey = rawTarget.has(args[0]);
+                const result2 = res.apply(target, args);
+                if (hadKey) {
+                  const triggerKey = toTriggerKey(args[0]);
+                  if (triggerKey !== void 0) {
+                    trigger(target, TriggerOpTypes.DELETE, triggerKey, void 0, void 0);
+                  }
+                  trigger(target, TriggerOpTypes.DELETE, ITERATE_KEY);
+                }
+                return result2;
+              } else if (key === "clear") {
+                const hadItems = rawTarget.size > 0;
+                const result2 = res.apply(target, args);
+                if (hadItems) {
+                  trigger(target, TriggerOpTypes.CLEAR, void 0, void 0, void 0);
+                }
+                return result2;
+              }
+              const result = res.apply(target, args);
+              trigger(target, TriggerOpTypes.ADD, ITERATE_KEY);
+              return result;
+            };
+          }
+          if (key === "get") {
+            return (...args) => {
+              track(target, TrackOpTypes.GET, args[0]);
+              return res.apply(target, args);
+            };
+          }
+        } else {
+          if (MUTATING_METHODS.has(key)) {
+            return (..._args) => {
+              if (key === "delete") return false;
+              return void 0;
+            };
+          }
+        }
+        return res.bind(target);
+      }
+      return res;
+    }
+  };
+}
+var mutableHandlers = createMutableHandler(false, false);
+var readonlyHandlers = createMutableHandler(true, false);
+var shallowReactiveHandlers = createMutableHandler(false, true);
+var shallowReadonlyHandlers = createMutableHandler(true, true);
+var mutableCollectionHandlers = createCollectionHandler(false, false);
+var readonlyCollectionHandlers = createCollectionHandler(true, false);
+var shallowCollectionHandlers = createCollectionHandler(false, true);
+var shallowReadonlyCollectionHandlers = createCollectionHandler(true, true);
+var reactiveMap = /* @__PURE__ */ new WeakMap();
+var shallowReactiveMap = /* @__PURE__ */ new WeakMap();
+var readonlyMap = /* @__PURE__ */ new WeakMap();
+var shallowReadonlyMap = /* @__PURE__ */ new WeakMap();
+function reactive(target) {
+  if (isReadonly(target)) return target;
+  return createReactiveObject(
+    target,
+    false,
+    false,
+    mutableHandlers,
+    mutableCollectionHandlers,
+    reactiveMap
+  );
+}
+function shallowReactive(target) {
+  return createReactiveObject(
+    target,
+    false,
+    true,
+    shallowReactiveHandlers,
+    shallowCollectionHandlers,
+    shallowReactiveMap
+  );
+}
+function readonly(target) {
+  return createReactiveObject(
+    target,
+    true,
+    false,
+    readonlyHandlers,
+    readonlyCollectionHandlers,
+    readonlyMap
+  );
+}
+function shallowReadonly(target) {
+  return createReactiveObject(
+    target,
+    true,
+    true,
+    shallowReadonlyHandlers,
+    shallowReadonlyCollectionHandlers,
+    shallowReadonlyMap
+  );
+}
+function isReactive(value) {
+  if (isReadonly(value)) {
+    return isReactive(value[ReactiveFlags.RAW]);
+  }
+  return !!(value && value[ReactiveFlags.IS_REACTIVE]);
+}
+function isReadonly(value) {
+  return !!(value && value[ReactiveFlags.IS_READONLY]);
+}
+function isProxy(value) {
+  return isReactive(value) || isReadonly(value);
+}
+function markRaw(value) {
+  if (Object.isFrozen(value) || Object.isSealed(value)) {
+    return value;
+  }
+  Object.defineProperty(value, ReactiveFlags.SKIP, { value: true });
+  return value;
+}
+var RefImpl = class {
+  constructor(value, isShallow) {
+    // 使用 Dep 类型替代 Set<any>，提供更精确的类型约束
+    this.dep = createDep();
+    this.__v_isRef = true;
+    this.__v_isShallow = isShallow || void 0;
+    this._rawValue = isShallow ? value : toRaw(value);
+    this._value = isShallow ? value : toReactive(value);
+  }
+  get value() {
+    trackRefValue(this);
+    return this._value;
+  }
+  set value(newVal) {
+    const useDirectValue = this.__v_isShallow;
+    newVal = useDirectValue ? newVal : toRaw(newVal);
+    if (commonIs.hasChanged(newVal, this._rawValue)) {
+      const oldVal = this._rawValue;
+      this._rawValue = newVal;
+      this._value = useDirectValue ? newVal : toReactive(newVal);
+      triggerRefValue(this, newVal, oldVal);
+    }
+  }
+};
+var ShallowRefImpl = class {
+  constructor(value) {
+    // 使用 Dep 类型替代 Set<any>，提供更精确的类型约束
+    this.dep = createDep();
+    this.__v_isRef = true;
+    this.__v_isShallow = true;
+    this._rawValue = value;
+    this._value = value;
+  }
+  get value() {
+    trackRefValue(this);
+    return this._value;
+  }
+  set value(newVal) {
+    if (commonIs.hasChanged(newVal, this._rawValue)) {
+      const oldVal = this._rawValue;
+      this._rawValue = newVal;
+      this._value = newVal;
+      triggerRefValue(this, newVal, oldVal);
+    }
+  }
+};
+function trackRefValue(ref2) {
+  if (getShouldTrack() && getActiveEffect()) {
+    track(ref2, TrackOpTypes.GET, "value");
+  }
+}
+function triggerRefValue(ref2, newVal, oldVal) {
+  trigger(ref2, TriggerOpTypes.SET, "value", newVal, oldVal);
+}
+function ref(value) {
+  if (isRef(value)) {
+    return value;
+  }
+  return commonAssertions.unsafeCast(new RefImpl(value, false));
+}
+function shallowRef(value) {
+  if (isRef(value)) return commonAssertions.unsafeCast(value);
+  return commonAssertions.unsafeCast(new ShallowRefImpl(value));
+}
+function triggerRef(ref2) {
+  triggerRefValue(commonAssertions.unsafeCast(ref2), ref2.value);
+}
+function isShallowRef(r) {
+  return isRef(r) && !!r.__v_isShallow;
+}
+function isComputedRef(r) {
+  return isRef(r) && !!r.__v_isComputed;
+}
+function unref(r) {
+  return isRef(r) ? r.value : r;
+}
+function toRef(object, key) {
+  if (isRef(object[key])) return commonAssertions.unsafeCast(object[key]);
+  return commonAssertions.unsafeCast(new ObjectRefImpl(object, key));
+}
+function toRefs(object) {
+  const result = {};
+  for (const key in object) {
+    result[key] = toRef(object, key);
+  }
+  return result;
+}
+function customRef(factory) {
+  return commonAssertions.unsafeCast(new CustomRefImpl(factory));
+}
+function toValue(source) {
+  if (isRef(source)) return source.value;
+  if (typeof source === "function") {
+    return source();
+  }
+  return source;
+}
+var ObjectRefImpl = class {
+  constructor(_object, _key) {
+    this._object = _object;
+    this._key = _key;
+    this.__v_isRef = true;
+  }
+  get value() {
+    return this._object[this._key];
+  }
+  set value(newVal) {
+    this._object[this._key] = newVal;
+  }
+};
+var CustomRefImpl = class {
+  constructor(factory) {
+    this.__v_isRef = true;
+    this.dep = createDep();
+    const { get, set: set2 } = factory(
+      () => trackRefValue(this),
+      () => triggerRefValue(this)
+    );
+    this._getter = get;
+    this._setter = set2;
+  }
+  get value() {
+    return this._getter();
+  }
+  set value(newVal) {
+    this._setter(newVal);
+  }
+};
+function toReactive(value) {
+  return commonIs.isObject(value) ? reactive(value) : value;
+}
+var MAX_COMPUTED_DEPTH = 100;
+var computedDepth = 0;
+var computedStack = /* @__PURE__ */ new Set();
+var _a;
+_a = ComputedRefSymbol;
+var _ComputedRefImpl = class _ComputedRefImpl {
+  // 60秒后清理缓存
+  constructor(getter, _setter, isSSR) {
+    this._setter = _setter;
+    // 使用 Dep 类型替代 Set<any>，提供更精确的类型约束
+    this.dep = createDep();
+    this._dirty = true;
+    this._initialized = false;
+    this[_a] = true;
+    this.__v_isRef = true;
+    this.__v_isComputed = true;
+    // FIX: P2-6 计算属性缓存清理相关属性
+    this._cacheCleanupTimer = null;
+    this.effect = new ReactiveEffect(getter, () => {
+      if (!this._dirty) {
+        this._dirty = true;
+        triggerRefValue(this);
+      }
+      this._resetCacheCleanupTimer();
+    });
+    this.effect.computed = true;
+    const effect2 = this.effect;
+    effect2.onStop = () => {
+      this._cleanupCache();
+    };
+    if (isSSR) {
+      try {
+        this._value = getter();
+        this._dirty = false;
+      } catch (e) {
+        this._dirty = true;
+      }
+    }
+  }
+  // FIX: P2-6 重置缓存清理定时器
+  _resetCacheCleanupTimer() {
+    if (this._cacheCleanupTimer) {
+      clearTimeout(this._cacheCleanupTimer);
+    }
+    this._cacheCleanupTimer = setTimeout(() => {
+      if (!this.effect.active) {
+        this._cleanupCache();
+      }
+    }, _ComputedRefImpl.CACHE_CLEANUP_DELAY);
+  }
+  // FIX: P2-6 清理缓存值
+  _cleanupCache() {
+    if (!this.effect.active) {
+      if (this._cacheCleanupTimer) {
+        clearTimeout(this._cacheCleanupTimer);
+        this._cacheCleanupTimer = null;
+      }
+      this._value = commonAssertions.unsafeCast(void 0);
+      this._initialized = false;
+      this._dirty = true;
+    }
+  }
+  // FIX: P2-6 手动清理缓存的公共方法
+  /**
+   * 手动清理计算属性的缓存值。
+   * 在组件卸载时调用此方法可以释放内存。
+   */
+  cleanupCache() {
+    if (this._cacheCleanupTimer) {
+      clearTimeout(this._cacheCleanupTimer);
+      this._cacheCleanupTimer = null;
+    }
+    this._cleanupCache();
+  }
+  get value() {
+    trackRefValue(this);
+    if (this._dirty) {
+      if (this.effect.active) {
+        if (computedStack.has(this)) {
+          throw new Error(
+            `[LytJS/reactivity] Circular dependency detected in computed property. A computed property is indirectly referencing itself, causing an infinite loop.
+  Error Code: CIRCULAR_REFERENCE (4008) 
+  Suggestion: Check your computed property dependencies and avoid referencing the computed itself or other computeds that depend on it.`
+          );
+        }
+        computedDepth++;
+        if (computedDepth > MAX_COMPUTED_DEPTH) {
+          computedDepth--;
+          throw new Error(
+            `[LytJS/reactivity] Maximum computed depth exceeded (${MAX_COMPUTED_DEPTH}). Possible infinite loop in computed properties.
+  Error Code: CIRCULAR_REFERENCE (4008) 
+  Suggestion: Check for circular dependencies in your computed properties.`
+          );
+        }
+        computedStack.add(this);
+        try {
+          const value = this.effect.run();
+          if (value !== void 0) {
+            this._value = value;
+            this._initialized = true;
+          }
+          this._dirty = false;
+        } catch (e) {
+          if (this._initialized) {
+            this._dirty = false;
+          }
+          throw e;
+        } finally {
+          computedStack.delete(this);
+          computedDepth--;
+        }
+      }
+    }
+    return this._value;
+  }
+  set value(newValue) {
+    if (this._setter) {
+      this._setter(newValue);
+    }
+  }
+};
+_ComputedRefImpl.CACHE_CLEANUP_DELAY = 6e4;
+var ComputedRefImpl = _ComputedRefImpl;
+var _isSSR = false;
+function setSSRMode(isSSR) {
+  _isSSR = isSSR;
+}
+function computed2(getterOrOptions) {
+  let getter;
+  let setter;
+  if (commonIs.isFunction(getterOrOptions)) {
+    getter = getterOrOptions;
+    setter = void 0;
+  } else {
+    getter = getterOrOptions.get;
+    setter = getterOrOptions.set;
+  }
+  return new ComputedRefImpl(getter, setter, _isSSR);
+}
+function getSource(source) {
+  if (isRef(source)) return () => source.value;
+  if (commonIs.isObject(source) && isReactive(source)) return () => traverse(source);
+  if (typeof source === "function") return source;
+  return commonIs.NOOP;
+}
+var MAX_TRAVERSE_DEPTH = 100;
+function traverse(value, seen, depth = 0) {
+  const _seen = /* @__PURE__ */ new Set();
+  if (!commonIs.isObject(value) || _seen.has(value)) return value;
+  const stack = [{ value, depth }];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    const { value: val, depth: d } = current;
+    if (!commonIs.isObject(val) || _seen.has(val)) continue;
+    if (d > MAX_TRAVERSE_DEPTH) {
+      continue;
+    }
+    _seen.add(val);
+    if (commonIs.isArray(val)) {
+      for (let i = val.length - 1; i >= 0; i--) {
+        stack.push({ value: val[i], depth: d + 1 });
+      }
+    } else if (val instanceof Map) {
+      val.forEach((v, key) => {
+        stack.push({ value: v, depth: d + 1 });
+        if (commonIs.isObject(key)) {
+          stack.push({ value: key, depth: d + 1 });
+        }
+      });
+    } else if (val instanceof Set) {
+      val.forEach((v) => {
+        stack.push({ value: v, depth: d + 1 });
+      });
+    } else {
+      const keys = Object.keys(val);
+      for (let i = keys.length - 1; i >= 0; i--) {
+        stack.push({
+          value: val[keys[i]],
+          depth: d + 1
+        });
+      }
+    }
+  }
+  return value;
+}
+function watch(source, cb, options) {
+  const {
+    immediate,
+    deep,
+    flush = "pre",
+    once,
+    onTrack,
+    onTrigger,
+    scheduler: userScheduler
+  } = options || {};
+  let getter;
+  let forceTrigger = false;
+  let isMultiSource = false;
+  if (commonIs.isArray(source)) {
+    isMultiSource = true;
+    forceTrigger = source.some((s) => commonIs.isObject(s) && isReactive(s));
+    getter = () => source.map((s) => {
+      if (isRef(s)) return s.value;
+      if (commonIs.isObject(s) && isReactive(s)) return traverse(s);
+      if (commonIs.isFunction(s)) return s();
+      return void 0;
+    });
+  } else {
+    getter = getSource(source);
+    if (commonIs.isObject(source) && isReactive(source)) {
+      forceTrigger = true;
+    }
+  }
+  if (deep) {
+    const baseGetter = getter;
+    getter = () => traverse(baseGetter());
+  }
+  let oldValue = isMultiSource ? new Array(source.length).fill(void 0) : void 0;
+  const cleanupFns = [];
+  let isStopped = false;
+  let consecutiveErrors = 0;
+  const MAX_CONSECUTIVE_ERRORS = 3;
+  const onCleanup = (fn) => {
+    cleanupFns.push(fn);
+  };
+  const job = () => {
+    if (!watcher.active || isStopped) return;
+    if (cb) {
+      let newValue;
+      try {
+        newValue = watcher.run();
+        consecutiveErrors = 0;
+      } catch (e) {
+        consecutiveErrors++;
+        if (consecutiveErrors <= MAX_CONSECUTIVE_ERRORS) {
+          commonError.error(`Error in watch getter: ${e}`);
+        }
+        throw e;
+      }
+      if (deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => commonIs.hasChanged(v, oldValue[i])) : commonIs.hasChanged(newValue, oldValue))) {
+        if (cleanupFns.length > 0) {
+          cleanupFns.forEach((f) => f());
+          cleanupFns.length = 0;
+        }
+        try {
+          cb(
+            newValue,
+            oldValue,
+            onCleanup
+          );
+          consecutiveErrors = 0;
+        } catch (e) {
+          consecutiveErrors++;
+          if (consecutiveErrors <= MAX_CONSECUTIVE_ERRORS) {
+            commonError.error(`Error in watch callback: ${e}`);
+          }
+        }
+        oldValue = newValue;
+        if (once) {
+          isStopped = true;
+          watcher.stop();
+        }
+      }
+    } else {
+      try {
+        watcher.run();
+        consecutiveErrors = 0;
+      } catch (e) {
+        consecutiveErrors++;
+        if (consecutiveErrors <= MAX_CONSECUTIVE_ERRORS) {
+          commonError.error(`Error in watch effect run: ${e}`);
+        }
+        throw e;
+      }
+    }
+  };
+  const rawScheduler = userScheduler || (flush === "sync" ? job : () => {
+    if (flush === "post") {
+      commonScheduler.queuePostFlushCb(job);
+    } else {
+      commonScheduler.queuePreFlushCb(job);
+    }
+  });
+  const scheduler = userScheduler ? (...args) => rawScheduler(job, ...args) : rawScheduler;
+  const watcher = new ReactiveEffect(getter, scheduler);
+  watcher.onStop = () => {
+    if (cleanupFns.length > 0) {
+      for (let i = cleanupFns.length - 1; i >= 0; i--) {
+        cleanupFns[i]();
+      }
+      cleanupFns.length = 0;
+    }
+  };
+  if (immediate) {
+    job();
+  } else {
+    oldValue = watcher.run();
+  }
+  return () => {
+    if (isStopped) return;
+    isStopped = true;
+    watcher.stop();
+    getter = () => {
+    };
+    cleanupFns.length = 0;
+    cb = commonIs.NOOP;
+    oldValue = void 0;
+    consecutiveErrors = 0;
+  };
+}
+function watchEffect(effectFn, options) {
+  return doWatchEffect(effectFn, options);
+}
+function watchPostEffect(effectFn, options) {
+  return doWatchEffect(effectFn, { ...options, flush: "post" });
+}
+function watchSyncEffect(effectFn, options) {
+  return doWatchEffect(effectFn, { ...options, flush: "sync" });
+}
+function doWatchEffect(source, options = {}) {
+  const { flush = "pre", onTrack, onTrigger } = options;
+  const cleanupFns = [];
+  let isStopped = false;
+  const onCleanup = (fn) => {
+    cleanupFns.push(fn);
+  };
+  const getter = () => {
+    if (cleanupFns.length > 0) {
+      cleanupFns.forEach((f) => f());
+      cleanupFns.length = 0;
+    }
+    source(onCleanup);
+  };
+  let effectRef;
+  const schedulerFn = flush === "sync" ? () => effectRef?.run() : () => {
+    if (flush === "post") {
+      commonScheduler.queuePostFlushCb(() => effectRef?.run());
+    } else {
+      commonScheduler.queuePreFlushCb(() => effectRef?.run());
+    }
+  };
+  const currentEffect = new ReactiveEffect(getter, schedulerFn);
+  effectRef = currentEffect;
+  currentEffect.onStop = () => {
+    if (cleanupFns.length > 0) {
+      for (let i = cleanupFns.length - 1; i >= 0; i--) {
+        cleanupFns[i]();
+      }
+      cleanupFns.length = 0;
+    }
+  };
+  currentEffect.run();
+  return () => {
+    if (isStopped) return;
+    isStopped = true;
+    currentEffect.stop();
+    cleanupFns.length = 0;
+    source = commonIs.NOOP;
+    effectRef = void 0;
+  };
+}
+
+// src/batch.ts
+var scopeStack = [];
+var globalBatchDepth = 0;
+var MAX_NESTING_DEPTH = 100;
+function batchScope(callback, options = {}) {
+  const { async = false, name = "batchScope", onError } = options;
+  if (globalBatchDepth >= MAX_NESTING_DEPTH) {
+    const error3 = new Error(
+      `[lytjs/reactivity] Maximum batchScope nesting depth (${MAX_NESTING_DEPTH}) exceeded. This may indicate an infinite loop.`
+    );
+    if (onError) {
+      onError(error3);
+      throw error3;
+    }
+    throw error3;
+  }
+  const ctx = {
+    depth: globalBatchDepth,
+    name,
+    committed: false,
+    cancelled: false
+  };
+  scopeStack.push(ctx);
+  globalBatchDepth++;
+  try {
+    if (async) {
+      let result;
+      const promise = batchAsync(() => {
+        result = callback(ctx);
+      });
+      promise.then(() => {
+        ctx.committed = true;
+        scopeStack.pop();
+        globalBatchDepth--;
+      }).catch((error3) => {
+        scopeStack.pop();
+        globalBatchDepth--;
+        if (onError) {
+          onError(error3);
+        } else {
+          throw error3;
+        }
+      });
+      return result;
+    } else {
+      let result;
+      batch(() => {
+        result = callback(ctx);
+      });
+      ctx.committed = true;
+      if (result === void 0) {
+        throw new Error(
+          "[lytjs/reactivity] batchScope sync mode: callback returned undefined."
+        );
+      }
+      return result;
+    }
+  } catch (error3) {
+    if (onError) {
+      onError(error3);
+      throw error3;
+    }
+    throw error3;
+  } finally {
+    if (!async) {
+      scopeStack.pop();
+      globalBatchDepth--;
+    }
+  }
+}
+async function batchScopeAsync(callback, options = {}) {
+  const { name = "batchScopeAsync", onError } = options;
+  if (globalBatchDepth >= MAX_NESTING_DEPTH) {
+    const error3 = new Error(
+      `[lytjs/reactivity] Maximum batchScope nesting depth (${MAX_NESTING_DEPTH}) exceeded.`
+    );
+    if (onError) {
+      onError(error3);
+      return Promise.reject(error3);
+    }
+    return Promise.reject(error3);
+  }
+  const ctx = {
+    depth: globalBatchDepth,
+    name,
+    committed: false,
+    cancelled: false
+  };
+  scopeStack.push(ctx);
+  globalBatchDepth++;
+  try {
+    let result;
+    await batchAsync(async () => {
+      result = await callback(ctx);
+    });
+    ctx.committed = true;
+    return result;
+  } catch (error3) {
+    if (onError) {
+      onError(error3);
+      throw error3;
+    }
+    throw error3;
+  } finally {
+    scopeStack.pop();
+    globalBatchDepth--;
+  }
+}
+function batchScopeUntrack(fn) {
+  return untrack(fn);
+}
+function getBatchScopeDepth() {
+  return globalBatchDepth;
+}
+function getCurrentBatchScopeStack() {
+  return [...scopeStack];
+}
+function isInBatchScope() {
+  return globalBatchDepth > 0;
+}
+function flushBatchScopes() {
+  return Promise.resolve();
+}
+function _notifyDevToolsSignalChange(signalId, value) {
+  return;
+}
+function _notifyDevToolsEffectRun(effectId) {
+  return;
+}
+
+exports.ComputedRefSymbol = ComputedRefSymbol;
+exports.ReactiveSymbol = ReactiveSymbol;
+exports.ReadonlySymbol = ReadonlySymbol;
+exports.RefSymbol = RefSymbol;
+exports.ShallowRefSymbol = ShallowRefSymbol;
+exports._notifyDevToolsEffectRun = _notifyDevToolsEffectRun;
+exports._notifyDevToolsSignalChange = _notifyDevToolsSignalChange;
+exports.batch = batch;
+exports.batchAsync = batchAsync;
+exports.batchScope = batchScope;
+exports.batchScopeAsync = batchScopeAsync;
+exports.batchScopeUntrack = batchScopeUntrack;
+exports.computed = computed2;
+exports.computedSignal = computedSignal;
+exports.customRef = customRef;
+exports.effect = effect;
+exports.effectScope = effectScope;
+exports.enableTracking = enableTracking;
+exports.flushBatchScopes = flushBatchScopes;
+exports.getBatchScopeDepth = getBatchScopeDepth;
+exports.getCurrentBatchScopeStack = getCurrentBatchScopeStack;
+exports.getCurrentScope = getCurrentScope;
+exports.getSkippedTrackingCount = getSkippedTrackingCount;
+exports.isComputedRef = isComputedRef;
+exports.isInBatchScope = isInBatchScope;
+exports.isProxy = isProxy;
+exports.isReactive = isReactive;
+exports.isReadonly = isReadonly;
+exports.isRef = isRef;
+exports.isShallowRef = isShallowRef;
+exports.markRaw = markRaw;
+exports.onEffectCleanup = onEffectCleanup;
+exports.onScopeDispose = onScopeDispose;
+exports.pauseTracking = pauseTracking;
+exports.reactive = reactive;
+exports.readonly = readonly;
+exports.readonlySignal = readonlySignal;
+exports.ref = ref;
+exports.resetSkippedTrackingCount = resetSkippedTrackingCount;
+exports.resetTracking = resetTracking;
+exports.set = set;
+exports.setSSRMode = setSSRMode;
+exports.shallowReactive = shallowReactive;
+exports.shallowReadonly = shallowReadonly;
+exports.shallowRef = shallowRef;
+exports.shouldSkipTracking = shouldSkipTracking;
+exports.signal = signal;
+exports.signalBatch = signalBatch;
+exports.signalComputed = computed;
+exports.signalUntrack = signalUntrack;
+exports.stop = stop;
+exports.toRaw = toRaw;
+exports.toRef = toRef;
+exports.toRefs = toRefs;
+exports.toValue = toValue;
+exports.triggerRef = triggerRef;
+exports.unref = unref;
+exports.untrack = untrack;
+exports.update = update;
+exports.valueOf = valueOf;
+exports.watch = watch;
+exports.watchEffect = watchEffect;
+exports.watchPostEffect = watchPostEffect;
+exports.watchSyncEffect = watchSyncEffect;
+exports.withFirstRenderOptimization = withFirstRenderOptimization;
+exports.writableComputedSignal = writableComputedSignal;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map