@rpgjs/server 5.0.0-beta.5 → 5.0.0-beta.7

package/dist/index.js

@@ -1,4 +1,4 @@
-import { $ as RpgCommonPlayer, A as isArray, At as createErrorClass, B as ProjectileMovement, C as SDEF, Ct as isSignal, D as arrayFlat, Dt as finalize$1, E as PrebuiltGui, Et as untracked, F as ModulesToken, G as Knockback, H as PathFollow, I as RpgModule, J as Entity, K as IceMovement, L as WorldMapsManager, M as isInstanceOf, N as isString, O as arrayUniq, Ot as combineLatest, P as random, Q as Direction, R as RpgCommonMap, S as PDEF, St as isObjectSubject, T as PerlinNoise2D, Tt as signal, U as Oscillate, V as ProjectileType, W as LinearRepulsion, X as Vector2, Y as EntityState, Z as RpgShape, _ as ATK, _t as ObjectSubject, a as isMapUpdateAuthorized, at as createStatesSnapshot, b as MAXHP, bt as isArraySubject, ct as getByPath, d as context, dt as persist, et as Skill, f as inject, ft as sync, g as AGI, gt as ArraySubject, h as injector, ht as users, j as isFunction, k as capitalize, kt as BehaviorSubject, l as context$1, lt as id, m as inject$1, mt as type, n as MAP_UPDATE_TOKEN_ENV, nt as __decorate, ot as createStatesSnapshotDeep, p as setInject, pt as syncClass, q as Dash, r as MAP_UPDATE_TOKEN_HEADER, rt as __decorateMetadata, st as generateShortUUID$1, t as provideServerModules, tt as Item, u as clearInject, ut as load, v as DEX, vt as computed, w as STR, wt as linkedSignal, x as MAXSP, xt as isComputed, y as INT, yt as effect, z as SeekAvoid } from "./module-BmvXIvlE.js";
+import { $ as Skill, A as isArray$2, B as ProjectileMovement, C as SDEF, D as arrayFlat, E as PrebuiltGui, F as ModulesToken, G as Knockback, H as PathFollow, I as RpgModule, J as Entity, K as IceMovement, L as WorldMapsManager, M as isInstanceOf, N as isString, O as arrayUniq, P as random, Q as RpgCommonPlayer, R as RpgCommonMap, S as PDEF, T as PerlinNoise2D, U as Oscillate, V as ProjectileType, W as LinearRepulsion, X as RpgShape, Y as Vector2, Z as Direction, _ as ATK, a as isMapUpdateAuthorized, at as map, b as MAXHP, ct as BehaviorSubject, d as context, dt as Observable, et as Item, f as inject, ft as identity, g as AGI, gt as __spreadArray, h as injector, ht as __read, it as filter, j as isFunction$1, k as capitalize, l as context$1, lt as createOperatorSubscriber, m as inject$1, mt as isFunction, n as MAP_UPDATE_TOKEN_ENV, nt as __decorateMetadata, ot as from, p as setInject, pt as createErrorClass, q as Dash, r as MAP_UPDATE_TOKEN_HEADER, rt as signal$1, st as executeSchedule, t as provideServerModules, tt as __decorate, u as clearInject, ut as operate, v as DEX, w as STR, x as MAXSP, y as INT, z as SeekAvoid } from "./module-5HOX9Ovu.js";
 //#region ../../node_modules/.pnpm/dset@3.1.4/node_modules/dset/dist/index.mjs
 function dset(obj, keys, val) {
 	keys.split && (keys = keys.split("."));
@@ -126,7 +126,7 @@ var ZodIssueCode = util.arrayToEnum([
 var quotelessJson = (obj) => {
 	return JSON.stringify(obj, null, 2).replace(/"([^"]+)":/g, "$1:");
 };
-var ZodError$1 = class ZodError$1 extends Error {
+var ZodError = class ZodError extends Error {
 	get errors() {
 		return this.issues;
 	}
@@ -174,7 +174,7 @@ var ZodError$1 = class ZodError$1 extends Error {
 		return fieldErrors;
 	}
 	static assert(value) {
-		if (!(value instanceof ZodError$1)) throw new Error(`Not a ZodError: ${value}`);
+		if (!(value instanceof ZodError)) throw new Error(`Not a ZodError: ${value}`);
 	}
 	toString() {
 		return this.message;
@@ -201,8 +201,8 @@ var ZodError$1 = class ZodError$1 extends Error {
 		return this.flatten();
 	}
 };
-ZodError$1.create = (issues) => {
-	return new ZodError$1(issues);
+ZodError.create = (issues) => {
+	return new ZodError(issues);
 };
 var errorMap = (issue, _ctx) => {
 	let message;
@@ -444,7 +444,7 @@ var handleResult = (ctx, result) => {
 			success: false,
 			get error() {
 				if (this._error) return this._error;
-				const error = new ZodError$1(ctx.common.issues);
+				const error = new ZodError(ctx.common.issues);
 				this._error = error;
 				return this._error;
 			}
@@ -2379,7 +2379,7 @@ var ZodUnion$1 = class extends ZodType$1 {
 				ctx.common.issues.push(...result.ctx.common.issues);
 				return result.result;
 			}
-			const unionErrors = results.map((result) => new ZodError$1(result.ctx.common.issues));
+			const unionErrors = results.map((result) => new ZodError(result.ctx.common.issues));
 			addIssueToContext(ctx, {
 				code: ZodIssueCode.invalid_union,
 				unionErrors
@@ -2432,7 +2432,7 @@ var ZodUnion$1 = class extends ZodType$1 {
 				ctx.common.issues.push(...dirty.ctx.common.issues);
 				return dirty.result;
 			}
-			const unionErrors = issues.map((issues) => new ZodError$1(issues));
+			const unionErrors = issues.map((issues) => new ZodError(issues));
 			addIssueToContext(ctx, {
 				code: ZodIssueCode.invalid_union,
 				unionErrors
@@ -2934,7 +2934,7 @@ var ZodFunction = class ZodFunction extends ZodType$1 {
 		if (this._def.returns instanceof ZodPromise) {
 			const me = this;
 			return OK(async function(...args) {
-				const error = new ZodError$1([]);
+				const error = new ZodError([]);
 				const parsedArgs = await me._def.args.parseAsync(args, params).catch((e) => {
 					error.addIssue(makeArgsIssue(args, e));
 					throw error;
@@ -2949,10 +2949,10 @@ var ZodFunction = class ZodFunction extends ZodType$1 {
 			const me = this;
 			return OK(function(...args) {
 				const parsedArgs = me._def.args.safeParse(args, params);
-				if (!parsedArgs.success) throw new ZodError$1([makeArgsIssue(args, parsedArgs.error)]);
+				if (!parsedArgs.success) throw new ZodError([makeArgsIssue(args, parsedArgs.error)]);
 				const result = Reflect.apply(fn, this, parsedArgs.data);
 				const parsedReturns = me._def.returns.safeParse(result, params);
-				if (!parsedReturns.success) throw new ZodError$1([makeReturnsIssue(result, parsedReturns.error)]);
+				if (!parsedReturns.success) throw new ZodError([makeReturnsIssue(result, parsedReturns.error)]);
 				return parsedReturns.data;
 			});
 		}
@@ -3380,7 +3380,7 @@ var ZodCatch$1 = class extends ZodType$1 {
 				status: "valid",
 				value: result.status === "valid" ? result.value : this._def.catchValue({
 					get error() {
-						return new ZodError$1(newCtx.common.issues);
+						return new ZodError(newCtx.common.issues);
 					},
 					input: newCtx.data
 				})
@@ -3390,7 +3390,7 @@ var ZodCatch$1 = class extends ZodType$1 {
 			status: "valid",
 			value: result.status === "valid" ? result.value : this._def.catchValue({
 				get error() {
-					return new ZodError$1(newCtx.common.issues);
+					return new ZodError(newCtx.common.issues);
 				},
 				input: newCtx.data
 			})
@@ -3760,9 +3760,25 @@ var z = /* @__PURE__ */ Object.freeze({
 	NEVER: INVALID,
 	ZodIssueCode,
 	quotelessJson,
-	ZodError: ZodError$1
+	ZodError
 });
 //#endregion
+//#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/isScheduler.js
+function isScheduler(value) {
+	return value && isFunction(value.schedule);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/args.js
+function last(arr) {
+	return arr[arr.length - 1];
+}
+function popResultSelector(args) {
+	return isFunction(last(args)) ? args.pop() : void 0;
+}
+function popScheduler(args) {
+	return isScheduler(last(args)) ? args.pop() : void 0;
+}
+//#endregion
 //#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/EmptyError.js
 var EmptyError = createErrorClass(function(_super) {
 	return function EmptyErrorImpl() {
@@ -3793,12 +3809,855 @@ function lastValueFrom(source, config) {
 	});
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@signe+room@2.9.0/node_modules/@signe/room/dist/index.js
+//#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/mapOneOrManyArgs.js
+var isArray$1 = Array.isArray;
+function callOrApply(fn, args) {
+	return isArray$1(args) ? fn.apply(void 0, __spreadArray([], __read(args))) : fn(args);
+}
+function mapOneOrManyArgs(fn) {
+	return map(function(args) {
+		return callOrApply(fn, args);
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/argsArgArrayOrObject.js
+var isArray = Array.isArray;
+var getPrototypeOf = Object.getPrototypeOf, objectProto = Object.prototype, getKeys = Object.keys;
+function argsArgArrayOrObject(args) {
+	if (args.length === 1) {
+		var first_1 = args[0];
+		if (isArray(first_1)) return {
+			args: first_1,
+			keys: null
+		};
+		if (isPOJO(first_1)) {
+			var keys = getKeys(first_1);
+			return {
+				args: keys.map(function(key) {
+					return first_1[key];
+				}),
+				keys
+			};
+		}
+	}
+	return {
+		args,
+		keys: null
+	};
+}
+function isPOJO(obj) {
+	return obj && typeof obj === "object" && getPrototypeOf(obj) === objectProto;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/createObject.js
+function createObject(keys, values) {
+	return keys.reduce(function(result, key, i) {
+		return result[key] = values[i], result;
+	}, {});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/observable/combineLatest.js
+function combineLatest() {
+	var args = [];
+	for (var _i = 0; _i < arguments.length; _i++) args[_i] = arguments[_i];
+	var scheduler = popScheduler(args);
+	var resultSelector = popResultSelector(args);
+	var _a = argsArgArrayOrObject(args), observables = _a.args, keys = _a.keys;
+	if (observables.length === 0) return from([], scheduler);
+	var result = new Observable(combineLatestInit(observables, scheduler, keys ? function(values) {
+		return createObject(keys, values);
+	} : identity));
+	return resultSelector ? result.pipe(mapOneOrManyArgs(resultSelector)) : result;
+}
+function combineLatestInit(observables, scheduler, valueTransform) {
+	if (valueTransform === void 0) valueTransform = identity;
+	return function(subscriber) {
+		maybeSchedule(scheduler, function() {
+			var length = observables.length;
+			var values = new Array(length);
+			var active = length;
+			var remainingFirstValues = length;
+			var _loop_1 = function(i) {
+				maybeSchedule(scheduler, function() {
+					var source = from(observables[i], scheduler);
+					var hasFirstValue = false;
+					source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+						values[i] = value;
+						if (!hasFirstValue) {
+							hasFirstValue = true;
+							remainingFirstValues--;
+						}
+						if (!remainingFirstValues) subscriber.next(valueTransform(values.slice()));
+					}, function() {
+						if (!--active) subscriber.complete();
+					}));
+				}, subscriber);
+			};
+			for (var i = 0; i < length; i++) _loop_1(i);
+		}, subscriber);
+	};
+}
+function maybeSchedule(scheduler, execute, subscription) {
+	if (scheduler) executeSchedule(subscription, scheduler, execute);
+	else execute();
+}
+//#endregion
+//#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/operators/finalize.js
+function finalize$1(callback) {
+	return operate(function(source, subscriber) {
+		try {
+			source.subscribe(subscriber);
+		} finally {
+			subscriber.add(callback);
+		}
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@signe+reactive@2.10.0/node_modules/@signe/reactive/dist/index.js
+var ArraySubject = class extends BehaviorSubject {
+	constructor(items = []) {
+		super({
+			type: "init",
+			items
+		});
+		this._items = [];
+		this.createProxy(items);
+	}
+	createProxy(items) {
+		this._items = new Proxy(items, {
+			get: (target, prop, receiver) => {
+				const origMethod = target[prop];
+				if (typeof origMethod === "function") return (...args) => {
+					let changeType = "update";
+					let index = void 0;
+					let isMutateFn = false;
+					let itemsToEmit = [];
+					let changeSplice = true;
+					switch (prop) {
+						case "push":
+							index = target.length;
+							changeType = "add";
+							isMutateFn = true;
+							break;
+						case "pop":
+							index = target.length - 1;
+							changeType = "remove";
+							isMutateFn = true;
+							break;
+						case "unshift":
+							index = 0;
+							changeType = "add";
+							isMutateFn = true;
+							break;
+						case "shift":
+							index = 0;
+							changeType = "remove";
+							isMutateFn = true;
+							break;
+						case "splice":
+							index = args[0];
+							const deleteCount = args[1];
+							const newItems = args.slice(2);
+							itemsToEmit = newItems;
+							if (deleteCount > 0 && newItems.length === 0) changeType = "remove";
+							else if (deleteCount === 0 && newItems.length > 0) changeType = "add";
+							else if (deleteCount === 0 && newItems.length === 0) changeSplice = false;
+							else changeType = "update";
+							isMutateFn = true;
+							break;
+					}
+					const result = origMethod.apply(target, args);
+					if (isMutateFn && changeSplice) if (prop === "splice") this.next({
+						type: changeType,
+						index,
+						items: itemsToEmit
+					});
+					else this.next({
+						type: changeType,
+						index,
+						items: args
+					});
+					return result;
+				};
+				return Reflect.get(target, prop, receiver);
+			},
+			set: (target, prop, value) => {
+				const index = !isNaN(Number(prop)) ? Number(prop) : void 0;
+				target[prop] = value;
+				this.next({
+					type: "update",
+					index,
+					items: [value]
+				});
+				return true;
+			}
+		});
+	}
+	get items() {
+		return this._items;
+	}
+	set items(newItems) {
+		this.createProxy(newItems);
+		this.next({
+			type: "reset",
+			items: newItems
+		});
+	}
+};
+var isArraySubject = (value) => {
+	return "_items" in value;
+};
+var ObjectSubject = class extends BehaviorSubject {
+	constructor(obj = {}) {
+		super({
+			type: "init",
+			value: obj
+		});
+		this.createProxy(obj);
+	}
+	createProxy(obj) {
+		this._obj = new Proxy(obj, {
+			get: (target, prop, receiver) => {
+				return Reflect.get(target, prop, receiver);
+			},
+			set: (target, prop, value, receiver) => {
+				const key = prop;
+				const changeType = key in target ? "update" : "add";
+				target[key] = value;
+				this.next({
+					type: changeType,
+					key,
+					value
+				});
+				return true;
+			},
+			deleteProperty: (target, prop) => {
+				const key = prop;
+				if (key in target) {
+					const value = target[key];
+					delete target[key];
+					this.next({
+						type: "remove",
+						key,
+						value
+					});
+					return true;
+				}
+				return false;
+			}
+		});
+	}
+	get obj() {
+		return this._obj;
+	}
+	set obj(newObj) {
+		this.createProxy(newObj);
+		this.next({
+			type: "reset",
+			value: newObj
+		});
+	}
+};
+var isObjectSubject = (value) => {
+	return "_obj" in value;
+};
+var getGlobalReactiveStore = () => {
+	const globalKey = "__REACTIVE_STORE__";
+	if (typeof globalThis !== "undefined") {
+		if (!globalThis[globalKey]) globalThis[globalKey] = {
+			currentDependencyTracker: null,
+			currentSubscriptionsTracker: null
+		};
+		return globalThis[globalKey];
+	}
+	let globalObj;
+	if (typeof window !== "undefined") globalObj = window;
+	else if (typeof process !== "undefined" && process.versions && process.versions.node) globalObj = Function("return this")();
+	else if (typeof self !== "undefined") globalObj = self;
+	else {
+		console.warn("Unable to find global object, using local instance");
+		return {
+			currentDependencyTracker: null,
+			currentSubscriptionsTracker: null
+		};
+	}
+	if (!globalObj[globalKey]) globalObj[globalKey] = {
+		currentDependencyTracker: null,
+		currentSubscriptionsTracker: null
+	};
+	return globalObj[globalKey];
+};
+var reactiveStore = getGlobalReactiveStore();
+var trackDependency = (signal2) => {
+	if (reactiveStore.currentDependencyTracker) reactiveStore.currentDependencyTracker(signal2);
+};
+function signal(defaultValue, options) {
+	let subject;
+	if (Array.isArray(defaultValue)) subject = new ArraySubject(defaultValue);
+	else if (typeof defaultValue === "object" && defaultValue !== null) subject = new ObjectSubject(defaultValue);
+	else subject = new BehaviorSubject(defaultValue);
+	const getValue = () => {
+		if (subject instanceof ArraySubject) return subject.items;
+		else if (subject instanceof ObjectSubject) return subject.obj;
+		return subject.value;
+	};
+	const fn = function() {
+		trackDependency(fn);
+		return getValue();
+	};
+	fn.set = (value) => {
+		const currentValue = getValue();
+		let shouldEmit = true;
+		if (options?.equal) shouldEmit = !options.equal(currentValue, value);
+		else shouldEmit = currentValue !== value;
+		if (shouldEmit) if (subject instanceof ArraySubject) subject.items = value;
+		else if (subject instanceof ObjectSubject) subject.obj = value;
+		else subject.next(value);
+	};
+	fn._isFrozen = false;
+	fn.freeze = () => {
+		fn._isFrozen = true;
+	};
+	fn.unfreeze = () => {
+		fn._isFrozen = false;
+		if (subject instanceof ArraySubject) subject.next({
+			type: "init",
+			items: subject.items
+		});
+		else if (subject instanceof ObjectSubject) subject.next({
+			type: "init",
+			value: subject.obj
+		});
+		else subject.next(subject.value);
+	};
+	fn.mutate = (mutateFn) => {
+		mutateFn(getValue());
+	};
+	fn.update = (updateFn) => {
+		const updatedValue = updateFn(getValue());
+		fn.set(updatedValue);
+	};
+	fn.observable = subject.asObservable().pipe(filter(() => !fn._isFrozen));
+	fn._subject = subject;
+	return fn;
+}
+function isSignal(value) {
+	return !!(value && value.observable);
+}
+function isComputed(value) {
+	return isSignal(value) && !!value.dependencies;
+}
+function computed(computeFunction, disposableFn) {
+	const dependencies = /* @__PURE__ */ new Set();
+	let init = true;
+	let lastComputedValue;
+	const previousTracker = reactiveStore.currentDependencyTracker;
+	reactiveStore.currentDependencyTracker = (signal2) => {
+		dependencies.add(signal2);
+	};
+	lastComputedValue = computeFunction();
+	if (computeFunction["isEffect"]) disposableFn = lastComputedValue;
+	reactiveStore.currentDependencyTracker = previousTracker;
+	const computedObservable = combineLatest([...dependencies].map((dep) => {
+		if (isComputed(dep) && "dependencies" in dep) {
+			const computedDep = dep;
+			if (computedDep.dependencies.size === 0) return new BehaviorSubject(computedDep()).asObservable();
+		}
+		return dep.observable;
+	})).pipe(filter(() => !init), map(() => computeFunction()), finalize$1(() => disposableFn?.()));
+	const fn = function() {
+		trackDependency(fn);
+		return lastComputedValue;
+	};
+	fn.observable = computedObservable;
+	fn.subscription = computedObservable.subscribe((value) => {
+		lastComputedValue = value;
+	});
+	fn.dependencies = dependencies;
+	reactiveStore.currentSubscriptionsTracker?.(fn.subscription);
+	init = false;
+	return fn;
+}
+function linkedSignal(computationOrOptions, simpleOptions) {
+	const dependencies = /* @__PURE__ */ new Set();
+	let init = true;
+	let lastComputedValue;
+	let computeFunction;
+	let sourceSignal;
+	let computationFn;
+	let equalFn;
+	let previousValue;
+	let isOverridden = false;
+	let overriddenValue;
+	let depVersion = 0;
+	let overrideDepVersion = null;
+	if (typeof computationOrOptions === "function") {
+		computeFunction = computationOrOptions;
+		equalFn = simpleOptions?.equal;
+	} else {
+		const options = computationOrOptions;
+		sourceSignal = options.source;
+		computationFn = options.computation;
+		equalFn = options.equal;
+		if (typeof sourceSignal === "function" && !isSignal(sourceSignal)) {
+			const sourceFn = sourceSignal;
+			computeFunction = () => {
+				const sourceValue = sourceFn();
+				if (computationFn.length > 1) {
+					const result = computationFn(sourceValue, previousValue);
+					previousValue = {
+						source: sourceValue,
+						value: result
+					};
+					return result;
+				} else {
+					const result = computationFn(sourceValue);
+					previousValue = {
+						source: sourceValue,
+						value: result
+					};
+					return result;
+				}
+			};
+		} else {
+			const source = typeof sourceSignal === "function" ? sourceSignal : sourceSignal;
+			computeFunction = () => {
+				const sourceValue = source();
+				if (computationFn.length > 1) {
+					const result = computationFn(sourceValue, previousValue);
+					previousValue = {
+						source: sourceValue,
+						value: result
+					};
+					return result;
+				} else {
+					const result = computationFn(sourceValue);
+					previousValue = {
+						source: sourceValue,
+						value: result
+					};
+					return result;
+				}
+			};
+		}
+	}
+	const previousTracker = reactiveStore.currentDependencyTracker;
+	reactiveStore.currentDependencyTracker = (signal2) => {
+		dependencies.add(signal2);
+	};
+	if (sourceSignal && typeof sourceSignal === "function" && !isSignal(sourceSignal)) lastComputedValue = computeFunction();
+	else if (sourceSignal && isSignal(sourceSignal)) {
+		dependencies.add(sourceSignal);
+		lastComputedValue = computeFunction();
+	} else lastComputedValue = computeFunction();
+	reactiveStore.currentDependencyTracker = previousTracker;
+	const subject = new BehaviorSubject(lastComputedValue);
+	const observables = [...dependencies].map((dep) => {
+		if (isComputed(dep) && "dependencies" in dep) {
+			const computedDep = dep;
+			if (computedDep.dependencies.size === 0) return new BehaviorSubject(computedDep()).asObservable();
+		}
+		return dep.observable;
+	});
+	let linkedObservable;
+	if (observables.length > 0) linkedObservable = combineLatest(observables).pipe(filter(() => !init), map(() => {
+		const computed2 = computeFunction();
+		if (equalFn) {
+			if (!equalFn(lastComputedValue, computed2)) {
+				lastComputedValue = computed2;
+				isOverridden = false;
+			}
+		} else if (lastComputedValue !== computed2) {
+			lastComputedValue = computed2;
+			isOverridden = false;
+		}
+		return lastComputedValue;
+	}));
+	else linkedObservable = subject.asObservable().pipe(filter(() => !init));
+	const fn = function() {
+		trackDependency(fn);
+		if (isOverridden && dependencies.size > 0) {
+			if (overrideDepVersion !== depVersion) {
+				const computed2 = computeFunction();
+				isOverridden = false;
+				overriddenValue = void 0;
+				lastComputedValue = computed2;
+				overrideDepVersion = null;
+				return computed2;
+			}
+			return overriddenValue;
+		}
+		if (isOverridden) return overriddenValue;
+		if (dependencies.size === 0) lastComputedValue = computeFunction();
+		return lastComputedValue;
+	};
+	fn.observable = new Observable((observer) => {
+		const depSubscription = linkedObservable.subscribe((value) => {
+			if (dependencies.size > 0) {
+				depVersion++;
+				isOverridden = false;
+				overrideDepVersion = null;
+				lastComputedValue = value;
+			} else lastComputedValue = value;
+			observer.next(value);
+		});
+		let subjectSubscription;
+		if (dependencies.size === 0) subjectSubscription = subject.pipe(filter(() => !init)).subscribe((value) => {
+			observer.next(value);
+		});
+		observer.next(lastComputedValue);
+		return () => {
+			depSubscription.unsubscribe();
+			if (subjectSubscription) subjectSubscription.unsubscribe();
+		};
+	});
+	fn.subscription = fn.observable.subscribe(() => {});
+	fn.dependencies = dependencies;
+	fn._subject = subject;
+	fn.set = (value) => {
+		if (!isOverridden) {
+			overrideDepVersion = depVersion;
+			if (computationFn && sourceSignal) previousValue = {
+				source: untracked(() => {
+					if (typeof sourceSignal === "function") {
+						const source = sourceSignal;
+						return isSignal(source) ? source() : sourceSignal();
+					}
+					return sourceSignal();
+				}),
+				value
+			};
+		}
+		isOverridden = true;
+		overriddenValue = value;
+		lastComputedValue = value;
+		subject.next(value);
+	};
+	reactiveStore.currentSubscriptionsTracker?.(fn.subscription);
+	init = false;
+	return fn;
+}
+function untracked(fn) {
+	const prevDepTracker = reactiveStore.currentDependencyTracker;
+	const prevSubTracker = reactiveStore.currentSubscriptionsTracker;
+	reactiveStore.currentDependencyTracker = null;
+	reactiveStore.currentSubscriptionsTracker = null;
+	try {
+		return fn();
+	} finally {
+		reactiveStore.currentDependencyTracker = prevDepTracker;
+		reactiveStore.currentSubscriptionsTracker = prevSubTracker;
+	}
+}
+function effect(fn) {
+	fn["isEffect"] = true;
+	return computed(fn);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@signe+sync@2.10.0/node_modules/@signe/sync/dist/index.js
+function isClass$1(obj) {
+	return typeof obj === "function" && obj.prototype && obj.prototype.constructor === obj;
+}
+var isObject$2 = (item) => item && typeof item === "object" && !Array.isArray(item) && item !== null;
+function isInstanceOfClass(value) {
+	if (value === null || typeof value !== "object" || value === void 0 || Array.isArray(value)) return false;
+	return Object.getPrototypeOf(value) !== Object.prototype;
+}
+function generateShortUUID() {
+	const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+	let uuid = "";
+	for (let i = 0; i < 8; i++) {
+		const randomIndex = Math.floor(Math.random() * 62);
+		uuid += chars[randomIndex];
+	}
+	return uuid;
+}
+var DELETE_TOKEN = "$delete";
+var syncClass = (instance, options = {}) => {
+	const cacheSync = /* @__PURE__ */ new Map();
+	const cachePersist = /* @__PURE__ */ new Map();
+	instance.$valuesChanges = {
+		set: (path, value) => {
+			cacheSync.set(path, value);
+			options.onSync?.(cacheSync);
+		},
+		setPersist: (path, value) => {
+			if (path == "") path = ".";
+			cachePersist.set(path, value);
+			options.onPersist?.(cachePersist);
+		},
+		has: (path) => {
+			return cacheSync.has(path);
+		},
+		get: (path) => {
+			return cacheSync.get(path);
+		}
+	};
+	createSyncClass(instance);
+};
+function createStatesSnapshot(instance) {
+	let persistObject = {};
+	if (instance?.$snapshot) for (const key of instance.$snapshot.keys()) {
+		const signal = instance.$snapshot.get(key);
+		const persist2 = signal.options.persist ?? true;
+		let value = signal();
+		if (isObject$2(value) || Array.isArray(value)) continue;
+		if (persist2) persistObject[key] = value;
+	}
+	return persistObject;
+}
+var SNAPSHOT_SKIP = Symbol("snapshot-skip");
+var serializeSnapshotDeep = (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 serialized = serializeSnapshotDeep(item, path ? `${path}.${index}` : String(index), 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 serialized = serializeSnapshotDeep(childValue, path ? `${path}.${normalizedKey}` : normalizedKey, options, seen);
+			if (serialized !== SNAPSHOT_SKIP) result[normalizedKey] = serialized;
+		}
+		return result;
+	}
+	return value;
+};
+function createStatesSnapshotDeep(instance, options = {}) {
+	const persistObject = {};
+	if (instance?.$snapshot) for (const key of instance.$snapshot.keys()) {
+		const signal = instance.$snapshot.get(key);
+		if (!(signal.options.persist ?? true)) continue;
+		const serialized = serializeSnapshotDeep(signal(), key, options, /* @__PURE__ */ new WeakSet());
+		if (serialized !== SNAPSHOT_SKIP) persistObject[key] = serialized;
+	}
+	return persistObject;
+}
+function setMetadata(target, key, value) {
+	const propId = target.constructor._propertyMetadata?.get(key);
+	if (propId) if (isSignal(target[propId])) target[propId].set(value);
+	else target[propId] = value;
+}
+var createSyncClass = (currentClass, parentKey = null, parentClass = null, path = "") => {
+	currentClass.$path = path;
+	if (parentClass) currentClass.$valuesChanges = parentClass.$valuesChanges;
+	if (parentKey) setMetadata(currentClass, "id", parentKey);
+	if (currentClass.$snapshot) for (const key of currentClass.$snapshot.keys()) {
+		const signal = currentClass.$snapshot.get(key);
+		const syncToClient = signal.options?.syncToClient ?? true;
+		const persist2 = signal.options?.persist ?? true;
+		const transform = signal.options?.transform;
+		let signalValue = signal();
+		if (transform) signalValue = transform(signalValue);
+		if (isObject$2(signalValue) || Array.isArray(signalValue)) signalValue = { ...signalValue };
+		const transformedValue = signalValue;
+		const newPath = (path ? path + "." : "") + key;
+		if (syncToClient) currentClass.$valuesChanges.set(newPath, transformedValue);
+		if (persist2) {
+			if (parentClass) currentClass.$valuesChanges.setPersist(path, transformedValue);
+		}
+		if (isComputed(signal)) signal.observable.subscribe((newValue) => {
+			if (syncToClient) {
+				const transformedNewValue = transform ? transform(newValue) : newValue;
+				currentClass.$valuesChanges.set(newPath, transformedNewValue);
+			}
+		});
+	}
+};
+var type = (_signal, path, options = {}, currentInstance) => {
+	const { syncToClient = true, persist: persist2 = true, transform } = options;
+	let init = true;
+	const handleObjectSubject = (value, propPath) => {
+		const newPath = `${propPath}${value.key ? `.${value.key}` : ""}`;
+		if ([
+			"add",
+			"reset",
+			"update"
+		].includes(value.type)) if (isInstanceOfClass(value.value)) createSyncClass(value.value, value.key, currentInstance, newPath);
+		else if (value.type === "update" && (isObject$2(value.value) || Array.isArray(value.value))) createSyncClass(value.value, value.key, currentInstance, newPath);
+		else savePath(newPath, value.value);
+		else if (value.type === "remove") savePath(newPath, DELETE_TOKEN);
+	};
+	const handleArraySubject = (value, propPath) => {
+		if (value.type === "reset" && Array.isArray(value.items)) {
+			value.items.forEach((item, index) => {
+				const newPath2 = `${propPath}.${index}`;
+				if (isInstanceOfClass(item)) createSyncClass(item, value.key, currentInstance, newPath2);
+				else savePath(newPath2, item);
+			});
+			return;
+		}
+		const newPath = `${propPath}.${value.index}`;
+		const firstItem = value.items?.[0];
+		if (["add", "update"].includes(value.type) && firstItem !== void 0) if (isInstanceOfClass(firstItem)) createSyncClass(firstItem, value.key, currentInstance, newPath);
+		else if (value.type === "update" && (isObject$2(firstItem) || Array.isArray(firstItem))) createSyncClass(firstItem, value.key, currentInstance, newPath);
+		else savePath(newPath, firstItem);
+		else if (value.type === "remove") savePath(newPath, DELETE_TOKEN);
+	};
+	const savePath = (propPath, value) => {
+		const transformedValue = transform && value !== "$delete" ? transform(value) : value;
+		if (syncToClient) currentInstance.$valuesChanges.set(propPath, transformedValue);
+		if (persist2 && currentInstance.$path !== void 0) currentInstance.$valuesChanges.setPersist(transformedValue == "$delete" ? propPath : currentInstance.$path, transformedValue);
+	};
+	const setupSubscription = (signal, signalPath) => {
+		if (!isSignal(signal)) return;
+		if (syncToClient && currentInstance.$valuesChanges) {
+			const initialValue = signal();
+			const transformedInitialValue = transform ? transform(initialValue) : initialValue;
+			currentInstance.$valuesChanges.set(signalPath, transformedInitialValue);
+		}
+		signal.options = options;
+		signal.observable.subscribe((value) => {
+			if (init) return;
+			if (currentInstance.$path !== void 0) {
+				const fullPath = `${currentInstance.$path ? currentInstance.$path + "." : ""}${signalPath}`;
+				if (isComputed(signal)) savePath(fullPath, value);
+				else if (isObjectSubject(signal._subject)) handleObjectSubject(value, fullPath);
+				else if (isArraySubject(signal._subject)) handleArraySubject(value, fullPath);
+				else savePath(fullPath, value);
+			}
+		});
+		if (!currentInstance.$snapshot) currentInstance.$snapshot = /* @__PURE__ */ new Map();
+		currentInstance.$snapshot.set(path, signal);
+	};
+	if (!isSignal(_signal)) {
+		if (_signal && typeof _signal === "object" && !Array.isArray(_signal)) {
+			for (const key in _signal) if (Object.prototype.hasOwnProperty.call(_signal, key)) {
+				const value = _signal[key];
+				const propertyPath = `${path}.${key}`;
+				if (isSignal(value)) setupSubscription(value, propertyPath);
+				else if (value && typeof value === "object" && !Array.isArray(value)) type(value, propertyPath, options, currentInstance);
+			}
+			init = false;
+		}
+		return _signal;
+	}
+	setupSubscription(_signal, path);
+	init = false;
+	return _signal;
+};
+function sync(options) {
+	let classType;
+	let persist2 = true;
+	let syncToClient = true;
+	let transform;
+	if (typeof options === "function") classType = options;
+	else if (typeof options === "object") {
+		classType = options.classType;
+		if (options.hasOwnProperty("persist")) persist2 = options.persist;
+		if (options.hasOwnProperty("syncToClient")) syncToClient = options.syncToClient;
+		if (options.hasOwnProperty("transform")) transform = options.transform;
+	}
+	return function(target, propertyKey) {
+		const privatePropertyKey = `__${propertyKey}`;
+		const getter = function() {
+			return this[privatePropertyKey];
+		};
+		const setter = function(newVal) {
+			this[privatePropertyKey] = type(newVal, propertyKey, {
+				classType,
+				persist: persist2,
+				syncToClient,
+				transform
+			}, this);
+		};
+		Object.defineProperty(target, propertyKey, {
+			get: getter,
+			set: setter,
+			enumerable: true,
+			configurable: true
+		});
+	};
+}
+function id() {
+	return function(target, propertyKey) {
+		if (!target.constructor._propertyMetadata) target.constructor._propertyMetadata = /* @__PURE__ */ new Map();
+		target.constructor._propertyMetadata.set("id", propertyKey);
+	};
+}
+function users(options) {
+	return function(target, propertyKey) {
+		if (!target.constructor._propertyMetadata) target.constructor._propertyMetadata = /* @__PURE__ */ new Map();
+		target.constructor._propertyMetadata.set("users", propertyKey);
+		sync(options)(target, propertyKey);
+	};
+}
+function persist() {
+	return sync({
+		persist: true,
+		syncToClient: false
+	});
+}
+function load(rootInstance, values, valueIsObject) {
+	if (valueIsObject) loadFromObject(rootInstance, values);
+	else loadFromPaths(rootInstance, values);
+}
+function loadFromPaths(rootInstance, values) {
+	for (const [path, value] of Object.entries(values)) loadValue(rootInstance, path.split("."), value);
+}
+function loadFromObject(rootInstance, values, currentPath = "") {
+	for (let key in values) {
+		const value = values[key];
+		const newPath = currentPath ? `${currentPath}.${key}` : key;
+		if (typeof value === "object" && !Array.isArray(value) && value !== null) loadFromObject(rootInstance, value, newPath);
+		else loadValue(rootInstance, newPath.split("."), value);
+	}
+}
+function loadValue(rootInstance, parts, value) {
+	let current = rootInstance;
+	for (let i = 0; i < parts.length; i++) {
+		const part = parts[i];
+		if (i === parts.length - 1) if (value == "$delete") {
+			if (isSignal(current)) current = current();
+			Reflect.deleteProperty(current, part);
+		} else if (current[part]?._subject) current[part].set(value);
+		else if (isSignal(current) && Array.isArray(current()) && !isNaN(Number(part))) current()[Number(part)] = value;
+		else current[part] = value;
+		else {
+			if (isSignal(current)) current = current();
+			if (current[part] === void 0) {
+				const classType = getByPath(rootInstance, parts.slice(0, i).join("."))?.options?.classType;
+				if (classType) {
+					current[part] = !isClass$1(classType) ? classType(part) : new classType();
+					setMetadata(current[part], "id", part);
+				} else current[part] = {};
+			}
+			current = current[part];
+		}
+	}
+}
+function getByPath(root, path) {
+	const parts = path.split(".");
+	let current = root;
+	for (const part of parts) {
+		if (isSignal(current)) current = current();
+		if (current[part]) current = current[part];
+		else return;
+	}
+	return current;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@signe+room@2.10.0/node_modules/@signe/room/dist/index.js
 var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", {
-	value,
-	configurable: true
-});
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp(target, key, result);
+	return result;
+};
 function Action(name, bodyValidation) {
 	return function(target, propertyKey) {
 		if (!target.constructor._actionMetadata) target.constructor._actionMetadata = /* @__PURE__ */ new Map();
@@ -3808,13 +4667,11 @@ function Action(name, bodyValidation) {
 		});
 	};
 }
-__name(Action, "Action");
 function UnhandledAction() {
 	return function(target, propertyKey) {
 		target.constructor._unhandledActionMetadata = { key: propertyKey };
 	};
 }
-__name(UnhandledAction, "UnhandledAction");
 function Request2(options, bodyValidation) {
 	return function(target, propertyKey) {
 		if (!target.constructor._requestMetadata) target.constructor._requestMetadata = /* @__PURE__ */ new Map();
@@ -3829,7 +4686,6 @@ function Request2(options, bodyValidation) {
 		});
 	};
 }
-__name(Request2, "Request");
 function Room(options) {
 	return function(target) {
 		target.path = options.path;
@@ -3840,13 +4696,6 @@ function Room(options) {
 		if (options.guards) target["_roomGuards"] = options.guards;
 	};
 }
-__name(Room, "Room");
-function RoomGuard(guards) {
-	return function(target) {
-		target["_roomGuards"] = guards;
-	};
-}
-__name(RoomGuard, "RoomGuard");
 function Guard(guards) {
 	return function(target, propertyKey, descriptor) {
 		if (!target.constructor["_actionGuards"]) target.constructor["_actionGuards"] = /* @__PURE__ */ new Map();
@@ -3854,47 +4703,15 @@ function Guard(guards) {
 		target.constructor["_actionGuards"].set(propertyKey, guards);
 	};
 }
-__name(Guard, "Guard");
-function generateShortUUID() {
-	const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-	let uuid = "";
-	for (let i = 0; i < 8; i++) {
-		const randomIndex = Math.floor(Math.random() * 62);
-		uuid += chars[randomIndex];
-	}
-	return uuid;
-}
-__name(generateShortUUID, "generateShortUUID");
-var Storage = class {
-	static {
-		__name(this, "Storage");
-	}
-	memory = /* @__PURE__ */ new Map();
-	async put(key, value) {
-		this.memory.set(key, value);
-	}
-	async get(key) {
-		return this.memory.get(key);
-	}
-	async delete(key) {
-		this.memory.delete(key);
-	}
-	async list() {
-		return this.memory;
-	}
-};
 function isPromise(value) {
 	return value instanceof Promise;
 }
-__name(isPromise, "isPromise");
 async function awaitReturn(val) {
 	return isPromise(val) ? await val : val;
 }
-__name(awaitReturn, "awaitReturn");
 function isClass(obj) {
 	return typeof obj === "function" && obj.prototype && obj.prototype.constructor === obj;
 }
-__name(isClass, "isClass");
 function throttle(func, wait) {
 	let timeout = null;
 	let lastArgs = null;
@@ -3911,7 +4728,6 @@ function throttle(func, wait) {
 		} else lastArgs = args;
 	};
 }
-__name(throttle, "throttle");
 function extractParams(pattern, str) {
 	const regexPattern = pattern.replace(/{(\w+)}/g, "(?<$1>[\\w-]+)");
 	const match = new RegExp(`^${regexPattern}$`).exec(str);
@@ -3919,7 +4735,6 @@ function extractParams(pattern, str) {
 	else if (pattern === str) return {};
 	else return null;
 }
-__name(extractParams, "extractParams");
 function dremove(obj, keys) {
 	if (typeof keys === "string") keys = keys.split(".");
 	let i = 0;
@@ -3935,7 +4750,6 @@ function dremove(obj, keys) {
 	k = keys[i];
 	if (t && typeof t === "object" && !(k === "__proto__" || k === "constructor" || k === "prototype")) delete t[k];
 }
-__name(dremove, "dremove");
 function buildObject(valuesMap, allMemory) {
 	let memoryObj = {};
 	for (let path of valuesMap.keys()) {
@@ -3946,27 +4760,15 @@ function buildObject(valuesMap, allMemory) {
 	}
 	return memoryObj;
 }
-__name(buildObject, "buildObject");
-function response(status, body) {
-	return new Response(JSON.stringify(body), {
-		status,
-		headers: { "Content-Type": "application/json" }
-	});
-}
-__name(response, "response");
 var ServerResponse = class {
-	static {
-		__name(this, "ServerResponse");
-	}
-	interceptors;
-	statusCode = 200;
-	responseBody = {};
-	responseHeaders = { "Content-Type": "application/json" };
 	/**
 	* Creates a new ServerResponse instance
 	* @param interceptors Array of interceptor functions that can modify the response
 	*/
 	constructor(interceptors = []) {
+		this.statusCode = 200;
+		this.responseBody = {};
+		this.responseHeaders = { "Content-Type": "application/json" };
 		this.interceptors = interceptors;
 	}
 	/**
@@ -4164,22 +4966,14 @@ function cors(res, options = {}) {
 		headers: newHeaders
 	});
 }
-__name(cors, "cors");
 function createCorsInterceptor(options = {}) {
 	return (res) => cors(res, options);
 }
-__name(createCorsInterceptor, "createCorsInterceptor");
 var Message = z.object({
 	action: z.string(),
 	value: z.any()
 });
 var Server = class {
-	static {
-		__name(this, "Server");
-	}
-	room;
-	subRoom;
-	rooms;
 	/**
 	* @constructor
 	* @param {Party.Room} room - The room object representing the current game or application instance.
@@ -4306,7 +5100,7 @@ var Server = class {
 			}
 		}
 		if (!instance) return null;
-		const loadMemory = /* @__PURE__ */ __name(async () => {
+		const loadMemory = async () => {
 			const root = await this.room.storage.get(".");
 			const memory = await this.room.storage.list();
 			const tmpObject = root || {};
@@ -4316,7 +5110,7 @@ var Server = class {
 				dset(tmpObject, key, value);
 			}
 			load(instance, tmpObject, true);
-		}, "loadMemory");
+		};
 		instance.$memoryAll = {};
 		instance.$autoSync = instance["autoSync"] !== false;
 		instance.$pendingSync = /* @__PURE__ */ new Map();
@@ -4398,7 +5192,7 @@ var Server = class {
 				return null;
 			}
 		};
-		const syncCb = /* @__PURE__ */ __name((values) => {
+		const syncCb = (values) => {
 			if (options.getMemoryAll) buildObject(values, instance.$memoryAll);
 			if (init && this.isHibernate) {
 				init = false;
@@ -4415,8 +5209,8 @@ var Server = class {
 				value: packet
 			}, instance);
 			values.clear();
-		}, "syncCb");
-		const persistCb = /* @__PURE__ */ __name(async (values) => {
+		};
+		const persistCb = async (values) => {
 			if (initPersist) {
 				values.clear();
 				return;
@@ -4427,7 +5221,7 @@ var Server = class {
 				else await this.room.storage.put(path, itemValue);
 			}
 			values.clear();
-		}, "persistCb");
+		};
 		syncClass(instance, {
 			onSync: instance["throttleSync"] ? throttle(syncCb, instance["throttleSync"]) : syncCb,
 			onPersist: instance["throttleStorage"] ? throttle(persistCb, instance["throttleStorage"]) : persistCb
@@ -4586,7 +5380,7 @@ var Server = class {
 			if (transferData) await this.room.storage.delete(`transfer:${transferToken}`);
 		}
 		const existingSession = await this.getSession(conn.id);
-		const publicId = existingSession?.publicId || transferData?.publicId || generateShortUUID$1();
+		const publicId = existingSession?.publicId || transferData?.publicId || generateShortUUID();
 		let user = null;
 		const signal2 = this.getUsersProperty(subRoom);
 		const usersPropName = this.getUsersPropName(subRoom);
@@ -4755,28 +5549,28 @@ var Server = class {
 		} : void 0 };
 		const virtualConnection = {
 			id: privateId,
-			send: /* @__PURE__ */ __name((data) => {
+			send: (data) => {
 				shardConnection.send(JSON.stringify({
 					targetClientId: privateId,
 					data
 				}));
-			}, "send"),
+			},
 			state: {},
-			setState: /* @__PURE__ */ __name((state) => {
+			setState: (state) => {
 				const clients = shardState.clients;
 				const currentState = clients.get(privateId) || {};
 				const mergedState = Object.assign({}, currentState, state);
 				clients.set(privateId, mergedState);
 				virtualConnection.state = clients.get(privateId);
 				return virtualConnection.state;
-			}, "setState"),
-			close: /* @__PURE__ */ __name(() => {
+			},
+			close: () => {
 				shardConnection.send(JSON.stringify({
 					type: "shard.closeClient",
 					privateId
 				}));
 				if (shardState.clients) shardState.clients.delete(privateId);
-			}, "close")
+			}
 		};
 		if (!shardState.clients.has(privateId)) shardState.clients.set(privateId, {});
 		await this.onConnectClient(virtualConnection, virtualContext);
@@ -4800,27 +5594,27 @@ var Server = class {
 		}
 		const virtualConnection = {
 			id: privateId,
-			send: /* @__PURE__ */ __name((data) => {
+			send: (data) => {
 				shardConnection.send(JSON.stringify({
 					targetClientId: privateId,
 					data
 				}));
-			}, "send"),
+			},
 			state: clients.get(privateId),
-			setState: /* @__PURE__ */ __name((state) => {
+			setState: (state) => {
 				const currentState = clients.get(privateId) || {};
 				const mergedState = Object.assign({}, currentState, state);
 				clients.set(privateId, mergedState);
 				virtualConnection.state = clients.get(privateId);
 				return virtualConnection.state;
-			}, "setState"),
-			close: /* @__PURE__ */ __name(() => {
+			},
+			close: () => {
 				shardConnection.send(JSON.stringify({
 					type: "shard.closeClient",
 					privateId
 				}));
 				if (shardState.clients) shardState.clients.delete(privateId);
-			}, "close")
+			}
 		};
 		const payloadString = typeof payload === "string" ? payload : JSON.stringify(payload);
 		await this.onMessage(payloadString, virtualConnection);
@@ -4844,12 +5638,12 @@ var Server = class {
 		}
 		const virtualConnection = {
 			id: privateId,
-			send: /* @__PURE__ */ __name(() => {}, "send"),
+			send: () => {},
 			state: clientState,
-			setState: /* @__PURE__ */ __name(() => {
+			setState: () => {
 				return {};
-			}, "setState"),
-			close: /* @__PURE__ */ __name(() => {}, "close")
+			},
+			close: () => {}
 		};
 		await this.onClose(virtualConnection);
 		clients.delete(privateId);
@@ -4949,7 +5743,7 @@ var Server = class {
 					await this.room.storage.put(`${usersPropName}.${publicId}`, userSnapshot);
 				}
 			}
-			const transferToken = generateShortUUID$1();
+			const transferToken = generateShortUUID();
 			await this.room.storage.put(`transfer:${transferToken}`, {
 				privateId,
 				publicId,
@@ -5088,424 +5882,30 @@ var Server = class {
 			const response2 = await this.tryMatchRequestHandler(enhancedReq, res, subRoom);
 			if (response2) return response2;
 			const legacyResponse = await awaitReturn(subRoom["onRequest"]?.(enhancedReq, res));
-			if (!legacyResponse) return res.notFound();
-			if (legacyResponse instanceof Response) return legacyResponse;
-			return res.success(legacyResponse);
-		} catch (error) {
-			console.error(`Error processing request from shard ${shardId}:`, error);
-			return res.serverError();
-		}
-	}
-	/**
-	* @method createEnhancedRequest
-	* @private
-	* @param {Party.Request} originalReq - The original request received from the shard
-	* @param {string | null} originalClientIp - The original client IP, if available
-	* @description Creates an enhanced request object that preserves the original client context
-	* @returns {Party.Request} The enhanced request object
-	*/
-	createEnhancedRequest(originalReq, originalClientIp) {
-		const clonedReq = originalReq.clone();
-		clonedReq.viaShard = true;
-		if (originalClientIp) clonedReq.originalClientIp = originalClientIp;
-		return clonedReq;
-	}
-};
-var Shard = class {
-	static {
-		__name(this, "Shard");
-	}
-	room;
-	ws;
-	connectionMap;
-	mainServerStub;
-	worldUrl;
-	worldId;
-	lastReportedConnections;
-	statsInterval;
-	statsIntervalId;
-	constructor(room) {
-		this.room = room;
-		this.connectionMap = /* @__PURE__ */ new Map();
-		this.worldUrl = null;
-		this.worldId = "default";
-		this.lastReportedConnections = 0;
-		this.statsInterval = 3e4;
-		this.statsIntervalId = null;
-	}
-	async onStart() {
-		const roomId = this.room.id.split(":")[0];
-		const roomStub = this.room.context.parties.main.get(roomId);
-		if (!roomStub) {
-			console.warn("No room room stub found in main party context");
-			return;
-		}
-		this.mainServerStub = roomStub;
-		this.ws = await roomStub.socket({ headers: { "x-shard-id": this.room.id } });
-		this.ws.addEventListener("message", (event) => {
-			try {
-				const message = JSON.parse(event.data);
-				if (message.targetClientId) {
-					const clientConn = this.connectionMap.get(message.targetClientId);
-					if (clientConn) {
-						delete message.targetClientId;
-						clientConn.send(message.data);
-					}
-				} else this.room.broadcast(event.data);
-			} catch (error) {
-				console.error("Error processing message from main server:", error);
-			}
-		});
-		await this.updateWorldStats();
-		this.startPeriodicStatsUpdates();
-	}
-	startPeriodicStatsUpdates() {
-		if (!this.worldUrl) return;
-		if (this.statsIntervalId) clearInterval(this.statsIntervalId);
-		this.statsIntervalId = setInterval(() => {
-			this.updateWorldStats().catch((error) => {
-				console.error("Error in periodic stats update:", error);
-			});
-		}, this.statsInterval);
-	}
-	stopPeriodicStatsUpdates() {
-		if (this.statsIntervalId) {
-			clearInterval(this.statsIntervalId);
-			this.statsIntervalId = null;
-		}
-	}
-	onConnect(conn, ctx) {
-		this.connectionMap.set(conn.id, conn);
-		const headers = {};
-		if (ctx.request?.headers) ctx.request.headers.forEach((value, key) => {
-			headers[key] = value;
-		});
-		const requestInfo = ctx.request ? {
-			headers,
-			url: ctx.request.url,
-			method: ctx.request.method
-		} : null;
-		this.ws.send(JSON.stringify({
-			type: "shard.clientConnected",
-			privateId: conn.id,
-			requestInfo
-		}));
-		this.updateWorldStats();
-	}
-	onMessage(message, sender) {
-		try {
-			const parsedMessage = typeof message === "string" ? JSON.parse(message) : message;
-			const wrappedMessage = JSON.stringify({
-				type: "shard.clientMessage",
-				privateId: sender.id,
-				publicId: sender.state?.publicId,
-				payload: parsedMessage
-			});
-			this.ws.send(wrappedMessage);
-		} catch (error) {
-			console.error("Error forwarding message to main server:", error);
-		}
-	}
-	onClose(conn) {
-		this.connectionMap.delete(conn.id);
-		this.ws.send(JSON.stringify({
-			type: "shard.clientDisconnected",
-			privateId: conn.id,
-			publicId: conn.state?.publicId
-		}));
-		this.updateWorldStats();
-	}
-	async updateWorldStats() {
-		const currentConnections = this.connectionMap.size;
-		if (currentConnections === this.lastReportedConnections) return true;
-		try {
-			const response2 = await this.room.context.parties.world.get("world-default").fetch("/update-shard", {
-				method: "POST",
-				headers: {
-					"Content-Type": "application/json",
-					"x-access-shard": this.room.env.SHARD_SECRET
-				},
-				body: JSON.stringify({
-					shardId: this.room.id,
-					connections: currentConnections
-				})
-			});
-			if (!response2.ok) {
-				const errorData = await response2.json().catch(() => ({ error: "Unknown error" }));
-				console.error(`Failed to update World stats: ${response2.status} - ${errorData.error || "Unknown error"}`);
-				return false;
-			}
-			this.lastReportedConnections = currentConnections;
-			return true;
-		} catch (error) {
-			console.error("Error updating World stats:", error);
-			return false;
-		}
-	}
-	/**
-	* @method onRequest
-	* @async
-	* @param {Party.Request} req - The HTTP request to handle
-	* @description Forwards HTTP requests to the main server, preserving client context
-	* @returns {Promise<Response>} The response from the main server
-	*/
-	async onRequest(req) {
-		if (!this.mainServerStub) return response(503, { error: "Shard not connected to main server" });
-		try {
-			const path = new URL(req.url).pathname;
-			const method = req.method;
-			let body = null;
-			if (method !== "GET" && method !== "HEAD") body = await req.text();
-			const headers = new Headers();
-			req.headers.forEach((value, key) => {
-				headers.set(key, value);
-			});
-			headers.set("x-shard-id", this.room.id);
-			headers.set("x-forwarded-by-shard", "true");
-			const clientIp = req.headers.get("x-forwarded-for") || "unknown";
-			if (clientIp) headers.set("x-original-client-ip", clientIp);
-			const requestInit = {
-				method,
-				headers,
-				body
-			};
-			return await this.mainServerStub.fetch(path, requestInit);
-		} catch (error) {
-			return response(500, { error: "Error forwarding request" });
-		}
-	}
-	/**
-	* @method onAlarm
-	* @async
-	* @description Executed periodically, used to perform maintenance tasks
-	*/
-	async onAlarm() {
-		await this.updateWorldStats();
-	}
-};
-async function testRoom(Room3, options = {}) {
-	const createServer = /* @__PURE__ */ __name((io2) => {
-		const server2 = new Server(io2);
-		server2.rooms = [Room3];
-		return server2;
-	}, "createServer");
-	const isShard = options.shard || false;
-	const io = new ServerIo(Room3.path, isShard ? {
-		parties: {
-			game: createServer,
-			...options.parties || {}
-		},
-		partyFn: options.partyFn,
-		env: options.env
-	} : {
-		parties: options.parties,
-		partyFn: options.partyFn,
-		env: options.env
-	});
-	Room3.prototype.throttleSync = 0;
-	Room3.prototype.throttleStorage = 0;
-	Room3.prototype.options = options;
-	let server;
-	if (options.shard) {
-		const shardServer = new Shard(io);
-		shardServer.subRoom = null;
-		server = shardServer;
-		if (io.context.parties.main instanceof Map) for (const lobby of io.context.parties.main.values()) await lobby.server.onStart();
-	} else {
-		server = await createServer(io);
-		if (io.context.parties.main instanceof Map) {
-			for (const lobby of io.context.parties.main.values()) if (lobby.server && lobby.server !== server) await lobby.server.onStart();
-		}
-	}
-	await server.onStart();
-	return {
-		server,
-		room: server.subRoom,
-		createClient: /* @__PURE__ */ __name(async (id2, opts) => {
-			return await io.connection(server, id2, opts);
-		}, "createClient"),
-		getServerUser: /* @__PURE__ */ __name(async (client, prop = "users") => {
-			const privateId = client.conn.id;
-			const session = await server.getSession(privateId);
-			return server.subRoom[prop]()[session?.publicId];
-		}, "getServerUser")
-	};
-}
-__name(testRoom, "testRoom");
-async function request(room, path, options = { method: "GET" }) {
-	const url = new URL("http://localhost" + path);
-	const request1 = new Request(url.toString(), options);
-	return await room.onRequest(request1);
-}
-__name(request, "request");
-function tick(ms = 0) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-__name(tick, "tick");
-var MockPartyClient = class {
-	static {
-		__name(this, "MockPartyClient");
-	}
-	server;
-	events;
-	id;
-	conn;
-	constructor(server, id2) {
-		this.server = server;
-		this.events = /* @__PURE__ */ new Map();
-		this.id = id2 || generateShortUUID();
-		this.conn = new MockConnection(this);
-	}
-	addEventListener(event, cb) {
-		if (!this.events.has(event)) this.events.set(event, []);
-		this.events.get(event).push(cb);
-	}
-	removeEventListener(event, cb) {
-		if (!this.events.has(event)) return;
-		const callbacks = this.events.get(event);
-		const index = callbacks.indexOf(cb);
-		if (index !== -1) callbacks.splice(index, 1);
-		if (callbacks.length === 0) this.events.delete(event);
-	}
-	_trigger(event, data) {
-		const callbacks = this.events.get(event);
-		if (callbacks) for (const cb of callbacks) cb(data);
-	}
-	send(data) {
-		return this.server.onMessage(JSON.stringify(data), this.conn);
-	}
-};
-var MockLobby = class MockLobby2 {
-	static {
-		__name(this, "MockLobby");
-	}
-	server;
-	lobbyId;
-	constructor(server, lobbyId) {
-		this.server = server;
-		this.lobbyId = lobbyId;
-	}
-	socket(_init) {
-		return new MockPartyClient(this.server);
-	}
-	async connection(idOrOptions, maybeOptions) {
-		const id2 = typeof idOrOptions === "string" ? idOrOptions : idOrOptions?.id;
-		const options = (typeof idOrOptions === "string" ? maybeOptions : idOrOptions) || {};
-		return this.server.room.connection(this.server, id2, options);
-	}
-	fetch(url, options) {
-		const baseUrl = url.includes("shard") ? "" : "/parties/main/" + this.lobbyId;
-		return request(this.server, baseUrl + url, options);
-	}
-};
-var MockContext = class MockContext2 {
-	static {
-		__name(this, "MockContext");
-	}
-	room;
-	parties;
-	constructor(room, options = {}) {
-		this.room = room;
-		this.parties = { main: /* @__PURE__ */ new Map() };
-		const parties = options.parties || {};
-		if (options.partyFn) {
-			const serverCache = /* @__PURE__ */ new Map();
-			this.parties.main = { get: /* @__PURE__ */ __name(async (lobbyId) => {
-				if (!serverCache.has(lobbyId)) {
-					const server = await options.partyFn(lobbyId);
-					serverCache.set(lobbyId, new MockLobby(server, lobbyId));
-				}
-				return serverCache.get(lobbyId);
-			}, "get") };
-		} else for (let lobbyId in parties) {
-			const server = parties[lobbyId](room);
-			this.parties.main.set(lobbyId, new MockLobby(server, lobbyId));
+			if (!legacyResponse) return res.notFound();
+			if (legacyResponse instanceof Response) return legacyResponse;
+			return res.success(legacyResponse);
+		} catch (error) {
+			console.error(`Error processing request from shard ${shardId}:`, error);
+			return res.serverError();
 		}
 	}
-};
-var MockPartyRoom = class MockPartyRoom2 {
-	static {
-		__name(this, "MockPartyRoom");
-	}
-	id;
-	clients;
-	storage;
-	context;
-	env;
-	constructor(id2, options = {}) {
-		this.id = id2;
-		this.clients = /* @__PURE__ */ new Map();
-		this.storage = new Storage();
-		this.env = {};
-		this.id = id2 || generateShortUUID();
-		this.context = new MockContext(this, {
-			parties: options.parties,
-			partyFn: options.partyFn
-		});
-		this.env = options.env || {};
-	}
-	async connection(server, id2, opts) {
-		const socket = new MockPartyClient(server, id2);
-		const url = new URL("http://localhost");
-		if (opts?.query) for (const [key, value] of Object.entries(opts.query)) url.searchParams.set(key, String(value));
-		const request2 = new Request(url.toString(), {
-			method: "GET",
-			headers: {
-				"Content-Type": "application/json",
-				...opts?.headers || {}
-			}
-		});
-		await server.onConnect(socket.conn, { request: request2 });
-		this.clients.set(socket.id, socket);
-		return socket;
-	}
-	broadcast(data) {
-		this.clients.forEach((client) => {
-			client._trigger("message", data);
-		});
-	}
-	getConnection(id2) {
-		return this.clients.get(id2);
-	}
-	getConnections() {
-		return Array.from(this.clients.values()).map((client) => client.conn);
-	}
-	clear() {
-		this.clients.clear();
-	}
-};
-var MockConnection = class {
-	static {
-		__name(this, "MockConnection");
-	}
-	client;
-	server;
-	id;
-	constructor(client) {
-		this.client = client;
-		this.state = {};
-		this.server = client.server;
-		this.id = client.id;
-	}
-	state;
-	setState(value) {
-		this.state = value;
-	}
-	send(data) {
-		this.client._trigger("message", data);
-	}
-	close() {
-		this.server.onClose(this);
+	/**
+	* @method createEnhancedRequest
+	* @private
+	* @param {Party.Request} originalReq - The original request received from the shard
+	* @param {string | null} originalClientIp - The original client IP, if available
+	* @description Creates an enhanced request object that preserves the original client context
+	* @returns {Party.Request} The enhanced request object
+	*/
+	createEnhancedRequest(originalReq, originalClientIp) {
+		const clonedReq = originalReq.clone();
+		clonedReq.viaShard = true;
+		if (originalClientIp) clonedReq.originalClientIp = originalClientIp;
+		return clonedReq;
 	}
 };
-var ServerIo = MockPartyRoom;
 var JWTAuth = class {
-	static {
-		__name(this, "JWTAuth");
-	}
-	secret;
-	encoder;
-	decoder;
 	/**
 	* Constructor for the JWTAuth class
 	* @param {string} secret - The secret key used for signing and verifying tokens
@@ -5615,7 +6015,7 @@ var JWTAuth = class {
 		}
 	}
 };
-var guardManageWorld = /* @__PURE__ */ __name(async (_, req, room) => {
+var guardManageWorld = async (_, req, room) => {
 	const tokenShard = req.headers.get("x-access-shard");
 	if (tokenShard) {
 		if (tokenShard !== room.env.SHARD_SECRET) return false;
@@ -5631,18 +6031,7 @@ var guardManageWorld = /* @__PURE__ */ __name(async (_, req, room) => {
 		return false;
 	}
 	return true;
-}, "guardManageWorld");
-function _ts_decorate(decorators, target, key, desc) {
-	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-	return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-__name(_ts_decorate, "_ts_decorate");
-function _ts_metadata(k, v) {
-	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-__name(_ts_metadata, "_ts_metadata");
+};
 var MAX_PLAYERS_PER_SHARD = 75;
 z.object({
 	name: z.string(),
@@ -5678,61 +6067,48 @@ z.object({
 		maxConnections: z.number().int().positive()
 	}).optional()
 });
-var RoomConfig = class RoomConfig2 {
-	static {
-		__name(this, "RoomConfig");
-	}
-	id;
-	name = signal("");
-	balancingStrategy = signal("round-robin");
-	public = signal(true);
-	maxPlayersPerShard = signal(MAX_PLAYERS_PER_SHARD);
-	minShards = signal(1);
-	maxShards = signal(void 0);
+var RoomConfig = class {
+	constructor() {
+		this.name = signal$1("");
+		this.balancingStrategy = signal$1("round-robin");
+		this.public = signal$1(true);
+		this.maxPlayersPerShard = signal$1(MAX_PLAYERS_PER_SHARD);
+		this.minShards = signal$1(1);
+		this.maxShards = signal$1(void 0);
+	}
 };
-_ts_decorate([id(), _ts_metadata("design:type", String)], RoomConfig.prototype, "id", void 0);
-_ts_decorate([sync()], RoomConfig.prototype, "name", void 0);
-_ts_decorate([sync()], RoomConfig.prototype, "balancingStrategy", void 0);
-_ts_decorate([sync()], RoomConfig.prototype, "public", void 0);
-_ts_decorate([sync()], RoomConfig.prototype, "maxPlayersPerShard", void 0);
-_ts_decorate([sync()], RoomConfig.prototype, "minShards", void 0);
-_ts_decorate([sync()], RoomConfig.prototype, "maxShards", void 0);
-var ShardInfo = class ShardInfo2 {
-	static {
-		__name(this, "ShardInfo");
-	}
-	id;
-	roomId = signal("");
-	url = signal("");
-	currentConnections = signal(0);
-	maxConnections = signal(MAX_PLAYERS_PER_SHARD);
-	status = signal("active");
-	lastHeartbeat = signal(0);
+__decorateClass([id()], RoomConfig.prototype, "id", 2);
+__decorateClass([sync()], RoomConfig.prototype, "name", 2);
+__decorateClass([sync()], RoomConfig.prototype, "balancingStrategy", 2);
+__decorateClass([sync()], RoomConfig.prototype, "public", 2);
+__decorateClass([sync()], RoomConfig.prototype, "maxPlayersPerShard", 2);
+__decorateClass([sync()], RoomConfig.prototype, "minShards", 2);
+__decorateClass([sync()], RoomConfig.prototype, "maxShards", 2);
+var ShardInfo = class {
+	constructor() {
+		this.roomId = signal$1("");
+		this.url = signal$1("");
+		this.currentConnections = signal$1(0);
+		this.maxConnections = signal$1(MAX_PLAYERS_PER_SHARD);
+		this.status = signal$1("active");
+		this.lastHeartbeat = signal$1(0);
+	}
 };
-_ts_decorate([id(), _ts_metadata("design:type", String)], ShardInfo.prototype, "id", void 0);
-_ts_decorate([sync()], ShardInfo.prototype, "roomId", void 0);
-_ts_decorate([sync()], ShardInfo.prototype, "url", void 0);
-_ts_decorate([sync({ persist: false })], ShardInfo.prototype, "currentConnections", void 0);
-_ts_decorate([sync()], ShardInfo.prototype, "maxConnections", void 0);
-_ts_decorate([sync()], ShardInfo.prototype, "status", void 0);
-_ts_decorate([sync()], ShardInfo.prototype, "lastHeartbeat", void 0);
+__decorateClass([id()], ShardInfo.prototype, "id", 2);
+__decorateClass([sync()], ShardInfo.prototype, "roomId", 2);
+__decorateClass([sync()], ShardInfo.prototype, "url", 2);
+__decorateClass([sync({ persist: false })], ShardInfo.prototype, "currentConnections", 2);
+__decorateClass([sync()], ShardInfo.prototype, "maxConnections", 2);
+__decorateClass([sync()], ShardInfo.prototype, "status", 2);
+__decorateClass([sync()], ShardInfo.prototype, "lastHeartbeat", 2);
 var WorldRoom = class {
-	static {
-		__name(this, "WorldRoom");
-	}
-	room;
-	rooms;
-	shards;
-	rrCounters;
-	defaultShardUrlTemplate;
-	defaultMaxConnectionsPerShard;
 	constructor(room) {
 		this.room = room;
-		this.rooms = signal({});
-		this.shards = signal({});
-		this.rrCounters = signal({});
-		this.defaultShardUrlTemplate = signal("{shardId}");
-		this.defaultMaxConnectionsPerShard = signal(MAX_PLAYERS_PER_SHARD);
+		this.rooms = signal$1({});
+		this.shards = signal$1({});
+		this.rrCounters = signal$1({});
+		this.defaultShardUrlTemplate = signal$1("{shardId}");
+		this.defaultMaxConnectionsPerShard = signal$1(MAX_PLAYERS_PER_SHARD);
 		const { AUTH_JWT_SECRET, SHARD_SECRET } = this.room.env;
 		if (!AUTH_JWT_SECRET) throw new Error("AUTH_JWT_SECRET env variable is not set");
 		if (!SHARD_SECRET) throw new Error("SHARD_SECRET env variable is not set");
@@ -5843,15 +6219,14 @@ var WorldRoom = class {
 	async findOptimalShard(roomId, autoCreate = true) {
 		let room = this.rooms()[roomId];
 		if (!room) if (autoCreate) {
-			const mockRequest = { json: /* @__PURE__ */ __name(async () => ({
+			await this.registerRoom({ json: async () => ({
 				name: roomId,
 				balancingStrategy: "round-robin",
 				public: true,
 				maxPlayersPerShard: this.defaultMaxConnectionsPerShard(),
 				minShards: 1,
 				maxShards: void 0
-			}), "json") };
-			await this.registerRoom(mockRequest);
+			}) });
 			room = this.rooms()[roomId];
 			if (!room) return { error: `Failed to create room ${roomId}` };
 		} else return { error: `Room ${roomId} does not exist` };
@@ -5908,73 +6283,31 @@ var WorldRoom = class {
 		return newShard;
 	}
 };
-_ts_decorate([sync(RoomConfig)], WorldRoom.prototype, "rooms", void 0);
-_ts_decorate([sync(ShardInfo)], WorldRoom.prototype, "shards", void 0);
-_ts_decorate([persist()], WorldRoom.prototype, "rrCounters", void 0);
-_ts_decorate([
-	Request2({
-		path: "register-room",
-		method: "POST"
-	}),
-	Guard([guardManageWorld]),
-	_ts_metadata("design:type", Function),
-	_ts_metadata("design:paramtypes", [Object]),
-	_ts_metadata("design:returntype", Promise)
-], WorldRoom.prototype, "registerRoom", null);
-_ts_decorate([
-	Request2({
-		path: "update-shard",
-		method: "POST"
-	}),
-	Guard([guardManageWorld]),
-	_ts_metadata("design:type", Function),
-	_ts_metadata("design:paramtypes", [Object, typeof ServerResponse === "undefined" ? Object : ServerResponse]),
-	_ts_metadata("design:returntype", Promise)
-], WorldRoom.prototype, "updateShardStats", null);
-_ts_decorate([
-	Request2({
-		path: "scale-room",
-		method: "POST"
-	}),
-	Guard([guardManageWorld]),
-	_ts_metadata("design:type", Function),
-	_ts_metadata("design:paramtypes", [Object, typeof ServerResponse === "undefined" ? Object : ServerResponse]),
-	_ts_metadata("design:returntype", Promise)
-], WorldRoom.prototype, "scaleRoom", null);
-_ts_decorate([
-	Request2({
-		path: "connect",
-		method: "POST"
-	}),
-	_ts_metadata("design:type", Function),
-	_ts_metadata("design:paramtypes", [Object, typeof ServerResponse === "undefined" ? Object : ServerResponse]),
-	_ts_metadata("design:returntype", Promise)
-], WorldRoom.prototype, "connect", null);
-WorldRoom = _ts_decorate([
-	Room({
-		path: "world-{worldId}",
-		maxUsers: 100,
-		throttleStorage: 2e3,
-		throttleSync: 500
-	}),
-	_ts_metadata("design:type", Function),
-	_ts_metadata("design:paramtypes", [Object])
-], WorldRoom);
-function createRequireSessionGuard(storage) {
-	return async (sender, value) => {
-		if (!sender || !sender.id) return false;
-		try {
-			const session = await storage.get(`session:${sender.id}`);
-			if (!session) return false;
-			if (!session.publicId) return false;
-			return true;
-		} catch (error) {
-			console.error("Error checking session in requireSession guard:", error);
-			return false;
-		}
-	};
-}
-__name(createRequireSessionGuard, "createRequireSessionGuard");
+__decorateClass([sync(RoomConfig)], WorldRoom.prototype, "rooms", 2);
+__decorateClass([sync(ShardInfo)], WorldRoom.prototype, "shards", 2);
+__decorateClass([persist()], WorldRoom.prototype, "rrCounters", 2);
+__decorateClass([Request2({
+	path: "register-room",
+	method: "POST"
+}), Guard([guardManageWorld])], WorldRoom.prototype, "registerRoom", 1);
+__decorateClass([Request2({
+	path: "update-shard",
+	method: "POST"
+}), Guard([guardManageWorld])], WorldRoom.prototype, "updateShardStats", 1);
+__decorateClass([Request2({
+	path: "scale-room",
+	method: "POST"
+}), Guard([guardManageWorld])], WorldRoom.prototype, "scaleRoom", 1);
+__decorateClass([Request2({
+	path: "connect",
+	method: "POST"
+})], WorldRoom.prototype, "connect", 1);
+WorldRoom = __decorateClass([Room({
+	path: "world-{worldId}",
+	maxUsers: 100,
+	throttleStorage: 2e3,
+	throttleSync: 500
+})], WorldRoom);
 //#endregion
 //#region src/Player/ComponentManager.ts
 /**
@@ -6576,7 +6909,7 @@ var MoveList = class MoveList {
 					break;
 			}
 			let direction = method(newDirection);
-			if (isFunction(direction)) direction = direction(player, map);
+			if (isFunction$1(direction)) direction = direction(player, map);
 			return direction;
 		};
 	}
@@ -9880,7 +10213,7 @@ function WithSkillManager(Base) {
 				throw SkillLog.chanceToUseFailed(skill);
 			}
 			if (otherPlayer) {
-				const players = isArray(otherPlayer) ? otherPlayer : [otherPlayer];
+				const players = isArray$2(otherPlayer) ? otherPlayer : [otherPlayer];
 				for (const player of players) {
 					this.applyStates(player, skill);
 					player.applyDamage(this, skill);
@@ -10521,7 +10854,7 @@ var RpgPlayer = class extends BasicPlayerMixins(RpgCommonPlayer) {
 				const height = hitbox?.h ?? 32;
 				const centerX = positions.x + width / 2;
 				const centerY = positions.y + height / 2;
-				this.map.physic.teleport(entity, {
+				this.map.physic.teleportEntity(entity, {
 					x: centerX,
 					y: centerY
 				});
@@ -11294,18 +11627,58 @@ var RpgEvent = class extends RpgPlayer {
 	* 
 	* Stops all movements before removing to prevent "unable to resolve entity" errors
 	* from the MovementManager when the entity is destroyed while moving.
+	*
+	* Pass options to keep the sprite visible briefly on clients while
+	* `sprite.onBeforeRemove` runs a visual transition. Gameplay collision is
+	* removed immediately; the event is deleted from the map after `timeoutMs`.
+	*
+	* The server only sends the removal context. The client decides how to render
+	* `transition` in `sprite.onBeforeRemove`, so the payload can describe an
+	* animation, sound, particle effect, GUI transition, or project-specific data.
+	*
+	* @example
+	* ```ts
+	* event.remove({
+	*   reason: 'defeated',
+	*   transition: {
+	*     type: 'enemy-death',
+	*     animation: 'die',
+	*     graphic: 'slime_die',
+	*     sound: 'slime-death',
+	*     duration: 700
+	*   },
+	*   timeoutMs: 700
+	* })
+	* ```
 	*/
-	remove() {
+	remove(options) {
 		const map = this.getCurrentMap();
 		if (!map) return;
 		this.stopMoveTo();
-		map.removeEvent(this.id);
+		const timeoutMs = Math.max(0, options?.timeoutMs ?? options?.transition?.duration ?? 0);
+		if (!options || timeoutMs <= 0) {
+			map.removeEvent(this.id);
+			return;
+		}
+		this._removeTransition.set(JSON.stringify({
+			active: true,
+			reason: options.reason,
+			data: options.data,
+			transition: options.transition,
+			timeoutMs
+		}));
+		map.removeHitbox?.(this.id, this, "npc");
+		setTimeout(() => {
+			map.removeEvent(this.id);
+		}, timeoutMs);
 	}
 	isEvent() {
 		return true;
 	}
 };
-Object.freeze({ status: "aborted" });
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/core.js
+var _a$1;
 function $constructor(name, initializer, params) {
 	function init(inst, def) {
 		if (!inst._zod) Object.defineProperty(inst, "_zod", {
@@ -11356,13 +11729,14 @@ var $ZodEncodeError = class extends Error {
 		this.name = "ZodEncodeError";
 	}
 };
-var globalConfig = {};
+(_a$1 = globalThis).__zod_globalConfig ?? (_a$1.__zod_globalConfig = {});
+var globalConfig = globalThis.__zod_globalConfig;
 function config(newConfig) {
 	if (newConfig) Object.assign(globalConfig, newConfig);
 	return globalConfig;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/util.js
+//#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/util.js
 function getEnumValues(entries) {
 	const numericValues = Object.values(entries).filter((v) => typeof v === "number");
 	return Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
@@ -11390,17 +11764,13 @@ function cleanRegex(source) {
 	return source.slice(start, end);
 }
 function floatSafeRemainder(val, step) {
-	const valDecCount = (val.toString().split(".")[1] || "").length;
-	const stepString = step.toString();
-	let stepDecCount = (stepString.split(".")[1] || "").length;
-	if (stepDecCount === 0 && /\d?e-\d?/.test(stepString)) {
-		const match = stepString.match(/\d?e-(\d?)/);
-		if (match?.[1]) stepDecCount = Number.parseInt(match[1]);
-	}
-	const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
-	return Number.parseInt(val.toFixed(decCount).replace(".", "")) % Number.parseInt(step.toFixed(decCount).replace(".", "")) / 10 ** decCount;
+	const ratio = val / step;
+	const roundedRatio = Math.round(ratio);
+	const tolerance = Number.EPSILON * Math.max(Math.abs(ratio), 1);
+	if (Math.abs(ratio - roundedRatio) < tolerance) return 0;
+	return ratio - roundedRatio;
 }
-var EVALUATING = Symbol("evaluating");
+var EVALUATING = /* @__PURE__ */ Symbol("evaluating");
 function defineLazy(object, key, getter) {
 	let value = void 0;
 	Object.defineProperty(object, key, {
@@ -11441,7 +11811,8 @@ var captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace :
 function isObject(data) {
 	return typeof data === "object" && data !== null && !Array.isArray(data);
 }
-var allowsEval = cached(() => {
+var allowsEval = /* @__PURE__ */ cached(() => {
+	if (globalConfig.jitless) return false;
 	if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) return false;
 	try {
 		new Function("");
@@ -11463,9 +11834,11 @@ function isPlainObject(o) {
 function shallowClone(o) {
 	if (isPlainObject(o)) return { ...o };
 	if (Array.isArray(o)) return [...o];
+	if (o instanceof Map) return new Map(o);
+	if (o instanceof Set) return new Set(o);
 	return o;
 }
-var propertyKeyTypes = new Set([
+var propertyKeyTypes = /* @__PURE__ */ new Set([
 	"string",
 	"number",
 	"symbol"
@@ -11569,6 +11942,7 @@ function safeExtend(schema, shape) {
 	} }));
 }
 function merge(a, b) {
+	if (a._zod.def.checks?.length) throw new Error(".merge() cannot be used on object schemas containing refinements. Use .safeExtend() instead.");
 	return clone(a, mergeDefs(a._zod.def, {
 		get shape() {
 			const _shape = {
@@ -11581,7 +11955,7 @@ function merge(a, b) {
 		get catchall() {
 			return b._zod.def.catchall;
 		},
-		checks: []
+		checks: b._zod.def.checks ?? []
 	}));
 }
 function partial(Class, schema, mask) {
@@ -11634,6 +12008,11 @@ function aborted(x, startIndex = 0) {
 	for (let i = startIndex; i < x.issues.length; i++) if (x.issues[i]?.continue !== true) return true;
 	return false;
 }
+function explicitlyAborted(x, startIndex = 0) {
+	if (x.aborted === true) return true;
+	for (let i = startIndex; i < x.issues.length; i++) if (x.issues[i]?.continue === false) return true;
+	return false;
+}
 function prefixIssues(path, issues) {
 	return issues.map((iss) => {
 		var _a;
@@ -11646,15 +12025,12 @@ function unwrapMessage(message) {
 	return typeof message === "string" ? message : message?.message;
 }
 function finalizeIssue(iss, ctx, config) {
-	const full = {
-		...iss,
-		path: iss.path ?? []
-	};
-	if (!iss.message) full.message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config.customError?.(iss)) ?? unwrapMessage(config.localeError?.(iss)) ?? "Invalid input";
-	delete full.inst;
-	delete full.continue;
-	if (!ctx?.reportInput) delete full.input;
-	return full;
+	const message = iss.message ? iss.message : unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config.customError?.(iss)) ?? unwrapMessage(config.localeError?.(iss)) ?? "Invalid input";
+	const { inst: _inst, continue: _continue, input: _input, ...rest } = iss;
+	rest.path ?? (rest.path = []);
+	rest.message = message;
+	if (ctx?.reportInput) rest.input = _input;
+	return rest;
 }
 function getLengthableOrigin(input) {
 	if (Array.isArray(input)) return "array";
@@ -11672,7 +12048,7 @@ function issue(...args) {
 	return { ...iss };
 }
 //#endregion
-//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/errors.js
+//#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/errors.js
 var initializer$1 = (inst, def) => {
 	inst.name = "$ZodError";
 	Object.defineProperty(inst, "_zod", {
@@ -11705,23 +12081,26 @@ function flattenError(error, mapper = (issue) => issue.message) {
 }
 function formatError(error, mapper = (issue) => issue.message) {
 	const fieldErrors = { _errors: [] };
-	const processError = (error) => {
-		for (const issue of error.issues) if (issue.code === "invalid_union" && issue.errors.length) issue.errors.map((issues) => processError({ issues }));
-		else if (issue.code === "invalid_key") processError({ issues: issue.issues });
-		else if (issue.code === "invalid_element") processError({ issues: issue.issues });
-		else if (issue.path.length === 0) fieldErrors._errors.push(mapper(issue));
+	const processError = (error, path = []) => {
+		for (const issue of error.issues) if (issue.code === "invalid_union" && issue.errors.length) issue.errors.map((issues) => processError({ issues }, [...path, ...issue.path]));
+		else if (issue.code === "invalid_key") processError({ issues: issue.issues }, [...path, ...issue.path]);
+		else if (issue.code === "invalid_element") processError({ issues: issue.issues }, [...path, ...issue.path]);
 		else {
-			let curr = fieldErrors;
-			let i = 0;
-			while (i < issue.path.length) {
-				const el = issue.path[i];
-				if (!(i === issue.path.length - 1)) curr[el] = curr[el] || { _errors: [] };
-				else {
-					curr[el] = curr[el] || { _errors: [] };
-					curr[el]._errors.push(mapper(issue));
+			const fullpath = [...path, ...issue.path];
+			if (fullpath.length === 0) fieldErrors._errors.push(mapper(issue));
+			else {
+				let curr = fieldErrors;
+				let i = 0;
+				while (i < fullpath.length) {
+					const el = fullpath[i];
+					if (!(i === fullpath.length - 1)) curr[el] = curr[el] || { _errors: [] };
+					else {
+						curr[el] = curr[el] || { _errors: [] };
+						curr[el]._errors.push(mapper(issue));
+					}
+					curr = curr[el];
+					i++;
 				}
-				curr = curr[el];
-				i++;
 			}
 		}
 	};
@@ -11729,9 +12108,12 @@ function formatError(error, mapper = (issue) => issue.message) {
 	return fieldErrors;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/parse.js
+//#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/parse.js
 var _parse = (_Err) => (schema, value, _ctx, _params) => {
-	const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
+	const ctx = _ctx ? {
+		..._ctx,
+		async: false
+	} : { async: false };
 	const result = schema._zod.run({
 		value,
 		issues: []
@@ -11745,7 +12127,10 @@ var _parse = (_Err) => (schema, value, _ctx, _params) => {
 	return result.value;
 };
 var _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
-	const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
+	const ctx = _ctx ? {
+		..._ctx,
+		async: true
+	} : { async: true };
 	let result = schema._zod.run({
 		value,
 		issues: []
@@ -11778,7 +12163,10 @@ var _safeParse = (_Err) => (schema, value, _ctx) => {
 };
 var safeParse$1 = /* @__PURE__ */ _safeParse($ZodRealError);
 var _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
-	const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
+	const ctx = _ctx ? {
+		..._ctx,
+		async: true
+	} : { async: true };
 	let result = schema._zod.run({
 		value,
 		issues: []
@@ -11794,36 +12182,53 @@ var _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
 };
 var safeParseAsync$1 = /* @__PURE__ */ _safeParseAsync($ZodRealError);
 var _encode = (_Err) => (schema, value, _ctx) => {
-	const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
+	const ctx = _ctx ? {
+		..._ctx,
+		direction: "backward"
+	} : { direction: "backward" };
 	return _parse(_Err)(schema, value, ctx);
 };
 var _decode = (_Err) => (schema, value, _ctx) => {
 	return _parse(_Err)(schema, value, _ctx);
 };
 var _encodeAsync = (_Err) => async (schema, value, _ctx) => {
-	const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
+	const ctx = _ctx ? {
+		..._ctx,
+		direction: "backward"
+	} : { direction: "backward" };
 	return _parseAsync(_Err)(schema, value, ctx);
 };
 var _decodeAsync = (_Err) => async (schema, value, _ctx) => {
 	return _parseAsync(_Err)(schema, value, _ctx);
 };
 var _safeEncode = (_Err) => (schema, value, _ctx) => {
-	const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
+	const ctx = _ctx ? {
+		..._ctx,
+		direction: "backward"
+	} : { direction: "backward" };
 	return _safeParse(_Err)(schema, value, ctx);
 };
 var _safeDecode = (_Err) => (schema, value, _ctx) => {
 	return _safeParse(_Err)(schema, value, _ctx);
 };
 var _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {
-	const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
+	const ctx = _ctx ? {
+		..._ctx,
+		direction: "backward"
+	} : { direction: "backward" };
 	return _safeParseAsync(_Err)(schema, value, ctx);
 };
 var _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {
 	return _safeParseAsync(_Err)(schema, value, _ctx);
 };
 //#endregion
-//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/regexes.js
-var cuid = /^[cC][^\s-]{8,}$/;
+//#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/regexes.js
+/**
+* @deprecated CUID v1 is deprecated by its authors due to information leakage
+* (timestamps embedded in the id). Use {@link cuid2} instead.
+* See https://github.com/paralleldrive/cuid.
+*/
+var cuid = /^[cC][0-9a-z]{6,}$/;
 var cuid2 = /^[0-9a-z]+$/;
 var ulid = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/;
 var xid = /^[0-9a-vA-V]{20}$/;
@@ -11852,6 +12257,7 @@ var cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]
 var cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
 var base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
 var base64url = /^[A-Za-z0-9_-]*$/;
+var httpProtocol = /^https?$/;
 var e164 = /^\+[1-9]\d{6,14}$/;
 var 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])))`;
 var date$1 = /* @__PURE__ */ new RegExp(`^${dateSource}$`);
@@ -11879,7 +12285,7 @@ var number$1 = /^-?\d+(?:\.\d+)?$/;
 var lowercase = /^[^A-Z]*$/;
 var uppercase = /^[^a-z]*$/;
 //#endregion
-//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/checks.js
+//#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/checks.js
 var $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
 	var _a;
 	inst._zod ?? (inst._zod = {});
@@ -12237,7 +12643,7 @@ var $ZodCheckOverwrite = /* @__PURE__ */ $constructor("$ZodCheckOverwrite", (ins
 	};
 });
 //#endregion
-//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/doc.js
+//#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/doc.js
 var Doc = class {
 	constructor(args = []) {
 		this.content = [];
@@ -12268,14 +12674,14 @@ var Doc = class {
 	}
 };
 //#endregion
-//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/versions.js
+//#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/versions.js
 var version = {
 	major: 4,
-	minor: 3,
-	patch: 6
+	minor: 4,
+	patch: 3
 };
 //#endregion
-//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/schemas.js
+//#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/schemas.js
 var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
 	var _a;
 	inst ?? (inst = {});
@@ -12296,6 +12702,7 @@ var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
 			let asyncResult;
 			for (const ch of checks) {
 				if (ch._zod.def.when) {
+					if (explicitlyAborted(payload)) continue;
 					if (!ch._zod.def.when(payload)) continue;
 				} else if (isAborted) continue;
 				const currLen = payload.issues.length;
@@ -12415,6 +12822,19 @@ var $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (inst, def) => {
 	inst._zod.check = (payload) => {
 		try {
 			const trimmed = payload.value.trim();
+			if (!def.normalize && def.protocol?.source === httpProtocol.source) {
+				if (!/^https?:\/\//i.test(trimmed)) {
+					payload.issues.push({
+						code: "invalid_format",
+						format: "url",
+						note: "Invalid URL format",
+						input: payload.value,
+						inst,
+						continue: !def.abort
+					});
+					return;
+				}
+			}
 			const url = new URL(trimmed);
 			if (def.hostname) {
 				def.hostname.lastIndex = 0;
@@ -12462,6 +12882,11 @@ var $ZodNanoID = /* @__PURE__ */ $constructor("$ZodNanoID", (inst, def) => {
 	def.pattern ?? (def.pattern = nanoid);
 	$ZodStringFormat.init(inst, def);
 });
+/**
+* @deprecated CUID v1 is deprecated by its authors due to information leakage
+* (timestamps embedded in the id). Use {@link $ZodCUID2} instead.
+* See https://github.com/paralleldrive/cuid.
+*/
 var $ZodCUID = /* @__PURE__ */ $constructor("$ZodCUID", (inst, def) => {
 	def.pattern ?? (def.pattern = cuid);
 	$ZodStringFormat.init(inst, def);
@@ -12551,6 +12976,7 @@ var $ZodCIDRv6 = /* @__PURE__ */ $constructor("$ZodCIDRv6", (inst, def) => {
 });
 function isValidBase64(data) {
 	if (data === "") return true;
+	if (/\s/.test(data)) return false;
 	if (data.length % 4 !== 0) return false;
 	try {
 		atob(data);
@@ -12702,13 +13128,23 @@ var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
 		return payload;
 	};
 });
-function handlePropertyResult(result, final, key, input, isOptionalOut) {
+function handlePropertyResult(result, final, key, input, isOptionalIn, isOptionalOut) {
+	const isPresent = key in input;
 	if (result.issues.length) {
-		if (isOptionalOut && !(key in input)) return;
+		if (isOptionalIn && isOptionalOut && !isPresent) return;
 		final.issues.push(...prefixIssues(key, result.issues));
 	}
+	if (!isPresent && !isOptionalIn) {
+		if (!result.issues.length) final.issues.push({
+			code: "invalid_type",
+			expected: "nonoptional",
+			input: void 0,
+			path: [key]
+		});
+		return;
+	}
 	if (result.value === void 0) {
-		if (key in input) final.value[key] = void 0;
+		if (isPresent) final.value[key] = void 0;
 	} else final.value[key] = result.value;
 }
 function normalizeDef(def) {
@@ -12728,8 +13164,10 @@ function handleCatchall(proms, input, payload, ctx, def, inst) {
 	const keySet = def.keySet;
 	const _catchall = def.catchall._zod;
 	const t = _catchall.def.type;
+	const isOptionalIn = _catchall.optin === "optional";
 	const isOptionalOut = _catchall.optout === "optional";
 	for (const key in input) {
+		if (key === "__proto__") continue;
 		if (keySet.has(key)) continue;
 		if (t === "never") {
 			unrecognized.push(key);
@@ -12739,8 +13177,8 @@ function handleCatchall(proms, input, payload, ctx, def, inst) {
 			value: input[key],
 			issues: []
 		}, ctx);
-		if (r instanceof Promise) proms.push(r.then((r) => handlePropertyResult(r, payload, key, input, isOptionalOut)));
-		else handlePropertyResult(r, payload, key, input, isOptionalOut);
+		if (r instanceof Promise) proms.push(r.then((r) => handlePropertyResult(r, payload, key, input, isOptionalIn, isOptionalOut)));
+		else handlePropertyResult(r, payload, key, input, isOptionalIn, isOptionalOut);
 	}
 	if (unrecognized.length) payload.issues.push({
 		code: "unrecognized_keys",
@@ -12796,13 +13234,14 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
 		const shape = value.shape;
 		for (const key of value.keys) {
 			const el = shape[key];
+			const isOptionalIn = el._zod.optin === "optional";
 			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, isOptionalOut)));
-			else handlePropertyResult(r, payload, key, input, isOptionalOut);
+			if (r instanceof Promise) proms.push(r.then((r) => handlePropertyResult(r, payload, key, input, isOptionalIn, isOptionalOut)));
+			else handlePropertyResult(r, payload, key, input, isOptionalIn, isOptionalOut);
 		}
 		if (!catchall) return proms.length ? Promise.all(proms).then(() => payload) : payload;
 		return handleCatchall(proms, input, payload, ctx, _normalized.value, inst);
@@ -12831,9 +13270,11 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
 		for (const key of normalized.keys) {
 			const id = ids[key];
 			const k = esc(key);
-			const isOptionalOut = shape[key]?._zod?.optout === "optional";
+			const schema = shape[key];
+			const isOptionalIn = schema?._zod?.optin === "optional";
+			const isOptionalOut = schema?._zod?.optout === "optional";
 			doc.write(`const ${id} = ${parseStr(key)};`);
-			if (isOptionalOut) doc.write(`
+			if (isOptionalIn && isOptionalOut) doc.write(`
         if (${id}.issues.length) {
           if (${k} in input) {
             payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
@@ -12851,6 +13292,32 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
           newResult[${k}] = ${id}.value;
         }
         
+      `);
+			else if (!isOptionalIn) doc.write(`
+        const ${id}_present = ${k} in input;
+        if (${id}.issues.length) {
+          payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
+            ...iss,
+            path: iss.path ? [${k}, ...iss.path] : [${k}]
+          })));
+        }
+        if (!${id}_present && !${id}.issues.length) {
+          payload.issues.push({
+            code: "invalid_type",
+            expected: "nonoptional",
+            input: undefined,
+            path: [${k}]
+          });
+        }
+
+        if (${id}_present) {
+          if (${id}.value === undefined) {
+            newResult[${k}] = undefined;
+          } else {
+            newResult[${k}] = ${id}.value;
+          }
+        }
+
       `);
 			else doc.write(`
         if (${id}.issues.length) {
@@ -12876,7 +13343,7 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
 		return (payload, ctx) => fn(shape, payload, ctx);
 	};
 	let fastpass;
-	const isObject$2 = isObject;
+	const isObject$4 = isObject;
 	const jit = !globalConfig.jitless;
 	const fastEnabled = jit && allowsEval.value;
 	const catchall = def.catchall;
@@ -12884,7 +13351,7 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
 	inst._zod.parse = (payload, ctx) => {
 		value ?? (value = _normalized.value);
 		const input = payload.value;
-		if (!isObject$2(input)) {
+		if (!isObject$4(input)) {
 			payload.issues.push({
 				expected: "object",
 				code: "invalid_type",
@@ -12933,10 +13400,9 @@ var $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => {
 			return new RegExp(`^(${patterns.map((p) => cleanRegex(p.source)).join("|")})$`);
 		}
 	});
-	const single = def.options.length === 1;
-	const first = def.options[0]._zod.run;
+	const first = def.options.length === 1 ? def.options[0]._zod.run : null;
 	inst._zod.parse = (payload, ctx) => {
-		if (single) return first(payload, ctx);
+		if (first) return first(payload, ctx);
 		let async = false;
 		const results = [];
 		for (const option of def.options) {
@@ -13077,20 +13543,23 @@ var $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
 });
 var $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) => {
 	$ZodType.init(inst, def);
+	inst._zod.optin = "optional";
 	inst._zod.parse = (payload, ctx) => {
 		if (ctx.direction === "backward") throw new $ZodEncodeError(inst.constructor.name);
 		const _out = def.transform(payload.value, payload);
 		if (ctx.async) return (_out instanceof Promise ? _out : Promise.resolve(_out)).then((output) => {
 			payload.value = output;
+			payload.fallback = true;
 			return payload;
 		});
 		if (_out instanceof Promise) throw new $ZodAsyncError();
 		payload.value = _out;
+		payload.fallback = true;
 		return payload;
 	};
 });
 function handleOptionalResult(result, input) {
-	if (result.issues.length && input === void 0) return {
+	if (input === void 0 && (result.issues.length || result.fallback)) return {
 		issues: [],
 		value: void 0
 	};
@@ -13109,9 +13578,10 @@ var $ZodOptional = /* @__PURE__ */ $constructor("$ZodOptional", (inst, def) => {
 	});
 	inst._zod.parse = (payload, ctx) => {
 		if (def.innerType._zod.optin === "optional") {
+			const input = payload.value;
 			const result = def.innerType._zod.run(payload, ctx);
-			if (result instanceof Promise) return result.then((r) => handleOptionalResult(r, payload.value));
-			return handleOptionalResult(result, payload.value);
+			if (result instanceof Promise) return result.then((r) => handleOptionalResult(r, input));
+			return handleOptionalResult(result, input);
 		}
 		if (payload.value === void 0) return payload;
 		return def.innerType._zod.run(payload, ctx);
@@ -13196,7 +13666,7 @@ function handleNonOptionalResult(payload, inst) {
 }
 var $ZodCatch = /* @__PURE__ */ $constructor("$ZodCatch", (inst, def) => {
 	$ZodType.init(inst, def);
-	defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
+	inst._zod.optin = "optional";
 	defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
 	defineLazy(inst._zod, "values", () => def.innerType._zod.values);
 	inst._zod.parse = (payload, ctx) => {
@@ -13211,6 +13681,7 @@ var $ZodCatch = /* @__PURE__ */ $constructor("$ZodCatch", (inst, def) => {
 					input: payload.value
 				});
 				payload.issues = [];
+				payload.fallback = true;
 			}
 			return payload;
 		});
@@ -13222,6 +13693,7 @@ var $ZodCatch = /* @__PURE__ */ $constructor("$ZodCatch", (inst, def) => {
 				input: payload.value
 			});
 			payload.issues = [];
+			payload.fallback = true;
 		}
 		return payload;
 	};
@@ -13250,7 +13722,8 @@ function handlePipeResult(left, next, ctx) {
 	}
 	return next._zod.run({
 		value: left.value,
-		issues: left.issues
+		issues: left.issues,
+		fallback: left.fallback
 	}, ctx);
 }
 var $ZodReadonly = /* @__PURE__ */ $constructor("$ZodReadonly", (inst, def) => {
@@ -13297,7 +13770,7 @@ function handleRefineResult(result, payload, input, inst) {
 	}
 }
 //#endregion
-//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/registries.js
+//#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/registries.js
 var _a;
 var $ZodRegistry = class {
 	constructor() {
@@ -13344,7 +13817,7 @@ function registry() {
 (_a = globalThis).__zod_globalRegistry ?? (_a.__zod_globalRegistry = registry());
 var globalRegistry = globalThis.__zod_globalRegistry;
 //#endregion
-//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/api.js
+//#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/api.js
 /* @__NO_SIDE_EFFECTS__ */
 function _string(Class, params) {
 	return new Class({
@@ -13445,6 +13918,11 @@ function _nanoid(Class, params) {
 		...normalizeParams(params)
 	});
 }
+/**
+* @deprecated CUID v1 is deprecated by its authors due to information leakage
+* (timestamps embedded in the id). Use {@link _cuid2} instead.
+* See https://github.com/paralleldrive/cuid.
+*/
 /* @__NO_SIDE_EFFECTS__ */
 function _cuid(Class, params) {
 	return new Class({
@@ -13813,7 +14291,7 @@ function _refine(Class, fn, _params) {
 	});
 }
 /* @__NO_SIDE_EFFECTS__ */
-function _superRefine(fn) {
+function _superRefine(fn, params) {
 	const ch = /* @__PURE__ */ _check((payload) => {
 		payload.addIssue = (issue$2) => {
 			if (typeof issue$2 === "string") payload.issues.push(issue(issue$2, payload.value, ch._zod.def));
@@ -13828,7 +14306,7 @@ function _superRefine(fn) {
 			}
 		};
 		return fn(payload.value, payload);
-	});
+	}, params);
 	return ch;
 }
 /* @__NO_SIDE_EFFECTS__ */
@@ -13841,7 +14319,7 @@ function _check(fn, params) {
 	return ch;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/to-json-schema.js
+//#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/to-json-schema.js
 function initializeContext(params) {
 	let target = params?.target ?? "draft-2020-12";
 	if (target === "draft-4") target = "draft-04";
@@ -13860,7 +14338,7 @@ function initializeContext(params) {
 		external: params?.external ?? void 0
 	};
 }
-function process(schema, ctx, _params = {
+function process$1(schema, ctx, _params = {
 	path: [],
 	schemaPath: []
 }) {
@@ -13897,7 +14375,7 @@ function process(schema, ctx, _params = {
 		const parent = schema._zod.parent;
 		if (parent) {
 			if (!result.ref) result.ref = parent;
-			process(parent, ctx, params);
+			process$1(parent, ctx, params);
 			ctx.seen.get(parent).isParent = true;
 		}
 	}
@@ -13907,7 +14385,7 @@ function process(schema, ctx, _params = {
 		delete result.schema.examples;
 		delete result.schema.default;
 	}
-	if (ctx.io === "input" && result.schema._prefault) (_a = result.schema).default ?? (_a.default = result.schema._prefault);
+	if (ctx.io === "input" && "_prefault" in result.schema) (_a = result.schema).default ?? (_a.default = result.schema._prefault);
 	delete result.schema._prefault;
 	return ctx.seen.get(schema).schema;
 }
@@ -14047,10 +14525,15 @@ function finalize(ctx, schema) {
 		result.$id = ctx.external.uri(id);
 	}
 	Object.assign(result, root.def ?? root.schema);
+	const rootMetaId = ctx.metadataRegistry.get(schema)?.id;
+	if (rootMetaId !== void 0 && result.id === rootMetaId) delete result.id;
 	const defs = ctx.external?.defs ?? {};
 	for (const entry of ctx.seen.entries()) {
 		const seen = entry[1];
-		if (seen.def && seen.defId) defs[seen.defId] = seen.def;
+		if (seen.def && seen.defId) {
+			if (seen.def.id === seen.defId) delete seen.def.id;
+			defs[seen.defId] = seen.def;
+		}
 	}
 	if (ctx.external) {} else if (Object.keys(defs).length > 0) if (ctx.target === "draft-2020-12") result.$defs = defs;
 	else result.definitions = defs;
@@ -14084,7 +14567,10 @@ function isTransforming(_schema, _ctx) {
 	if (def.type === "promise" || def.type === "optional" || def.type === "nonoptional" || def.type === "nullable" || def.type === "readonly" || def.type === "default" || def.type === "prefault") return isTransforming(def.innerType, ctx);
 	if (def.type === "intersection") return isTransforming(def.left, ctx) || isTransforming(def.right, ctx);
 	if (def.type === "record" || def.type === "map") return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
-	if (def.type === "pipe") return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
+	if (def.type === "pipe") {
+		if (_schema._zod.traits.has("$ZodCodec")) return true;
+		return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
+	}
 	if (def.type === "object") {
 		for (const key in def.shape) if (isTransforming(def.shape[key], ctx)) return true;
 		return false;
@@ -14109,7 +14595,7 @@ var createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
 		...params,
 		processors
 	});
-	process(schema, ctx);
+	process$1(schema, ctx);
 	extractDefs(ctx, schema);
 	return finalize(ctx, schema);
 };
@@ -14121,12 +14607,12 @@ var createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) =
 		io,
 		processors
 	});
-	process(schema, ctx);
+	process$1(schema, ctx);
 	extractDefs(ctx, schema);
 	return finalize(ctx, schema);
 };
 //#endregion
-//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/json-schema-processors.js
+//#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/json-schema-processors.js
 var formatMap = {
 	guid: "uuid",
 	url: "uri",
@@ -14160,31 +14646,24 @@ var numberProcessor = (schema, ctx, _json, _params) => {
 	const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
 	if (typeof format === "string" && format.includes("int")) json.type = "integer";
 	else json.type = "number";
-	if (typeof exclusiveMinimum === "number") if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
+	const exMin = typeof exclusiveMinimum === "number" && exclusiveMinimum >= (minimum ?? Number.NEGATIVE_INFINITY);
+	const exMax = typeof exclusiveMaximum === "number" && exclusiveMaximum <= (maximum ?? Number.POSITIVE_INFINITY);
+	const legacy = ctx.target === "draft-04" || ctx.target === "openapi-3.0";
+	if (exMin) if (legacy) {
 		json.minimum = exclusiveMinimum;
 		json.exclusiveMinimum = true;
 	} else json.exclusiveMinimum = exclusiveMinimum;
-	if (typeof minimum === "number") {
-		json.minimum = minimum;
-		if (typeof exclusiveMinimum === "number" && ctx.target !== "draft-04") if (exclusiveMinimum >= minimum) delete json.minimum;
-		else delete json.exclusiveMinimum;
-	}
-	if (typeof exclusiveMaximum === "number") if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
+	else if (typeof minimum === "number") json.minimum = minimum;
+	if (exMax) if (legacy) {
 		json.maximum = exclusiveMaximum;
 		json.exclusiveMaximum = true;
 	} else json.exclusiveMaximum = exclusiveMaximum;
-	if (typeof maximum === "number") {
-		json.maximum = maximum;
-		if (typeof exclusiveMaximum === "number" && ctx.target !== "draft-04") if (exclusiveMaximum <= maximum) delete json.maximum;
-		else delete json.exclusiveMaximum;
-	}
+	else if (typeof maximum === "number") json.maximum = maximum;
 	if (typeof multipleOf === "number") json.multipleOf = multipleOf;
 };
 var neverProcessor = (_schema, _ctx, json, _params) => {
 	json.not = {};
 };
-var anyProcessor = (_schema, _ctx, _json, _params) => {};
-var unknownProcessor = (_schema, _ctx, _json, _params) => {};
 var enumProcessor = (schema, _ctx, json, _params) => {
 	const def = schema._zod.def;
 	const values = getEnumValues(def.entries);
@@ -14205,7 +14684,7 @@ var arrayProcessor = (schema, ctx, _json, params) => {
 	if (typeof minimum === "number") json.minItems = minimum;
 	if (typeof maximum === "number") json.maxItems = maximum;
 	json.type = "array";
-	json.items = process(def.element, ctx, {
+	json.items = process$1(def.element, ctx, {
 		...params,
 		path: [...params.path, "items"]
 	});
@@ -14216,7 +14695,7 @@ var objectProcessor = (schema, ctx, _json, params) => {
 	json.type = "object";
 	json.properties = {};
 	const shape = def.shape;
-	for (const key in shape) json.properties[key] = process(shape[key], ctx, {
+	for (const key in shape) json.properties[key] = process$1(shape[key], ctx, {
 		...params,
 		path: [
 			...params.path,
@@ -14234,7 +14713,7 @@ var objectProcessor = (schema, ctx, _json, params) => {
 	if (def.catchall?._zod.def.type === "never") json.additionalProperties = false;
 	else if (!def.catchall) {
 		if (ctx.io === "output") json.additionalProperties = false;
-	} else if (def.catchall) json.additionalProperties = process(def.catchall, ctx, {
+	} else if (def.catchall) json.additionalProperties = process$1(def.catchall, ctx, {
 		...params,
 		path: [...params.path, "additionalProperties"]
 	});
@@ -14242,7 +14721,7 @@ var objectProcessor = (schema, ctx, _json, params) => {
 var unionProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
 	const isExclusive = def.inclusive === false;
-	const options = def.options.map((x, i) => process(x, ctx, {
+	const options = def.options.map((x, i) => process$1(x, ctx, {
 		...params,
 		path: [
 			...params.path,
@@ -14255,7 +14734,7 @@ var unionProcessor = (schema, ctx, json, params) => {
 };
 var intersectionProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
-	const a = process(def.left, ctx, {
+	const a = process$1(def.left, ctx, {
 		...params,
 		path: [
 			...params.path,
@@ -14263,7 +14742,7 @@ var intersectionProcessor = (schema, ctx, json, params) => {
 			0
 		]
 	});
-	const b = process(def.right, ctx, {
+	const b = process$1(def.right, ctx, {
 		...params,
 		path: [
 			...params.path,
@@ -14276,7 +14755,7 @@ var intersectionProcessor = (schema, ctx, json, params) => {
 };
 var nullableProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
-	const inner = process(def.innerType, ctx, params);
+	const inner = process$1(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	if (ctx.target === "openapi-3.0") {
 		seen.ref = def.innerType;
@@ -14285,27 +14764,27 @@ var nullableProcessor = (schema, ctx, json, params) => {
 };
 var nonoptionalProcessor = (schema, ctx, _json, params) => {
 	const def = schema._zod.def;
-	process(def.innerType, ctx, params);
+	process$1(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 };
 var defaultProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
-	process(def.innerType, ctx, params);
+	process$1(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 	json.default = JSON.parse(JSON.stringify(def.defaultValue));
 };
 var prefaultProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
-	process(def.innerType, ctx, params);
+	process$1(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 	if (ctx.io === "input") json._prefault = JSON.parse(JSON.stringify(def.defaultValue));
 };
 var catchProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
-	process(def.innerType, ctx, params);
+	process$1(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 	let catchValue;
@@ -14318,26 +14797,27 @@ var catchProcessor = (schema, ctx, json, params) => {
 };
 var pipeProcessor = (schema, ctx, _json, params) => {
 	const def = schema._zod.def;
-	const innerType = ctx.io === "input" ? def.in._zod.def.type === "transform" ? def.out : def.in : def.out;
-	process(innerType, ctx, params);
+	const inIsTransform = def.in._zod.traits.has("$ZodTransform");
+	const innerType = ctx.io === "input" ? inIsTransform ? def.out : def.in : def.out;
+	process$1(innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = innerType;
 };
 var readonlyProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
-	process(def.innerType, ctx, params);
+	process$1(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 	json.readOnly = true;
 };
 var optionalProcessor = (schema, ctx, _json, params) => {
 	const def = schema._zod.def;
-	process(def.innerType, ctx, params);
+	process$1(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 };
 //#endregion
-//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/iso.js
+//#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/iso.js
 var ZodISODateTime = /* @__PURE__ */ $constructor("ZodISODateTime", (inst, def) => {
 	$ZodISODateTime.init(inst, def);
 	ZodStringFormat.init(inst, def);
@@ -14367,7 +14847,7 @@ function duration(params) {
 	return /* @__PURE__ */ _isoDuration(ZodISODuration, params);
 }
 //#endregion
-//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/errors.js
+//#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/errors.js
 var initializer = (inst, issues) => {
 	$ZodError.init(inst, issues);
 	inst.name = "ZodError";
@@ -14387,10 +14867,9 @@ var initializer = (inst, issues) => {
 		} }
 	});
 };
-$constructor("ZodError", initializer);
-var ZodRealError = $constructor("ZodError", initializer, { Parent: Error });
+var ZodRealError = /* @__PURE__ */ $constructor("ZodError", initializer, { Parent: Error });
 //#endregion
-//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/parse.js
+//#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/parse.js
 var parse = /* @__PURE__ */ _parse(ZodRealError);
 var parseAsync = /* @__PURE__ */ _parseAsync(ZodRealError);
 var safeParse = /* @__PURE__ */ _safeParse(ZodRealError);
@@ -14404,7 +14883,43 @@ var safeDecode = /* @__PURE__ */ _safeDecode(ZodRealError);
 var safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync(ZodRealError);
 var safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);
 //#endregion
-//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/schemas.js
+//#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/schemas.js
+var _installedGroups = /* @__PURE__ */ new WeakMap();
+function _installLazyMethods(inst, group, methods) {
+	const proto = Object.getPrototypeOf(inst);
+	let installed = _installedGroups.get(proto);
+	if (!installed) {
+		installed = /* @__PURE__ */ new Set();
+		_installedGroups.set(proto, installed);
+	}
+	if (installed.has(group)) return;
+	installed.add(group);
+	for (const key in methods) {
+		const fn = methods[key];
+		Object.defineProperty(proto, key, {
+			configurable: true,
+			enumerable: false,
+			get() {
+				const bound = fn.bind(this);
+				Object.defineProperty(this, key, {
+					configurable: true,
+					writable: true,
+					enumerable: true,
+					value: bound
+				});
+				return bound;
+			},
+			set(v) {
+				Object.defineProperty(this, key, {
+					configurable: true,
+					writable: true,
+					enumerable: true,
+					value: v
+				});
+			}
+		});
+	}
+}
 var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
 	$ZodType.init(inst, def);
 	Object.assign(inst["~standard"], { jsonSchema: {
@@ -14415,20 +14930,6 @@ var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
 	inst.def = def;
 	inst.type = def.type;
 	Object.defineProperty(inst, "_def", { value: def });
-	inst.check = (...checks) => {
-		return inst.clone(mergeDefs(def, { checks: [...def.checks ?? [], ...checks.map((ch) => typeof ch === "function" ? { _zod: {
-			check: ch,
-			def: { check: "custom" },
-			onattach: []
-		} } : ch)] }), { parent: true });
-	};
-	inst.with = inst.check;
-	inst.clone = (def, params) => clone(inst, def, params);
-	inst.brand = () => inst;
-	inst.register = ((reg, meta) => {
-		reg.add(inst, meta);
-		return inst;
-	});
 	inst.parse = (data, params) => parse(inst, data, params, { callee: inst.parse });
 	inst.safeParse = (data, params) => safeParse(inst, data, params);
 	inst.parseAsync = async (data, params) => parseAsync(inst, data, params, { callee: inst.parseAsync });
@@ -14442,43 +14943,106 @@ var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
 	inst.safeDecode = (data, params) => safeDecode(inst, data, params);
 	inst.safeEncodeAsync = async (data, params) => safeEncodeAsync(inst, data, params);
 	inst.safeDecodeAsync = async (data, params) => safeDecodeAsync(inst, data, params);
-	inst.refine = (check, params) => inst.check(refine(check, params));
-	inst.superRefine = (refinement) => inst.check(superRefine(refinement));
-	inst.overwrite = (fn) => inst.check(/* @__PURE__ */ _overwrite(fn));
-	inst.optional = () => optional(inst);
-	inst.exactOptional = () => exactOptional(inst);
-	inst.nullable = () => nullable(inst);
-	inst.nullish = () => optional(nullable(inst));
-	inst.nonoptional = (params) => nonoptional(inst, params);
-	inst.array = () => array(inst);
-	inst.or = (arg) => union([inst, arg]);
-	inst.and = (arg) => intersection(inst, arg);
-	inst.transform = (tx) => pipe(inst, transform(tx));
-	inst.default = (def) => _default(inst, def);
-	inst.prefault = (def) => prefault(inst, def);
-	inst.catch = (params) => _catch(inst, params);
-	inst.pipe = (target) => pipe(inst, target);
-	inst.readonly = () => readonly(inst);
-	inst.describe = (description) => {
-		const cl = inst.clone();
-		globalRegistry.add(cl, { description });
-		return cl;
-	};
+	_installLazyMethods(inst, "ZodType", {
+		check(...chks) {
+			const def = this.def;
+			return this.clone(mergeDefs(def, { checks: [...def.checks ?? [], ...chks.map((ch) => typeof ch === "function" ? { _zod: {
+				check: ch,
+				def: { check: "custom" },
+				onattach: []
+			} } : ch)] }), { parent: true });
+		},
+		with(...chks) {
+			return this.check(...chks);
+		},
+		clone(def, params) {
+			return clone(this, def, params);
+		},
+		brand() {
+			return this;
+		},
+		register(reg, meta) {
+			reg.add(this, meta);
+			return this;
+		},
+		refine(check, params) {
+			return this.check(refine(check, params));
+		},
+		superRefine(refinement, params) {
+			return this.check(superRefine(refinement, params));
+		},
+		overwrite(fn) {
+			return this.check(/* @__PURE__ */ _overwrite(fn));
+		},
+		optional() {
+			return optional(this);
+		},
+		exactOptional() {
+			return exactOptional(this);
+		},
+		nullable() {
+			return nullable(this);
+		},
+		nullish() {
+			return optional(nullable(this));
+		},
+		nonoptional(params) {
+			return nonoptional(this, params);
+		},
+		array() {
+			return array(this);
+		},
+		or(arg) {
+			return union([this, arg]);
+		},
+		and(arg) {
+			return intersection(this, arg);
+		},
+		transform(tx) {
+			return pipe(this, transform(tx));
+		},
+		default(d) {
+			return _default(this, d);
+		},
+		prefault(d) {
+			return prefault(this, d);
+		},
+		catch(params) {
+			return _catch(this, params);
+		},
+		pipe(target) {
+			return pipe(this, target);
+		},
+		readonly() {
+			return readonly(this);
+		},
+		describe(description) {
+			const cl = this.clone();
+			globalRegistry.add(cl, { description });
+			return cl;
+		},
+		meta(...args) {
+			if (args.length === 0) return globalRegistry.get(this);
+			const cl = this.clone();
+			globalRegistry.add(cl, args[0]);
+			return cl;
+		},
+		isOptional() {
+			return this.safeParse(void 0).success;
+		},
+		isNullable() {
+			return this.safeParse(null).success;
+		},
+		apply(fn) {
+			return fn(this);
+		}
+	});
 	Object.defineProperty(inst, "description", {
 		get() {
 			return globalRegistry.get(inst)?.description;
 		},
 		configurable: true
 	});
-	inst.meta = (...args) => {
-		if (args.length === 0) return globalRegistry.get(inst);
-		const cl = inst.clone();
-		globalRegistry.add(cl, args[0]);
-		return cl;
-	};
-	inst.isOptional = () => inst.safeParse(void 0).success;
-	inst.isNullable = () => inst.safeParse(null).success;
-	inst.apply = (fn) => fn(inst);
 	return inst;
 });
 /** @internal */
@@ -14490,21 +15054,53 @@ var _ZodString = /* @__PURE__ */ $constructor("_ZodString", (inst, def) => {
 	inst.format = bag.format ?? null;
 	inst.minLength = bag.minimum ?? null;
 	inst.maxLength = bag.maximum ?? null;
-	inst.regex = (...args) => inst.check(/* @__PURE__ */ _regex(...args));
-	inst.includes = (...args) => inst.check(/* @__PURE__ */ _includes(...args));
-	inst.startsWith = (...args) => inst.check(/* @__PURE__ */ _startsWith(...args));
-	inst.endsWith = (...args) => inst.check(/* @__PURE__ */ _endsWith(...args));
-	inst.min = (...args) => inst.check(/* @__PURE__ */ _minLength(...args));
-	inst.max = (...args) => inst.check(/* @__PURE__ */ _maxLength(...args));
-	inst.length = (...args) => inst.check(/* @__PURE__ */ _length(...args));
-	inst.nonempty = (...args) => inst.check(/* @__PURE__ */ _minLength(1, ...args));
-	inst.lowercase = (params) => inst.check(/* @__PURE__ */ _lowercase(params));
-	inst.uppercase = (params) => inst.check(/* @__PURE__ */ _uppercase(params));
-	inst.trim = () => inst.check(/* @__PURE__ */ _trim());
-	inst.normalize = (...args) => inst.check(/* @__PURE__ */ _normalize(...args));
-	inst.toLowerCase = () => inst.check(/* @__PURE__ */ _toLowerCase());
-	inst.toUpperCase = () => inst.check(/* @__PURE__ */ _toUpperCase());
-	inst.slugify = () => inst.check(/* @__PURE__ */ _slugify());
+	_installLazyMethods(inst, "_ZodString", {
+		regex(...args) {
+			return this.check(/* @__PURE__ */ _regex(...args));
+		},
+		includes(...args) {
+			return this.check(/* @__PURE__ */ _includes(...args));
+		},
+		startsWith(...args) {
+			return this.check(/* @__PURE__ */ _startsWith(...args));
+		},
+		endsWith(...args) {
+			return this.check(/* @__PURE__ */ _endsWith(...args));
+		},
+		min(...args) {
+			return this.check(/* @__PURE__ */ _minLength(...args));
+		},
+		max(...args) {
+			return this.check(/* @__PURE__ */ _maxLength(...args));
+		},
+		length(...args) {
+			return this.check(/* @__PURE__ */ _length(...args));
+		},
+		nonempty(...args) {
+			return this.check(/* @__PURE__ */ _minLength(1, ...args));
+		},
+		lowercase(params) {
+			return this.check(/* @__PURE__ */ _lowercase(params));
+		},
+		uppercase(params) {
+			return this.check(/* @__PURE__ */ _uppercase(params));
+		},
+		trim() {
+			return this.check(/* @__PURE__ */ _trim());
+		},
+		normalize(...args) {
+			return this.check(/* @__PURE__ */ _normalize(...args));
+		},
+		toLowerCase() {
+			return this.check(/* @__PURE__ */ _toLowerCase());
+		},
+		toUpperCase() {
+			return this.check(/* @__PURE__ */ _toUpperCase());
+		},
+		slugify() {
+			return this.check(/* @__PURE__ */ _slugify());
+		}
+	});
 });
 var ZodString = /* @__PURE__ */ $constructor("ZodString", (inst, def) => {
 	$ZodString.init(inst, def);
@@ -14568,6 +15164,11 @@ var ZodNanoID = /* @__PURE__ */ $constructor("ZodNanoID", (inst, def) => {
 	$ZodNanoID.init(inst, def);
 	ZodStringFormat.init(inst, def);
 });
+/**
+* @deprecated CUID v1 is deprecated by its authors due to information leakage
+* (timestamps embedded in the id). Use {@link ZodCUID2} instead.
+* See https://github.com/paralleldrive/cuid.
+*/
 var ZodCUID = /* @__PURE__ */ $constructor("ZodCUID", (inst, def) => {
 	$ZodCUID.init(inst, def);
 	ZodStringFormat.init(inst, def);
@@ -14624,21 +15225,53 @@ var ZodNumber = /* @__PURE__ */ $constructor("ZodNumber", (inst, def) => {
 	$ZodNumber.init(inst, def);
 	ZodType.init(inst, def);
 	inst._zod.processJSONSchema = (ctx, json, params) => numberProcessor(inst, ctx, json, params);
-	inst.gt = (value, params) => inst.check(/* @__PURE__ */ _gt(value, params));
-	inst.gte = (value, params) => inst.check(/* @__PURE__ */ _gte(value, params));
-	inst.min = (value, params) => inst.check(/* @__PURE__ */ _gte(value, params));
-	inst.lt = (value, params) => inst.check(/* @__PURE__ */ _lt(value, params));
-	inst.lte = (value, params) => inst.check(/* @__PURE__ */ _lte(value, params));
-	inst.max = (value, params) => inst.check(/* @__PURE__ */ _lte(value, params));
-	inst.int = (params) => inst.check(int(params));
-	inst.safe = (params) => inst.check(int(params));
-	inst.positive = (params) => inst.check(/* @__PURE__ */ _gt(0, params));
-	inst.nonnegative = (params) => inst.check(/* @__PURE__ */ _gte(0, params));
-	inst.negative = (params) => inst.check(/* @__PURE__ */ _lt(0, params));
-	inst.nonpositive = (params) => inst.check(/* @__PURE__ */ _lte(0, params));
-	inst.multipleOf = (value, params) => inst.check(/* @__PURE__ */ _multipleOf(value, params));
-	inst.step = (value, params) => inst.check(/* @__PURE__ */ _multipleOf(value, params));
-	inst.finite = () => inst;
+	_installLazyMethods(inst, "ZodNumber", {
+		gt(value, params) {
+			return this.check(/* @__PURE__ */ _gt(value, params));
+		},
+		gte(value, params) {
+			return this.check(/* @__PURE__ */ _gte(value, params));
+		},
+		min(value, params) {
+			return this.check(/* @__PURE__ */ _gte(value, params));
+		},
+		lt(value, params) {
+			return this.check(/* @__PURE__ */ _lt(value, params));
+		},
+		lte(value, params) {
+			return this.check(/* @__PURE__ */ _lte(value, params));
+		},
+		max(value, params) {
+			return this.check(/* @__PURE__ */ _lte(value, params));
+		},
+		int(params) {
+			return this.check(int(params));
+		},
+		safe(params) {
+			return this.check(int(params));
+		},
+		positive(params) {
+			return this.check(/* @__PURE__ */ _gt(0, params));
+		},
+		nonnegative(params) {
+			return this.check(/* @__PURE__ */ _gte(0, params));
+		},
+		negative(params) {
+			return this.check(/* @__PURE__ */ _lt(0, params));
+		},
+		nonpositive(params) {
+			return this.check(/* @__PURE__ */ _lte(0, params));
+		},
+		multipleOf(value, params) {
+			return this.check(/* @__PURE__ */ _multipleOf(value, params));
+		},
+		step(value, params) {
+			return this.check(/* @__PURE__ */ _multipleOf(value, params));
+		},
+		finite() {
+			return this;
+		}
+	});
 	const bag = inst._zod.bag;
 	inst.minValue = Math.max(bag.minimum ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null;
 	inst.maxValue = Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null;
@@ -14659,7 +15292,7 @@ function int(params) {
 var ZodAny = /* @__PURE__ */ $constructor("ZodAny", (inst, def) => {
 	$ZodAny.init(inst, def);
 	ZodType.init(inst, def);
-	inst._zod.processJSONSchema = (ctx, json, params) => anyProcessor(inst, ctx, json, params);
+	inst._zod.processJSONSchema = (ctx, json, params) => void 0;
 });
 function any() {
 	return /* @__PURE__ */ _any(ZodAny);
@@ -14667,7 +15300,7 @@ function any() {
 var ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
 	$ZodUnknown.init(inst, def);
 	ZodType.init(inst, def);
-	inst._zod.processJSONSchema = (ctx, json, params) => unknownProcessor(inst, ctx, json, params);
+	inst._zod.processJSONSchema = (ctx, json, params) => void 0;
 });
 function unknown() {
 	return /* @__PURE__ */ _unknown(ZodUnknown);
@@ -14685,11 +15318,23 @@ var ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
 	ZodType.init(inst, def);
 	inst._zod.processJSONSchema = (ctx, json, params) => arrayProcessor(inst, ctx, json, params);
 	inst.element = def.element;
-	inst.min = (minLength, params) => inst.check(/* @__PURE__ */ _minLength(minLength, params));
-	inst.nonempty = (params) => inst.check(/* @__PURE__ */ _minLength(1, params));
-	inst.max = (maxLength, params) => inst.check(/* @__PURE__ */ _maxLength(maxLength, params));
-	inst.length = (len, params) => inst.check(/* @__PURE__ */ _length(len, params));
-	inst.unwrap = () => inst.element;
+	_installLazyMethods(inst, "ZodArray", {
+		min(n, params) {
+			return this.check(/* @__PURE__ */ _minLength(n, params));
+		},
+		nonempty(params) {
+			return this.check(/* @__PURE__ */ _minLength(1, params));
+		},
+		max(n, params) {
+			return this.check(/* @__PURE__ */ _maxLength(n, params));
+		},
+		length(n, params) {
+			return this.check(/* @__PURE__ */ _length(n, params));
+		},
+		unwrap() {
+			return this.element;
+		}
+	});
 });
 function array(element, params) {
 	return /* @__PURE__ */ _array(ZodArray, element, params);
@@ -14701,38 +15346,62 @@ var ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
 	defineLazy(inst, "shape", () => {
 		return def.shape;
 	});
-	inst.keyof = () => _enum(Object.keys(inst._zod.def.shape));
-	inst.catchall = (catchall) => inst.clone({
-		...inst._zod.def,
-		catchall
-	});
-	inst.passthrough = () => inst.clone({
-		...inst._zod.def,
-		catchall: unknown()
-	});
-	inst.loose = () => inst.clone({
-		...inst._zod.def,
-		catchall: unknown()
-	});
-	inst.strict = () => inst.clone({
-		...inst._zod.def,
-		catchall: never()
-	});
-	inst.strip = () => inst.clone({
-		...inst._zod.def,
-		catchall: void 0
+	_installLazyMethods(inst, "ZodObject", {
+		keyof() {
+			return _enum(Object.keys(this._zod.def.shape));
+		},
+		catchall(catchall) {
+			return this.clone({
+				...this._zod.def,
+				catchall
+			});
+		},
+		passthrough() {
+			return this.clone({
+				...this._zod.def,
+				catchall: unknown()
+			});
+		},
+		loose() {
+			return this.clone({
+				...this._zod.def,
+				catchall: unknown()
+			});
+		},
+		strict() {
+			return this.clone({
+				...this._zod.def,
+				catchall: never()
+			});
+		},
+		strip() {
+			return this.clone({
+				...this._zod.def,
+				catchall: void 0
+			});
+		},
+		extend(incoming) {
+			return extend(this, incoming);
+		},
+		safeExtend(incoming) {
+			return safeExtend(this, incoming);
+		},
+		merge(other) {
+			return merge(this, other);
+		},
+		pick(mask) {
+			return pick(this, mask);
+		},
+		omit(mask) {
+			return omit(this, mask);
+		},
+		partial(...args) {
+			return partial(ZodOptional, this, args[0]);
+		},
+		required(...args) {
+			return required(ZodNonOptional, this, args[0]);
+		}
 	});
-	inst.extend = (incoming) => {
-		return extend(inst, incoming);
-	};
-	inst.safeExtend = (incoming) => {
-		return safeExtend(inst, incoming);
-	};
-	inst.merge = (other) => merge(inst, other);
-	inst.pick = (mask) => pick(inst, mask);
-	inst.omit = (mask) => omit(inst, mask);
-	inst.partial = (...args) => partial(ZodOptional, inst, args[0]);
-	inst.required = (...args) => required(ZodNonOptional, inst, args[0]);
 });
 function object(shape, params) {
 	return new ZodObject({
@@ -14823,9 +15492,11 @@ var ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
 		const output = def.transform(payload.value, payload);
 		if (output instanceof Promise) return output.then((output) => {
 			payload.value = output;
+			payload.fallback = true;
 			return payload;
 		});
 		payload.value = output;
+		payload.fallback = true;
 		return payload;
 	};
 });
@@ -14963,8 +15634,8 @@ var ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => {
 function refine(fn, _params = {}) {
 	return /* @__PURE__ */ _refine(ZodCustom, fn, _params);
 }
-function superRefine(fn) {
-	return /* @__PURE__ */ _superRefine(fn);
+function superRefine(fn, params) {
+	return /* @__PURE__ */ _superRefine(fn, params);
 }
 //#endregion
 //#region src/decorators/event.ts
@@ -15312,11 +15983,11 @@ var RpgMap = class RpgMap extends RpgCommonMap {
 		return clone;
 	}
 	buildRuntimeEventId(baseId, mode, scenarioOwnerId) {
-		const fallbackId = baseId || generateShortUUID$1();
+		const fallbackId = baseId || generateShortUUID();
 		if (mode !== EventMode.Scenario || !scenarioOwnerId) return fallbackId;
 		const scopedId = `${fallbackId}::${scenarioOwnerId}`;
 		if (!this.events()[scopedId]) return scopedId;
-		return `${scopedId}::${generateShortUUID$1()}`;
+		return `${scopedId}::${generateShortUUID()}`;
 	}
 	setEventRuntimeMetadata(eventId, mode, scenarioOwnerId) {
 		this._eventModeById.set(eventId, mode);
@@ -15743,7 +16414,11 @@ var RpgMap = class RpgMap extends RpgCommonMap {
 	* ```
 	*/
 	onAction(player, action) {
-		const events = this.getCollisions(player.id).map((id) => this.getEvent(id)).filter((event) => !!event && this.isEventVisibleForPlayer(event, player));
+		const direction = typeof player.getDirection === "function" ? player.getDirection() : typeof player.direction === "function" ? player.direction() : void 0;
+		const collisions = new Set(this.getCollisions(player.id));
+		const interactionCollisions = this.getInteractionCollisions?.(player.id, direction);
+		if (Array.isArray(interactionCollisions)) interactionCollisions.forEach((id) => collisions.add(id));
+		const events = Array.from(collisions).map((id) => this.getEvent(id)).filter((event) => !!event && this.isEventVisibleForPlayer(event, player));
 		if (events.length > 0) events.forEach((event) => {
 			event.execMethod("onAction", [player, action]);
 		});
@@ -16890,23 +17565,18 @@ var RpgMap = class RpgMap extends RpgCommonMap {
 		if (typeof x !== "number" || typeof y !== "number") throw new Error("Shape x and y must be numbers");
 		if (typeof width !== "number" || width <= 0) throw new Error("Shape width must be a positive number");
 		if (typeof height !== "number" || height <= 0) throw new Error("Shape height must be a positive number");
-		const name = obj.name || generateShortUUID$1();
+		const name = obj.name || generateShortUUID();
 		if (this._shapes.has(name)) throw new Error(`Shape with name "${name}" already exists`);
 		const centerX = x + width / 2;
 		const centerY = y + height / 2;
 		const entityId = `shape-${name}`;
-		this.physic.createEntity({
-			uuid: entityId,
-			position: {
-				x: centerX,
-				y: centerY
-			},
+		this.physic.createStaticObstacle(entityId, {
+			x: centerX,
+			y: centerY,
 			width,
 			height,
-			mass: Infinity,
-			state: EntityState.Static,
 			restitution: 0
-		}).freeze();
+		});
 		const properties = { ...obj.properties || {} };
 		if (obj.z !== void 0) properties.z = obj.z;
 		if (obj.color !== void 0) properties.color = obj.color;