@rpgjs/server 5.0.0-alpha.29 → 5.0.0-alpha.30

package/dist/index.js

@@ -4409,8 +4409,8 @@ var z = /*#__PURE__*/Object.freeze({
     ZodError: ZodError
 });
 
-var __defProp$8 = Object.defineProperty;
-var __name$3 = (target, value) => __defProp$8(target, "name", { value, configurable: true });
+var __defProp$a = Object.defineProperty;
+var __name$3 = (target, value) => __defProp$a(target, "name", { value, configurable: true });
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -6204,8 +6204,8 @@ function throttleTime(duration, scheduler, config) {
     return throttle$1(function () { return duration$; }, config);
 }
 
-var __defProp$7 = Object.defineProperty;
-var __name$2 = (target, value) => __defProp$7(target, "name", { value, configurable: true });
+var __defProp$9 = Object.defineProperty;
+var __name$2 = (target, value) => __defProp$9(target, "name", { value, configurable: true });
 var ArraySubject = class extends BehaviorSubject {
   static {
     __name$2(this, "ArraySubject");
@@ -6810,6 +6810,70 @@ function createStatesSnapshot(instance) {
   return persistObject;
 }
 __name$3(createStatesSnapshot, "createStatesSnapshot");
+var SNAPSHOT_SKIP = Symbol("snapshot-skip");
+var serializeSnapshotDeep = /* @__PURE__ */ __name$3((value, path, options, seen) => {
+  if (isSignal(value)) {
+    return serializeSnapshotDeep(value(), path, options, seen);
+  }
+  if (value instanceof Map) {
+    return SNAPSHOT_SKIP;
+  }
+  if (options.filter && !options.filter(value, path)) {
+    return SNAPSHOT_SKIP;
+  }
+  if (value instanceof Date) {
+    return options.dateToString ? options.dateToString(value) : value.toISOString();
+  }
+  if (value && typeof value === "object") {
+    if (seen.has(value)) {
+      return SNAPSHOT_SKIP;
+    }
+    seen.add(value);
+    if (Array.isArray(value)) {
+      const result2 = [];
+      value.forEach((item, index) => {
+        const itemPath = path ? `${path}.${index}` : String(index);
+        const serialized = serializeSnapshotDeep(item, itemPath, options, seen);
+        if (serialized !== SNAPSHOT_SKIP) {
+          result2.push(serialized);
+        }
+      });
+      return result2;
+    }
+    const result = {};
+    const idKey = isInstanceOfClass(value) ? value.constructor?._propertyMetadata?.get("id") : void 0;
+    const entries = Object.entries(value).filter(([key]) => isInstanceOfClass(value) ? key.startsWith("__") || (idKey ? key === idKey : false) : true);
+    for (const [key, childValue] of entries) {
+      const normalizedKey = key.startsWith("__") ? key.slice(2) : key;
+      const childPath = path ? `${path}.${normalizedKey}` : normalizedKey;
+      const serialized = serializeSnapshotDeep(childValue, childPath, options, seen);
+      if (serialized !== SNAPSHOT_SKIP) {
+        result[normalizedKey] = serialized;
+      }
+    }
+    return result;
+  }
+  return value;
+}, "serializeSnapshotDeep");
+function createStatesSnapshotDeep(instance, options = {}) {
+  const persistObject = {};
+  if (instance?.$snapshot) {
+    for (const key of instance.$snapshot.keys()) {
+      const signal = instance.$snapshot.get(key);
+      const persist2 = signal.options.persist ?? true;
+      if (!persist2) {
+        continue;
+      }
+      const value = signal();
+      const serialized = serializeSnapshotDeep(value, key, options, /* @__PURE__ */ new WeakSet());
+      if (serialized !== SNAPSHOT_SKIP) {
+        persistObject[key] = serialized;
+      }
+    }
+  }
+  return persistObject;
+}
+__name$3(createStatesSnapshotDeep, "createStatesSnapshotDeep");
 function setMetadata(target, key, value) {
   const meta = target.constructor._propertyMetadata;
   const propId = meta?.get(key);
@@ -7135,8 +7199,8 @@ function getByPath(root, path) {
 }
 __name$3(getByPath, "getByPath");
 
-var __defProp$6 = Object.defineProperty;
-var __name$1 = (target, value) => __defProp$6(target, "name", { value, configurable: true });
+var __defProp$8 = Object.defineProperty;
+var __name$1 = (target, value) => __defProp$8(target, "name", { value, configurable: true });
 
 // src/decorators.ts
 function Action(name, bodyValidation) {
@@ -7815,7 +7879,7 @@ var Server = class {
         console.error("[sessionTransfer] `users` property not defined in the room.");
         return null;
       }
-      const userSnapshot = createStatesSnapshot(user);
+      const userSnapshot = createStatesSnapshotDeep(user);
       const transferData = {
         privateId,
         userSnapshot,
@@ -8070,7 +8134,7 @@ var Server = class {
         } else {
           user = isClass(classType) ? new classType() : classType(conn, ctx);
           signal2()[publicId] = user;
-          const snapshot = createStatesSnapshot(user);
+          const snapshot = createStatesSnapshotDeep(user);
           this.room.storage.put(`${usersPropName}.${publicId}`, snapshot);
         }
       } else {
@@ -8471,9 +8535,17 @@ var Server = class {
         if (signal2 && usersPropName) {
           const { classType } = signal2.options;
           const user = isClass(classType) ? new classType() : classType();
-          load(user, userSnapshot, true);
+          const hydratedSnapshot = await awaitReturn(subRoom["onSessionRestore"]?.({
+            userSnapshot,
+            user,
+            publicId,
+            privateId,
+            sessionState,
+            room: this.room
+          })) ?? userSnapshot;
+          load(user, hydratedSnapshot, true);
           signal2()[publicId] = user;
-          await this.room.storage.put(`${usersPropName}.${publicId}`, userSnapshot);
+          await this.room.storage.put(`${usersPropName}.${publicId}`, hydratedSnapshot);
         }
       }
       const transferToken = generateShortUUID$1();
@@ -9808,13 +9880,13 @@ function createRequireSessionGuard(storage) {
 }
 __name$1(createRequireSessionGuard, "createRequireSessionGuard");
 
-var __defProp$5 = Object.defineProperty;
-var __decorateClass$4 = (decorators, target, key, kind) => {
+var __defProp$7 = Object.defineProperty;
+var __decorateClass$6 = (decorators, target, key, kind) => {
   var result = void 0 ;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (decorator(target, key, result) ) || result;
-  if (result) __defProp$5(target, key, result);
+  if (result) __defProp$7(target, key, result);
   return result;
 };
 class Item {
@@ -9823,39 +9895,67 @@ class Item {
     this.name = signal("");
     this.description = signal("");
     this.price = signal(0);
+    this.atk = signal(0);
+    this.pdef = signal(0);
+    this.sdef = signal(0);
     this.quantity = signal(1);
     this.onAdd = () => {
     };
     this.description.set(data?.description ?? "");
     this.price.set(data?.price ?? 0);
     this.name.set(data?.name ?? "");
+    this.atk.set(data?.atk ?? 0);
+    this.pdef.set(data?.pdef ?? 0);
+    this.sdef.set(data?.sdef ?? 0);
     this.onAdd = data?.onAdd?.bind(this) ?? (() => {
     });
   }
 }
-__decorateClass$4([
+__decorateClass$6([
   id()
 ], Item.prototype, "id");
-__decorateClass$4([
-  sync()
-], Item.prototype, "name");
-__decorateClass$4([
-  sync()
-], Item.prototype, "description");
-__decorateClass$4([
-  sync()
-], Item.prototype, "price");
-__decorateClass$4([
+__decorateClass$6([
   sync()
 ], Item.prototype, "quantity");
 
-var __defProp$4 = Object.defineProperty;
-var __decorateClass$3 = (decorators, target, key, kind) => {
+var __defProp$6 = Object.defineProperty;
+var __decorateClass$5 = (decorators, target, key, kind) => {
+  var result = void 0 ;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(target, key, result) ) || result;
+  if (result) __defProp$6(target, key, result);
+  return result;
+};
+class Skill {
+  constructor(data) {
+    this.id = signal("");
+    this.name = signal("");
+    this.description = signal("");
+    this.spCost = signal(0);
+    this.hitRate = signal(0);
+    this.power = signal(0);
+    this.coefficient = signal({});
+    this.id.set(data?.id ?? "");
+    this.name.set(data?.name ?? "");
+    this.description.set(data?.description ?? "");
+    this.spCost.set(data?.spCost ?? 0);
+    this.hitRate.set(data?.hitRate ?? 0);
+    this.power.set(data?.power ?? 0);
+    this.coefficient.set(data?.coefficient ?? {});
+  }
+}
+__decorateClass$5([
+  id()
+], Skill.prototype, "id");
+
+var __defProp$5 = Object.defineProperty;
+var __decorateClass$4 = (decorators, target, key, kind) => {
   var result = void 0 ;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (decorator(target, key, result) ) || result;
-  if (result) __defProp$4(target, key, result);
+  if (result) __defProp$5(target, key, result);
   return result;
 };
 var Direction = /* @__PURE__ */ ((Direction2) => {
@@ -10026,109 +10126,111 @@ class RpgCommonPlayer {
     return this.direction();
   }
 }
-__decorateClass$3([
+__decorateClass$4([
   id()
 ], RpgCommonPlayer.prototype, "id");
-__decorateClass$3([
+__decorateClass$4([
   sync()
 ], RpgCommonPlayer.prototype, "name");
-__decorateClass$3([
+__decorateClass$4([
   sync()
 ], RpgCommonPlayer.prototype, "type");
-__decorateClass$3([
+__decorateClass$4([
   sync()
 ], RpgCommonPlayer.prototype, "x");
-__decorateClass$3([
+__decorateClass$4([
   sync()
 ], RpgCommonPlayer.prototype, "y");
-__decorateClass$3([
+__decorateClass$4([
   sync()
 ], RpgCommonPlayer.prototype, "z");
-__decorateClass$3([
+__decorateClass$4([
   sync()
 ], RpgCommonPlayer.prototype, "tint");
-__decorateClass$3([
+__decorateClass$4([
   sync()
 ], RpgCommonPlayer.prototype, "direction");
-__decorateClass$3([
+__decorateClass$4([
   sync()
 ], RpgCommonPlayer.prototype, "speed");
-__decorateClass$3([
+__decorateClass$4([
   sync()
 ], RpgCommonPlayer.prototype, "graphics");
-__decorateClass$3([
-  sync()
+__decorateClass$4([
+  sync({
+    persist: false
+  })
 ], RpgCommonPlayer.prototype, "canMove");
-__decorateClass$3([
+__decorateClass$4([
   sync()
 ], RpgCommonPlayer.prototype, "hitbox");
-__decorateClass$3([
+__decorateClass$4([
   sync()
 ], RpgCommonPlayer.prototype, "_gold");
-__decorateClass$3([
+__decorateClass$4([
   sync()
 ], RpgCommonPlayer.prototype, "animationName");
-__decorateClass$3([
+__decorateClass$4([
   sync()
 ], RpgCommonPlayer.prototype, "hpSignal");
-__decorateClass$3([
+__decorateClass$4([
   sync()
 ], RpgCommonPlayer.prototype, "spSignal");
-__decorateClass$3([
+__decorateClass$4([
   sync()
 ], RpgCommonPlayer.prototype, "_exp");
-__decorateClass$3([
+__decorateClass$4([
   sync()
 ], RpgCommonPlayer.prototype, "_level");
-__decorateClass$3([
+__decorateClass$4([
   sync()
 ], RpgCommonPlayer.prototype, "_class");
-__decorateClass$3([
+__decorateClass$4([
   sync(Item)
 ], RpgCommonPlayer.prototype, "items");
-__decorateClass$3([
+__decorateClass$4([
   sync()
 ], RpgCommonPlayer.prototype, "equipments");
-__decorateClass$3([
+__decorateClass$4([
   sync()
 ], RpgCommonPlayer.prototype, "states");
-__decorateClass$3([
-  sync()
+__decorateClass$4([
+  sync(Skill)
 ], RpgCommonPlayer.prototype, "skills");
-__decorateClass$3([
+__decorateClass$4([
   sync()
 ], RpgCommonPlayer.prototype, "_effects");
-__decorateClass$3([
+__decorateClass$4([
   sync()
 ], RpgCommonPlayer.prototype, "_through");
-__decorateClass$3([
+__decorateClass$4([
   sync()
 ], RpgCommonPlayer.prototype, "_throughOtherPlayer");
-__decorateClass$3([
+__decorateClass$4([
   sync()
 ], RpgCommonPlayer.prototype, "_throughEvent");
-__decorateClass$3([
+__decorateClass$4([
   sync()
 ], RpgCommonPlayer.prototype, "_frequency");
-__decorateClass$3([
+__decorateClass$4([
   sync()
 ], RpgCommonPlayer.prototype, "_frames");
-__decorateClass$3([
+__decorateClass$4([
   sync()
 ], RpgCommonPlayer.prototype, "componentsTop");
-__decorateClass$3([
+__decorateClass$4([
   sync()
 ], RpgCommonPlayer.prototype, "componentsBottom");
-__decorateClass$3([
+__decorateClass$4([
   sync()
 ], RpgCommonPlayer.prototype, "componentsCenter");
-__decorateClass$3([
+__decorateClass$4([
   sync()
 ], RpgCommonPlayer.prototype, "componentsLeft");
-__decorateClass$3([
+__decorateClass$4([
   sync()
 ], RpgCommonPlayer.prototype, "componentsRight");
-__decorateClass$3([
+__decorateClass$4([
   connected()
 ], RpgCommonPlayer.prototype, "isConnected");
 
@@ -17668,6 +17770,7 @@ var PrebuiltGui = /* @__PURE__ */ ((PrebuiltGui2) => {
   PrebuiltGui2["Save"] = "rpg-save";
   PrebuiltGui2["Controls"] = "rpg-controls";
   PrebuiltGui2["Notification"] = "rpg-notification";
+  PrebuiltGui2["TitleScreen"] = "rpg-title-screen";
   return PrebuiltGui2;
 })(PrebuiltGui || {});
 
@@ -17869,6 +17972,16 @@ class PerlinNoise2D {
   }
 }
 
+const MAXHP = "maxHp";
+const MAXSP = "maxSp";
+const ATK = "atk";
+const PDEF = "pdef";
+const SDEF = "sdef";
+const STR = "str";
+const AGI = "agi";
+const INT = "int";
+const DEX = "dex";
+
 function WithComponentManager(Base) {
   return class extends Base {
     setGraphic(graphic) {
@@ -18149,8 +18262,8 @@ function WithComponentManager(Base) {
   };
 }
 
-var __defProp$3 = Object.defineProperty;
-var __name = (target, value) => __defProp$3(target, "name", { value, configurable: true });
+var __defProp$4 = Object.defineProperty;
+var __name = (target, value) => __defProp$4(target, "name", { value, configurable: true });
 
 // src/inject.ts
 var DEFAULT_INSTANCE_KEY = "__default__";
@@ -18520,6 +18633,7 @@ class Gui {
     this._close = () => {
     };
     this._blockPlayerInput = false;
+    this._events = /* @__PURE__ */ new Map();
   }
   open(data, {
     waitingAction = false,
@@ -18541,6 +18655,17 @@ class Gui {
       }
     });
   }
+  on(event, callback) {
+    this._events.set(event, callback);
+  }
+  async emit(event, data) {
+    const callback = this._events.get(event);
+    if (callback) {
+      return await callback(data);
+    } else {
+      return null;
+    }
+  }
   close(data) {
     this.player.emit("gui.exit", this.id);
     if (this._blockPlayerInput) {
@@ -18548,6 +18673,13 @@ class Gui {
     }
     this._close(data);
   }
+  update(data, { clientActionId } = {}) {
+    this.player.emit("gui.update", {
+      guiId: this.id,
+      data,
+      clientActionId
+    });
+  }
 }
 
 class AdditiveKnockback {
@@ -19751,9 +19883,17 @@ class DialogGui extends Gui {
     if (!options.choices) options.choices = [];
     if (options.autoClose == void 0) options.autoClose = false;
     if (!options.position) options.position = "bottom" /* Bottom */;
-    if (options.fullWidth == void 0) options.fullWidth = true;
+    if (options.fullWidth == void 0) options.fullWidth = false;
     if (options.typewriterEffect == void 0) options.typewriterEffect = true;
     const event = options.talkWith;
+    const resolveName = (target) => {
+      if (!target) return void 0;
+      const rawName = target.name;
+      if (typeof rawName === "function") return rawName();
+      if (rawName && typeof rawName.get === "function") return rawName.get();
+      return rawName;
+    };
+    const speaker = options.speaker ?? resolveName(event);
     let memoryDir;
     if (event) {
       memoryDir = event.direction();
@@ -19765,6 +19905,7 @@ class DialogGui extends Gui {
       position: options.position,
       fullWidth: options.fullWidth,
       typewriterEffect: options.typewriterEffect,
+      speaker,
       // remove value property. It is not useful to know this on the client side.
       choices: options.choices.map((choice) => ({
         text: choice.text
@@ -19787,20 +19928,293 @@ class DialogGui extends Gui {
   }
 }
 
-class MenuGui extends Gui {
+class SaveLoadGui extends Gui {
   constructor(player) {
-    super(PrebuiltGui.MainMenu, player);
+    super(PrebuiltGui.Save, player);
+  }
+  open(slots = [], options = {}) {
+    const mode = options.mode || "load";
+    const maxSlots = options.maxSlots ?? slots.length;
+    const normalizedSlots = Array.from({ length: maxSlots }, (_, index) => slots[index] ?? null);
+    const uiSlots = normalizedSlots.map((slot) => {
+      if (!slot) return null;
+      const { snapshot, ...data } = slot;
+      return data;
+    });
+    const onSelect = async ({ index }) => {
+      if (typeof index !== "number") return;
+      if (index < 0 || index >= normalizedSlots.length) return;
+      const slot = normalizedSlots[index];
+      if (mode === "load") {
+        const result = await this.player.load(index, { reason: "load", source: "gui" }, { changeMap: true });
+        if (!result.ok) return;
+        this.close(index);
+        return;
+      }
+      if (mode === "save") {
+        const result = await this.player.save(index, {}, { reason: "manual", source: "gui" });
+        if (!result) return;
+        const updatedSlot = {
+          ...slot || {},
+          ...result.meta
+        };
+        normalizedSlots[index] = updatedSlot;
+        slots[index] = updatedSlot;
+        this.close(index);
+      }
+    };
+    this.on("save", onSelect);
+    this.on("load", onSelect);
+    this.on("select", onSelect);
+    return super.open({ slots: uiSlots, mode }, {
+      waitingAction: true,
+      blockPlayerInput: true
+    });
+  }
+}
+
+let context$1 = null;
+function inject(service, _context) {
+  const c = _context ?? context$1;
+  if (!c) throw new Error("Context is not set. use setInject() to set the context");
+  return inject$1(c, service);
+}
+function setInject(_context) {
+  context$1 = _context;
+}
+function clearInject() {
+  context$1 = null;
+}
+
+const SaveStorageToken = "SaveStorageToken";
+class InMemorySaveStorageStrategy {
+  constructor() {
+    this.slotsByPlayer = /* @__PURE__ */ new Map();
+  }
+  async list(player) {
+    return this.stripSnapshots(this.getSlots(player));
+  }
+  async get(player, index) {
+    const slots = this.getSlots(player);
+    const slot = slots[index];
+    return slot ?? null;
+  }
+  async save(player, index, snapshot, meta) {
+    const slots = this.getSlots(player);
+    const existing = slots[index];
+    slots[index] = {
+      ...existing ?? {},
+      ...meta,
+      snapshot
+    };
+  }
+  async delete(player, index) {
+    const slots = this.getSlots(player);
+    slots[index] = null;
+  }
+  getSlots(player) {
+    const key = player.id ?? "unknown";
+    if (!this.slotsByPlayer.has(key)) {
+      this.slotsByPlayer.set(key, []);
+    }
+    return this.slotsByPlayer.get(key);
+  }
+  stripSnapshots(slots) {
+    return slots.map((slot) => {
+      if (!slot) return null;
+      const { snapshot, ...meta } = slot;
+      return meta;
+    });
+  }
+}
+let cachedSaveStorage = null;
+let cachedAutoSave = null;
+const AutoSaveToken = "AutoSaveToken";
+function resolveSaveStorageStrategy() {
+  if (cachedSaveStorage) return cachedSaveStorage;
+  try {
+    cachedSaveStorage = inject(SaveStorageToken);
+  } catch {
+    cachedSaveStorage = new InMemorySaveStorageStrategy();
+  }
+  return cachedSaveStorage;
+}
+function resolveAutoSaveStrategy() {
+  if (cachedAutoSave) return cachedAutoSave;
+  try {
+    cachedAutoSave = inject(AutoSaveToken);
+  } catch {
+    cachedAutoSave = null;
+  }
+  cachedAutoSave ||= {
+    canSave: () => true,
+    canLoad: () => true,
+    shouldAutoSave: () => false,
+    getDefaultSlot: () => 0
+  };
+  return cachedAutoSave;
+}
+function resolveSaveSlot(slot, policy, player, context) {
+  if (typeof slot === "number") return slot;
+  const resolver = policy.getDefaultSlot;
+  if (!resolver) return null;
+  return resolver(player, context);
+}
+function shouldAutoSave(player, context) {
+  const strategy = resolveAutoSaveStrategy();
+  if (!strategy.shouldAutoSave) return false;
+  return strategy.shouldAutoSave(player, context);
+}
+function buildSaveSlotMeta(player, overrides = {}) {
+  const mapId = player.getCurrentMap()?.id;
+  const base = {
+    level: typeof player.level === "number" ? player.level : void 0,
+    exp: typeof player.exp === "number" ? player.exp : void 0,
+    map: typeof mapId === "string" ? mapId : void 0,
+    date: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return { ...base, ...overrides };
+}
+function provideSaveStorage(strategy) {
+  return {
+    provide: SaveStorageToken,
+    useValue: strategy
+  };
+}
+function provideAutoSave(strategy) {
+  return {
+    provide: AutoSaveToken,
+    useValue: strategy
+  };
+}
+
+class MenuGui extends Gui {
+  constructor(player2) {
+    super(PrebuiltGui.MainMenu, player2);
+    this.menuOptions = {};
+  }
+  buildSaveLoad(options) {
+    const autoSave = resolveAutoSaveStrategy();
+    const canSave = autoSave.canSave ? autoSave.canSave(this.player, { reason: "manual", source: "menu" }) : true;
+    const autoSlotIndex = options.saveAutoSlotIndex ?? autoSave.getDefaultSlot?.(this.player, { reason: "auto", source: "menu" }) ?? 0;
+    return {
+      mode: "save",
+      canSave,
+      showAutoSlot: options.saveShowAutoSlot === true,
+      autoSlotIndex,
+      autoSlotLabel: options.saveAutoSlotLabel
+    };
+  }
+  buildMenuData(options) {
+    const disabledSet = new Set(options.disabled || []);
+    const defaultMenus = [
+      { id: "items", label: "Items" },
+      { id: "skills", label: "Skills" },
+      { id: "equip", label: "Equip" },
+      { id: "options", label: "Options" },
+      { id: "save", label: "Save" },
+      { id: "exit", label: "Exit" }
+    ];
+    const menus = (options.menus && options.menus.length ? options.menus : defaultMenus).map((menu) => ({
+      ...menu,
+      disabled: menu.disabled || disabledSet.has(menu.id)
+    }));
+    const player2 = this.player;
+    const databaseById = player2.databaseById?.bind(player2);
+    const equippedIds = new Set(
+      (player2.equipments?.() || []).map((it) => it?.id?.() ?? it?.id ?? it?.name)
+    );
+    const buildStats = () => {
+      const params = player2.param || {};
+      const statKeys = [
+        "str",
+        "dex",
+        "int",
+        "agi",
+        "maxHp",
+        "maxSp"
+      ];
+      const stats = {};
+      statKeys.forEach((key) => {
+        stats[key] = params[key] ?? 0;
+      });
+      stats.pdef = player2.pdef ?? params.pdef ?? 0;
+      stats.sdef = player2.sdef ?? params.sdef ?? 0;
+      stats.atk = player2.atk ?? params.atk ?? 0;
+      return stats;
+    };
+    const items = (player2.items?.() || []).map((item) => {
+      const id = item.id();
+      const data = databaseById ? databaseById(id) : {};
+      const type = data?._type ?? "item";
+      const consumable = data?.consumable;
+      const isConsumable = consumable !== void 0 ? consumable : type === "item";
+      const usable = isConsumable === false ? false : consumable === void 0 && type !== "item" ? false : true;
+      return {
+        id,
+        name: item.name(),
+        description: item.description(),
+        quantity: item.quantity(),
+        icon: data?.icon ?? item?.icon,
+        atk: item.atk(),
+        pdef: item.pdef(),
+        sdef: item.sdef(),
+        consumable: isConsumable,
+        type,
+        usable,
+        equipped: equippedIds.has(id)
+      };
+    });
+    const menuEquips = items.filter((item) => item.type === "weapon" || item.type === "armor");
+    const skills = (player2.skills?.() || []).map((skill) => ({
+      id: skill?.id() ?? skill?.name(),
+      name: skill?.name() ?? skill?.id() ?? "Skill",
+      description: skill?.description() ?? "",
+      spCost: skill?.spCost() ?? 0
+    }));
+    const saveLoad = this.buildSaveLoad(options);
+    return { menus, items, equips: menuEquips, skills, saveLoad, playerStats: buildStats() };
   }
-  open() {
-    this.on("useItem", (id) => {
+  refreshMenu(clientActionId) {
+    const data = this.buildMenuData(this.menuOptions);
+    this.update(data, { clientActionId });
+  }
+  open(options = {}) {
+    this.menuOptions = options;
+    const data = this.buildMenuData(options);
+    this.on("useItem", ({ id, clientActionId }) => {
       try {
         this.player.useItem(id);
         this.player.syncChanges();
       } catch (err) {
         this.player.showNotification(err.msg);
+      } finally {
+        this.refreshMenu(clientActionId);
+      }
+    });
+    this.on("equipItem", ({ id, equip, clientActionId }) => {
+      try {
+        this.player.equip(id, equip);
+        this.player.syncChanges();
+      } catch (err) {
+        this.player.showNotification(err.msg);
+      } finally {
+        this.refreshMenu(clientActionId);
       }
     });
-    return super.open("", {
+    this.on("openSave", async () => {
+      this.close();
+      const gui = new SaveLoadGui(this.player);
+      player._gui[gui.id] = gui;
+      await gui.open(options.saveSlots || [], {
+        mode: "save",
+        maxSlots: options.saveMaxSlots
+      });
+    });
+    this.on("exit", () => {
+      this.close("exit");
+    });
+    return super.open(data, {
       waitingAction: true,
       blockPlayerInput: true
     });
@@ -19810,33 +20224,127 @@ class MenuGui extends Gui {
 class ShopGui extends Gui {
   constructor(player) {
     super(PrebuiltGui.Shop, player);
-  }
-  open(items) {
-    items = items.map((item) => {
-      const it = new item();
+    this.itemsInput = [];
+    this.sellMultipliers = {};
+    this.baseSellMultiplier = 0.5;
+  }
+  normalizeSellMultipliers(sell) {
+    if (!sell) return {};
+    if (Array.isArray(sell)) {
+      return sell.reduce((acc, entry) => {
+        if (entry && entry.id) acc[entry.id] = entry.multiplier ?? 0;
+        return acc;
+      }, {});
+    }
+    return { ...sell };
+  }
+  buildShopData() {
+    const player = this.player;
+    const databaseById = player.databaseById?.bind(player);
+    const equippedIds = new Set(
+      (player.equipments?.() || []).map((it) => it?.id?.() ?? it?.id ?? it?.name)
+    );
+    const playerParams = {
+      ...player.param || {},
+      atk: player.atk ?? 0,
+      def: player.pdef ?? 0,
+      pdef: player.pdef ?? 0,
+      sdef: player.sdef ?? 0
+    };
+    const getStatValue = (data, key, fallbackKeys = []) => {
+      if (data && typeof data[key] === "number") return data[key];
+      for (const fallbackKey of fallbackKeys) {
+        if (data && typeof data[fallbackKey] === "number") return data[fallbackKey];
+      }
+      const modifier = data?.paramsModifier?.[key];
+      if (modifier && typeof modifier.value === "number") return modifier.value;
+      for (const fallbackKey of fallbackKeys) {
+        const fallbackModifier = data?.paramsModifier?.[fallbackKey];
+        if (fallbackModifier && typeof fallbackModifier.value === "number") return fallbackModifier.value;
+      }
+      return void 0;
+    };
+    const buildItemData = (item, overrides = {}) => {
+      const rawId = typeof item === "string" ? item : typeof item?.id === "function" ? item.id() : item?.id ?? item?.name;
+      const data = databaseById(rawId);
+      const itemName = typeof item?.name === "function" ? item.name() : item?.name;
+      const itemDescription = typeof item?.description === "function" ? item.description() : item?.description;
+      const itemPrice = typeof item?.price === "function" ? item.price() : item?.price;
+      const itemIcon = typeof item?.icon === "function" ? item.icon() : item?.icon;
+      const atk = getStatValue(data, "atk");
+      const def = getStatValue(data, "def", ["pdef", "sdef"]);
+      const intValue = getStatValue(data, "int");
+      const agi = getStatValue(data, "agi");
+      const stats = {
+        ...atk !== void 0 ? { atk } : {},
+        ...def !== void 0 ? { def } : {},
+        ...intValue !== void 0 ? { int: intValue } : {},
+        ...agi !== void 0 ? { agi } : {}
+      };
       return {
-        price: it.price,
-        name: it.name,
-        description: it.description,
-        id: it.id,
-        type: item.type
+        price: overrides.price ?? data?.price ?? itemPrice ?? 0,
+        name: data?.name ?? itemName ?? rawId,
+        description: data?.description ?? itemDescription ?? "",
+        icon: data?.icon ?? itemIcon,
+        id: rawId,
+        type: data?._type ?? item.type ?? item?._type,
+        stats: Object.keys(stats).length ? stats : void 0,
+        equipped: rawId ? equippedIds.has(rawId) : false,
+        ...overrides.quantity !== void 0 ? { quantity: overrides.quantity } : {}
       };
-    });
-    this.on("buyItem", ({ id, nb }) => {
+    };
+    const items = this.itemsInput.map((item) => buildItemData(item));
+    const sellItems = (player.items?.() || []).map((item) => {
+      const id = item?.id?.();
+      if (!id) return null;
+      const multiplier = Object.prototype.hasOwnProperty.call(this.sellMultipliers, id) ? this.sellMultipliers[id] : this.baseSellMultiplier;
+      const basePrice = databaseById(id)?.price ?? (typeof item?.price === "function" ? item.price() : item?.price) ?? 0;
+      const price = basePrice * multiplier;
+      const quantity = item?.quantity?.();
+      return buildItemData(item, { price, quantity });
+    }).filter(Boolean);
+    return { items, sellItems, playerParams, message: this.messageInput, face: this.faceInput };
+  }
+  refreshShop(clientActionId) {
+    this.update(this.buildShopData(), { clientActionId });
+  }
+  open(itemsOrOptions) {
+    const options = Array.isArray(itemsOrOptions) ? { items: itemsOrOptions } : itemsOrOptions || { items: [] };
+    this.itemsInput = options.items || [];
+    this.baseSellMultiplier = typeof options.sellMultiplier === "number" ? options.sellMultiplier : 0.5;
+    this.sellMultipliers = this.normalizeSellMultipliers(options.sell);
+    this.messageInput = options.message;
+    this.faceInput = options.face;
+    this.on("buyItem", ({ id, nb, clientActionId }) => {
       try {
         this.player.buyItem(id, nb);
+        this.player.syncChanges();
       } catch (err) {
         console.log(err);
+      } finally {
+        this.refreshShop(clientActionId);
       }
     });
-    this.on("sellItem", ({ id, nb }) => {
+    this.on("sellItem", ({ id, nb, clientActionId }) => {
       try {
-        this.player.sellItem(id, nb);
+        const multiplier = Object.prototype.hasOwnProperty.call(this.sellMultipliers, id) ? this.sellMultipliers[id] : this.baseSellMultiplier;
+        const basePrice = this.player.databaseById?.(id)?.price ?? (typeof inventory?.price === "function" ? inventory.price() : inventory?.price) ?? 0;
+        const price = basePrice * multiplier;
+        if (!basePrice || price <= 0) return;
+        const inventory = this.player.getItem?.(id);
+        if (!inventory) return;
+        const quantity = inventory.quantity();
+        if (quantity - nb < 0) return;
+        this.player._gold.update((gold) => gold + price * nb);
+        this.player.removeItem(id, nb);
+        this.player.syncChanges();
       } catch (err) {
         console.log(err);
+      } finally {
+        this.refreshShop(clientActionId);
       }
     });
-    return super.open({ items }, {
+    return super.open(this.buildShopData(), {
       waitingAction: true,
       blockPlayerInput: true
     });
@@ -19849,18 +20357,48 @@ class NotificationGui extends Gui {
   }
 }
 
-function WithGuiManager(Base) {
-  class GuiManagerMixin extends Base {
-    constructor() {
-      super(...arguments);
-      this._gui = {};
-    }
-    showText(msg, options = {}) {
-      const gui = new DialogGui(this);
-      this._gui[gui.id] = gui;
-      return gui.openDialog(msg, options);
-    }
-    showChoices(msg, choices, options) {
+class TitleGui extends Gui {
+  constructor(player) {
+    super(PrebuiltGui.TitleScreen, player);
+  }
+  open(options = {}) {
+    this.on("select", (selection) => {
+      this.close(selection);
+    });
+    return super.open(options, {
+      waitingAction: true,
+      blockPlayerInput: true
+    });
+  }
+}
+
+class GameoverGui extends Gui {
+  constructor(player) {
+    super(PrebuiltGui.Gameover, player);
+  }
+  open(options = {}) {
+    this.on("select", (selection) => {
+      this.close(selection);
+    });
+    return super.open(options, {
+      waitingAction: true,
+      blockPlayerInput: true
+    });
+  }
+}
+
+function WithGuiManager(Base) {
+  class GuiManagerMixin extends Base {
+    constructor() {
+      super(...arguments);
+      this._gui = {};
+    }
+    showText(msg, options = {}) {
+      const gui = new DialogGui(this);
+      this._gui[gui.id] = gui;
+      return gui.openDialog(msg, options);
+    }
+    showChoices(msg, choices, options) {
       return this.showText(msg, {
         choices,
         ...options
@@ -19870,18 +20408,35 @@ function WithGuiManager(Base) {
       });
     }
     showNotification(message, options = {}) {
-      const gui = new NotificationGui(this);
-      this._gui[gui.id] = gui;
-      const data = {
+      this.emit("notification", {
         message,
         ...options
-      };
-      return gui.open(data);
+      });
+      return Promise.resolve(true);
     }
-    callMainMenu() {
+    callMainMenu(options = {}) {
       const gui = new MenuGui(this);
       this._gui[gui.id] = gui;
-      return gui.open();
+      return gui.open(options);
+    }
+    callGameover(options = {}) {
+      const gui = new GameoverGui(this);
+      this._gui[gui.id] = gui;
+      return gui.open(options);
+    }
+    showSaveLoad(slots = [], options = {}) {
+      const gui = new SaveLoadGui(this);
+      this._gui[gui.id] = gui;
+      return gui.open(slots, options).then((index) => {
+        if (typeof index !== "number") return null;
+        return index;
+      });
+    }
+    showSave(slots = [], options = {}) {
+      return this.showSaveLoad(slots, { ...options, mode: "save" });
+    }
+    showLoad(slots = [], options = {}) {
+      return this.showSaveLoad(slots, { ...options, mode: "load" });
     }
     /**
      * Calls shop menu. Opens the GUI named `rpg-shop`
@@ -19936,6 +20491,9 @@ function WithGuiManager(Base) {
       this._gui[guiId] = gui;
       return gui;
     }
+    getGui(guiId) {
+      return this._gui[guiId];
+    }
     /**
      * Closes the GUI and removes it from memory
      *
@@ -20032,91 +20590,30 @@ function WithVariableManager(Base) {
   return class extends Base {
     constructor() {
       super(...arguments);
-      this.variables = /* @__PURE__ */ new Map();
+      this.variables = type(signal({}), "variables", { persist: true }, this);
     }
     setVariable(key, val) {
-      this.variables.set(key, val);
+      this.variables()[key] = val;
     }
     getVariable(key) {
-      return this.variables.get(key);
+      return this.variables()[key];
     }
     removeVariable(key) {
-      return this.variables.delete(key);
+      delete this.variables()[key];
+      return true;
     }
     hasVariable(key) {
-      return this.variables.has(key);
+      return key in this.variables();
     }
     getVariableKeys() {
-      return Array.from(this.variables.keys());
+      return Object.keys(this.variables());
     }
     clearVariables() {
-      this.variables.clear();
+      this.variables.set({});
     }
   };
 }
 
-const MAXHP = "maxHp";
-const MAXSP = "maxSp";
-const ATK = "atk";
-const PDEF = "pdef";
-const SDEF = "sdef";
-const STR = "str";
-const AGI = "agi";
-const INT = "int";
-const DEX = "dex";
-const MAXHP_CURVE = {
-  start: 741,
-  end: 7467
-};
-const MAXSP_CURVE = {
-  start: 534,
-  end: 5500
-};
-const STR_CURVE = {
-  start: 67,
-  end: 635
-};
-const AGI_CURVE = {
-  start: 58,
-  end: 582
-};
-const INT_CURVE = {
-  start: 36,
-  end: 7318
-};
-const DEX_CURVE = {
-  start: 54,
-  end: 564
-};
-const DAMAGE_CRITICAL = function(damage, a, b) {
-  if (random(0, 100) < 4 * a[DEX] / b[AGI]) {
-    damage *= 2;
-  }
-  return damage;
-};
-const DAMAGE_PHYSIC = function(a, b) {
-  let damage = Math.round((a[ATK] - b[PDEF] / 2) * ((20 + a[STR]) / 20));
-  if (damage < 0) damage = 0;
-  return damage;
-};
-const DAMAGE_GUARD = function(damage) {
-  return damage / 2;
-};
-const COEFFICIENT_ELEMENTS = function(a, b, bDef) {
-  return (a.rate + 1) * (b.rate + 1) / (bDef.rate == 0 ? bDef.rate * 4 : 1);
-};
-const DAMAGE_SKILL = function(a, b, skill) {
-  let power = skill.power + a[ATK] * (skill.coefficient[ATK] || 0);
-  if (power > 0) {
-    power -= b[PDEF] * (skill.coefficient[PDEF] || 0) / 2;
-    power -= b[SDEF] * (skill.coefficient[SDEF] || 0) / 2;
-    power = Math.max(power, 0);
-  }
-  let rate = 20;
-  [STR, DEX, AGI, INT].forEach((val) => rate += a[val] * (skill.coefficient[val] || 0));
-  return Math.round(power * rate / 20);
-};
-
 function WithParameterManager(Base) {
   return class extends Base {
     constructor() {
@@ -20678,17 +21175,20 @@ function WithItemManager(Base) {
         return isInstanceOf(it, itemClass);
       });
     }
-    addItem(item, nb = 1) {
-      const map = this.getCurrentMap() || this.map;
-      if (!map || !map.database) {
+    _getItemMap(required = true) {
+      const map = this.getCurrentMap?.() || this.map;
+      if (required && (!map || !map.database)) {
         throw new Error("Player must be on a map to add items");
       }
+      return map;
+    }
+    _resolveItemInput(item, map, databaseByIdOverride) {
       let itemId;
       let data;
       let itemInstance = null;
       if (isString(item)) {
         itemId = item;
-        data = this.databaseById(itemId);
+        data = databaseByIdOverride ? databaseByIdOverride(itemId) : this.databaseById(itemId);
       } else if (typeof item === "function" || item.prototype) {
         itemId = item.name;
         const existingData = map.database()[itemId];
@@ -20712,6 +21212,114 @@ function WithItemManager(Base) {
         }
         itemInstance = itemObj;
       }
+      return { itemId, data, itemInstance };
+    }
+    _createItemInstance(itemId, data, nb, itemInstance) {
+      const instance = new Item(data);
+      instance.id.set(itemId);
+      instance.quantity.set(nb);
+      if (itemInstance) {
+        instance._itemInstance = itemInstance;
+        if (itemInstance.onAdd) {
+          instance.onAdd = itemInstance.onAdd.bind(itemInstance);
+        }
+      }
+      return instance;
+    }
+    /**
+     * Create an item instance without inventory changes or hook execution.
+     */
+    createItemInstance(item, nb = 1) {
+      const map = this._getItemMap();
+      const { itemId, data, itemInstance } = this._resolveItemInput(item, map);
+      const instance = this._createItemInstance(itemId, data, nb, itemInstance);
+      return { itemId, data, itemInstance, instance };
+    }
+    /**
+     * Resolve item snapshot entries into Item instances without side effects.
+     */
+    resolveItemsSnapshot(snapshot, mapOverride) {
+      if (!snapshot || !Array.isArray(snapshot.items)) {
+        return snapshot;
+      }
+      const map = mapOverride ?? this._getItemMap(false);
+      if (!map || !map.database) {
+        return snapshot;
+      }
+      const databaseByIdOverride = (id) => {
+        const data = map.database()[id];
+        if (!data) {
+          throw new Error(
+            `The ID=${id} data is not found in the database. Add the data in the property "database"`
+          );
+        }
+        return data;
+      };
+      const items = snapshot.items.map((entry) => {
+        const itemId = isString(entry) ? entry : entry?.id;
+        if (!itemId) {
+          return entry;
+        }
+        const nb = !isString(entry) && typeof entry?.nb === "number" ? entry.nb : !isString(entry) && typeof entry?.quantity === "number" ? entry.quantity : 1;
+        const { data, itemInstance } = this._resolveItemInput(
+          itemId,
+          map,
+          databaseByIdOverride
+        );
+        return this._createItemInstance(itemId, data, nb, itemInstance);
+      });
+      return { ...snapshot, items };
+    }
+    /**
+     * Resolve equipment snapshot entries into Item instances without side effects.
+     */
+    resolveEquipmentsSnapshot(snapshot, mapOverride) {
+      if (!snapshot || !Array.isArray(snapshot.equipments)) {
+        return snapshot;
+      }
+      const map = mapOverride ?? this._getItemMap(false);
+      if (!map || !map.database) {
+        return snapshot;
+      }
+      const databaseByIdOverride = (id) => {
+        const data = map.database()[id];
+        if (!data) {
+          throw new Error(
+            `The ID=${id} data is not found in the database. Add the data in the property "database"`
+          );
+        }
+        return data;
+      };
+      const resolvedItems = Array.isArray(snapshot.items) ? snapshot.items : [];
+      const getItemId = (entry) => {
+        if (isString(entry)) return entry;
+        if (typeof entry?.id === "function") return entry.id();
+        return entry?.id;
+      };
+      const equipments = snapshot.equipments.map((entry) => {
+        const itemId = getItemId(entry);
+        if (!itemId) {
+          return entry;
+        }
+        const existing = resolvedItems.find((item) => {
+          const existingId = getItemId(item);
+          return existingId === itemId;
+        });
+        if (existing) {
+          return existing;
+        }
+        const { data, itemInstance } = this._resolveItemInput(
+          itemId,
+          map,
+          databaseByIdOverride
+        );
+        return this._createItemInstance(itemId, data, 1, itemInstance);
+      });
+      return { ...snapshot, equipments };
+    }
+    addItem(item, nb = 1) {
+      const map = this._getItemMap();
+      const { itemId, data, itemInstance } = this._resolveItemInput(item, map);
       const existingItem = this.items().find((it) => it.id() == itemId);
       let instance;
       if (existingItem) {
@@ -20733,15 +21341,7 @@ function WithItemManager(Base) {
           }
         }
       } else {
-        instance = new Item(data);
-        instance.id.set(itemId);
-        instance.quantity.set(nb);
-        if (itemInstance) {
-          instance._itemInstance = itemInstance;
-          if (itemInstance.onAdd) {
-            instance.onAdd = itemInstance.onAdd.bind(itemInstance);
-          }
-        }
+        instance = this._createItemInstance(itemId, data, nb, itemInstance);
         this.items().push(instance);
       }
       const hookTarget = instance._itemInstance || instance;
@@ -20936,6 +21536,59 @@ function WithEffectManager(Base) {
   };
 }
 
+const MAXHP_CURVE = {
+  start: 741,
+  end: 7467
+};
+const MAXSP_CURVE = {
+  start: 534,
+  end: 5500
+};
+const STR_CURVE = {
+  start: 67,
+  end: 635
+};
+const AGI_CURVE = {
+  start: 58,
+  end: 582
+};
+const INT_CURVE = {
+  start: 36,
+  end: 7318
+};
+const DEX_CURVE = {
+  start: 54,
+  end: 564
+};
+const DAMAGE_CRITICAL = function(damage, a, b) {
+  if (random(0, 100) < 4 * a[DEX] / b[AGI]) {
+    damage *= 2;
+  }
+  return damage;
+};
+const DAMAGE_PHYSIC = function(a, b) {
+  let damage = Math.round((a[ATK] - b[PDEF] / 2) * ((20 + a[STR]) / 20));
+  if (damage < 0) damage = 0;
+  return damage;
+};
+const DAMAGE_GUARD = function(damage) {
+  return damage / 2;
+};
+const COEFFICIENT_ELEMENTS = function(a, b, bDef) {
+  return (a.rate + 1) * (b.rate + 1) / (bDef.rate == 0 ? bDef.rate * 4 : 1);
+};
+const DAMAGE_SKILL = function(a, b, skill) {
+  let power = skill.power + a[ATK] * (skill.coefficient[ATK] || 0);
+  if (power > 0) {
+    power -= b[PDEF] * (skill.coefficient[PDEF] || 0) / 2;
+    power -= b[SDEF] * (skill.coefficient[SDEF] || 0) / 2;
+    power = Math.max(power, 0);
+  }
+  let rate = 20;
+  [STR, DEX, AGI, INT].forEach((val) => rate += a[val] * (skill.coefficient[val] || 0));
+  return Math.round(power * rate / 20);
+};
+
 function WithElementManager(Base) {
   return class extends Base {
     constructor() {
@@ -20996,6 +21649,105 @@ function WithElementManager(Base) {
 
 function WithSkillManager(Base) {
   return class extends Base {
+    _getSkillMap(required = true) {
+      const map = this.getCurrentMap?.() || this.map;
+      if (required && (!map || !map.database)) {
+        throw new Error("Player must be on a map to learn skills");
+      }
+      return map;
+    }
+    _resolveSkillInput(skillInput, map, databaseByIdOverride) {
+      let skillId = "";
+      let skillData;
+      let skillInstance = null;
+      if (isString(skillInput)) {
+        skillId = skillInput;
+        skillData = databaseByIdOverride ? databaseByIdOverride(skillId) : this.databaseById(skillId);
+      } else if (typeof skillInput === "function") {
+        const SkillClassCtor = skillInput;
+        skillId = SkillClassCtor.id || SkillClassCtor.name;
+        const existingData = map?.database()?.[skillId];
+        if (existingData) {
+          skillData = existingData;
+        } else if (map) {
+          map.addInDatabase(skillId, SkillClassCtor);
+          skillData = SkillClassCtor;
+        } else {
+          skillData = SkillClassCtor;
+        }
+        skillInstance = new SkillClassCtor();
+        skillData = { ...skillData, ...skillInstance, id: skillId };
+      } else {
+        const skillObj = skillInput;
+        skillId = skillObj.id || `skill-${Date.now()}`;
+        skillObj.id = skillId;
+        const existingData = map?.database()?.[skillId];
+        if (existingData) {
+          skillData = { ...existingData, ...skillObj };
+          if (map) {
+            map.addInDatabase(skillId, skillData, { force: true });
+          }
+        } else if (map) {
+          map.addInDatabase(skillId, skillObj);
+          skillData = skillObj;
+        } else {
+          skillData = skillObj;
+        }
+        skillInstance = skillObj;
+      }
+      return { skillId, skillData, skillInstance };
+    }
+    _createSkillInstance(skillId, skillData, skillInstance) {
+      const instance = new Skill(skillData);
+      instance.id.set(skillId);
+      if (skillInstance) {
+        instance._skillInstance = skillInstance;
+      }
+      return instance;
+    }
+    /**
+     * Create a skill instance without learning side effects.
+     */
+    createSkillInstance(skillInput) {
+      const map = this._getSkillMap();
+      const { skillId, skillData, skillInstance } = this._resolveSkillInput(skillInput, map);
+      const instance = this._createSkillInstance(skillId, skillData, skillInstance);
+      return { skillId, skillData, skillInstance, instance };
+    }
+    /**
+     * Resolve skill snapshot entries into Skill instances without side effects.
+     */
+    resolveSkillsSnapshot(snapshot, mapOverride) {
+      if (!snapshot || !Array.isArray(snapshot.skills)) {
+        return snapshot;
+      }
+      const map = mapOverride ?? this._getSkillMap(false);
+      if (!map || !map.database) {
+        return snapshot;
+      }
+      const databaseByIdOverride = (id) => {
+        const data = map.database()[id];
+        if (!data) {
+          throw new Error(
+            `The ID=${id} data is not found in the database. Add the data in the property "database"`
+          );
+        }
+        return data;
+      };
+      const skills = snapshot.skills.map((entry) => {
+        const skillId = isString(entry) ? entry : entry?.id;
+        if (!skillId) {
+          return entry;
+        }
+        const { skillData, skillInstance } = this._resolveSkillInput(
+          skillId,
+          map,
+          databaseByIdOverride
+        );
+        return this._createSkillInstance(skillId, skillData, skillInstance);
+      });
+      return { ...snapshot, skills };
+    }
     /**
      * Find the index of a skill in the skills array
      * 
@@ -21014,7 +21766,7 @@ function WithSkillManager(Base) {
         searchId = skillInput.id || "";
       }
       return this.skills().findIndex((skill) => {
-        const skillId = skill.id || skill.name || "";
+        const skillId = skill.id() || skill.name() || "";
         return skillId === searchId;
       });
     }
@@ -21065,53 +21817,20 @@ function WithSkillManager(Base) {
      *   spCost: 20,
      *   onLearn(player) {
      *     console.log('Learned custom skill!');
-     *   }
-     * });
-     * ```
-     */
-    learnSkill(skillInput) {
-      const map = this.getCurrentMap() || this.map;
-      let skillId = "";
-      let skillData;
-      if (isString(skillInput)) {
-        skillId = skillInput;
-        skillData = this.databaseById(skillId);
-      } else if (typeof skillInput === "function") {
-        const SkillClassCtor = skillInput;
-        skillId = SkillClassCtor.id || SkillClassCtor.name;
-        const existingData = map?.database()?.[skillId];
-        if (existingData) {
-          skillData = existingData;
-        } else if (map) {
-          map.addInDatabase(skillId, SkillClassCtor);
-          skillData = SkillClassCtor;
-        } else {
-          skillData = SkillClassCtor;
-        }
-        const skillInstance = new SkillClassCtor();
-        skillData = { ...skillData, ...skillInstance, id: skillId };
-      } else {
-        const skillObj = skillInput;
-        skillId = skillObj.id || `skill-${Date.now()}`;
-        skillObj.id = skillId;
-        const existingData = map?.database()?.[skillId];
-        if (existingData) {
-          skillData = { ...existingData, ...skillObj };
-          if (map) {
-            map.addInDatabase(skillId, skillData, { force: true });
-          }
-        } else if (map) {
-          map.addInDatabase(skillId, skillObj);
-          skillData = skillObj;
-        } else {
-          skillData = skillObj;
-        }
-      }
+     *   }
+     * });
+     * ```
+     */
+    learnSkill(skillInput) {
+      const map = this._getSkillMap();
+      const { skillId, skillData, skillInstance } = this._resolveSkillInput(skillInput, map);
       if (this.getSkill(skillId)) {
         throw SkillLog.alreadyLearned(skillData);
       }
-      this.skills().push(skillData);
-      this["execMethod"]("onLearn", [this], skillData);
+      const instance = this._createSkillInstance(skillId, skillData, skillInstance);
+      this.skills().push(instance);
+      const hookTarget = instance._skillInstance || instance;
+      this["execMethod"]("onLearn", [this], hookTarget);
       return skillData;
     }
     /**
@@ -21147,7 +21866,8 @@ function WithSkillManager(Base) {
       }
       const skillData = this.skills()[index];
       this.skills().splice(index, 1);
-      this["execMethod"]("onForget", [this], skillData);
+      const hookTarget = skillData?._skillInstance || skillData;
+      this["execMethod"]("onForget", [this], hookTarget);
       return skillData;
     }
     /**
@@ -21192,7 +21912,8 @@ function WithSkillManager(Base) {
       this.sp -= spCost / costMultiplier;
       const hitRate = skill.hitRate ?? 1;
       if (Math.random() > hitRate) {
-        this["execMethod"]("onUseFailed", [this, otherPlayer], skill);
+        const hookTarget2 = skill?._skillInstance || skill;
+        this["execMethod"]("onUseFailed", [this, otherPlayer], hookTarget2);
         throw SkillLog.chanceToUseFailed(skill);
       }
       if (otherPlayer) {
@@ -21202,7 +21923,8 @@ function WithSkillManager(Base) {
           player.applyDamage(this, skill);
         }
       }
-      this["execMethod"]("onUse", [this, otherPlayer], skill);
+      const hookTarget = skill?._skillInstance || skill;
+      this["execMethod"]("onUse", [this, otherPlayer], hookTarget);
       return skill;
     }
   };
@@ -21316,9 +22038,54 @@ function WithBattleManager(Base) {
 
 function WithClassManager(Base) {
   return class extends Base {
+    _resolveClassInput(classInput, databaseByIdOverride) {
+      if (isString(classInput)) {
+        return databaseByIdOverride ? databaseByIdOverride(classInput) : this.databaseById(classInput);
+      }
+      return classInput;
+    }
+    _createClassInstance(classInput) {
+      const classClass = this._resolveClassInput(classInput);
+      const instance = new classClass();
+      return { classClass, instance };
+    }
+    /**
+     * Create a class instance without side effects.
+     */
+    createClassInstance(classInput) {
+      return this._createClassInstance(classInput);
+    }
+    /**
+     * Resolve class snapshot entry into a class instance without side effects.
+     */
+    resolveClassSnapshot(snapshot, mapOverride) {
+      if (!snapshot || snapshot._class == null) {
+        return snapshot;
+      }
+      const map = mapOverride ?? (this.getCurrentMap?.() || this.map);
+      if (!map || !map.database) {
+        return snapshot;
+      }
+      const databaseByIdOverride = (id) => {
+        const data = map.database()[id];
+        if (!data) {
+          throw new Error(
+            `The ID=${id} data is not found in the database. Add the data in the property "database"`
+          );
+        }
+        return data;
+      };
+      const classId = isString(snapshot._class) ? snapshot._class : snapshot._class?.id;
+      if (!classId) {
+        return snapshot;
+      }
+      const classClass = this._resolveClassInput(classId, databaseByIdOverride);
+      const { instance } = this._createClassInstance(classClass);
+      return { ...snapshot, _class: instance };
+    }
     setClass(_class) {
-      if (isString(_class)) _class = this.databaseById(_class);
-      const classInstance = new _class();
+      const { instance } = this._createClassInstance(_class);
+      const classInstance = instance;
       this["execMethod"]("onSet", [this], classInstance);
       return classInstance;
     }
@@ -21348,6 +22115,60 @@ function WithStateManager(Base) {
       super(...arguments);
       this._statesEfficiency = signal([]);
     }
+    _getStateMap(required = true) {
+      const map = this.getCurrentMap?.() || this.map;
+      if (required && (!map || !map.database)) {
+        throw new Error("Player must be on a map to resolve states");
+      }
+      return map;
+    }
+    _resolveStateInput(stateInput, databaseByIdOverride) {
+      if (isString(stateInput)) {
+        return databaseByIdOverride ? databaseByIdOverride(stateInput) : this.databaseById(stateInput);
+      }
+      return stateInput;
+    }
+    _createStateInstance(stateClass) {
+      return new stateClass();
+    }
+    /**
+     * Create a state instance without side effects.
+     */
+    createStateInstance(stateInput) {
+      const stateClass = this._resolveStateInput(stateInput);
+      const instance = this._createStateInstance(stateClass);
+      return { stateClass, instance };
+    }
+    /**
+     * Resolve state snapshot entries into state instances without side effects.
+     */
+    resolveStatesSnapshot(snapshot, mapOverride) {
+      if (!snapshot || !Array.isArray(snapshot.states)) {
+        return snapshot;
+      }
+      const map = mapOverride ?? this._getStateMap(false);
+      if (!map || !map.database) {
+        return snapshot;
+      }
+      const databaseByIdOverride = (id) => {
+        const data = map.database()[id];
+        if (!data) {
+          throw new Error(
+            `The ID=${id} data is not found in the database. Add the data in the property "database"`
+          );
+        }
+        return data;
+      };
+      const states = snapshot.states.map((entry) => {
+        const stateId = isString(entry) ? entry : entry?.id;
+        if (!stateId) {
+          return entry;
+        }
+        const stateClass = this._resolveStateInput(stateId, databaseByIdOverride);
+        return this._createStateInstance(stateClass);
+      });
+      return { ...snapshot, states };
+    }
     get statesDefense() {
       return this.getFeature("statesDefense", "state");
     }
@@ -21387,7 +22208,7 @@ function WithStateManager(Base) {
         if (Math.random() > chance) {
           throw StateLog.addFailed(stateClass);
         }
-        const instance = new stateClass();
+        const instance = this._createStateInstance(stateClass);
         this.states().push(instance);
         this.applyStates(this, instance);
         return instance;
@@ -21418,13 +22239,13 @@ function WithStateManager(Base) {
   };
 }
 
-var __defProp$2 = Object.defineProperty;
-var __decorateClass$2 = (decorators, target, key, kind) => {
+var __defProp$3 = Object.defineProperty;
+var __decorateClass$3 = (decorators, target, key, kind) => {
   var result = void 0 ;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (decorator(target, key, result) ) || result;
-  if (result) __defProp$2(target, key, result);
+  if (result) __defProp$3(target, key, result);
   return result;
 };
 function combinePlayerMixins(mixins) {
@@ -21700,16 +22521,71 @@ const _RpgPlayer = class _RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
       value
     });
   }
-  async save() {
-    const snapshot = createStatesSnapshot(this);
+  snapshot() {
+    return createStatesSnapshotDeep(this);
+  }
+  async applySnapshot(snapshot) {
+    const data = typeof snapshot === "string" ? JSON.parse(snapshot) : snapshot;
+    const withItems = this.resolveItemsSnapshot?.(data) ?? data;
+    const withSkills = this.resolveSkillsSnapshot?.(withItems) ?? withItems;
+    const withStates = this.resolveStatesSnapshot?.(withSkills) ?? withSkills;
+    const withClass = this.resolveClassSnapshot?.(withStates) ?? withStates;
+    const resolvedSnapshot = this.resolveEquipmentsSnapshot?.(withClass) ?? withClass;
+    load(this, resolvedSnapshot);
+    if (Array.isArray(resolvedSnapshot.items)) {
+      this.items.set(resolvedSnapshot.items);
+    }
+    if (Array.isArray(resolvedSnapshot.skills)) {
+      this.skills.set(resolvedSnapshot.skills);
+    }
+    if (Array.isArray(resolvedSnapshot.states)) {
+      this.states.set(resolvedSnapshot.states);
+    }
+    if (resolvedSnapshot._class != null && this._class?.set) {
+      this._class.set(resolvedSnapshot._class);
+    }
+    if (Array.isArray(resolvedSnapshot.equipments)) {
+      this.equipments.set(resolvedSnapshot.equipments);
+    }
+    await lastValueFrom(this.hooks.callHooks("server-player-onLoad", this, resolvedSnapshot));
+    return resolvedSnapshot;
+  }
+  async save(slot = "auto", meta = {}, context = {}) {
+    const policy = resolveAutoSaveStrategy();
+    if (policy.canSave && !policy.canSave(this, context)) {
+      return null;
+    }
+    const resolvedSlot = resolveSaveSlot(slot, policy, this, context);
+    if (resolvedSlot === null) {
+      return null;
+    }
+    const snapshot = this.snapshot();
     await lastValueFrom(this.hooks.callHooks("server-player-onSave", this, snapshot));
-    return JSON.stringify(snapshot);
+    const storage = resolveSaveStorageStrategy();
+    const finalMeta = buildSaveSlotMeta(this, meta);
+    await storage.save(this, resolvedSlot, JSON.stringify(snapshot), finalMeta);
+    return { index: resolvedSlot, meta: finalMeta };
   }
-  async load(snapshot) {
-    const data = JSON.parse(snapshot);
-    const dataLoaded = load(this, data);
-    await lastValueFrom(this.hooks.callHooks("server-player-onLoad", this, dataLoaded));
-    return dataLoaded;
+  async load(slot = "auto", context = {}, options = {}) {
+    const policy = resolveAutoSaveStrategy();
+    if (policy.canLoad && !policy.canLoad(this, context)) {
+      return { ok: false };
+    }
+    const resolvedSlot = resolveSaveSlot(slot, policy, this, context);
+    if (resolvedSlot === null) {
+      return { ok: false };
+    }
+    const storage = resolveSaveStorageStrategy();
+    const slotData = await storage.get(this, resolvedSlot);
+    if (!slotData?.snapshot) {
+      return { ok: false };
+    }
+    await this.applySnapshot(slotData.snapshot);
+    const { snapshot, ...meta } = slotData;
+    if (options.changeMap !== false && meta.map) {
+      await this.changeMap(meta.map);
+    }
+    return { ok: true, slot: meta, index: resolvedSlot };
   }
   /**
    * @deprecated Use setGraphicAnimation instead.
@@ -21778,6 +22654,9 @@ const _RpgPlayer = class _RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
     */
   syncChanges() {
     this._eventChanges();
+    if (shouldAutoSave(this, { reason: "auto", source: "syncChanges" })) {
+      void this.save("auto", {}, { reason: "auto", source: "syncChanges" });
+    }
   }
   databaseById(id) {
     const map2 = this.map;
@@ -22338,7 +23217,7 @@ const _RpgPlayer = class _RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
     return false;
   }
 };
-__decorateClass$2([
+__decorateClass$3([
   sync(_RpgPlayer)
 ], _RpgPlayer.prototype, "events");
 let RpgPlayer = _RpgPlayer;
@@ -22368,8 +23247,8 @@ class RpgEvent extends RpgPlayer {
   }
 }
 
-const context$1 = new Context();
-context$1["side"] = "server";
+const context = new Context();
+context["side"] = "server";
 
 /** A special constant with type `never` */
 function $constructor(name, initializer, params) {
@@ -22625,6 +23504,11 @@ const NUMBER_FORMAT_RANGES = {
 };
 function pick(schema, mask) {
     const currDef = schema._zod.def;
+    const checks = currDef.checks;
+    const hasChecks = checks && checks.length > 0;
+    if (hasChecks) {
+        throw new Error(".pick() cannot be used on object schemas containing refinements");
+    }
     const def = mergeDefs(schema._zod.def, {
         get shape() {
             const newShape = {};
@@ -22645,6 +23529,11 @@ function pick(schema, mask) {
 }
 function omit(schema, mask) {
     const currDef = schema._zod.def;
+    const checks = currDef.checks;
+    const hasChecks = checks && checks.length > 0;
+    if (hasChecks) {
+        throw new Error(".omit() cannot be used on object schemas containing refinements");
+    }
     const def = mergeDefs(schema._zod.def, {
         get shape() {
             const newShape = { ...schema._zod.def.shape };
@@ -22670,7 +23559,14 @@ function extend(schema, shape) {
     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.");
+        // Only throw if new shape overlaps with existing shape
+        // Use getOwnPropertyDescriptor to check key existence without accessing values
+        const existingShape = schema._zod.def.shape;
+        for (const key in shape) {
+            if (Object.getOwnPropertyDescriptor(existingShape, key) !== undefined) {
+                throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
+            }
+        }
     }
     const def = mergeDefs(schema._zod.def, {
         get shape() {
@@ -22678,7 +23574,6 @@ function extend(schema, shape) {
             assignProp(this, "shape", _shape); // self-caching
             return _shape;
         },
-        checks: [],
     });
     return clone(schema, def);
 }
@@ -22686,15 +23581,13 @@ function safeExtend(schema, shape) {
     if (!isPlainObject(shape)) {
         throw new Error("Invalid input to safeExtend: expected a plain object");
     }
-    const def = {
-        ...schema._zod.def,
+    const def = mergeDefs(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) {
@@ -22712,6 +23605,12 @@ function merge(a, b) {
     return clone(a, def);
 }
 function partial(Class, schema, mask) {
+    const currDef = schema._zod.def;
+    const checks = currDef.checks;
+    const hasChecks = checks && checks.length > 0;
+    if (hasChecks) {
+        throw new Error(".partial() cannot be used on object schemas containing refinements");
+    }
     const def = mergeDefs(schema._zod.def, {
         get shape() {
             const oldShape = schema._zod.def.shape;
@@ -22781,7 +23680,6 @@ function required(Class, schema, mask) {
             assignProp(this, "shape", shape); // self-caching
             return shape;
         },
-        checks: [],
     });
     return clone(schema, def);
 }
@@ -23031,7 +23929,8 @@ const cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?:
 const base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
 const base64url = /^[A-Za-z0-9_-]*$/;
 // https://blog.stevenlevithan.com/archives/validate-phone-number#r4-3 (regex sans spaces)
-const e164 = /^\+(?:[0-9]){6,14}[0-9]$/;
+// E.164: leading digit must be 1-9; total digits (excluding '+') between 7-15
+const e164 = /^\+[1-9]\d{6,14}$/;
 // 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])))`;
 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])))`;
 const date$1 = /*@__PURE__*/ new RegExp(`^${dateSource}$`);
@@ -23066,7 +23965,7 @@ const string$1 = (params) => {
     return new RegExp(`^${regex}$`);
 };
 const integer = /^-?\d+$/;
-const number$1 = /^-?\d+(?:\.\d+)?/;
+const number$1 = /^-?\d+(?:\.\d+)?$/;
 // regex for string with no uppercase letters
 const lowercase = /^[^A-Z]*$/;
 // regex for string with no lowercase letters
@@ -23104,7 +24003,7 @@ const $ZodCheckLessThan = /*@__PURE__*/ $constructor("$ZodCheckLessThan", (inst,
         payload.issues.push({
             origin,
             code: "too_big",
-            maximum: def.value,
+            maximum: typeof def.value === "object" ? def.value.getTime() : def.value,
             input: payload.value,
             inclusive: def.inclusive,
             inst,
@@ -23132,7 +24031,7 @@ const $ZodCheckGreaterThan = /*@__PURE__*/ $constructor("$ZodCheckGreaterThan",
         payload.issues.push({
             origin,
             code: "too_small",
-            minimum: def.value,
+            minimum: typeof def.value === "object" ? def.value.getTime() : def.value,
             input: payload.value,
             inclusive: def.inclusive,
             inst,
@@ -23220,6 +24119,7 @@ const $ZodCheckNumberFormat = /*@__PURE__*/ $constructor("$ZodCheckNumberFormat"
                         note: "Integers must be within the safe integer range.",
                         inst,
                         origin,
+                        inclusive: true,
                         continue: !def.abort,
                     });
                 }
@@ -23232,6 +24132,7 @@ const $ZodCheckNumberFormat = /*@__PURE__*/ $constructor("$ZodCheckNumberFormat"
                         note: "Integers must be within the safe integer range.",
                         inst,
                         origin,
+                        inclusive: true,
                         continue: !def.abort,
                     });
                 }
@@ -23255,7 +24156,9 @@ const $ZodCheckNumberFormat = /*@__PURE__*/ $constructor("$ZodCheckNumberFormat"
                 input,
                 code: "too_big",
                 maximum,
+                inclusive: true,
                 inst,
+                continue: !def.abort,
             });
         }
     };
@@ -23518,8 +24421,8 @@ class Doc {
 
 const version = {
     major: 4,
-    minor: 2,
-    patch: 1,
+    minor: 3,
+    patch: 5,
 };
 
 const $ZodType = /*@__PURE__*/ $constructor("$ZodType", (inst, def) => {
@@ -23629,7 +24532,8 @@ const $ZodType = /*@__PURE__*/ $constructor("$ZodType", (inst, def) => {
             return runChecks(result, checks, ctx);
         };
     }
-    inst["~standard"] = {
+    // Lazy initialize ~standard to avoid creating objects for every schema
+    defineLazy(inst, "~standard", () => ({
         validate: (value) => {
             try {
                 const r = safeParse$1(inst, value);
@@ -23641,7 +24545,7 @@ const $ZodType = /*@__PURE__*/ $constructor("$ZodType", (inst, def) => {
         },
         vendor: "zod",
         version: 1,
-    };
+    }));
 });
 const $ZodString = /*@__PURE__*/ $constructor("$ZodString", (inst, def) => {
     $ZodType.init(inst, def);
@@ -24049,8 +24953,12 @@ const $ZodArray = /*@__PURE__*/ $constructor("$ZodArray", (inst, def) => {
         return payload; //handleArrayResultsAsync(parseResults, final);
     };
 });
-function handlePropertyResult(result, final, key, input) {
+function handlePropertyResult(result, final, key, input, isOptionalOut) {
     if (result.issues.length) {
+        // For optional-out schemas, ignore errors on absent keys
+        if (isOptionalOut && !(key in input)) {
+            return;
+        }
         final.issues.push(...prefixIssues(key, result.issues));
     }
     if (result.value === undefined) {
@@ -24084,6 +24992,7 @@ function handleCatchall(proms, input, payload, ctx, def, inst) {
     const keySet = def.keySet;
     const _catchall = def.catchall._zod;
     const t = _catchall.def.type;
+    const isOptionalOut = _catchall.optout === "optional";
     for (const key in input) {
         if (keySet.has(key))
             continue;
@@ -24093,10 +25002,10 @@ function handleCatchall(proms, input, payload, ctx, def, inst) {
         }
         const r = _catchall.run({ value: input[key], issues: [] }, ctx);
         if (r instanceof Promise) {
-            proms.push(r.then((r) => handlePropertyResult(r, payload, key, input)));
+            proms.push(r.then((r) => handlePropertyResult(r, payload, key, input, isOptionalOut)));
         }
         else {
-            handlePropertyResult(r, payload, key, input);
+            handlePropertyResult(r, payload, key, input, isOptionalOut);
         }
     }
     if (unrecognized.length) {
@@ -24164,12 +25073,13 @@ const $ZodObject = /*@__PURE__*/ $constructor("$ZodObject", (inst, def) => {
         const shape = value.shape;
         for (const key of value.keys) {
             const el = shape[key];
+            const isOptionalOut = el._zod.optout === "optional";
             const r = el._zod.run({ value: input[key], issues: [] }, ctx);
             if (r instanceof Promise) {
-                proms.push(r.then((r) => handlePropertyResult(r, payload, key, input)));
+                proms.push(r.then((r) => handlePropertyResult(r, payload, key, input, isOptionalOut)));
             }
             else {
-                handlePropertyResult(r, payload, key, input);
+                handlePropertyResult(r, payload, key, input, isOptionalOut);
             }
         }
         if (!catchall) {
@@ -24201,8 +25111,33 @@ const $ZodObjectJIT = /*@__PURE__*/ $constructor("$ZodObjectJIT", (inst, def) =>
         for (const key of normalized.keys) {
             const id = ids[key];
             const k = esc(key);
+            const schema = shape[key];
+            const isOptionalOut = schema?._zod?.optout === "optional";
             doc.write(`const ${id} = ${parseStr(key)};`);
-            doc.write(`
+            if (isOptionalOut) {
+                // For optional-out schemas, ignore errors on absent keys
+                doc.write(`
+        if (${id}.issues.length) {
+          if (${k} in input) {
+            payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
+              ...iss,
+              path: iss.path ? [${k}, ...iss.path] : [${k}]
+            })));
+          }
+        }
+        
+        if (${id}.value === undefined) {
+          if (${k} in input) {
+            newResult[${k}] = undefined;
+          }
+        } else {
+          newResult[${k}] = ${id}.value;
+        }
+        
+      `);
+            }
+            else {
+                doc.write(`
         if (${id}.issues.length) {
           payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
             ...iss,
@@ -24210,7 +25145,6 @@ const $ZodObjectJIT = /*@__PURE__*/ $constructor("$ZodObjectJIT", (inst, def) =>
           })));
         }
         
-        
         if (${id}.value === undefined) {
           if (${k} in input) {
             newResult[${k}] = undefined;
@@ -24220,6 +25154,7 @@ const $ZodObjectJIT = /*@__PURE__*/ $constructor("$ZodObjectJIT", (inst, def) =>
         }
         
       `);
+            }
         }
         doc.write(`payload.value = newResult;`);
         doc.write(`return payload;`);
@@ -24386,11 +25321,38 @@ function mergeValues(a, b) {
     return { valid: false, mergeErrorPath: [] };
 }
 function handleIntersectionResults(result, left, right) {
-    if (left.issues.length) {
-        result.issues.push(...left.issues);
+    // Track which side(s) report each key as unrecognized
+    const unrecKeys = new Map();
+    let unrecIssue;
+    for (const iss of left.issues) {
+        if (iss.code === "unrecognized_keys") {
+            unrecIssue ?? (unrecIssue = iss);
+            for (const k of iss.keys) {
+                if (!unrecKeys.has(k))
+                    unrecKeys.set(k, {});
+                unrecKeys.get(k).l = true;
+            }
+        }
+        else {
+            result.issues.push(iss);
+        }
     }
-    if (right.issues.length) {
-        result.issues.push(...right.issues);
+    for (const iss of right.issues) {
+        if (iss.code === "unrecognized_keys") {
+            for (const k of iss.keys) {
+                if (!unrecKeys.has(k))
+                    unrecKeys.set(k, {});
+                unrecKeys.get(k).r = true;
+            }
+        }
+        else {
+            result.issues.push(iss);
+        }
+    }
+    // Report only keys unrecognized by BOTH sides
+    const bothKeys = [...unrecKeys].filter(([, f]) => f.l && f.r).map(([k]) => k);
+    if (bothKeys.length && unrecIssue) {
+        result.issues.push({ ...unrecIssue, keys: bothKeys });
     }
     if (aborted(result))
         return result;
@@ -24475,6 +25437,17 @@ const $ZodOptional = /*@__PURE__*/ $constructor("$ZodOptional", (inst, def) => {
         return def.innerType._zod.run(payload, ctx);
     };
 });
+const $ZodExactOptional = /*@__PURE__*/ $constructor("$ZodExactOptional", (inst, def) => {
+    // Call parent init - inherits optin/optout = "optional"
+    $ZodOptional.init(inst, def);
+    // Override values/pattern to NOT add undefined
+    defineLazy(inst._zod, "values", () => def.innerType._zod.values);
+    defineLazy(inst._zod, "pattern", () => def.innerType._zod.pattern);
+    // Override parse to just delegate (no undefined handling)
+    inst._zod.parse = (payload, ctx) => {
+        return def.innerType._zod.run(payload, ctx);
+    };
+});
 const $ZodNullable = /*@__PURE__*/ $constructor("$ZodNullable", (inst, def) => {
     $ZodType.init(inst, def);
     defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
@@ -24697,9 +25670,6 @@ class $ZodRegistry {
         const meta = _meta[0];
         this._map.set(schema, meta);
         if (meta && typeof meta === "object" && "id" in meta) {
-            if (this._idmap.has(meta.id)) {
-                throw new Error(`ID ${meta.id} already exists in the registry`);
-            }
             this._idmap.set(meta.id, schema);
         }
         return this;
@@ -24740,12 +25710,14 @@ function registry() {
 (_a = globalThis).__zod_globalRegistry ?? (_a.__zod_globalRegistry = registry());
 const globalRegistry = globalThis.__zod_globalRegistry;
 
+// @__NO_SIDE_EFFECTS__
 function _string(Class, params) {
     return new Class({
         type: "string",
         ...normalizeParams(params),
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _email(Class, params) {
     return new Class({
         type: "string",
@@ -24755,6 +25727,7 @@ function _email(Class, params) {
         ...normalizeParams(params),
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _guid(Class, params) {
     return new Class({
         type: "string",
@@ -24764,6 +25737,7 @@ function _guid(Class, params) {
         ...normalizeParams(params),
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _uuid(Class, params) {
     return new Class({
         type: "string",
@@ -24773,6 +25747,7 @@ function _uuid(Class, params) {
         ...normalizeParams(params),
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _uuidv4(Class, params) {
     return new Class({
         type: "string",
@@ -24783,6 +25758,7 @@ function _uuidv4(Class, params) {
         ...normalizeParams(params),
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _uuidv6(Class, params) {
     return new Class({
         type: "string",
@@ -24793,6 +25769,7 @@ function _uuidv6(Class, params) {
         ...normalizeParams(params),
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _uuidv7(Class, params) {
     return new Class({
         type: "string",
@@ -24803,6 +25780,7 @@ function _uuidv7(Class, params) {
         ...normalizeParams(params),
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _url(Class, params) {
     return new Class({
         type: "string",
@@ -24812,6 +25790,7 @@ function _url(Class, params) {
         ...normalizeParams(params),
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _emoji(Class, params) {
     return new Class({
         type: "string",
@@ -24821,6 +25800,7 @@ function _emoji(Class, params) {
         ...normalizeParams(params),
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _nanoid(Class, params) {
     return new Class({
         type: "string",
@@ -24830,6 +25810,7 @@ function _nanoid(Class, params) {
         ...normalizeParams(params),
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _cuid(Class, params) {
     return new Class({
         type: "string",
@@ -24839,6 +25820,7 @@ function _cuid(Class, params) {
         ...normalizeParams(params),
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _cuid2(Class, params) {
     return new Class({
         type: "string",
@@ -24848,6 +25830,7 @@ function _cuid2(Class, params) {
         ...normalizeParams(params),
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _ulid(Class, params) {
     return new Class({
         type: "string",
@@ -24857,6 +25840,7 @@ function _ulid(Class, params) {
         ...normalizeParams(params),
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _xid(Class, params) {
     return new Class({
         type: "string",
@@ -24866,6 +25850,7 @@ function _xid(Class, params) {
         ...normalizeParams(params),
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _ksuid(Class, params) {
     return new Class({
         type: "string",
@@ -24875,6 +25860,7 @@ function _ksuid(Class, params) {
         ...normalizeParams(params),
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _ipv4(Class, params) {
     return new Class({
         type: "string",
@@ -24884,6 +25870,7 @@ function _ipv4(Class, params) {
         ...normalizeParams(params),
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _ipv6(Class, params) {
     return new Class({
         type: "string",
@@ -24893,6 +25880,7 @@ function _ipv6(Class, params) {
         ...normalizeParams(params),
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _cidrv4(Class, params) {
     return new Class({
         type: "string",
@@ -24902,6 +25890,7 @@ function _cidrv4(Class, params) {
         ...normalizeParams(params),
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _cidrv6(Class, params) {
     return new Class({
         type: "string",
@@ -24911,6 +25900,7 @@ function _cidrv6(Class, params) {
         ...normalizeParams(params),
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _base64(Class, params) {
     return new Class({
         type: "string",
@@ -24920,6 +25910,7 @@ function _base64(Class, params) {
         ...normalizeParams(params),
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _base64url(Class, params) {
     return new Class({
         type: "string",
@@ -24929,6 +25920,7 @@ function _base64url(Class, params) {
         ...normalizeParams(params),
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _e164(Class, params) {
     return new Class({
         type: "string",
@@ -24938,6 +25930,7 @@ function _e164(Class, params) {
         ...normalizeParams(params),
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _jwt(Class, params) {
     return new Class({
         type: "string",
@@ -24947,6 +25940,7 @@ function _jwt(Class, params) {
         ...normalizeParams(params),
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _isoDateTime(Class, params) {
     return new Class({
         type: "string",
@@ -24958,6 +25952,7 @@ function _isoDateTime(Class, params) {
         ...normalizeParams(params),
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _isoDate(Class, params) {
     return new Class({
         type: "string",
@@ -24966,6 +25961,7 @@ function _isoDate(Class, params) {
         ...normalizeParams(params),
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _isoTime(Class, params) {
     return new Class({
         type: "string",
@@ -24975,6 +25971,7 @@ function _isoTime(Class, params) {
         ...normalizeParams(params),
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _isoDuration(Class, params) {
     return new Class({
         type: "string",
@@ -24983,6 +25980,7 @@ function _isoDuration(Class, params) {
         ...normalizeParams(params),
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _number(Class, params) {
     return new Class({
         type: "number",
@@ -24990,6 +25988,7 @@ function _number(Class, params) {
         ...normalizeParams(params),
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _int(Class, params) {
     return new Class({
         type: "number",
@@ -24999,22 +25998,26 @@ function _int(Class, params) {
         ...normalizeParams(params),
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _any(Class) {
     return new Class({
         type: "any",
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _unknown(Class) {
     return new Class({
         type: "unknown",
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _never(Class, params) {
     return new Class({
         type: "never",
         ...normalizeParams(params),
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _lt(value, params) {
     return new $ZodCheckLessThan({
         check: "less_than",
@@ -25023,6 +26026,7 @@ function _lt(value, params) {
         inclusive: false,
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _lte(value, params) {
     return new $ZodCheckLessThan({
         check: "less_than",
@@ -25031,6 +26035,7 @@ function _lte(value, params) {
         inclusive: true,
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _gt(value, params) {
     return new $ZodCheckGreaterThan({
         check: "greater_than",
@@ -25039,6 +26044,7 @@ function _gt(value, params) {
         inclusive: false,
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _gte(value, params) {
     return new $ZodCheckGreaterThan({
         check: "greater_than",
@@ -25047,6 +26053,7 @@ function _gte(value, params) {
         inclusive: true,
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _multipleOf(value, params) {
     return new $ZodCheckMultipleOf({
         check: "multiple_of",
@@ -25054,6 +26061,7 @@ function _multipleOf(value, params) {
         value,
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _maxLength(maximum, params) {
     const ch = new $ZodCheckMaxLength({
         check: "max_length",
@@ -25062,6 +26070,7 @@ function _maxLength(maximum, params) {
     });
     return ch;
 }
+// @__NO_SIDE_EFFECTS__
 function _minLength(minimum, params) {
     return new $ZodCheckMinLength({
         check: "min_length",
@@ -25069,6 +26078,7 @@ function _minLength(minimum, params) {
         minimum,
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _length(length, params) {
     return new $ZodCheckLengthEquals({
         check: "length_equals",
@@ -25076,6 +26086,7 @@ function _length(length, params) {
         length,
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _regex(pattern, params) {
     return new $ZodCheckRegex({
         check: "string_format",
@@ -25084,6 +26095,7 @@ function _regex(pattern, params) {
         pattern,
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _lowercase(params) {
     return new $ZodCheckLowerCase({
         check: "string_format",
@@ -25091,6 +26103,7 @@ function _lowercase(params) {
         ...normalizeParams(params),
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _uppercase(params) {
     return new $ZodCheckUpperCase({
         check: "string_format",
@@ -25098,6 +26111,7 @@ function _uppercase(params) {
         ...normalizeParams(params),
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _includes(includes, params) {
     return new $ZodCheckIncludes({
         check: "string_format",
@@ -25106,6 +26120,7 @@ function _includes(includes, params) {
         includes,
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _startsWith(prefix, params) {
     return new $ZodCheckStartsWith({
         check: "string_format",
@@ -25114,6 +26129,7 @@ function _startsWith(prefix, params) {
         prefix,
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _endsWith(suffix, params) {
     return new $ZodCheckEndsWith({
         check: "string_format",
@@ -25122,6 +26138,7 @@ function _endsWith(suffix, params) {
         suffix,
     });
 }
+// @__NO_SIDE_EFFECTS__
 function _overwrite(tx) {
     return new $ZodCheckOverwrite({
         check: "overwrite",
@@ -25129,25 +26146,31 @@ function _overwrite(tx) {
     });
 }
 // normalize
+// @__NO_SIDE_EFFECTS__
 function _normalize(form) {
     return _overwrite((input) => input.normalize(form));
 }
 // trim
+// @__NO_SIDE_EFFECTS__
 function _trim() {
     return _overwrite((input) => input.trim());
 }
 // toLowerCase
+// @__NO_SIDE_EFFECTS__
 function _toLowerCase() {
     return _overwrite((input) => input.toLowerCase());
 }
 // toUpperCase
+// @__NO_SIDE_EFFECTS__
 function _toUpperCase() {
     return _overwrite((input) => input.toUpperCase());
 }
 // slugify
+// @__NO_SIDE_EFFECTS__
 function _slugify() {
     return _overwrite((input) => slugify(input));
 }
+// @__NO_SIDE_EFFECTS__
 function _array(Class, element, params) {
     return new Class({
         type: "array",
@@ -25159,6 +26182,7 @@ function _array(Class, element, params) {
     });
 }
 // same as _custom but defaults to abort:false
+// @__NO_SIDE_EFFECTS__
 function _refine(Class, fn, _params) {
     const schema = new Class({
         type: "custom",
@@ -25168,6 +26192,7 @@ function _refine(Class, fn, _params) {
     });
     return schema;
 }
+// @__NO_SIDE_EFFECTS__
 function _superRefine(fn) {
     const ch = _check((payload) => {
         payload.addIssue = (issue$1) => {
@@ -25190,6 +26215,7 @@ function _superRefine(fn) {
     });
     return ch;
 }
+// @__NO_SIDE_EFFECTS__
 function _check(fn, params) {
     const ch = new $ZodCheck({
         check: "custom",
@@ -25256,14 +26282,7 @@ function process$1(schema, ctx, _params = { path: [], schemaPath: [] }) {
             schemaPath: [..._params.schemaPath, schema],
             path: _params.path,
         };
-        const parent = schema._zod.parent;
-        if (parent) {
-            // schema was cloned from another schema
-            result.ref = parent;
-            process$1(parent, ctx, params);
-            ctx.seen.get(parent).isParent = true;
-        }
-        else if (schema._zod.processJSONSchema) {
+        if (schema._zod.processJSONSchema) {
             schema._zod.processJSONSchema(ctx, result.schema, params);
         }
         else {
@@ -25274,6 +26293,14 @@ function process$1(schema, ctx, _params = { path: [], schemaPath: [] }) {
             }
             processor(schema, ctx, _json, params);
         }
+        const parent = schema._zod.parent;
+        if (parent) {
+            // Also set ref if processor didn't (for inheritance)
+            if (!result.ref)
+                result.ref = parent;
+            process$1(parent, ctx, params);
+            ctx.seen.get(parent).isParent = true;
+        }
     }
     // metadata
     const meta = ctx.metadataRegistry.get(schema);
@@ -25299,6 +26326,18 @@ function extractDefs(ctx, schema
     const root = ctx.seen.get(schema);
     if (!root)
         throw new Error("Unprocessed schema. This is a bug in Zod.");
+    // Track ids to detect duplicates across different schemas
+    const idToSchema = new Map();
+    for (const entry of ctx.seen.entries()) {
+        const id = ctx.metadataRegistry.get(entry[0])?.id;
+        if (id) {
+            const existing = idToSchema.get(id);
+            if (existing && existing !== entry[0]) {
+                throw new Error(`Duplicate schema id "${id}" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.`);
+            }
+            idToSchema.set(id, entry[0]);
+        }
+    }
     // returns a ref to the schema
     // defId will be empty if the ref points to an external schema (or #)
     const makeURI = (entry) => {
@@ -25400,43 +26439,84 @@ function extractDefs(ctx, schema
     }
 }
 function finalize(ctx, schema) {
-    //
-    // iterate over seen map;
     const root = ctx.seen.get(schema);
     if (!root)
         throw new Error("Unprocessed schema. This is a bug in Zod.");
-    // flatten _refs
+    // flatten refs - inherit properties from parent schemas
     const flattenRef = (zodSchema) => {
         const seen = ctx.seen.get(zodSchema);
+        // already processed
+        if (seen.ref === null)
+            return;
         const schema = seen.def ?? seen.schema;
         const _cached = { ...schema };
-        // already seen
-        if (seen.ref === null) {
-            return;
-        }
-        // flatten ref if defined
         const ref = seen.ref;
-        seen.ref = null; // prevent recursion
+        seen.ref = null; // prevent infinite recursion
         if (ref) {
             flattenRef(ref);
+            const refSeen = ctx.seen.get(ref);
+            const refSchema = refSeen.schema;
             // merge referenced schema into current
-            const refSchema = ctx.seen.get(ref).schema;
             if (refSchema.$ref && (ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0")) {
+                // older drafts can't combine $ref with other properties
                 schema.allOf = schema.allOf ?? [];
                 schema.allOf.push(refSchema);
             }
             else {
                 Object.assign(schema, refSchema);
-                Object.assign(schema, _cached); // prevent overwriting any fields in the original schema
+            }
+            // restore child's own properties (child wins)
+            Object.assign(schema, _cached);
+            const isParentRef = zodSchema._zod.parent === ref;
+            // For parent chain, child is a refinement - remove parent-only properties
+            if (isParentRef) {
+                for (const key in schema) {
+                    if (key === "$ref" || key === "allOf")
+                        continue;
+                    if (!(key in _cached)) {
+                        delete schema[key];
+                    }
+                }
+            }
+            // When ref was extracted to $defs, remove properties that match the definition
+            if (refSchema.$ref) {
+                for (const key in schema) {
+                    if (key === "$ref" || key === "allOf")
+                        continue;
+                    if (key in refSeen.def && JSON.stringify(schema[key]) === JSON.stringify(refSeen.def[key])) {
+                        delete schema[key];
+                    }
+                }
+            }
+        }
+        // If parent was extracted (has $ref), propagate $ref to this schema
+        // This handles cases like: readonly().meta({id}).describe()
+        // where processor sets ref to innerType but parent should be referenced
+        const parent = zodSchema._zod.parent;
+        if (parent && parent !== ref) {
+            // Ensure parent is processed first so its def has inherited properties
+            flattenRef(parent);
+            const parentSeen = ctx.seen.get(parent);
+            if (parentSeen?.schema.$ref) {
+                schema.$ref = parentSeen.schema.$ref;
+                // De-duplicate with parent's definition
+                if (parentSeen.def) {
+                    for (const key in schema) {
+                        if (key === "$ref" || key === "allOf")
+                            continue;
+                        if (key in parentSeen.def && JSON.stringify(schema[key]) === JSON.stringify(parentSeen.def[key])) {
+                            delete schema[key];
+                        }
+                    }
+                }
             }
         }
         // execute overrides
-        if (!seen.isParent)
-            ctx.override({
-                zodSchema: zodSchema,
-                jsonSchema: schema,
-                path: seen.path ?? [],
-            });
+        ctx.override({
+            zodSchema: zodSchema,
+            jsonSchema: schema,
+            path: seen.path ?? [],
+        });
     };
     for (const entry of [...ctx.seen.entries()].reverse()) {
         flattenRef(entry[0]);
@@ -25489,8 +26569,8 @@ function finalize(ctx, schema) {
             value: {
                 ...schema["~standard"],
                 jsonSchema: {
-                    input: createStandardJSONSchemaMethod(schema, "input"),
-                    output: createStandardJSONSchemaMethod(schema, "output"),
+                    input: createStandardJSONSchemaMethod(schema, "input", ctx.processors),
+                    output: createStandardJSONSchemaMethod(schema, "output", ctx.processors),
                 },
             },
             enumerable: false,
@@ -25569,9 +26649,9 @@ const createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
     extractDefs(ctx, schema);
     return finalize(ctx, schema);
 };
-const createStandardJSONSchemaMethod = (schema, io) => (params) => {
+const createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => {
     const { libraryOptions, target } = params ?? {};
-    const ctx = initializeContext({ ...(libraryOptions ?? {}), target, io, processors: {} });
+    const ctx = initializeContext({ ...(libraryOptions ?? {}), target, io, processors });
     process$1(schema, ctx);
     extractDefs(ctx, schema);
     return finalize(ctx, schema);
@@ -25599,6 +26679,11 @@ const stringProcessor = (schema, ctx, _json, _params) => {
         json.format = formatMap[format] ?? format;
         if (json.format === "")
             delete json.format; // empty format is not valid
+        // JSON Schema format: "time" requires a full time with offset or Z
+        // z.iso.time() does not include timezone information, so format: "time" should never be used
+        if (format === "time") {
+            delete json.format;
+        }
     }
     if (contentEncoding)
         json.contentEncoding = contentEncoding;
@@ -25956,8 +27041,11 @@ const ZodType = /*@__PURE__*/ $constructor("ZodType", (inst, def) => {
                 ...(def.checks ?? []),
                 ...checks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch),
             ],
-        }));
+        }), {
+            parent: true,
+        });
     };
+    inst.with = inst.check;
     inst.clone = (def, params) => clone(inst, def, params);
     inst.brand = () => inst;
     inst.register = ((reg, meta) => {
@@ -25985,6 +27073,7 @@ const ZodType = /*@__PURE__*/ $constructor("ZodType", (inst, def) => {
     inst.overwrite = (fn) => inst.check(_overwrite(fn));
     // wrappers
     inst.optional = () => optional(inst);
+    inst.exactOptional = () => exactOptional(inst);
     inst.nullable = () => nullable(inst);
     inst.nullish = () => optional(nullable(inst));
     inst.nonoptional = (params) => nonoptional(inst, params);
@@ -26021,6 +27110,7 @@ const ZodType = /*@__PURE__*/ $constructor("ZodType", (inst, def) => {
     // helpers
     inst.isOptional = () => inst.safeParse(undefined).success;
     inst.isNullable = () => inst.safeParse(null).success;
+    inst.apply = (fn) => fn(inst);
     return inst;
 });
 /** @internal */
@@ -26418,6 +27508,18 @@ function optional(innerType) {
         innerType: innerType,
     });
 }
+const ZodExactOptional = /*@__PURE__*/ $constructor("ZodExactOptional", (inst, def) => {
+    $ZodExactOptional.init(inst, def);
+    ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => optionalProcessor(inst, ctx, json, params);
+    inst.unwrap = () => inst._zod.def.innerType;
+});
+function exactOptional(innerType) {
+    return new ZodExactOptional({
+        type: "optional",
+        innerType: innerType,
+    });
+}
 const ZodNullable = /*@__PURE__*/ $constructor("ZodNullable", (inst, def) => {
     $ZodNullable.init(inst, def);
     ZodType.init(inst, def);
@@ -26528,6 +27630,16 @@ function superRefine(fn) {
     return _superRefine(fn);
 }
 
+var __defProp$2 = Object.defineProperty;
+var __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor;
+var __decorateClass$2 = (decorators, target, key, kind) => {
+  var result = __getOwnPropDesc$2(target, key) ;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(target, key, result) ) || result;
+  if (result) __defProp$2(target, key, result);
+  return result;
+};
 class BaseRoom {
   constructor() {
     /**
@@ -26548,6 +27660,9 @@ class BaseRoom {
      */
     this.database = signal({});
   }
+  async onStart() {
+    await lastValueFrom(this.hooks.callHooks("server-databaseHooks-load", this));
+  }
   /**
    * Add data to the room's database
    * 
@@ -26619,7 +27734,101 @@ class BaseRoom {
     this.database.set(database);
     return true;
   }
+  /**
+  * Get the hooks system for this map
+  * 
+  * Returns the dependency-injected Hooks instance that allows you to trigger
+  * and listen to various game events.
+  * 
+  * @returns The Hooks instance for this map
+  * 
+  * @example
+  * ```ts
+  * // Trigger a custom hook
+  * map.hooks.callHooks('custom-event', data).subscribe();
+  * ```
+  */
+  get hooks() {
+    return inject(ModulesToken, context);
+  }
+  /**
+   * Resolve complex snapshot entries (e.g. inventory items) before load.
+   */
+  async onSessionRestore({ userSnapshot, user }) {
+    if (!userSnapshot) {
+      return userSnapshot;
+    }
+    let resolvedSnapshot = userSnapshot;
+    if (user && typeof user.resolveItemsSnapshot === "function") {
+      resolvedSnapshot = user.resolveItemsSnapshot(resolvedSnapshot, this);
+    }
+    if (user && typeof user.resolveSkillsSnapshot === "function") {
+      resolvedSnapshot = user.resolveSkillsSnapshot(resolvedSnapshot, this);
+    }
+    if (user && typeof user.resolveStatesSnapshot === "function") {
+      resolvedSnapshot = user.resolveStatesSnapshot(resolvedSnapshot, this);
+    }
+    if (user && typeof user.resolveClassSnapshot === "function") {
+      resolvedSnapshot = user.resolveClassSnapshot(resolvedSnapshot, this);
+    }
+    if (user && typeof user.resolveEquipmentsSnapshot === "function") {
+      resolvedSnapshot = user.resolveEquipmentsSnapshot(resolvedSnapshot, this);
+    }
+    return resolvedSnapshot;
+  }
+  async listSaveSlots(player, value) {
+    const storage = resolveSaveStorageStrategy();
+    try {
+      const slots = await storage.list(player);
+      player.emit("save.list.result", { requestId: value?.requestId, slots });
+      return slots;
+    } catch (error) {
+      player.showNotification(error?.message || "save.list failed");
+      return [];
+    }
+  }
+  async saveSlot(player, value) {
+    const storage = resolveSaveStorageStrategy();
+    try {
+      if (typeof value?.index !== "number") {
+        throw new Error("save.save requires an index");
+      }
+      const result = await player.save(value.index, value?.meta, { reason: "manual", source: "gui" });
+      if (!result) {
+        throw new Error("save.save is not allowed");
+      }
+      const slots = await storage.list(player);
+      player.emit("save.save.result", { requestId: value?.requestId, index: result.index, slots });
+    } catch (error) {
+      player.emit("save.error", { requestId: value?.requestId, message: error?.message || "save.save failed" });
+    }
+  }
+  async loadSlot(player, value) {
+    try {
+      if (typeof value?.index !== "number") {
+        throw new Error("save.load requires an index");
+      }
+      const result = await player.load(value.index, { reason: "load", source: "gui" }, { changeMap: true });
+      player.emit("save.load.result", {
+        requestId: value?.requestId,
+        index: value.index,
+        ok: result.ok,
+        slot: result.slot
+      });
+    } catch (error) {
+      player.emit("save.error", { requestId: value?.requestId, message: error?.message || "save.load failed" });
+    }
+  }
 }
+__decorateClass$2([
+  Action("save.list")
+], BaseRoom.prototype, "listSaveSlots");
+__decorateClass$2([
+  Action("save.save")
+], BaseRoom.prototype, "saveSlot");
+__decorateClass$2([
+  Action("save.load")
+], BaseRoom.prototype, "loadSlot");
 
 var __defProp$1 = Object.defineProperty;
 var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
@@ -26740,6 +27949,9 @@ let RpgMap = class extends RpgCommonMap {
       this.loop();
     }
   }
+  onStart() {
+    return BaseRoom.prototype.onStart.call(this);
+  }
   /**
    * Setup collision detection between players, events, and shapes
    * 
@@ -26946,7 +28158,7 @@ let RpgMap = class extends RpgCommonMap {
     } else {
       player.map = this;
     }
-    player.context = context$1;
+    player.context = context;
     player.conn = conn;
     player._onInit();
     this.dataIsReady$.pipe(
@@ -27009,10 +28221,16 @@ let RpgMap = class extends RpgCommonMap {
    * ```
    */
   get hooks() {
-    return inject$1(context$1, ModulesToken);
+    return BaseRoom.prototype.hooks;
+  }
+  async onSessionRestore(payload) {
+    return await BaseRoom.prototype.onSessionRestore.call(this, payload);
   }
-  guiInteraction(player, value) {
-    this.hooks.callHooks("server-player-guiInteraction", player, value);
+  async guiInteraction(player, value) {
+    const gui = player.getGui(value.guiId);
+    if (gui) {
+      await gui.emit(value.name, value.data);
+    }
     player.syncChanges();
   }
   guiExit(player, { guiId, data }) {
@@ -27041,6 +28259,15 @@ let RpgMap = class extends RpgCommonMap {
       });
     }
   }
+  async saveSlot(player, value) {
+    BaseRoom.prototype.saveSlot(player, value);
+  }
+  async loadSlot(player, value) {
+    BaseRoom.prototype.loadSlot(player, value);
+  }
+  async listSaveSlots(player, value) {
+    return await BaseRoom.prototype.listSaveSlots(player, value);
+  }
   async updateMap(request) {
     const map = await request.json();
     this.data.set(map);
@@ -27529,7 +28756,7 @@ let RpgMap = class extends RpgCommonMap {
       if (event.name) eventInstance.name.set(event.name);
     }
     eventInstance.map = this;
-    eventInstance.context = context$1;
+    eventInstance.context = context;
     await eventInstance.teleport({ x, y });
     this.events()[id] = eventInstance;
     await eventInstance.execMethod("onInit");
@@ -28208,6 +29435,15 @@ __decorateClass$1([
 __decorateClass$1([
   Action("move")
 ], RpgMap.prototype, "onInput", 1);
+__decorateClass$1([
+  Action("save.save")
+], RpgMap.prototype, "saveSlot", 1);
+__decorateClass$1([
+  Action("save.load")
+], RpgMap.prototype, "loadSlot", 1);
+__decorateClass$1([
+  Action("save.list")
+], RpgMap.prototype, "listSaveSlots", 1);
 __decorateClass$1([
   Request2({
     path: "/map/update",
@@ -28246,17 +29482,25 @@ let LobbyRoom = class extends BaseRoom {
       this.autoSync = false;
     }
   }
-  onJoin(player, conn) {
+  async onJoin(player, conn) {
     player.map = this;
-    player.context = context$1;
+    player.context = context;
     player.conn = conn;
-    const hooks = inject$1(context$1, ModulesToken);
-    hooks.callHooks("server-player-onConnected", player).subscribe();
+    this.hooks.callHooks("server-player-onConnected", player).subscribe();
+  }
+  async guiInteraction(player, value) {
+    const id = value.data.id;
+    if (id === "start") {
+      this.hooks.callHooks("server-player-onStart", player).subscribe();
+    }
   }
 };
 __decorateClass([
   users(RpgPlayer)
 ], LobbyRoom.prototype, "players", 2);
+__decorateClass([
+  Action("gui.interaction")
+], LobbyRoom.prototype, "guiInteraction", 1);
 LobbyRoom = __decorateClass([
   Room({
     path: "lobby-{id}"
@@ -28270,19 +29514,6 @@ class RpgServerEngine extends Server {
   }
 }
 
-let context = null;
-function inject(service, _context) {
-  const c = _context ?? context;
-  if (!c) throw new Error("Context is not set. use setInject() to set the context");
-  return inject$1(c, service);
-}
-function setInject(_context) {
-  context = _context;
-}
-function clearInject() {
-  context = null;
-}
-
 function createServer(options) {
   return class extends RpgServerEngine {
     constructor() {
@@ -28290,8 +29521,8 @@ function createServer(options) {
       this.config = options;
     }
     async onStart() {
-      setInject(context$1);
-      await injector(context$1, options.providers);
+      setInject(context);
+      await injector(context, options.providers);
       return super.onStart();
     }
   };
@@ -28616,6 +29847,60 @@ function provideServerModules(modules) {
   });
 }
 
+class LocalStorageSaveStorageStrategy {
+  constructor(options = {}) {
+    this.key = options.key ?? "rpgjs-save-slots";
+  }
+  async list(_player) {
+    return this.stripSnapshots(this.readSlots());
+  }
+  async get(_player, index) {
+    const slots = this.readSlots();
+    return slots[index] ?? null;
+  }
+  async save(_player, index, snapshot, meta) {
+    const slots = this.readSlots();
+    const existing = slots[index];
+    slots[index] = {
+      ...existing ?? {},
+      ...meta,
+      snapshot
+    };
+    this.writeSlots(slots);
+  }
+  async delete(_player, index) {
+    const slots = this.readSlots();
+    slots[index] = null;
+    this.writeSlots(slots);
+  }
+  readSlots() {
+    if (typeof localStorage === "undefined") {
+      return [];
+    }
+    const raw = localStorage.getItem(this.key);
+    if (!raw) return [];
+    try {
+      const parsed = JSON.parse(raw);
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
+    }
+  }
+  writeSlots(slots) {
+    if (typeof localStorage === "undefined") {
+      return;
+    }
+    localStorage.setItem(this.key, JSON.stringify(slots));
+  }
+  stripSnapshots(slots) {
+    return slots.map((slot) => {
+      if (!slot) return null;
+      const { snapshot, ...meta } = slot;
+      return meta;
+    });
+  }
+}
+
 var EventMode = /* @__PURE__ */ ((EventMode2) => {
   EventMode2["Shared"] = "shared";
   EventMode2["Scenario"] = "scenario";
@@ -28661,5 +29946,5 @@ function MapData(options) {
   };
 }
 
-export { AGI, AGI_CURVE, ATK, 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, PDEF, RpgEvent, RpgMap, RpgModule, RpgPlayer, RpgServerEngine, RpgShape, SDEF, STR, STR_CURVE, ShopGui, Speed, WithMoveManager, clearInject, computed, context, createServer, effect, inject, isArraySubject, isComputed, isObjectSubject, isSignal, linkedSignal, provideServerModules, setInject, signal, untracked };
+export { AGI, AGI_CURVE, ATK, ArraySubject, AutoSaveToken, COEFFICIENT_ELEMENTS, Components, DAMAGE_CRITICAL, DAMAGE_GUARD, DAMAGE_PHYSIC, DAMAGE_SKILL, DEX, DEX_CURVE, DialogGui, DialogPosition, EventData, EventMode, Frequency, GameoverGui, Gui, INT, INT_CURVE, InMemorySaveStorageStrategy, LocalStorageSaveStorageStrategy, MAXHP, MAXHP_CURVE, MAXSP, MAXSP_CURVE, MapData, MenuGui, Move, NotificationGui, ObjectSubject, PDEF, RpgEvent, RpgMap, RpgModule, RpgPlayer, RpgServerEngine, RpgShape, SDEF, STR, STR_CURVE, SaveLoadGui, SaveStorageToken, ShopGui, Speed, TitleGui, WithMoveManager, buildSaveSlotMeta, clearInject, computed, context$1 as context, createServer, effect, inject, isArraySubject, isComputed, isObjectSubject, isSignal, linkedSignal, provideAutoSave, provideSaveStorage, provideServerModules, resolveAutoSaveStrategy, resolveSaveSlot, resolveSaveStorageStrategy, setInject, shouldAutoSave, signal, untracked };
 //# sourceMappingURL=index.js.map