@rpgjs/server 5.0.0-alpha.22 → 5.0.0-alpha.24

package/dist/index.js

@@ -4297,8 +4297,8 @@ const z = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
 	void: voidType
 }, Symbol.toStringTag, { value: 'Module' }));
 
-var __defProp$7 = Object.defineProperty;
-var __name$5 = (target, value) => __defProp$7(target, "name", { value, configurable: true });
+var __defProp$8 = Object.defineProperty;
+var __name$6 = (target, value) => __defProp$8(target, "name", { value, configurable: true });
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -5673,11 +5673,11 @@ function finalize$1(callback) {
     });
 }
 
-var __defProp$6 = Object.defineProperty;
-var __name$4 = (target, value) => __defProp$6(target, "name", { value, configurable: true });
-var ArraySubject$1 = class ArraySubject extends BehaviorSubject$1 {
+var __defProp$7 = Object.defineProperty;
+var __name$5 = (target, value) => __defProp$7(target, "name", { value, configurable: true });
+var ArraySubject$2 = class ArraySubject extends BehaviorSubject$1 {
   static {
-    __name$4(this, "ArraySubject");
+    __name$5(this, "ArraySubject");
   }
   _items = [];
   constructor(items = []) {
@@ -5689,7 +5689,7 @@ var ArraySubject$1 = class ArraySubject extends BehaviorSubject$1 {
   }
   createProxy(items) {
     this._items = new Proxy(items, {
-      get: /* @__PURE__ */ __name$4((target, prop, receiver) => {
+      get: /* @__PURE__ */ __name$5((target, prop, receiver) => {
         const origMethod = target[prop];
         if (typeof origMethod === "function") {
           return (...args) => {
@@ -5757,7 +5757,7 @@ var ArraySubject$1 = class ArraySubject extends BehaviorSubject$1 {
         }
         return Reflect.get(target, prop, receiver);
       }, "get"),
-      set: /* @__PURE__ */ __name$4((target, prop, value) => {
+      set: /* @__PURE__ */ __name$5((target, prop, value) => {
         const index = !isNaN(Number(prop)) ? Number(prop) : void 0;
         target[prop] = value;
         this.next({
@@ -5782,12 +5782,12 @@ var ArraySubject$1 = class ArraySubject extends BehaviorSubject$1 {
     });
   }
 };
-var isArraySubject$1 = /* @__PURE__ */ __name$4((value) => {
+var isArraySubject$1 = /* @__PURE__ */ __name$5((value) => {
   return "_items" in value;
 }, "isArraySubject");
-var ObjectSubject$1 = class ObjectSubject extends BehaviorSubject$1 {
+var ObjectSubject$2 = class ObjectSubject extends BehaviorSubject$1 {
   static {
-    __name$4(this, "ObjectSubject");
+    __name$5(this, "ObjectSubject");
   }
   _obj;
   constructor(obj = {}) {
@@ -5799,10 +5799,10 @@ var ObjectSubject$1 = class ObjectSubject extends BehaviorSubject$1 {
   }
   createProxy(obj) {
     this._obj = new Proxy(obj, {
-      get: /* @__PURE__ */ __name$4((target, prop, receiver) => {
+      get: /* @__PURE__ */ __name$5((target, prop, receiver) => {
         return Reflect.get(target, prop, receiver);
       }, "get"),
-      set: /* @__PURE__ */ __name$4((target, prop, value, receiver) => {
+      set: /* @__PURE__ */ __name$5((target, prop, value, receiver) => {
         const key = prop;
         const changeType = key in target ? "update" : "add";
         target[key] = value;
@@ -5813,7 +5813,7 @@ var ObjectSubject$1 = class ObjectSubject extends BehaviorSubject$1 {
         });
         return true;
       }, "set"),
-      deleteProperty: /* @__PURE__ */ __name$4((target, prop) => {
+      deleteProperty: /* @__PURE__ */ __name$5((target, prop) => {
         const key = prop;
         if (key in target) {
           const value = target[key];
@@ -5840,10 +5840,10 @@ var ObjectSubject$1 = class ObjectSubject extends BehaviorSubject$1 {
     });
   }
 };
-var isObjectSubject$1 = /* @__PURE__ */ __name$4((value) => {
+var isObjectSubject$1 = /* @__PURE__ */ __name$5((value) => {
   return "_obj" in value;
 }, "isObjectSubject");
-var getGlobalReactiveStore$1 = /* @__PURE__ */ __name$4(() => {
+var getGlobalReactiveStore$2 = /* @__PURE__ */ __name$5(() => {
   const globalKey = "__REACTIVE_STORE__";
   if (typeof globalThis !== "undefined") {
     if (!globalThis[globalKey]) {
@@ -5876,40 +5876,49 @@ var getGlobalReactiveStore$1 = /* @__PURE__ */ __name$4(() => {
   }
   return globalObj[globalKey];
 }, "getGlobalReactiveStore");
-var reactiveStore$1 = getGlobalReactiveStore$1();
-var trackDependency$1 = /* @__PURE__ */ __name$4((signal2) => {
-  if (reactiveStore$1.currentDependencyTracker) {
-    reactiveStore$1.currentDependencyTracker(signal2);
+var reactiveStore$2 = getGlobalReactiveStore$2();
+var trackDependency$2 = /* @__PURE__ */ __name$5((signal2) => {
+  if (reactiveStore$2.currentDependencyTracker) {
+    reactiveStore$2.currentDependencyTracker(signal2);
   }
 }, "trackDependency");
-function signal$1(defaultValue) {
+function signal$2(defaultValue, options) {
   let subject;
   if (Array.isArray(defaultValue)) {
-    subject = new ArraySubject$1(defaultValue);
+    subject = new ArraySubject$2(defaultValue);
   } else if (typeof defaultValue === "object" && defaultValue !== null) {
-    subject = new ObjectSubject$1(defaultValue);
+    subject = new ObjectSubject$2(defaultValue);
   } else {
     subject = new BehaviorSubject$1(defaultValue);
   }
-  const getValue = /* @__PURE__ */ __name$4(() => {
-    if (subject instanceof ArraySubject$1) {
+  const getValue = /* @__PURE__ */ __name$5(() => {
+    if (subject instanceof ArraySubject$2) {
       return subject.items;
-    } else if (subject instanceof ObjectSubject$1) {
+    } else if (subject instanceof ObjectSubject$2) {
       return subject.obj;
     }
     return subject.value;
   }, "getValue");
-  const fn = /* @__PURE__ */ __name$4(function() {
-    trackDependency$1(fn);
+  const fn = /* @__PURE__ */ __name$5(function() {
+    trackDependency$2(fn);
     return getValue();
   }, "fn");
   fn.set = (value) => {
-    if (subject instanceof ArraySubject$1) {
-      subject.items = value;
-    } else if (subject instanceof ObjectSubject$1) {
-      subject.obj = value;
+    const currentValue = getValue();
+    let shouldEmit = true;
+    if (options?.equal) {
+      shouldEmit = !options.equal(currentValue, value);
     } else {
-      subject.next(value);
+      shouldEmit = currentValue !== value;
+    }
+    if (shouldEmit) {
+      if (subject instanceof ArraySubject$2) {
+        subject.items = value;
+      } else if (subject instanceof ObjectSubject$2) {
+        subject.obj = value;
+      } else {
+        subject.next(value);
+      }
     }
   };
   fn._isFrozen = false;
@@ -5918,12 +5927,12 @@ function signal$1(defaultValue) {
   };
   fn.unfreeze = () => {
     fn._isFrozen = false;
-    if (subject instanceof ArraySubject$1) {
+    if (subject instanceof ArraySubject$2) {
       subject.next({
         type: "init",
         items: subject.items
       });
-    } else if (subject instanceof ObjectSubject$1) {
+    } else if (subject instanceof ObjectSubject$2) {
       subject.next({
         type: "init",
         value: subject.obj
@@ -5944,33 +5953,42 @@ function signal$1(defaultValue) {
   fn._subject = subject;
   return fn;
 }
-__name$4(signal$1, "signal");
-function isSignal$1(value) {
+__name$5(signal$2, "signal");
+function isSignal$2(value) {
   return !!(value && value.observable);
 }
-__name$4(isSignal$1, "isSignal");
-function isComputed$1(value) {
-  return isSignal$1(value) && !!value.dependencies;
+__name$5(isSignal$2, "isSignal");
+function isComputed$2(value) {
+  return isSignal$2(value) && !!value.dependencies;
 }
-__name$4(isComputed$1, "isComputed");
-function computed$1(computeFunction, disposableFn) {
+__name$5(isComputed$2, "isComputed");
+function computed$2(computeFunction, disposableFn) {
   const dependencies = /* @__PURE__ */ new Set();
   let init = true;
   let lastComputedValue;
-  const previousTracker = reactiveStore$1.currentDependencyTracker;
-  reactiveStore$1.currentDependencyTracker = (signal2) => {
+  const previousTracker = reactiveStore$2.currentDependencyTracker;
+  reactiveStore$2.currentDependencyTracker = (signal2) => {
     dependencies.add(signal2);
   };
   lastComputedValue = computeFunction();
   if (computeFunction["isEffect"]) {
     disposableFn = lastComputedValue;
   }
-  reactiveStore$1.currentDependencyTracker = previousTracker;
-  const computedObservable = combineLatest$1([
+  reactiveStore$2.currentDependencyTracker = previousTracker;
+  const observables = [
     ...dependencies
-  ].map((signal2) => signal2.observable)).pipe(filter$1(() => !init), map$1(() => computeFunction()), finalize$1(() => disposableFn?.()));
-  const fn = /* @__PURE__ */ __name$4(function() {
-    trackDependency$1(fn);
+  ].map((dep) => {
+    if (isComputed$2(dep) && "dependencies" in dep) {
+      const computedDep = dep;
+      if (computedDep.dependencies.size === 0) {
+        return new BehaviorSubject$1(computedDep()).asObservable();
+      }
+    }
+    return dep.observable;
+  });
+  const computedObservable = combineLatest$1(observables).pipe(filter$1(() => !init), map$1(() => computeFunction()), finalize$1(() => disposableFn?.()));
+  const fn = /* @__PURE__ */ __name$5(function() {
+    trackDependency$2(fn);
     return lastComputedValue;
   }, "fn");
   fn.observable = computedObservable;
@@ -5978,49 +5996,236 @@ function computed$1(computeFunction, disposableFn) {
     lastComputedValue = value;
   });
   fn.dependencies = dependencies;
-  reactiveStore$1.currentSubscriptionsTracker?.(fn.subscription);
+  reactiveStore$2.currentSubscriptionsTracker?.(fn.subscription);
   init = false;
   return fn;
 }
-__name$4(computed$1, "computed");
-function untracked$1(fn) {
-  const prevDepTracker = reactiveStore$1.currentDependencyTracker;
-  const prevSubTracker = reactiveStore$1.currentSubscriptionsTracker;
-  reactiveStore$1.currentDependencyTracker = null;
-  reactiveStore$1.currentSubscriptionsTracker = null;
+__name$5(computed$2, "computed");
+function linkedSignal(computationOrOptions, simpleOptions) {
+  const dependencies = /* @__PURE__ */ new Set();
+  let init = true;
+  let lastComputedValue;
+  let computeFunction;
+  let sourceSignal;
+  let computationFn;
+  let equalFn;
+  let previousValue;
+  let isOverridden = false;
+  let overriddenValue;
+  let depVersion = 0;
+  let overrideDepVersion = null;
+  if (typeof computationOrOptions === "function") {
+    computeFunction = computationOrOptions;
+    equalFn = simpleOptions?.equal;
+  } else {
+    const options = computationOrOptions;
+    sourceSignal = options.source;
+    computationFn = options.computation;
+    equalFn = options.equal;
+    if (typeof sourceSignal === "function" && !isSignal$2(sourceSignal)) {
+      const sourceFn = sourceSignal;
+      computeFunction = /* @__PURE__ */ __name$5(() => {
+        const sourceValue = sourceFn();
+        if (computationFn.length > 1) {
+          const result = computationFn(sourceValue, previousValue);
+          previousValue = {
+            source: sourceValue,
+            value: result
+          };
+          return result;
+        } else {
+          const result = computationFn(sourceValue);
+          previousValue = {
+            source: sourceValue,
+            value: result
+          };
+          return result;
+        }
+      }, "computeFunction");
+    } else {
+      const source = typeof sourceSignal === "function" ? sourceSignal : sourceSignal;
+      computeFunction = /* @__PURE__ */ __name$5(() => {
+        const sourceValue = source();
+        if (computationFn.length > 1) {
+          const result = computationFn(sourceValue, previousValue);
+          previousValue = {
+            source: sourceValue,
+            value: result
+          };
+          return result;
+        } else {
+          const result = computationFn(sourceValue);
+          previousValue = {
+            source: sourceValue,
+            value: result
+          };
+          return result;
+        }
+      }, "computeFunction");
+    }
+  }
+  const previousTracker = reactiveStore$2.currentDependencyTracker;
+  reactiveStore$2.currentDependencyTracker = (signal2) => {
+    dependencies.add(signal2);
+  };
+  if (sourceSignal && typeof sourceSignal === "function" && !isSignal$2(sourceSignal)) {
+    lastComputedValue = computeFunction();
+  } else if (sourceSignal && isSignal$2(sourceSignal)) {
+    dependencies.add(sourceSignal);
+    lastComputedValue = computeFunction();
+  } else {
+    lastComputedValue = computeFunction();
+  }
+  reactiveStore$2.currentDependencyTracker = previousTracker;
+  const subject = new BehaviorSubject$1(lastComputedValue);
+  const observables = [
+    ...dependencies
+  ].map((dep) => {
+    if (isComputed$2(dep) && "dependencies" in dep) {
+      const computedDep = dep;
+      if (computedDep.dependencies.size === 0) {
+        return new BehaviorSubject$1(computedDep()).asObservable();
+      }
+    }
+    return dep.observable;
+  });
+  let linkedObservable;
+  if (observables.length > 0) {
+    linkedObservable = combineLatest$1(observables).pipe(filter$1(() => !init), map$1(() => {
+      const computed2 = computeFunction();
+      if (equalFn) {
+        if (!equalFn(lastComputedValue, computed2)) {
+          lastComputedValue = computed2;
+          isOverridden = false;
+        }
+      } else {
+        if (lastComputedValue !== computed2) {
+          lastComputedValue = computed2;
+          isOverridden = false;
+        }
+      }
+      return lastComputedValue;
+    }));
+  } else {
+    linkedObservable = subject.asObservable().pipe(filter$1(() => !init));
+  }
+  const fn = /* @__PURE__ */ __name$5(function() {
+    trackDependency$2(fn);
+    if (isOverridden && dependencies.size > 0) {
+      if (overrideDepVersion !== depVersion) {
+        const computed2 = computeFunction();
+        isOverridden = false;
+        overriddenValue = void 0;
+        lastComputedValue = computed2;
+        overrideDepVersion = null;
+        return computed2;
+      }
+      return overriddenValue;
+    }
+    if (isOverridden) {
+      return overriddenValue;
+    }
+    if (dependencies.size === 0) {
+      const computed2 = computeFunction();
+      lastComputedValue = computed2;
+    }
+    return lastComputedValue;
+  }, "fn");
+  fn.observable = new Observable$1((observer) => {
+    const depSubscription = linkedObservable.subscribe((value) => {
+      if (dependencies.size > 0) {
+        depVersion++;
+        isOverridden = false;
+        overrideDepVersion = null;
+        lastComputedValue = value;
+      } else {
+        lastComputedValue = value;
+      }
+      observer.next(value);
+    });
+    let subjectSubscription;
+    if (dependencies.size === 0) {
+      subjectSubscription = subject.pipe(filter$1(() => !init)).subscribe((value) => {
+        observer.next(value);
+      });
+    }
+    observer.next(lastComputedValue);
+    return () => {
+      depSubscription.unsubscribe();
+      if (subjectSubscription) {
+        subjectSubscription.unsubscribe();
+      }
+    };
+  });
+  fn.subscription = fn.observable.subscribe(() => {
+  });
+  fn.dependencies = dependencies;
+  fn._subject = subject;
+  fn.set = (value) => {
+    if (!isOverridden) {
+      overrideDepVersion = depVersion;
+      if (computationFn && sourceSignal) {
+        const sourceValue = untracked$2(() => {
+          if (typeof sourceSignal === "function") {
+            const source = sourceSignal;
+            return isSignal$2(source) ? source() : sourceSignal();
+          }
+          return sourceSignal();
+        });
+        previousValue = {
+          source: sourceValue,
+          value
+        };
+      }
+    }
+    isOverridden = true;
+    overriddenValue = value;
+    lastComputedValue = value;
+    subject.next(value);
+  };
+  reactiveStore$2.currentSubscriptionsTracker?.(fn.subscription);
+  init = false;
+  return fn;
+}
+__name$5(linkedSignal, "linkedSignal");
+function untracked$2(fn) {
+  const prevDepTracker = reactiveStore$2.currentDependencyTracker;
+  const prevSubTracker = reactiveStore$2.currentSubscriptionsTracker;
+  reactiveStore$2.currentDependencyTracker = null;
+  reactiveStore$2.currentSubscriptionsTracker = null;
   try {
     return fn();
   } finally {
-    reactiveStore$1.currentDependencyTracker = prevDepTracker;
-    reactiveStore$1.currentSubscriptionsTracker = prevSubTracker;
+    reactiveStore$2.currentDependencyTracker = prevDepTracker;
+    reactiveStore$2.currentSubscriptionsTracker = prevSubTracker;
   }
 }
-__name$4(untracked$1, "untracked");
+__name$5(untracked$2, "untracked");
 
 // src/effect.ts
-function effect$1(fn) {
+function effect$2(fn) {
   fn["isEffect"] = true;
-  return computed$1(fn);
+  return computed$2(fn);
 }
-__name$4(effect$1, "effect");
+__name$5(effect$2, "effect");
 
 // src/utils.ts
 function isFunction$3(val) {
   return {}.toString.call(val) === "[object Function]";
 }
-__name$5(isFunction$3, "isFunction");
+__name$6(isFunction$3, "isFunction");
 function isClass$2(obj) {
   return typeof obj === "function" && obj.prototype && obj.prototype.constructor === obj;
 }
-__name$5(isClass$2, "isClass");
-var isObject$2 = /* @__PURE__ */ __name$5((item) => item && typeof item === "object" && !Array.isArray(item) && item !== null, "isObject");
+__name$6(isClass$2, "isClass");
+var isObject$2 = /* @__PURE__ */ __name$6((item) => item && typeof item === "object" && !Array.isArray(item) && item !== null, "isObject");
 function isInstanceOfClass$1(value) {
   if (value === null || typeof value !== "object" || value === void 0 || Array.isArray(value)) {
     return false;
   }
   return Object.getPrototypeOf(value) !== Object.prototype;
 }
-__name$5(isInstanceOfClass$1, "isInstanceOfClass");
+__name$6(isInstanceOfClass$1, "isInstanceOfClass");
 function generateShortUUID$2() {
   const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
   let uuid = "";
@@ -6030,27 +6235,27 @@ function generateShortUUID$2() {
   }
   return uuid;
 }
-__name$5(generateShortUUID$2, "generateShortUUID");
+__name$6(generateShortUUID$2, "generateShortUUID");
 
 // src/core.ts
 var DELETE_TOKEN$1 = "$delete";
-var syncClass = /* @__PURE__ */ __name$5((instance, options = {}) => {
+var syncClass = /* @__PURE__ */ __name$6((instance, options = {}) => {
   const cacheSync = /* @__PURE__ */ new Map();
   const cachePersist = /* @__PURE__ */ new Map();
   instance.$valuesChanges = {
-    set: /* @__PURE__ */ __name$5((path, value) => {
+    set: /* @__PURE__ */ __name$6((path, value) => {
       cacheSync.set(path, value);
       options.onSync?.(cacheSync);
     }, "set"),
-    setPersist: /* @__PURE__ */ __name$5((path, value) => {
+    setPersist: /* @__PURE__ */ __name$6((path, value) => {
       if (path == "") path = ".";
       cachePersist.set(path, value);
       options.onPersist?.(cachePersist);
     }, "setPersist"),
-    has: /* @__PURE__ */ __name$5((path) => {
+    has: /* @__PURE__ */ __name$6((path) => {
       return cacheSync.has(path);
     }, "has"),
-    get: /* @__PURE__ */ __name$5((path) => {
+    get: /* @__PURE__ */ __name$6((path) => {
       return cacheSync.get(path);
     }, "get")
   };
@@ -6073,20 +6278,20 @@ function createStatesSnapshot$1(instance) {
   }
   return persistObject;
 }
-__name$5(createStatesSnapshot$1, "createStatesSnapshot");
+__name$6(createStatesSnapshot$1, "createStatesSnapshot");
 function setMetadata$1(target, key, value) {
   const meta = target.constructor._propertyMetadata;
   const propId = meta?.get(key);
   if (propId) {
-    if (isSignal$1(target[propId])) {
+    if (isSignal$2(target[propId])) {
       target[propId].set(value);
     } else {
       target[propId] = value;
     }
   }
 }
-__name$5(setMetadata$1, "setMetadata");
-var createSyncClass$1 = /* @__PURE__ */ __name$5((currentClass, parentKey = null, parentClass = null, path = "") => {
+__name$6(setMetadata$1, "setMetadata");
+var createSyncClass$1 = /* @__PURE__ */ __name$6((currentClass, parentKey = null, parentClass = null, path = "") => {
   currentClass.$path = path;
   if (parentClass) {
     currentClass.$valuesChanges = parentClass.$valuesChanges;
@@ -6117,7 +6322,7 @@ var createSyncClass$1 = /* @__PURE__ */ __name$5((currentClass, parentKey = null
       if (persist2) {
         if (parentClass) currentClass.$valuesChanges.setPersist(path, transformedValue);
       }
-      if (isComputed$1(signal)) {
+      if (isComputed$2(signal)) {
         signal.observable.subscribe((newValue) => {
           if (syncToClient) {
             const transformedNewValue = transform ? transform(newValue) : newValue;
@@ -6128,10 +6333,10 @@ var createSyncClass$1 = /* @__PURE__ */ __name$5((currentClass, parentKey = null
     }
   }
 }, "createSyncClass");
-var type$1 = /* @__PURE__ */ __name$5((_signal, path, options = {}, currentInstance) => {
+var type$1 = /* @__PURE__ */ __name$6((_signal, path, options = {}, currentInstance) => {
   const { syncToClient = true, persist: persist2 = true, transform } = options;
   let init = true;
-  const handleObjectSubject = /* @__PURE__ */ __name$5((value, propPath) => {
+  const handleObjectSubject = /* @__PURE__ */ __name$6((value, propPath) => {
     const newPath = `${propPath}${value.key ? `.${value.key}` : ""}`;
     if ([
       "add",
@@ -6149,7 +6354,7 @@ var type$1 = /* @__PURE__ */ __name$5((_signal, path, options = {}, currentInsta
       savePath(newPath, DELETE_TOKEN$1);
     }
   }, "handleObjectSubject");
-  const handleArraySubject = /* @__PURE__ */ __name$5((value, propPath) => {
+  const handleArraySubject = /* @__PURE__ */ __name$6((value, propPath) => {
     if (value.type === "reset" && Array.isArray(value.items)) {
       value.items.forEach((item, index) => {
         const newPath2 = `${propPath}.${index}`;
@@ -6178,7 +6383,7 @@ var type$1 = /* @__PURE__ */ __name$5((_signal, path, options = {}, currentInsta
       savePath(newPath, DELETE_TOKEN$1);
     }
   }, "handleArraySubject");
-  const savePath = /* @__PURE__ */ __name$5((propPath, value) => {
+  const savePath = /* @__PURE__ */ __name$6((propPath, value) => {
     const transformedValue = transform && value !== DELETE_TOKEN$1 ? transform(value) : value;
     if (syncToClient) {
       currentInstance.$valuesChanges.set(propPath, transformedValue);
@@ -6187,8 +6392,8 @@ var type$1 = /* @__PURE__ */ __name$5((_signal, path, options = {}, currentInsta
       currentInstance.$valuesChanges.setPersist(transformedValue == DELETE_TOKEN$1 ? propPath : currentInstance.$path, transformedValue);
     }
   }, "savePath");
-  const setupSubscription = /* @__PURE__ */ __name$5((signal, signalPath) => {
-    if (!isSignal$1(signal)) return;
+  const setupSubscription = /* @__PURE__ */ __name$6((signal, signalPath) => {
+    if (!isSignal$2(signal)) return;
     if (syncToClient && currentInstance.$valuesChanges) {
       const initialValue = signal();
       const transformedInitialValue = transform ? transform(initialValue) : initialValue;
@@ -6199,7 +6404,7 @@ var type$1 = /* @__PURE__ */ __name$5((_signal, path, options = {}, currentInsta
       if (init) return;
       if (currentInstance.$path !== void 0) {
         const fullPath = `${currentInstance.$path ? currentInstance.$path + "." : ""}${signalPath}`;
-        if (isComputed$1(signal)) {
+        if (isComputed$2(signal)) {
           savePath(fullPath, value);
         } else if (isObjectSubject$1(signal._subject)) {
           handleObjectSubject(value, fullPath);
@@ -6215,13 +6420,13 @@ var type$1 = /* @__PURE__ */ __name$5((_signal, path, options = {}, currentInsta
     }
     currentInstance.$snapshot.set(path, signal);
   }, "setupSubscription");
-  if (!isSignal$1(_signal)) {
+  if (!isSignal$2(_signal)) {
     if (_signal && typeof _signal === "object" && !Array.isArray(_signal)) {
       for (const key in _signal) {
         if (Object.prototype.hasOwnProperty.call(_signal, key)) {
           const value = _signal[key];
           const propertyPath = `${path}.${key}`;
-          if (isSignal$1(value)) {
+          if (isSignal$2(value)) {
             setupSubscription(value, propertyPath);
           } else if (value && typeof value === "object" && !Array.isArray(value)) {
             type$1(value, propertyPath, options, currentInstance);
@@ -6259,10 +6464,10 @@ function sync$1(options) {
   }
   return function(target, propertyKey) {
     const privatePropertyKey = `__${propertyKey}`;
-    const getter = /* @__PURE__ */ __name$5(function() {
+    const getter = /* @__PURE__ */ __name$6(function() {
       return this[privatePropertyKey];
     }, "getter");
-    const setter = /* @__PURE__ */ __name$5(function(newVal) {
+    const setter = /* @__PURE__ */ __name$6(function(newVal) {
       this[privatePropertyKey] = type$1(newVal, propertyKey, {
         classType,
         persist: persist2,
@@ -6278,7 +6483,7 @@ function sync$1(options) {
     });
   };
 }
-__name$5(sync$1, "sync");
+__name$6(sync$1, "sync");
 function id$1() {
   return function(target, propertyKey) {
     if (!target.constructor._propertyMetadata) {
@@ -6287,7 +6492,7 @@ function id$1() {
     target.constructor._propertyMetadata.set("id", propertyKey);
   };
 }
-__name$5(id$1, "id");
+__name$6(id$1, "id");
 function users$1(options) {
   return function(target, propertyKey) {
     if (!target.constructor._propertyMetadata) {
@@ -6297,14 +6502,14 @@ function users$1(options) {
     sync$1(options)(target, propertyKey);
   };
 }
-__name$5(users$1, "users");
+__name$6(users$1, "users");
 function persist$1() {
   return sync$1({
     persist: true,
     syncToClient: false
   });
 }
-__name$5(persist$1, "persist");
+__name$6(persist$1, "persist");
 function connected$1() {
   return function(target, propertyKey) {
     if (!target.constructor._propertyMetadata) {
@@ -6316,7 +6521,7 @@ function connected$1() {
     })(target, propertyKey);
   };
 }
-__name$5(connected$1, "connected");
+__name$6(connected$1, "connected");
 function load$1(rootInstance, values, valueIsObject) {
   if (valueIsObject) {
     loadFromObject$1(rootInstance, values);
@@ -6324,14 +6529,14 @@ function load$1(rootInstance, values, valueIsObject) {
     loadFromPaths$1(rootInstance, values);
   }
 }
-__name$5(load$1, "load");
+__name$6(load$1, "load");
 function loadFromPaths$1(rootInstance, values) {
   for (const [path, value] of Object.entries(values)) {
     const parts = path.split(".");
     loadValue$1(rootInstance, parts, value);
   }
 }
-__name$5(loadFromPaths$1, "loadFromPaths");
+__name$6(loadFromPaths$1, "loadFromPaths");
 function loadFromObject$1(rootInstance, values, currentPath = "") {
   for (let key in values) {
     const value = values[key];
@@ -6344,26 +6549,26 @@ function loadFromObject$1(rootInstance, values, currentPath = "") {
     }
   }
 }
-__name$5(loadFromObject$1, "loadFromObject");
+__name$6(loadFromObject$1, "loadFromObject");
 function loadValue$1(rootInstance, parts, value) {
   let current = rootInstance;
   for (let i = 0; i < parts.length; i++) {
     const part = parts[i];
     if (i === parts.length - 1) {
       if (value == DELETE_TOKEN$1) {
-        if (isSignal$1(current)) {
+        if (isSignal$2(current)) {
           current = current();
         }
         Reflect.deleteProperty(current, part);
       } else if (current[part]?._subject) {
         current[part].set(value);
-      } else if (isSignal$1(current) && Array.isArray(current()) && !isNaN(Number(part))) {
+      } else if (isSignal$2(current) && Array.isArray(current()) && !isNaN(Number(part))) {
         current()[Number(part)] = value;
       } else {
         current[part] = value;
       }
     } else {
-      if (isSignal$1(current)) {
+      if (isSignal$2(current)) {
         current = current();
       }
       const currentValue = current[part];
@@ -6381,12 +6586,12 @@ function loadValue$1(rootInstance, parts, value) {
     }
   }
 }
-__name$5(loadValue$1, "loadValue");
+__name$6(loadValue$1, "loadValue");
 function getByPath$1(root, path) {
   const parts = path.split(".");
   let current = root;
   for (const part of parts) {
-    if (isSignal$1(current)) {
+    if (isSignal$2(current)) {
       current = current();
     }
     if (current[part]) {
@@ -6397,7 +6602,332 @@ function getByPath$1(root, path) {
   }
   return current;
 }
-__name$5(getByPath$1, "getByPath");
+__name$6(getByPath$1, "getByPath");
+
+var __defProp$6 = Object.defineProperty;
+var __name$4 = (target, value) => __defProp$6(target, "name", { value, configurable: true });
+var ArraySubject$1 = class ArraySubject extends BehaviorSubject$1 {
+  static {
+    __name$4(this, "ArraySubject");
+  }
+  _items = [];
+  constructor(items = []) {
+    super({
+      type: "init",
+      items
+    });
+    this.createProxy(items);
+  }
+  createProxy(items) {
+    this._items = new Proxy(items, {
+      get: /* @__PURE__ */ __name$4((target, prop, receiver) => {
+        const origMethod = target[prop];
+        if (typeof origMethod === "function") {
+          return (...args) => {
+            let changeType = "update";
+            let index = void 0;
+            let isMutateFn = false;
+            let itemsToEmit = [];
+            let changeSplice = true;
+            switch (prop) {
+              case "push":
+                index = target.length;
+                changeType = "add";
+                isMutateFn = true;
+                break;
+              case "pop":
+                index = target.length - 1;
+                changeType = "remove";
+                isMutateFn = true;
+                break;
+              case "unshift":
+                index = 0;
+                changeType = "add";
+                isMutateFn = true;
+                break;
+              case "shift":
+                index = 0;
+                changeType = "remove";
+                isMutateFn = true;
+                break;
+              case "splice":
+                index = args[0];
+                const deleteCount = args[1];
+                const newItems = args.slice(2);
+                itemsToEmit = newItems;
+                if (deleteCount > 0 && newItems.length === 0) {
+                  changeType = "remove";
+                } else if (deleteCount === 0 && newItems.length > 0) {
+                  changeType = "add";
+                } else if (deleteCount === 0 && newItems.length === 0) {
+                  changeSplice = false;
+                } else {
+                  changeType = "update";
+                }
+                isMutateFn = true;
+                break;
+            }
+            const result = origMethod.apply(target, args);
+            if (isMutateFn && changeSplice) {
+              if (prop === "splice") {
+                this.next({
+                  type: changeType,
+                  index,
+                  items: itemsToEmit
+                });
+              } else {
+                this.next({
+                  type: changeType,
+                  index,
+                  items: args
+                });
+              }
+            }
+            return result;
+          };
+        }
+        return Reflect.get(target, prop, receiver);
+      }, "get"),
+      set: /* @__PURE__ */ __name$4((target, prop, value) => {
+        const index = !isNaN(Number(prop)) ? Number(prop) : void 0;
+        target[prop] = value;
+        this.next({
+          type: "update",
+          index,
+          items: [
+            value
+          ]
+        });
+        return true;
+      }, "set")
+    });
+  }
+  get items() {
+    return this._items;
+  }
+  set items(newItems) {
+    this.createProxy(newItems);
+    this.next({
+      type: "reset",
+      items: newItems
+    });
+  }
+};
+var ObjectSubject$1 = class ObjectSubject extends BehaviorSubject$1 {
+  static {
+    __name$4(this, "ObjectSubject");
+  }
+  _obj;
+  constructor(obj = {}) {
+    super({
+      type: "init",
+      value: obj
+    });
+    this.createProxy(obj);
+  }
+  createProxy(obj) {
+    this._obj = new Proxy(obj, {
+      get: /* @__PURE__ */ __name$4((target, prop, receiver) => {
+        return Reflect.get(target, prop, receiver);
+      }, "get"),
+      set: /* @__PURE__ */ __name$4((target, prop, value, receiver) => {
+        const key = prop;
+        const changeType = key in target ? "update" : "add";
+        target[key] = value;
+        this.next({
+          type: changeType,
+          key,
+          value
+        });
+        return true;
+      }, "set"),
+      deleteProperty: /* @__PURE__ */ __name$4((target, prop) => {
+        const key = prop;
+        if (key in target) {
+          const value = target[key];
+          delete target[key];
+          this.next({
+            type: "remove",
+            key,
+            value
+          });
+          return true;
+        }
+        return false;
+      }, "deleteProperty")
+    });
+  }
+  get obj() {
+    return this._obj;
+  }
+  set obj(newObj) {
+    this.createProxy(newObj);
+    this.next({
+      type: "reset",
+      value: newObj
+    });
+  }
+};
+var getGlobalReactiveStore$1 = /* @__PURE__ */ __name$4(() => {
+  const globalKey = "__REACTIVE_STORE__";
+  if (typeof globalThis !== "undefined") {
+    if (!globalThis[globalKey]) {
+      globalThis[globalKey] = {
+        currentDependencyTracker: null,
+        currentSubscriptionsTracker: null
+      };
+    }
+    return globalThis[globalKey];
+  }
+  let globalObj;
+  if (typeof window !== "undefined") {
+    globalObj = window;
+  } else if (typeof process !== "undefined" && process.versions && process.versions.node) {
+    globalObj = Function("return this")();
+  } else if (typeof self !== "undefined") {
+    globalObj = self;
+  } else {
+    console.warn("Unable to find global object, using local instance");
+    return {
+      currentDependencyTracker: null,
+      currentSubscriptionsTracker: null
+    };
+  }
+  if (!globalObj[globalKey]) {
+    globalObj[globalKey] = {
+      currentDependencyTracker: null,
+      currentSubscriptionsTracker: null
+    };
+  }
+  return globalObj[globalKey];
+}, "getGlobalReactiveStore");
+var reactiveStore$1 = getGlobalReactiveStore$1();
+var trackDependency$1 = /* @__PURE__ */ __name$4((signal2) => {
+  if (reactiveStore$1.currentDependencyTracker) {
+    reactiveStore$1.currentDependencyTracker(signal2);
+  }
+}, "trackDependency");
+function signal$1(defaultValue) {
+  let subject;
+  if (Array.isArray(defaultValue)) {
+    subject = new ArraySubject$1(defaultValue);
+  } else if (typeof defaultValue === "object" && defaultValue !== null) {
+    subject = new ObjectSubject$1(defaultValue);
+  } else {
+    subject = new BehaviorSubject$1(defaultValue);
+  }
+  const getValue = /* @__PURE__ */ __name$4(() => {
+    if (subject instanceof ArraySubject$1) {
+      return subject.items;
+    } else if (subject instanceof ObjectSubject$1) {
+      return subject.obj;
+    }
+    return subject.value;
+  }, "getValue");
+  const fn = /* @__PURE__ */ __name$4(function() {
+    trackDependency$1(fn);
+    return getValue();
+  }, "fn");
+  fn.set = (value) => {
+    if (subject instanceof ArraySubject$1) {
+      subject.items = value;
+    } else if (subject instanceof ObjectSubject$1) {
+      subject.obj = value;
+    } else {
+      subject.next(value);
+    }
+  };
+  fn._isFrozen = false;
+  fn.freeze = () => {
+    fn._isFrozen = true;
+  };
+  fn.unfreeze = () => {
+    fn._isFrozen = false;
+    if (subject instanceof ArraySubject$1) {
+      subject.next({
+        type: "init",
+        items: subject.items
+      });
+    } else if (subject instanceof ObjectSubject$1) {
+      subject.next({
+        type: "init",
+        value: subject.obj
+      });
+    } else {
+      subject.next(subject.value);
+    }
+  };
+  fn.mutate = (mutateFn) => {
+    const value = getValue();
+    mutateFn(value);
+  };
+  fn.update = (updateFn) => {
+    const updatedValue = updateFn(getValue());
+    fn.set(updatedValue);
+  };
+  fn.observable = subject.asObservable().pipe(filter$1(() => !fn._isFrozen));
+  fn._subject = subject;
+  return fn;
+}
+__name$4(signal$1, "signal");
+function isSignal$1(value) {
+  return !!(value && value.observable);
+}
+__name$4(isSignal$1, "isSignal");
+function isComputed$1(value) {
+  return isSignal$1(value) && !!value.dependencies;
+}
+__name$4(isComputed$1, "isComputed");
+function computed$1(computeFunction, disposableFn) {
+  const dependencies = /* @__PURE__ */ new Set();
+  let init = true;
+  let lastComputedValue;
+  const previousTracker = reactiveStore$1.currentDependencyTracker;
+  reactiveStore$1.currentDependencyTracker = (signal2) => {
+    dependencies.add(signal2);
+  };
+  lastComputedValue = computeFunction();
+  if (computeFunction["isEffect"]) {
+    disposableFn = lastComputedValue;
+  }
+  reactiveStore$1.currentDependencyTracker = previousTracker;
+  const computedObservable = combineLatest$1([
+    ...dependencies
+  ].map((signal2) => signal2.observable)).pipe(filter$1(() => !init), map$1(() => computeFunction()), finalize$1(() => disposableFn?.()));
+  const fn = /* @__PURE__ */ __name$4(function() {
+    trackDependency$1(fn);
+    return lastComputedValue;
+  }, "fn");
+  fn.observable = computedObservable;
+  fn.subscription = computedObservable.subscribe((value) => {
+    lastComputedValue = value;
+  });
+  fn.dependencies = dependencies;
+  reactiveStore$1.currentSubscriptionsTracker?.(fn.subscription);
+  init = false;
+  return fn;
+}
+__name$4(computed$1, "computed");
+function untracked$1(fn) {
+  const prevDepTracker = reactiveStore$1.currentDependencyTracker;
+  const prevSubTracker = reactiveStore$1.currentSubscriptionsTracker;
+  reactiveStore$1.currentDependencyTracker = null;
+  reactiveStore$1.currentSubscriptionsTracker = null;
+  try {
+    return fn();
+  } finally {
+    reactiveStore$1.currentDependencyTracker = prevDepTracker;
+    reactiveStore$1.currentSubscriptionsTracker = prevSubTracker;
+  }
+}
+__name$4(untracked$1, "untracked");
+
+// src/effect.ts
+function effect$1(fn) {
+  fn["isEffect"] = true;
+  return computed$1(fn);
+}
+__name$4(effect$1, "effect");
 
 var __defProp$5 = Object.defineProperty;
 var __name$3 = (target, value) => __defProp$5(target, "name", { value, configurable: true });
@@ -20572,14 +21102,14 @@ function WithParameterManager(Base) {
        * console.log(player.param[MAXHP]); // Updated value
        * ```
        */
-      this._paramsModifierSignal = signal$1({});
+      this._paramsModifierSignal = signal$2({});
       /**
        * Signal for base parameters configuration
        * 
        * Stores the start and end values for each parameter's level curve.
        * Changes to this signal trigger recalculation of all parameter values.
        */
-      this._parametersSignal = signal$1({});
+      this._parametersSignal = signal$2({});
       /**
        * Computed signal for all parameter values
        * 
@@ -20596,7 +21126,7 @@ function WithParameterManager(Base) {
        * console.log(player.param[MAXHP]); // New calculated value
        * ```
        */
-      this._param = type$1(computed$1(() => {
+      this._param = type$1(computed$2(() => {
         const obj = {};
         const parameters = this._parametersSignal();
         const level = this._level();
@@ -21609,7 +22139,7 @@ function WithStateManager(Base) {
   return class extends Base {
     constructor() {
       super(...arguments);
-      this._statesEfficiency = signal$1([]);
+      this._statesEfficiency = signal$2([]);
     }
     get statesDefense() {
       return this.getFeature("statesDefense", "state");
@@ -21725,7 +22255,7 @@ const _RpgPlayer = class _RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
     /** Last processed client input frame for reconciliation with server tick */
     this._lastFramePositions = null;
     this.frames = [];
-    this.events = signal$1([]);
+    this.events = signal$2([]);
     this.expCurve = {
       basis: 30,
       extra: 20,
@@ -22551,7 +23081,7 @@ const _RpgPlayer = class _RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
    */
   setSync(schema) {
     for (let key in schema) {
-      this[key] = type$1(signal$1(null), key, {
+      this[key] = type$1(signal$2(null), key, {
         syncWithClient: schema[key]?.$syncWithClient,
         persist: schema[key]?.$permanent
       }, this);
@@ -26096,8 +26626,8 @@ const MapUpdateSchema = object({
 let RpgMap = class extends RpgCommonMap {
   constructor() {
     super();
-    this.players = signal$1({});
-    this.events = signal$1({});
+    this.players = signal$2({});
+    this.events = signal$2({});
     /** 
      * Signal containing the map's database of items, classes, and other game data
      * 
@@ -26114,7 +26644,7 @@ let RpgMap = class extends RpgCommonMap {
      * const potion = map.database()['Potion'];
      * ```
      */
-    this.database = signal$1({});
+    this.database = signal$2({});
     /** 
      * Array of map configurations - can contain MapOptions objects or instances of map classes
      * 
@@ -27287,7 +27817,7 @@ let RpgMap = class extends RpgCommonMap {
     for (let key in schema) {
       const initial = typeof schema[key]?.$initial !== "undefined" ? schema[key].$initial : null;
       const holder = {};
-      this[key] = type$1(signal$1(initial), key, {
+      this[key] = type$1(signal$2(initial), key, {
         syncToClient: schema[key]?.$syncWithClient,
         persist: schema[key]?.$permanent
       }, holder);
@@ -27671,7 +28201,7 @@ var __decorateClass = (decorators, target, key, kind) => {
 };
 let LobbyRoom = class {
   constructor() {
-    this.players = signal$1({});
+    this.players = signal$2({});
   }
   onJoin(player, conn) {
     player.map = this;
@@ -28075,5 +28605,5 @@ function MapData(options) {
   };
 }
 
-export { AGI, AGI_CURVE, ATK, ArraySubject$1 as ArraySubject, COEFFICIENT_ELEMENTS, Components, DAMAGE_CRITICAL, DAMAGE_GUARD, DAMAGE_PHYSIC, DAMAGE_SKILL, DEX, DEX_CURVE, DialogGui, DialogPosition, EventData, EventMode, Frequency, Gui, INT, INT_CURVE, MAXHP, MAXHP_CURVE, MAXSP, MAXSP_CURVE, MapData, MenuGui, Move, NotificationGui, ObjectSubject$1 as ObjectSubject, PDEF, RpgEvent, RpgMap, RpgModule, RpgPlayer, RpgServerEngine, RpgShape, SDEF, STR, STR_CURVE, ShopGui, Speed, WithMoveManager, clearInject, computed$1 as computed, context, createServer, effect$1 as effect, inject, isArraySubject$1 as isArraySubject, isComputed$1 as isComputed, isObjectSubject$1 as isObjectSubject, isSignal$1 as isSignal, provideServerModules, setInject, signal$1 as signal, untracked$1 as untracked };
+export { AGI, AGI_CURVE, ATK, ArraySubject$2 as ArraySubject, COEFFICIENT_ELEMENTS, Components, DAMAGE_CRITICAL, DAMAGE_GUARD, DAMAGE_PHYSIC, DAMAGE_SKILL, DEX, DEX_CURVE, DialogGui, DialogPosition, EventData, EventMode, Frequency, Gui, INT, INT_CURVE, MAXHP, MAXHP_CURVE, MAXSP, MAXSP_CURVE, MapData, MenuGui, Move, NotificationGui, ObjectSubject$2 as ObjectSubject, PDEF, RpgEvent, RpgMap, RpgModule, RpgPlayer, RpgServerEngine, RpgShape, SDEF, STR, STR_CURVE, ShopGui, Speed, WithMoveManager, clearInject, computed$2 as computed, context, createServer, effect$2 as effect, inject, isArraySubject$1 as isArraySubject, isComputed$2 as isComputed, isObjectSubject$1 as isObjectSubject, isSignal$2 as isSignal, linkedSignal, provideServerModules, setInject, signal$2 as signal, untracked$2 as untracked };
 //# sourceMappingURL=index.js.map