@rpgjs/server 5.0.0-alpha.18 → 5.0.0-alpha.19

package/dist/index.js

@@ -6099,23 +6099,29 @@ var createSyncClass$1 = /* @__PURE__ */ __name$5((currentClass, parentKey = null
       const signal = currentClass.$snapshot.get(key);
       const syncToClient = signal.options?.syncToClient ?? true;
       const persist2 = signal.options?.persist ?? true;
+      const transform = signal.options?.transform;
       let signalValue = signal();
+      if (transform) {
+        signalValue = transform(signalValue);
+      }
       if (isObject$2(signalValue) || Array.isArray(signalValue)) {
         signalValue = {
           ...signalValue
         };
       }
+      const transformedValue = signalValue;
       const newPath = (path ? path + "." : "") + key;
       if (syncToClient) {
-        currentClass.$valuesChanges.set(newPath, signalValue);
+        currentClass.$valuesChanges.set(newPath, transformedValue);
       }
       if (persist2) {
-        if (parentClass) currentClass.$valuesChanges.setPersist(path, signalValue);
+        if (parentClass) currentClass.$valuesChanges.setPersist(path, transformedValue);
       }
       if (isComputed$1(signal)) {
         signal.observable.subscribe((newValue) => {
           if (syncToClient) {
-            currentClass.$valuesChanges.set(newPath, newValue);
+            const transformedNewValue = transform ? transform(newValue) : newValue;
+            currentClass.$valuesChanges.set(newPath, transformedNewValue);
           }
         });
       }
@@ -6123,7 +6129,7 @@ var createSyncClass$1 = /* @__PURE__ */ __name$5((currentClass, parentKey = null
   }
 }, "createSyncClass");
 var type$1 = /* @__PURE__ */ __name$5((_signal, path, options = {}, currentInstance) => {
-  const { syncToClient = true, persist: persist2 = true } = options;
+  const { syncToClient = true, persist: persist2 = true, transform } = options;
   let init = true;
   const handleObjectSubject = /* @__PURE__ */ __name$5((value, propPath) => {
     const newPath = `${propPath}${value.key ? `.${value.key}` : ""}`;
@@ -6173,18 +6179,20 @@ var type$1 = /* @__PURE__ */ __name$5((_signal, path, options = {}, currentInsta
     }
   }, "handleArraySubject");
   const savePath = /* @__PURE__ */ __name$5((propPath, value) => {
+    const transformedValue = transform && value !== DELETE_TOKEN$1 ? transform(value) : value;
     if (syncToClient) {
-      currentInstance.$valuesChanges.set(propPath, value);
+      currentInstance.$valuesChanges.set(propPath, transformedValue);
     }
     if (persist2 && currentInstance.$path !== void 0) {
-      currentInstance.$valuesChanges.setPersist(value == DELETE_TOKEN$1 ? propPath : currentInstance.$path, value);
+      currentInstance.$valuesChanges.setPersist(transformedValue == DELETE_TOKEN$1 ? propPath : currentInstance.$path, transformedValue);
     }
   }, "savePath");
   const setupSubscription = /* @__PURE__ */ __name$5((signal, signalPath) => {
     if (!isSignal$1(signal)) return;
     if (syncToClient && currentInstance.$valuesChanges) {
       const initialValue = signal();
-      currentInstance.$valuesChanges.set(signalPath, initialValue);
+      const transformedInitialValue = transform ? transform(initialValue) : initialValue;
+      currentInstance.$valuesChanges.set(signalPath, transformedInitialValue);
     }
     signal.options = options;
     signal.observable.subscribe((value) => {
@@ -6234,6 +6242,7 @@ function sync$1(options) {
   let classType;
   let persist2 = true;
   let syncToClient = true;
+  let transform;
   if (typeof options === "function") {
     classType = options;
   } else if (typeof options === "object") {
@@ -6244,6 +6253,9 @@ function sync$1(options) {
     if (options.hasOwnProperty("syncToClient")) {
       syncToClient = options.syncToClient;
     }
+    if (options.hasOwnProperty("transform")) {
+      transform = options.transform;
+    }
   }
   return function(target, propertyKey) {
     const privatePropertyKey = `__${propertyKey}`;
@@ -6254,7 +6266,8 @@ function sync$1(options) {
       this[privatePropertyKey] = type$1(newVal, propertyKey, {
         classType,
         persist: persist2,
-        syncToClient
+        syncToClient,
+        transform
       }, this);
     }, "setter");
     Object.defineProperty(target, propertyKey, {
@@ -8143,7 +8156,12 @@ async function testRoom(Room3, options = {}) {
     createClient: /* @__PURE__ */ __name$3(async (id2, opts) => {
       const client = await io.connection(server, id2, opts);
       return client;
-    }, "createClient")
+    }, "createClient"),
+    getServerUser: /* @__PURE__ */ __name$3(async (client, prop = "users") => {
+      const privateId = client.conn.id;
+      const session = await server.getSession(privateId);
+      return server.subRoom[prop]()[session?.publicId];
+    }, "getServerUser")
   };
 }
 __name$3(testRoom, "testRoom");
@@ -8156,6 +8174,10 @@ async function request(room, path, options = {
   return response2;
 }
 __name$3(request, "request");
+function tick(ms = 0) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+__name$3(tick, "tick");
 
 // src/mock.ts
 var MockPartyClient = class {
@@ -10922,23 +10944,29 @@ var createSyncClass = /* @__PURE__ */ __name$2((currentClass, parentKey = null,
       const signal = currentClass.$snapshot.get(key);
       const syncToClient = signal.options?.syncToClient ?? true;
       const persist2 = signal.options?.persist ?? true;
+      const transform = signal.options?.transform;
       let signalValue = signal();
+      if (transform) {
+        signalValue = transform(signalValue);
+      }
       if (isObject$1(signalValue) || Array.isArray(signalValue)) {
         signalValue = {
           ...signalValue
         };
       }
+      const transformedValue = signalValue;
       const newPath = (path ? path + "." : "") + key;
       if (syncToClient) {
-        currentClass.$valuesChanges.set(newPath, signalValue);
+        currentClass.$valuesChanges.set(newPath, transformedValue);
       }
       if (persist2) {
-        if (parentClass) currentClass.$valuesChanges.setPersist(path, signalValue);
+        if (parentClass) currentClass.$valuesChanges.setPersist(path, transformedValue);
       }
       if (isComputed(signal)) {
         signal.observable.subscribe((newValue) => {
           if (syncToClient) {
-            currentClass.$valuesChanges.set(newPath, newValue);
+            const transformedNewValue = transform ? transform(newValue) : newValue;
+            currentClass.$valuesChanges.set(newPath, transformedNewValue);
           }
         });
       }
@@ -10946,7 +10974,7 @@ var createSyncClass = /* @__PURE__ */ __name$2((currentClass, parentKey = null,
   }
 }, "createSyncClass");
 var type = /* @__PURE__ */ __name$2((_signal, path, options = {}, currentInstance) => {
-  const { syncToClient = true, persist: persist2 = true } = options;
+  const { syncToClient = true, persist: persist2 = true, transform } = options;
   let init = true;
   const handleObjectSubject = /* @__PURE__ */ __name$2((value, propPath) => {
     const newPath = `${propPath}${value.key ? `.${value.key}` : ""}`;
@@ -10996,18 +11024,20 @@ var type = /* @__PURE__ */ __name$2((_signal, path, options = {}, currentInstanc
     }
   }, "handleArraySubject");
   const savePath = /* @__PURE__ */ __name$2((propPath, value) => {
+    const transformedValue = transform && value !== DELETE_TOKEN ? transform(value) : value;
     if (syncToClient) {
-      currentInstance.$valuesChanges.set(propPath, value);
+      currentInstance.$valuesChanges.set(propPath, transformedValue);
     }
     if (persist2 && currentInstance.$path !== void 0) {
-      currentInstance.$valuesChanges.setPersist(value == DELETE_TOKEN ? propPath : currentInstance.$path, value);
+      currentInstance.$valuesChanges.setPersist(transformedValue == DELETE_TOKEN ? propPath : currentInstance.$path, transformedValue);
     }
   }, "savePath");
   const setupSubscription = /* @__PURE__ */ __name$2((signal, signalPath) => {
     if (!isSignal(signal)) return;
     if (syncToClient && currentInstance.$valuesChanges) {
       const initialValue = signal();
-      currentInstance.$valuesChanges.set(signalPath, initialValue);
+      const transformedInitialValue = transform ? transform(initialValue) : initialValue;
+      currentInstance.$valuesChanges.set(signalPath, transformedInitialValue);
     }
     signal.options = options;
     signal.observable.subscribe((value) => {
@@ -11057,6 +11087,7 @@ function sync(options) {
   let classType;
   let persist2 = true;
   let syncToClient = true;
+  let transform;
   if (typeof options === "function") {
     classType = options;
   } else if (typeof options === "object") {
@@ -11067,6 +11098,9 @@ function sync(options) {
     if (options.hasOwnProperty("syncToClient")) {
       syncToClient = options.syncToClient;
     }
+    if (options.hasOwnProperty("transform")) {
+      transform = options.transform;
+    }
   }
   return function(target, propertyKey) {
     const privatePropertyKey = `__${propertyKey}`;
@@ -11077,7 +11111,8 @@ function sync(options) {
       this[privatePropertyKey] = type(newVal, propertyKey, {
         classType,
         persist: persist2,
-        syncToClient
+        syncToClient,
+        transform
       }, this);
     }, "setter");
     Object.defineProperty(target, propertyKey, {
@@ -11229,6 +11264,7 @@ class Item {
     };
     this.description.set(data.description);
     this.price.set(data.price);
+    this.name.set(data.name);
     this.onAdd = data.onAdd?.bind(this) ?? (() => {
     });
   }
@@ -18459,6 +18495,16 @@ class WorldMapsManager {
 }
 
 const ModulesToken = "ModulesToken";
+function RpgModule(options) {
+  return (target) => {
+    if (options.hooks) {
+      target.hooks = options.hooks;
+    }
+    for (let key in options) {
+      target.prototype[key] = options[key];
+    }
+  };
+}
 class Hooks {
   constructor(modules, namespace) {
     this.modules = modules;
@@ -19183,29 +19229,136 @@ var __defProp$3 = Object.defineProperty;
 var __name = (target, value) => __defProp$3(target, "name", { value, configurable: true });
 
 // src/inject.ts
-function provide(context, name, value) {
-  context.set("inject:" + name, value);
+var DEFAULT_INSTANCE_KEY = "__default__";
+function toTokenName(token) {
+  return typeof token === "function" ? token.name : token;
+}
+__name(toTokenName, "toTokenName");
+function toInstanceKey(name) {
+  return name ?? DEFAULT_INSTANCE_KEY;
+}
+__name(toInstanceKey, "toInstanceKey");
+function getRecord(context, token) {
+  return context.get("inject:" + toTokenName(token));
+}
+__name(getRecord, "getRecord");
+function ensureRecord(context, token) {
+  const key = "inject:" + toTokenName(token);
+  let record = context.get(key);
+  if (!record) {
+    record = {
+      multi: false,
+      values: /* @__PURE__ */ new Map(),
+      injected: /* @__PURE__ */ new Set()
+    };
+  }
+  context.set(key, record);
+  return record;
+}
+__name(ensureRecord, "ensureRecord");
+function provide(context, token, value, options = {}) {
+  const record = ensureRecord(context, token);
+  const instanceKey = toInstanceKey(options.name);
+  if (options.multi) {
+    record.multi = true;
+  }
+  if (!record.multi && instanceKey !== DEFAULT_INSTANCE_KEY) {
+    record.multi = true;
+  }
+  record.values.set(instanceKey, value);
   return value;
 }
 __name(provide, "provide");
-function isInjected(context, name) {
-  return context.get("injected:" + name) === true;
+function isInjected(context, token, options = {}) {
+  const record = getRecord(context, token);
+  if (!record) {
+    return false;
+  }
+  if (options.name) {
+    return record.injected.has(toInstanceKey(options.name));
+  }
+  if (record.multi) {
+    return record.injected.size > 0;
+  }
+  return record.injected.has(DEFAULT_INSTANCE_KEY);
 }
 __name(isInjected, "isInjected");
-function isProvided(context, name) {
-  return context.get("inject:" + name) !== void 0;
+function isProvided(context, token, options = {}) {
+  const record = getRecord(context, token);
+  if (!record) {
+    return false;
+  }
+  if (options.name) {
+    return record.values.has(toInstanceKey(options.name));
+  }
+  if (record.multi) {
+    return record.values.size > 0;
+  }
+  return record.values.has(DEFAULT_INSTANCE_KEY);
 }
 __name(isProvided, "isProvided");
-function inject$1(context, service, args = []) {
-  const isClass = typeof service === "function";
-  const name = isClass ? service.name : service;
-  const value = context.get("inject:" + name);
-  if (value) {
-    context.set("injected:" + name, true);
-    return value;
+function hasInstance(context, token, options = {}) {
+  return isProvided(context, token, options);
+}
+__name(hasInstance, "hasInstance");
+function handleMissingInjection(token, options) {
+  const name = toTokenName(token);
+  if (options.name) {
+    throw new Error(`Injection provider ${name} with name ${options.name} not found`);
   }
   throw new Error(`Injection provider ${name} not found`);
 }
+__name(handleMissingInjection, "handleMissingInjection");
+function markInjected(record, key) {
+  record.injected.add(key);
+}
+__name(markInjected, "markInjected");
+function markAllInjected(record) {
+  for (const key of record.values.keys()) {
+    record.injected.add(key);
+  }
+}
+__name(markAllInjected, "markAllInjected");
+function inject$1(context, token, options = {}) {
+  const record = getRecord(context, token);
+  if (!record) {
+    if (options.optional) {
+      return options.multi ? [] : void 0;
+    }
+    return handleMissingInjection(token, options);
+  }
+  if (options.name) {
+    const instanceKey = toInstanceKey(options.name);
+    if (!record.values.has(instanceKey)) {
+      if (options.optional) {
+        return void 0;
+      }
+      return handleMissingInjection(token, options);
+    }
+    const value2 = record.values.get(instanceKey);
+    markInjected(record, instanceKey);
+    return value2;
+  }
+  if (options.multi || record.multi) {
+    if (record.values.size === 0) {
+      if (options.optional) {
+        return [];
+      }
+      return handleMissingInjection(token, options);
+    }
+    markAllInjected(record);
+    return Array.from(record.values.values());
+  }
+  const value = record.values.get(DEFAULT_INSTANCE_KEY);
+  if (value === void 0) {
+    if (options.optional) {
+      return void 0;
+    }
+    return handleMissingInjection(token, options);
+  }
+  markInjected(record, DEFAULT_INSTANCE_KEY);
+  return value;
+}
 __name(inject$1, "inject");
 function override(providers, newProvider, options) {
   let { upsert = false, key } = options ?? {};
@@ -19312,6 +19465,20 @@ function mergeConfig(baseConfig, config) {
 __name(mergeConfig, "mergeConfig");
 
 // src/provider.ts
+function extractProvideOptions(source) {
+  if (!source) {
+    return void 0;
+  }
+  const { multi, name } = source;
+  if (multi === void 0 && name === void 0) {
+    return void 0;
+  }
+  return {
+    multi,
+    name
+  };
+}
+__name(extractProvideOptions, "extractProvideOptions");
 function getDeps(provider) {
   if (typeof provider === "function") {
     return provider.deps ?? [];
@@ -19324,7 +19491,14 @@ function sortProviders(providers) {
   const map = /* @__PURE__ */ new Map();
   for (const p of providers) {
     const token = tokenName(typeof p === "function" ? p : p.provide);
-    map.set(token, p);
+    const list = map.get(token);
+    if (list) {
+      list.push(p);
+    } else {
+      map.set(token, [
+        p
+      ]);
+    }
   }
   const result = [];
   const visited = /* @__PURE__ */ new Set();
@@ -19336,13 +19510,15 @@ function sortProviders(providers) {
       throw new Error(`Circular dependency detected for provider ${name}`);
     }
     stack.add(name);
-    const provider = map.get(name);
-    if (provider) {
-      for (const dep of getDeps(provider)) {
-        visit(dep);
+    const providersForToken = map.get(name);
+    if (providersForToken) {
+      for (const provider of providersForToken) {
+        for (const dep of getDeps(provider)) {
+          visit(dep);
+        }
+        result.push(provider);
       }
       visited.add(name);
-      result.push(provider);
     }
     stack.delete(name);
   }, "visit");
@@ -19359,11 +19535,15 @@ async function injector(context, providers) {
   for (const provider of providers) {
     let token;
     let instance;
+    let options;
     if (typeof provider === "function") {
       token = provider;
       instance = new provider(context);
+      const diOptions = extractProvideOptions(provider.diOptions ?? provider.di);
+      options = diOptions;
     } else {
       token = provider.provide;
+      options = extractProvideOptions(provider);
       const provideUserClass = provider.useClass;
       const isClass = typeof provideUserClass === "function";
       if (isClass) {
@@ -19379,8 +19559,7 @@ async function injector(context, providers) {
         instance = inject$1(context, provider.useExisting);
       }
     }
-    const name = typeof token === "function" ? token.name : token;
-    provide(context, name, instance);
+    provide(context, token, instance, options);
   }
 }
 __name(injector, "injector");
@@ -21544,34 +21723,116 @@ function WithItemManager(Base) {
     /**
      * Add an item in the player's inventory. You can give more than one by specifying `nb`
      *
-     * `onAdd()` method is called on the ItemClass
+     * Supports three ways to add items:
+     * 1. **String**: Pass a string ID to retrieve the item from the database (requires item to be registered in `@RpgModule` database).
+     * 2. **Class**: Pass an item class (e.g., `Potion`). The class will be instantiated and automatically added to the map's database if not already present.
+     * 3. **Object**: Pass an item object with properties and hooks directly. The object will be automatically added to the map's database if not already present.
+     *
+     * For classes and objects, if they don't exist in the database, they are automatically added using `map.addInDatabase()`.
+     * This allows dynamic item creation without requiring pre-registration in the module database.
+     *
+     * `onAdd()` method is called on the ItemClass or ItemObject
      *
      * @title Add Item
      * @method player.addItem(item,nb=1)
-     * @param {ItemClass} itemClass
+     * @param {ItemClass | ItemObject | string} item - Item class, object, or string identifier
      * @param {number} [nb] Default 1
-     * @returns {{ nb: number, item: instance of ItemClass }}
+     * @returns {Item} The item instance added to inventory
      * @memberof ItemManager
      * @example
      *
      * ```ts
      * import Potion from 'your-database/potion'
+     * 
+     * // Using string ID (retrieves from database - item must be in @RpgModule database)
+     * player.addItem('Potion', 5)
+     * 
+     * // Using class (creates instance, auto-adds to map database if not present)
      * player.addItem(Potion, 5)
+     * 
+     * // Using object directly (auto-adds to map database if not present)
+     * player.addItem({
+     *   id: 'custom-potion',
+     *   name: 'Custom Potion',
+     *   description: 'A custom potion',
+     *   price: 150,
+     *   hpValue: 50,
+     *   consumable: true,
+     *   onAdd(player) {
+     *     console.log('Custom potion added!');
+     *   },
+     *   onUse(player) {
+     *     player.hp += 50;
+     *   }
+     * }, 3)
+     * 
+     * // Object without ID (auto-generates ID and adds to database)
+     * player.addItem({
+     *   name: 'Dynamic Item',
+     *   price: 100,
+     *   onUse(player) {
+     *     console.log('Dynamic item used!');
+     *   }
+     * })
      *  ```
      */
-    addItem(itemId, nb = 1) {
-      const data = this.databaseById(itemId);
-      const item = this.items().find((it) => it.id() == itemId);
+    addItem(item, nb = 1) {
+      const map = this.getCurrentMap();
+      if (!map) {
+        throw new Error("Player must be on a map to add items");
+      }
+      let itemId;
+      let data;
+      let itemInstance = null;
+      if (isString(item)) {
+        itemId = item;
+        data = this.databaseById(itemId);
+        if (!data) {
+          throw new Error(
+            `The ID=${itemId} data is not found in the database. Add the data in the property "database"`
+          );
+        }
+      } else if (typeof item === "function" || item.prototype) {
+        itemId = item.name;
+        const existingData = map.database()[itemId];
+        if (existingData) {
+          data = existingData;
+        } else {
+          map.addInDatabase(itemId, item);
+          data = item;
+        }
+        itemInstance = new item();
+      } else {
+        const itemObj = item;
+        itemId = itemObj.id || `item-${Date.now()}`;
+        const existingData = map.database()[itemId];
+        if (existingData) {
+          data = { ...existingData, ...itemObj };
+          map.addInDatabase(itemId, data, { force: true });
+        } else {
+          map.addInDatabase(itemId, itemObj);
+          data = itemObj;
+        }
+        itemInstance = itemObj;
+      }
+      const existingItem = this.items().find((it) => it.id() == itemId);
       let instance;
-      if (item) {
-        instance = item;
+      if (existingItem) {
+        instance = existingItem;
         instance.quantity.update((it) => it + nb);
       } else {
         instance = new Item(data);
         instance.id.set(itemId);
+        if (itemInstance) {
+          instance._itemInstance = itemInstance;
+          if (itemInstance.onAdd) {
+            instance.onAdd = itemInstance.onAdd.bind(itemInstance);
+          }
+        }
         this.items().push(instance);
       }
-      this["execMethod"]("onAdd", [this], instance);
+      const hookTarget = instance._itemInstance || instance;
+      this["execMethod"]("onAdd", [this], hookTarget);
       return instance;
     }
     /**
@@ -21618,7 +21879,8 @@ function WithItemManager(Base) {
       } else {
         this.items()[itemIndex].quantity.update((it) => it - nb);
       }
-      this["execMethod"]("onRemove", [this], item);
+      const hookTarget = item._itemInstance || item;
+      this["execMethod"]("onRemove", [this], hookTarget);
       return this.items()[itemIndex];
     }
     /**
@@ -21628,7 +21890,7 @@ function WithItemManager(Base) {
      *
      * @title Buy Item
      * @method player.buyItem(item,nb=1)
-     * @param {ItemClass | string} itemClass string is item id
+     * @param {ItemClass | string} itemClass Identifier of the object if the parameter is a string
      * @param {number} [nb] Default 1
      * @returns {{ nb: number, item: instance of ItemClass }}
      * @throws {ItemLog} haveNotPrice
@@ -21654,15 +21916,36 @@ function WithItemManager(Base) {
      * import Potion from 'your-database/potion'
      *
      * try {
+     *    // Using class
      *    player.buyItem(Potion)
+     *    
+     *    // Using string ID
+     *    player.buyItem('Potion')
      * }
      * catch (err) {
      *    console.log(err)
      * }
      * ```
      */
-    buyItem(itemId, nb = 1) {
-      const data = this.databaseById(itemId);
+    buyItem(item, nb = 1) {
+      let itemId;
+      let data;
+      if (isString(item)) {
+        itemId = item;
+        data = this.databaseById(itemId);
+      } else if (typeof item === "function" || item.prototype) {
+        itemId = item.name;
+        data = this.databaseById(itemId);
+      } else {
+        const itemObj = item;
+        itemId = itemObj.id || `item-${Date.now()}`;
+        try {
+          const dbData = this.databaseById(itemId);
+          data = { ...dbData, ...itemObj };
+        } catch {
+          data = itemObj;
+        }
+      }
       if (!data.price) {
         throw ItemLog.haveNotPrice(itemId);
       }
@@ -21671,7 +21954,7 @@ function WithItemManager(Base) {
         throw ItemLog.notEnoughGold(itemId, nb);
       }
       this._gold.update((gold) => gold - totalPrice);
-      return this.addItem(itemId, nb);
+      return this.addItem(item, nb);
     }
     /**
      * Sell an item and the player wins the amount of the item divided by 2
@@ -21680,7 +21963,7 @@ function WithItemManager(Base) {
      *
      * @title Sell Item
      * @method player.sellItem(item,nb=1)
-     * @param {ItemClass | string} itemClass string is item id
+     * @param {ItemClass | string} itemClass Identifier of the object if the parameter is a string
      * @param {number} [nbToSell] Default 1
      * @returns {{ nb: number, item: instance of ItemClass }}
      * @throws {ItemLog} haveNotPrice
@@ -21715,16 +21998,20 @@ function WithItemManager(Base) {
      *
      * try {
      *     player.addItem(Potion)
+     *     // Using class
      *     player.sellItem(Potion)
+     *     // Using string ID
+     *     player.sellItem('Potion')
      * }
      * catch (err) {
      *    console.log(err)
      * }
      * ```
      */
-    sellItem(itemId, nbToSell = 1) {
+    sellItem(itemClass, nbToSell = 1) {
+      const itemId = isString(itemClass) ? itemClass : itemClass.name;
       const data = this.databaseById(itemId);
-      const inventory = this.getItem(itemId);
+      const inventory = this.getItem(itemClass);
       if (!inventory) {
         throw ItemLog.notInInventory(itemId);
       }
@@ -21736,7 +22023,7 @@ function WithItemManager(Base) {
         throw ItemLog.haveNotPrice(itemId);
       }
       this._gold.update((gold) => gold + data.price / 2 * nbToSell);
-      this.removeItem(itemId, nbToSell);
+      this.removeItem(itemClass, nbToSell);
       return inventory;
     }
     getParamItem(name) {
@@ -21789,7 +22076,7 @@ function WithItemManager(Base) {
      *
      * @title Use an Item
      * @method player.useItem(item,nb=1)
-     * @param {ItemClass | string} itemClass string is item id
+     * @param {ItemClass | string} itemClass Identifier of the object if the parameter is a string
      * @returns {{ nb: number, item: instance of ItemClass }}
      * @throws {ItemLog} restriction
      * If the player has the `Effect.CAN_NOT_ITEM` effect
@@ -21835,15 +22122,19 @@ function WithItemManager(Base) {
      *
      * try {
      *     player.addItem(Potion)
+     *     // Using class
      *     player.useItem(Potion)
+     *     // Using string ID
+     *     player.useItem('Potion')
      * }
      * catch (err) {
      *    console.log(err)
      * }
      * ```
      */
-    useItem(itemId) {
-      const inventory = this.getItem(itemId);
+    useItem(itemClass) {
+      const itemId = isString(itemClass) ? itemClass : itemClass.name;
+      const inventory = this.getItem(itemClass);
       if (this.hasEffect?.("CAN_NOT_ITEM" /* CAN_NOT_ITEM */)) {
         throw ItemLog.restriction(itemId);
       }
@@ -21855,15 +22146,16 @@ function WithItemManager(Base) {
         throw ItemLog.notUseItem(itemId);
       }
       const hitRate = item.hitRate ?? 1;
+      const hookTarget = item._itemInstance || item;
       if (Math.random() > hitRate) {
-        this.removeItem(itemId);
-        this["execMethod"]("onUseFailed", [this], item);
+        this.removeItem(itemClass);
+        this["execMethod"]("onUseFailed", [this], hookTarget);
         throw ItemLog.chanceToUseFailed(itemId);
       }
       this.applyEffect?.(item);
       this.applyStates?.(this, item);
-      this["execMethod"]("onUse", [this], item);
-      this.removeItem(itemId);
+      this["execMethod"]("onUse", [this], hookTarget);
+      this.removeItem(itemClass);
       return inventory;
     }
     /**
@@ -21873,7 +22165,7 @@ function WithItemManager(Base) {
      * 
      * @title Equip Weapon or Armor
      * @method player.equip(itemClass,equip=true)
-     * @param {ItemClass | string} itemClass string is item id
+     * @param {ItemClass | string} itemClass Identifier of the object if the parameter is a string
      * @param {number} [equip] Equip the object if true or un-equipped if false
      * @returns {void}
      * @throws {ItemLog} notInInventory 
@@ -21908,15 +22200,19 @@ function WithItemManager(Base) {
      * 
      * try {
      *      player.addItem(Sword)
+     *      // Using class
      *      player.equip(Sword)
+     *      // Using string ID
+     *      player.equip('Sword')
      * }
      * catch (err) {
      *    console.log(err)
      * }
      * ```
      */
-    equip(itemId, equip = true) {
-      const inventory = this.getItem(itemId);
+    equip(itemClass, equip = true) {
+      const itemId = isString(itemClass) ? itemClass : itemClass.name;
+      const inventory = this.getItem(itemClass);
       if (!inventory) {
         throw ItemLog.notInInventory(itemId);
       }
@@ -21945,7 +22241,8 @@ function WithItemManager(Base) {
       } else {
         this.equipments().push(item);
       }
-      this["execMethod"]("onEquip", [this, equip], item);
+      const hookTarget = item._itemInstance || item;
+      this["execMethod"]("onEquip", [this, equip], hookTarget);
     }
   };
 }
@@ -23776,21 +24073,30 @@ context$1["side"] = "server";
 /** A special constant with type `never` */
 function $constructor(name, initializer, params) {
     function init(inst, def) {
-        var _a;
-        Object.defineProperty(inst, "_zod", {
-            value: inst._zod ?? {},
-            enumerable: false,
-        });
-        (_a = inst._zod).traits ?? (_a.traits = new Set());
+        if (!inst._zod) {
+            Object.defineProperty(inst, "_zod", {
+                value: {
+                    def,
+                    constr: _,
+                    traits: new Set(),
+                },
+                enumerable: false,
+            });
+        }
+        if (inst._zod.traits.has(name)) {
+            return;
+        }
         inst._zod.traits.add(name);
         initializer(inst, def);
         // support prototype modifications
-        for (const k in _.prototype) {
-            if (!(k in inst))
-                Object.defineProperty(inst, k, { value: _.prototype[k].bind(inst) });
+        const proto = _.prototype;
+        const keys = Object.keys(proto);
+        for (let i = 0; i < keys.length; i++) {
+            const k = keys[i];
+            if (!(k in inst)) {
+                inst[k] = proto[k].bind(inst);
+            }
         }
-        inst._zod.constr = _;
-        inst._zod.def = def;
     }
     // doesn't work if Parent has a constructor with arguments
     const Parent = params?.Parent ?? Object;
@@ -23823,6 +24129,12 @@ class $ZodAsyncError extends Error {
         super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
     }
 }
+class $ZodEncodeError extends Error {
+    constructor(name) {
+        super(`Encountered unidirectional transform during encode: ${name}`);
+        this.name = "ZodEncodeError";
+    }
+}
 const globalConfig = {};
 function config(newConfig) {
     return globalConfig;
@@ -23900,9 +24212,6 @@ function defineLazy(object, key, getter) {
         configurable: true,
     });
 }
-function objectClone(obj) {
-    return Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));
-}
 function assignProp(target, prop, value) {
     Object.defineProperty(target, prop, {
         value,
@@ -23922,6 +24231,14 @@ function mergeDefs(...defs) {
 function esc(str) {
     return JSON.stringify(str);
 }
+function slugify(input) {
+    return input
+        .toLowerCase()
+        .trim()
+        .replace(/[^\w\s-]/g, "")
+        .replace(/[\s_-]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
 const captureStackTrace = ("captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => { });
 function isObject(data) {
     return typeof data === "object" && data !== null && !Array.isArray(data);
@@ -23947,6 +24264,8 @@ function isPlainObject(o) {
     const ctor = o.constructor;
     if (ctor === undefined)
         return true;
+    if (typeof ctor !== "function")
+        return true;
     // modified prototype
     const prot = ctor.prototype;
     if (isObject(prot) === false)
@@ -23960,6 +24279,8 @@ function isPlainObject(o) {
 function shallowClone(o) {
     if (isPlainObject(o))
         return { ...o };
+    if (Array.isArray(o))
+        return [...o];
     return o;
 }
 const propertyKeyTypes = new Set(["string", "number", "symbol"]);
@@ -24045,6 +24366,11 @@ function extend(schema, shape) {
     if (!isPlainObject(shape)) {
         throw new Error("Invalid input to extend: expected a plain object");
     }
+    const checks = schema._zod.def.checks;
+    const hasChecks = checks && checks.length > 0;
+    if (hasChecks) {
+        throw new Error("Object schemas containing refinements cannot be extended. Use `.safeExtend()` instead.");
+    }
     const def = mergeDefs(schema._zod.def, {
         get shape() {
             const _shape = { ...schema._zod.def.shape, ...shape };
@@ -24055,6 +24381,21 @@ function extend(schema, shape) {
     });
     return clone(schema, def);
 }
+function safeExtend(schema, shape) {
+    if (!isPlainObject(shape)) {
+        throw new Error("Invalid input to safeExtend: expected a plain object");
+    }
+    const def = {
+        ...schema._zod.def,
+        get shape() {
+            const _shape = { ...schema._zod.def.shape, ...shape };
+            assignProp(this, "shape", _shape); // self-caching
+            return _shape;
+        },
+        checks: schema._zod.def.checks,
+    };
+    return clone(schema, def);
+}
 function merge(a, b) {
     const def = mergeDefs(a._zod.def, {
         get shape() {
@@ -24145,6 +24486,8 @@ function required(Class, schema, mask) {
 }
 // invalid_type | too_big | too_small | invalid_format | not_multiple_of | unrecognized_keys | invalid_union | invalid_key | invalid_element | invalid_value | custom
 function aborted(x, startIndex = 0) {
+    if (x.aborted === true)
+        return true;
     for (let i = startIndex; i < x.issues.length; i++) {
         if (x.issues[i]?.continue !== true) {
             return true;
@@ -24234,11 +24577,7 @@ function flattenError(error, mapper = (issue) => issue.message) {
     }
     return { formErrors, fieldErrors };
 }
-function formatError(error, _mapper) {
-    const mapper = _mapper ||
-        function (issue) {
-            return issue.message;
-        };
+function formatError(error, mapper = (issue) => issue.message) {
     const fieldErrors = { _errors: [] };
     const processError = (error) => {
         for (const issue of error.issues) {
@@ -24329,6 +24668,34 @@ const _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
         : { success: true, data: result.value };
 };
 const safeParseAsync$1 = /* @__PURE__*/ _safeParseAsync($ZodRealError);
+const _encode = (_Err) => (schema, value, _ctx) => {
+    const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
+    return _parse(_Err)(schema, value, ctx);
+};
+const _decode = (_Err) => (schema, value, _ctx) => {
+    return _parse(_Err)(schema, value, _ctx);
+};
+const _encodeAsync = (_Err) => async (schema, value, _ctx) => {
+    const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
+    return _parseAsync(_Err)(schema, value, ctx);
+};
+const _decodeAsync = (_Err) => async (schema, value, _ctx) => {
+    return _parseAsync(_Err)(schema, value, _ctx);
+};
+const _safeEncode = (_Err) => (schema, value, _ctx) => {
+    const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
+    return _safeParse(_Err)(schema, value, ctx);
+};
+const _safeDecode = (_Err) => (schema, value, _ctx) => {
+    return _safeParse(_Err)(schema, value, _ctx);
+};
+const _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {
+    const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
+    return _safeParseAsync(_Err)(schema, value, ctx);
+};
+const _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {
+    return _safeParseAsync(_Err)(schema, value, _ctx);
+};
 
 const cuid = /^[cC][^\s-]{8,}$/;
 const cuid2 = /^[0-9a-z]+$/;
@@ -24345,7 +24712,7 @@ const guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9
  * @param version Optionally specify a version 1-8. If no version is specified, all versions are supported. */
 const uuid = (version) => {
     if (!version)
-        return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000)$/;
+        return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
     return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
 };
 /** Practical email validation */
@@ -24356,15 +24723,12 @@ function emoji() {
     return new RegExp(_emoji$1, "u");
 }
 const ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
-const ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})$/;
+const ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;
 const cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
 const cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
 // https://stackoverflow.com/questions/7860392/determine-if-string-is-in-base64-using-javascript
 const base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
 const base64url = /^[A-Za-z0-9_-]*$/;
-// based on https://stackoverflow.com/questions/106179/regular-expression-to-match-dns-hostname-or-ip-address
-// export const hostname: RegExp = /^([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+$/;
-const hostname = /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/;
 // https://blog.stevenlevithan.com/archives/validate-phone-number#r4-3 (regex sans spaces)
 const e164 = /^\+(?:[0-9]){6,14}[0-9]$/;
 // const dateSource = `((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))`;
@@ -24400,8 +24764,8 @@ const string$1 = (params) => {
     const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
     return new RegExp(`^${regex}$`);
 };
-const integer = /^\d+$/;
-const number$1 = /^-?\d+(?:\.\d+)?/i;
+const integer = /^-?\d+$/;
+const number$1 = /^-?\d+(?:\.\d+)?/;
 // regex for string with no uppercase letters
 const lowercase = /^[^A-Z]*$/;
 // regex for string with no lowercase letters
@@ -24853,8 +25217,8 @@ class Doc {
 
 const version = {
     major: 4,
-    minor: 0,
-    patch: 17,
+    minor: 1,
+    patch: 13,
 };
 
 const $ZodType = /*@__PURE__*/ $constructor("$ZodType", (inst, def) => {
@@ -24868,7 +25232,6 @@ const $ZodType = /*@__PURE__*/ $constructor("$ZodType", (inst, def) => {
     if (inst._zod.traits.has("$ZodCheck")) {
         checks.unshift(inst);
     }
-    //
     for (const ch of checks) {
         for (const fn of ch._zod.onattach) {
             fn(inst);
@@ -24925,7 +25288,47 @@ const $ZodType = /*@__PURE__*/ $constructor("$ZodType", (inst, def) => {
             }
             return payload;
         };
+        // const handleChecksResult = (
+        //   checkResult: ParsePayload,
+        //   originalResult: ParsePayload,
+        //   ctx: ParseContextInternal
+        // ): util.MaybeAsync<ParsePayload> => {
+        //   // if the checks mutated the value && there are no issues, re-parse the result
+        //   if (checkResult.value !== originalResult.value && !checkResult.issues.length)
+        //     return inst._zod.parse(checkResult, ctx);
+        //   return originalResult;
+        // };
+        const handleCanaryResult = (canary, payload, ctx) => {
+            // abort if the canary is aborted
+            if (aborted(canary)) {
+                canary.aborted = true;
+                return canary;
+            }
+            // run checks first, then
+            const checkResult = runChecks(payload, checks, ctx);
+            if (checkResult instanceof Promise) {
+                if (ctx.async === false)
+                    throw new $ZodAsyncError();
+                return checkResult.then((checkResult) => inst._zod.parse(checkResult, ctx));
+            }
+            return inst._zod.parse(checkResult, ctx);
+        };
         inst._zod.run = (payload, ctx) => {
+            if (ctx.skipChecks) {
+                return inst._zod.parse(payload, ctx);
+            }
+            if (ctx.direction === "backward") {
+                // run canary
+                // initial pass (no checks)
+                const canary = inst._zod.parse({ value: payload.value, issues: [] }, { ...ctx, skipChecks: true });
+                if (canary instanceof Promise) {
+                    return canary.then((canary) => {
+                        return handleCanaryResult(canary, payload, ctx);
+                    });
+                }
+                return handleCanaryResult(canary, payload, ctx);
+            }
+            // forward
             const result = inst._zod.parse(payload, ctx);
             if (result instanceof Promise) {
                 if (ctx.async === false)
@@ -25018,7 +25421,7 @@ const $ZodURL = /*@__PURE__*/ $constructor("$ZodURL", (inst, def) => {
                         code: "invalid_format",
                         format: "url",
                         note: "Invalid hostname",
-                        pattern: hostname.source,
+                        pattern: def.hostname.source,
                         input: payload.value,
                         inst,
                         continue: !def.abort,
@@ -25108,18 +25511,12 @@ const $ZodISODuration = /*@__PURE__*/ $constructor("$ZodISODuration", (inst, def
 const $ZodIPv4 = /*@__PURE__*/ $constructor("$ZodIPv4", (inst, def) => {
     def.pattern ?? (def.pattern = ipv4);
     $ZodStringFormat.init(inst, def);
-    inst._zod.onattach.push((inst) => {
-        const bag = inst._zod.bag;
-        bag.format = `ipv4`;
-    });
+    inst._zod.bag.format = `ipv4`;
 });
 const $ZodIPv6 = /*@__PURE__*/ $constructor("$ZodIPv6", (inst, def) => {
     def.pattern ?? (def.pattern = ipv6);
     $ZodStringFormat.init(inst, def);
-    inst._zod.onattach.push((inst) => {
-        const bag = inst._zod.bag;
-        bag.format = `ipv6`;
-    });
+    inst._zod.bag.format = `ipv6`;
     inst._zod.check = (payload) => {
         try {
             // @ts-ignore
@@ -25145,8 +25542,11 @@ const $ZodCIDRv6 = /*@__PURE__*/ $constructor("$ZodCIDRv6", (inst, def) => {
     def.pattern ?? (def.pattern = cidrv6); // not used for validation
     $ZodStringFormat.init(inst, def);
     inst._zod.check = (payload) => {
-        const [address, prefix] = payload.value.split("/");
+        const parts = payload.value.split("/");
         try {
+            if (parts.length !== 2)
+                throw new Error();
+            const [address, prefix] = parts;
             if (!prefix)
                 throw new Error();
             const prefixNum = Number(prefix);
@@ -25186,9 +25586,7 @@ function isValidBase64(data) {
 const $ZodBase64 = /*@__PURE__*/ $constructor("$ZodBase64", (inst, def) => {
     def.pattern ?? (def.pattern = base64);
     $ZodStringFormat.init(inst, def);
-    inst._zod.onattach.push((inst) => {
-        inst._zod.bag.contentEncoding = "base64";
-    });
+    inst._zod.bag.contentEncoding = "base64";
     inst._zod.check = (payload) => {
         if (isValidBase64(payload.value))
             return;
@@ -25212,9 +25610,7 @@ function isValidBase64URL(data) {
 const $ZodBase64URL = /*@__PURE__*/ $constructor("$ZodBase64URL", (inst, def) => {
     def.pattern ?? (def.pattern = base64url);
     $ZodStringFormat.init(inst, def);
-    inst._zod.onattach.push((inst) => {
-        inst._zod.bag.contentEncoding = "base64url";
-    });
+    inst._zod.bag.contentEncoding = "base64url";
     inst._zod.check = (payload) => {
         if (isValidBase64URL(payload.value))
             return;
@@ -25298,9 +25694,9 @@ const $ZodNumber = /*@__PURE__*/ $constructor("$ZodNumber", (inst, def) => {
         return payload;
     };
 });
-const $ZodNumberFormat = /*@__PURE__*/ $constructor("$ZodNumber", (inst, def) => {
+const $ZodNumberFormat = /*@__PURE__*/ $constructor("$ZodNumberFormat", (inst, def) => {
     $ZodCheckNumberFormat.init(inst, def);
-    $ZodNumber.init(inst, def); // no format checksp
+    $ZodNumber.init(inst, def); // no format checks
 });
 const $ZodAny = /*@__PURE__*/ $constructor("$ZodAny", (inst, def) => {
     $ZodType.init(inst, def);
@@ -25375,25 +25771,75 @@ function handlePropertyResult(result, final, key, input) {
         final.value[key] = result.value;
     }
 }
+function normalizeDef(def) {
+    const keys = Object.keys(def.shape);
+    for (const k of keys) {
+        if (!def.shape?.[k]?._zod?.traits?.has("$ZodType")) {
+            throw new Error(`Invalid element at key "${k}": expected a Zod schema`);
+        }
+    }
+    const okeys = optionalKeys(def.shape);
+    return {
+        ...def,
+        keys,
+        keySet: new Set(keys),
+        numKeys: keys.length,
+        optionalKeys: new Set(okeys),
+    };
+}
+function handleCatchall(proms, input, payload, ctx, def, inst) {
+    const unrecognized = [];
+    // iterate over input keys
+    const keySet = def.keySet;
+    const _catchall = def.catchall._zod;
+    const t = _catchall.def.type;
+    for (const key in input) {
+        if (keySet.has(key))
+            continue;
+        if (t === "never") {
+            unrecognized.push(key);
+            continue;
+        }
+        const r = _catchall.run({ value: input[key], issues: [] }, ctx);
+        if (r instanceof Promise) {
+            proms.push(r.then((r) => handlePropertyResult(r, payload, key, input)));
+        }
+        else {
+            handlePropertyResult(r, payload, key, input);
+        }
+    }
+    if (unrecognized.length) {
+        payload.issues.push({
+            code: "unrecognized_keys",
+            keys: unrecognized,
+            input,
+            inst,
+        });
+    }
+    if (!proms.length)
+        return payload;
+    return Promise.all(proms).then(() => {
+        return payload;
+    });
+}
 const $ZodObject = /*@__PURE__*/ $constructor("$ZodObject", (inst, def) => {
     // requires cast because technically $ZodObject doesn't extend
     $ZodType.init(inst, def);
-    const _normalized = cached(() => {
-        const keys = Object.keys(def.shape);
-        for (const k of keys) {
-            if (!def.shape[k]._zod.traits.has("$ZodType")) {
-                throw new Error(`Invalid element at key "${k}": expected a Zod schema`);
-            }
-        }
-        const okeys = optionalKeys(def.shape);
-        return {
-            shape: def.shape,
-            keys,
-            keySet: new Set(keys),
-            numKeys: keys.length,
-            optionalKeys: new Set(okeys),
-        };
-    });
+    // const sh = def.shape;
+    const desc = Object.getOwnPropertyDescriptor(def, "shape");
+    if (!desc?.get) {
+        const sh = def.shape;
+        Object.defineProperty(def, "shape", {
+            get: () => {
+                const newSh = { ...sh };
+                Object.defineProperty(def, "shape", {
+                    value: newSh,
+                });
+                return newSh;
+            },
+        });
+    }
+    const _normalized = cached(() => normalizeDef(def));
     defineLazy(inst._zod, "propValues", () => {
         const shape = def.shape;
         const propValues = {};
@@ -25407,6 +25853,45 @@ const $ZodObject = /*@__PURE__*/ $constructor("$ZodObject", (inst, def) => {
         }
         return propValues;
     });
+    const isObject$1 = isObject;
+    const catchall = def.catchall;
+    let value;
+    inst._zod.parse = (payload, ctx) => {
+        value ?? (value = _normalized.value);
+        const input = payload.value;
+        if (!isObject$1(input)) {
+            payload.issues.push({
+                expected: "object",
+                code: "invalid_type",
+                input,
+                inst,
+            });
+            return payload;
+        }
+        payload.value = {};
+        const proms = [];
+        const shape = value.shape;
+        for (const key of value.keys) {
+            const el = shape[key];
+            const r = el._zod.run({ value: input[key], issues: [] }, ctx);
+            if (r instanceof Promise) {
+                proms.push(r.then((r) => handlePropertyResult(r, payload, key, input)));
+            }
+            else {
+                handlePropertyResult(r, payload, key, input);
+            }
+        }
+        if (!catchall) {
+            return proms.length ? Promise.all(proms).then(() => payload) : payload;
+        }
+        return handleCatchall(proms, input, payload, ctx, _normalized.value, inst);
+    };
+});
+const $ZodObjectJIT = /*@__PURE__*/ $constructor("$ZodObjectJIT", (inst, def) => {
+    // requires cast because technically $ZodObject doesn't extend
+    $ZodObject.init(inst, def);
+    const superParse = inst._zod.parse;
+    const _normalized = cached(() => normalizeDef(def));
     const generateFastpass = (shape) => {
         const doc = new Doc(["shape", "payload", "ctx"]);
         const normalized = _normalized.value;
@@ -25421,7 +25906,7 @@ const $ZodObject = /*@__PURE__*/ $constructor("$ZodObject", (inst, def) => {
             ids[key] = `key_${counter++}`;
         }
         // A: preserve key order {
-        doc.write(`const newResult = {}`);
+        doc.write(`const newResult = {};`);
         for (const key of normalized.keys) {
             const id = ids[key];
             const k = esc(key);
@@ -25434,6 +25919,7 @@ const $ZodObject = /*@__PURE__*/ $constructor("$ZodObject", (inst, def) => {
           })));
         }
         
+        
         if (${id}.value === undefined) {
           if (${k} in input) {
             newResult[${k}] = undefined;
@@ -25441,6 +25927,7 @@ const $ZodObject = /*@__PURE__*/ $constructor("$ZodObject", (inst, def) => {
         } else {
           newResult[${k}] = ${id}.value;
         }
+        
       `);
         }
         doc.write(`payload.value = newResult;`);
@@ -25467,63 +25954,16 @@ const $ZodObject = /*@__PURE__*/ $constructor("$ZodObject", (inst, def) => {
             });
             return payload;
         }
-        const proms = [];
         if (jit && fastEnabled && ctx?.async === false && ctx.jitless !== true) {
             // always synchronous
             if (!fastpass)
                 fastpass = generateFastpass(def.shape);
             payload = fastpass(payload, ctx);
+            if (!catchall)
+                return payload;
+            return handleCatchall([], input, payload, ctx, value, inst);
         }
-        else {
-            payload.value = {};
-            const shape = value.shape;
-            for (const key of value.keys) {
-                const el = shape[key];
-                const r = el._zod.run({ value: input[key], issues: [] }, ctx);
-                if (r instanceof Promise) {
-                    proms.push(r.then((r) => handlePropertyResult(r, payload, key, input)));
-                }
-                else {
-                    handlePropertyResult(r, payload, key, input);
-                }
-            }
-        }
-        if (!catchall) {
-            return proms.length ? Promise.all(proms).then(() => payload) : payload;
-        }
-        const unrecognized = [];
-        // iterate over input keys
-        const keySet = value.keySet;
-        const _catchall = catchall._zod;
-        const t = _catchall.def.type;
-        for (const key of Object.keys(input)) {
-            if (keySet.has(key))
-                continue;
-            if (t === "never") {
-                unrecognized.push(key);
-                continue;
-            }
-            const r = _catchall.run({ value: input[key], issues: [] }, ctx);
-            if (r instanceof Promise) {
-                proms.push(r.then((r) => handlePropertyResult(r, payload, key, input)));
-            }
-            else {
-                handlePropertyResult(r, payload, key, input);
-            }
-        }
-        if (unrecognized.length) {
-            payload.issues.push({
-                code: "unrecognized_keys",
-                keys: unrecognized,
-                input,
-                inst,
-            });
-        }
-        if (!proms.length)
-            return payload;
-        return Promise.all(proms).then(() => {
-            return payload;
-        });
+        return superParse(payload, ctx);
     };
 });
 function handleUnionResults(results, final, inst, ctx) {
@@ -25695,9 +26135,12 @@ const $ZodEnum = /*@__PURE__*/ $constructor("$ZodEnum", (inst, def) => {
 });
 const $ZodTransform = /*@__PURE__*/ $constructor("$ZodTransform", (inst, def) => {
     $ZodType.init(inst, def);
-    inst._zod.parse = (payload, _ctx) => {
+    inst._zod.parse = (payload, ctx) => {
+        if (ctx.direction === "backward") {
+            throw new $ZodEncodeError(inst.constructor.name);
+        }
         const _out = def.transform(payload.value, payload);
-        if (_ctx.async) {
+        if (ctx.async) {
             const output = _out instanceof Promise ? _out : Promise.resolve(_out);
             return output.then((output) => {
                 payload.value = output;
@@ -25753,6 +26196,7 @@ const $ZodNullable = /*@__PURE__*/ $constructor("$ZodNullable", (inst, def) => {
         return def.innerType._zod.values ? new Set([...def.innerType._zod.values, null]) : undefined;
     });
     inst._zod.parse = (payload, ctx) => {
+        // Forward direction (decode): allow null to pass through
         if (payload.value === null)
             return payload;
         return def.innerType._zod.run(payload, ctx);
@@ -25764,13 +26208,18 @@ const $ZodDefault = /*@__PURE__*/ $constructor("$ZodDefault", (inst, def) => {
     inst._zod.optin = "optional";
     defineLazy(inst._zod, "values", () => def.innerType._zod.values);
     inst._zod.parse = (payload, ctx) => {
+        if (ctx.direction === "backward") {
+            return def.innerType._zod.run(payload, ctx);
+        }
+        // Forward direction (decode): apply defaults for undefined input
         if (payload.value === undefined) {
             payload.value = def.defaultValue;
             /**
-             * $ZodDefault always returns the default value immediately.
+             * $ZodDefault returns the default value immediately in forward direction.
              * It doesn't pass the default value into the validator ("prefault"). There's no reason to pass the default value through validation. The validity of the default is enforced by TypeScript statically. Otherwise, it's the responsibility of the user to ensure the default is valid. In the case of pipes with divergent in/out types, you can specify the default on the `in` schema of your ZodPipe to set a "prefault" for the pipe.   */
             return payload;
         }
+        // Forward direction: continue with default handling
         const result = def.innerType._zod.run(payload, ctx);
         if (result instanceof Promise) {
             return result.then((result) => handleDefaultResult(result, def));
@@ -25789,6 +26238,10 @@ const $ZodPrefault = /*@__PURE__*/ $constructor("$ZodPrefault", (inst, def) => {
     inst._zod.optin = "optional";
     defineLazy(inst._zod, "values", () => def.innerType._zod.values);
     inst._zod.parse = (payload, ctx) => {
+        if (ctx.direction === "backward") {
+            return def.innerType._zod.run(payload, ctx);
+        }
+        // Forward direction (decode): apply prefault for undefined input
         if (payload.value === undefined) {
             payload.value = def.defaultValue;
         }
@@ -25826,6 +26279,10 @@ const $ZodCatch = /*@__PURE__*/ $constructor("$ZodCatch", (inst, def) => {
     defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
     defineLazy(inst._zod, "values", () => def.innerType._zod.values);
     inst._zod.parse = (payload, ctx) => {
+        if (ctx.direction === "backward") {
+            return def.innerType._zod.run(payload, ctx);
+        }
+        // Forward direction (decode): apply catch logic
         const result = def.innerType._zod.run(payload, ctx);
         if (result instanceof Promise) {
             return result.then((result) => {
@@ -25864,26 +26321,38 @@ const $ZodPipe = /*@__PURE__*/ $constructor("$ZodPipe", (inst, def) => {
     defineLazy(inst._zod, "optout", () => def.out._zod.optout);
     defineLazy(inst._zod, "propValues", () => def.in._zod.propValues);
     inst._zod.parse = (payload, ctx) => {
+        if (ctx.direction === "backward") {
+            const right = def.out._zod.run(payload, ctx);
+            if (right instanceof Promise) {
+                return right.then((right) => handlePipeResult(right, def.in, ctx));
+            }
+            return handlePipeResult(right, def.in, ctx);
+        }
         const left = def.in._zod.run(payload, ctx);
         if (left instanceof Promise) {
-            return left.then((left) => handlePipeResult(left, def, ctx));
+            return left.then((left) => handlePipeResult(left, def.out, ctx));
         }
-        return handlePipeResult(left, def, ctx);
+        return handlePipeResult(left, def.out, ctx);
     };
 });
-function handlePipeResult(left, def, ctx) {
+function handlePipeResult(left, next, ctx) {
     if (left.issues.length) {
+        // prevent further checks
+        left.aborted = true;
         return left;
     }
-    return def.out._zod.run({ value: left.value, issues: left.issues }, ctx);
+    return next._zod.run({ value: left.value, issues: left.issues }, ctx);
 }
 const $ZodReadonly = /*@__PURE__*/ $constructor("$ZodReadonly", (inst, def) => {
     $ZodType.init(inst, def);
     defineLazy(inst._zod, "propValues", () => def.innerType._zod.propValues);
     defineLazy(inst._zod, "values", () => def.innerType._zod.values);
-    defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
-    defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
+    defineLazy(inst._zod, "optin", () => def.innerType?._zod?.optin);
+    defineLazy(inst._zod, "optout", () => def.innerType?._zod?.optout);
     inst._zod.parse = (payload, ctx) => {
+        if (ctx.direction === "backward") {
+            return def.innerType._zod.run(payload, ctx);
+        }
         const result = def.innerType._zod.run(payload, ctx);
         if (result instanceof Promise) {
             return result.then(handleReadonlyResult);
@@ -25927,9 +26396,10 @@ function handleRefineResult(result, payload, input, inst) {
     }
 }
 
+var _a;
 class $ZodRegistry {
     constructor() {
-        this._map = new Map();
+        this._map = new WeakMap();
         this._idmap = new Map();
     }
     add(schema, ..._meta) {
@@ -25944,7 +26414,7 @@ class $ZodRegistry {
         return this;
     }
     clear() {
-        this._map = new Map();
+        this._map = new WeakMap();
         this._idmap = new Map();
         return this;
     }
@@ -25976,7 +26446,8 @@ class $ZodRegistry {
 function registry() {
     return new $ZodRegistry();
 }
-const globalRegistry = /*@__PURE__*/ registry();
+(_a = globalThis).__zod_globalRegistry ?? (_a.__zod_globalRegistry = registry());
+const globalRegistry = globalThis.__zod_globalRegistry;
 
 function _string(Class, params) {
     return new Class({
@@ -26382,6 +26853,10 @@ function _toLowerCase() {
 function _toUpperCase() {
     return _overwrite((input) => input.toUpperCase());
 }
+// slugify
+function _slugify() {
+    return _overwrite((input) => slugify(input));
+}
 function _array(Class, element, params) {
     return new Class({
         type: "array",
@@ -26416,7 +26891,7 @@ function _superRefine(fn) {
                 _issue.code ?? (_issue.code = "custom");
                 _issue.input ?? (_issue.input = payload.value);
                 _issue.inst ?? (_issue.inst = ch);
-                _issue.continue ?? (_issue.continue = !ch._zod.def.abort);
+                _issue.continue ?? (_issue.continue = !ch._zod.def.abort); // abort is always undefined, so this is always true...
                 payload.issues.push(issue(_issue));
             }
         };
@@ -26511,22 +26986,29 @@ const parse = /* @__PURE__ */ _parse(ZodRealError);
 const parseAsync = /* @__PURE__ */ _parseAsync(ZodRealError);
 const safeParse = /* @__PURE__ */ _safeParse(ZodRealError);
 const safeParseAsync = /* @__PURE__ */ _safeParseAsync(ZodRealError);
+// Codec functions
+const encode = /* @__PURE__ */ _encode(ZodRealError);
+const decode = /* @__PURE__ */ _decode(ZodRealError);
+const encodeAsync = /* @__PURE__ */ _encodeAsync(ZodRealError);
+const decodeAsync = /* @__PURE__ */ _decodeAsync(ZodRealError);
+const safeEncode = /* @__PURE__ */ _safeEncode(ZodRealError);
+const safeDecode = /* @__PURE__ */ _safeDecode(ZodRealError);
+const safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync(ZodRealError);
+const safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);
 
 const ZodType = /*@__PURE__*/ $constructor("ZodType", (inst, def) => {
     $ZodType.init(inst, def);
     inst.def = def;
+    inst.type = def.type;
     Object.defineProperty(inst, "_def", { value: def });
     // base methods
     inst.check = (...checks) => {
-        return inst.clone({
-            ...def,
+        return inst.clone(mergeDefs(def, {
             checks: [
                 ...(def.checks ?? []),
                 ...checks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch),
             ],
-        }
-        // { parent: true }
-        );
+        }));
     };
     inst.clone = (def, params) => clone(inst, def, params);
     inst.brand = () => inst;
@@ -26540,6 +27022,15 @@ const ZodType = /*@__PURE__*/ $constructor("ZodType", (inst, def) => {
     inst.parseAsync = async (data, params) => parseAsync(inst, data, params, { callee: inst.parseAsync });
     inst.safeParseAsync = async (data, params) => safeParseAsync(inst, data, params);
     inst.spa = inst.safeParseAsync;
+    // encoding/decoding
+    inst.encode = (data, params) => encode(inst, data, params);
+    inst.decode = (data, params) => decode(inst, data, params);
+    inst.encodeAsync = async (data, params) => encodeAsync(inst, data, params);
+    inst.decodeAsync = async (data, params) => decodeAsync(inst, data, params);
+    inst.safeEncode = (data, params) => safeEncode(inst, data, params);
+    inst.safeDecode = (data, params) => safeDecode(inst, data, params);
+    inst.safeEncodeAsync = async (data, params) => safeEncodeAsync(inst, data, params);
+    inst.safeDecodeAsync = async (data, params) => safeDecodeAsync(inst, data, params);
     // refinements
     inst.refine = (check, params) => inst.check(refine(check, params));
     inst.superRefine = (refinement) => inst.check(superRefine(refinement));
@@ -26608,6 +27099,7 @@ const _ZodString = /*@__PURE__*/ $constructor("_ZodString", (inst, def) => {
     inst.normalize = (...args) => inst.check(_normalize(...args));
     inst.toLowerCase = () => inst.check(_toLowerCase());
     inst.toUpperCase = () => inst.check(_toUpperCase());
+    inst.slugify = () => inst.check(_slugify());
 });
 const ZodString = /*@__PURE__*/ $constructor("ZodString", (inst, def) => {
     $ZodString.init(inst, def);
@@ -26814,9 +27306,11 @@ function array(element, params) {
     return _array(ZodArray, element, params);
 }
 const ZodObject = /*@__PURE__*/ $constructor("ZodObject", (inst, def) => {
-    $ZodObject.init(inst, def);
+    $ZodObjectJIT.init(inst, def);
     ZodType.init(inst, def);
-    defineLazy(inst, "shape", () => def.shape);
+    defineLazy(inst, "shape", () => {
+        return def.shape;
+    });
     inst.keyof = () => _enum(Object.keys(inst._zod.def.shape));
     inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall: catchall });
     inst.passthrough = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
@@ -26826,6 +27320,9 @@ const ZodObject = /*@__PURE__*/ $constructor("ZodObject", (inst, def) => {
     inst.extend = (incoming) => {
         return extend(inst, incoming);
     };
+    inst.safeExtend = (incoming) => {
+        return safeExtend(inst, incoming);
+    };
     inst.merge = (other) => merge(inst, other);
     inst.pick = (mask) => pick(inst, mask);
     inst.omit = (mask) => omit(inst, mask);
@@ -26835,10 +27332,7 @@ const ZodObject = /*@__PURE__*/ $constructor("ZodObject", (inst, def) => {
 function object(shape, params) {
     const def = {
         type: "object",
-        get shape() {
-            assignProp(this, "shape", shape ? objectClone(shape) : {});
-            return this.shape;
-        },
+        shape: shape ?? {},
         ...normalizeParams(params),
     };
     return new ZodObject(def);
@@ -26917,6 +27411,9 @@ const ZodTransform = /*@__PURE__*/ $constructor("ZodTransform", (inst, def) => {
     $ZodTransform.init(inst, def);
     ZodType.init(inst, def);
     inst._zod.parse = (payload, _ctx) => {
+        if (_ctx.direction === "backward") {
+            throw new $ZodEncodeError(inst.constructor.name);
+        }
         payload.addIssue = (issue$1) => {
             if (typeof issue$1 === "string") {
                 payload.issues.push(issue(issue$1, payload.value, def));
@@ -27525,8 +28022,68 @@ let RpgMap = class extends RpgCommonMap {
       world.configure(maps);
     }
   }
-  addInDatabase(id, data) {
-    this.database()[id] = data;
+  /**
+   * Add data to the map's database
+   * 
+   * This method allows you to dynamically add items, classes, or any data to the map's database.
+   * By default, if an ID already exists, the operation is ignored to prevent overwriting existing data.
+   * 
+   * @param id - Unique identifier for the data
+   * @param data - The data to store (can be a class, object, or any value)
+   * @param options - Optional configuration
+   * @param options.force - If true, overwrites existing data even if ID already exists (default: false)
+   * @returns true if data was added, false if ignored (ID already exists)
+   * 
+   * @example
+   * ```ts
+   * // Add an item class to the database
+   * map.addInDatabase('Potion', PotionClass);
+   * 
+   * // Add an item object to the database
+   * map.addInDatabase('custom-item', {
+   *   name: 'Custom Item',
+   *   price: 100
+   * });
+   * 
+   * // Force overwrite existing data
+   * map.addInDatabase('Potion', UpdatedPotionClass, { force: true });
+   * ```
+   */
+  addInDatabase(id, data, options) {
+    const database = this.database();
+    if (database[id] !== void 0 && !options?.force) {
+      return false;
+    }
+    database[id] = data;
+    return true;
+  }
+  /**
+   * Remove data from the map's database
+   * 
+   * This method allows you to remove items or data from the map's database.
+   * 
+   * @param id - Unique identifier of the data to remove
+   * @returns true if data was removed, false if ID didn't exist
+   * 
+   * @example
+   * ```ts
+   * // Remove an item from the database
+   * map.removeInDatabase('Potion');
+   * 
+   * // Check if removal was successful
+   * const removed = map.removeInDatabase('custom-item');
+   * if (removed) {
+   *   console.log('Item removed successfully');
+   * }
+   * ```
+   */
+  removeInDatabase(id) {
+    const database = this.database();
+    if (database[id] === void 0) {
+      return false;
+    }
+    delete database[id];
+    return true;
   }
   /**
    * Creates a dynamic event on the map
@@ -28381,5 +28938,5 @@ function provideServerModules(modules) {
   });
 }
 
-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, Frequency, Gui, INT, INT_CURVE, MAXHP, MAXHP_CURVE, MAXSP, MAXSP_CURVE, MenuGui, Move, NotificationGui, ObjectSubject$1 as ObjectSubject, PDEF, RpgEvent, RpgMap, 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$1 as ArraySubject, COEFFICIENT_ELEMENTS, Components, DAMAGE_CRITICAL, DAMAGE_GUARD, DAMAGE_PHYSIC, DAMAGE_SKILL, DEX, DEX_CURVE, DialogGui, DialogPosition, Frequency, Gui, INT, INT_CURVE, MAXHP, MAXHP_CURVE, MAXSP, MAXSP_CURVE, 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 };
 //# sourceMappingURL=index.js.map