@esengine/server 4.3.0 → 4.5.0

package/dist/index.js

@@ -1,7 +1,8 @@
-export { createHttpRouter, createServer } from './chunk-M7VONMZJ.js';
+export { ECSRoom } from './chunk-ZUTL4RI7.js';
+export { DistributedRoomManager, MemoryAdapter, RoomManager, createHttpRouter, createServer } from './chunk-NWZLKNGV.js';
 import './chunk-I4QQSQ72.js';
-export { Player, Room, onMessage } from './chunk-FACTBKJ3.js';
-import { __name } from './chunk-T626JPC7.js';
+export { Player, Room, onMessage } from './chunk-T3QJOPNG.js';
+import { __name, __publicField } from './chunk-T626JPC7.js';
 export { ErrorCode, RpcError } from '@esengine/rpc';
 
 // src/helpers/define.ts
@@ -9,15 +10,1512 @@ function defineApi(definition) {
   return definition;
 }
 __name(defineApi, "defineApi");
+function defineApiWithSchema(schema, definition) {
+  return {
+    ...definition,
+    schema
+  };
+}
+__name(defineApiWithSchema, "defineApiWithSchema");
 function defineMsg(definition) {
   return definition;
 }
 __name(defineMsg, "defineMsg");
+function defineMsgWithSchema(schema, definition) {
+  return {
+    ...definition,
+    schema
+  };
+}
+__name(defineMsgWithSchema, "defineMsgWithSchema");
 function defineHttp(definition) {
   return definition;
 }
 __name(defineHttp, "defineHttp");
 
-export { defineApi, defineHttp, defineMsg };
+// src/schema/base.ts
+var _BaseValidator = class _BaseValidator {
+  constructor() {
+    __publicField(this, "_options", {});
+  }
+  validate(value, path = []) {
+    if (value === void 0) {
+      if (this._options.isOptional) {
+        if (this._options.defaultValue !== void 0) {
+          return {
+            success: true,
+            data: this._options.defaultValue
+          };
+        }
+        return {
+          success: true,
+          data: void 0
+        };
+      }
+      return {
+        success: false,
+        error: {
+          path,
+          message: "Required",
+          expected: this.typeName,
+          received: void 0
+        }
+      };
+    }
+    if (value === null) {
+      if (this._options.isNullable) {
+        return {
+          success: true,
+          data: null
+        };
+      }
+      return {
+        success: false,
+        error: {
+          path,
+          message: "Expected non-null value",
+          expected: this.typeName,
+          received: null
+        }
+      };
+    }
+    return this._validate(value, path);
+  }
+  is(value) {
+    return this.validate(value).success;
+  }
+  optional() {
+    const clone = this._clone();
+    clone._options.isOptional = true;
+    return clone;
+  }
+  default(defaultValue) {
+    const clone = this._clone();
+    clone._options.isOptional = true;
+    clone._options.defaultValue = defaultValue;
+    return clone;
+  }
+  nullable() {
+    const clone = this._clone();
+    clone._options.isNullable = true;
+    return clone;
+  }
+};
+__name(_BaseValidator, "BaseValidator");
+var BaseValidator = _BaseValidator;
+
+// src/schema/primitives.ts
+var _StringValidator = class _StringValidator extends BaseValidator {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "typeName", "string");
+    __publicField(this, "_stringOptions", {});
+  }
+  _validate(value, path) {
+    if (typeof value !== "string") {
+      return {
+        success: false,
+        error: {
+          path,
+          message: `Expected string, received ${typeof value}`,
+          expected: "string",
+          received: value
+        }
+      };
+    }
+    const { minLength, maxLength, pattern } = this._stringOptions;
+    if (minLength !== void 0 && value.length < minLength) {
+      return {
+        success: false,
+        error: {
+          path,
+          message: `String must be at least ${minLength} characters`,
+          expected: `string(minLength: ${minLength})`,
+          received: value
+        }
+      };
+    }
+    if (maxLength !== void 0 && value.length > maxLength) {
+      return {
+        success: false,
+        error: {
+          path,
+          message: `String must be at most ${maxLength} characters`,
+          expected: `string(maxLength: ${maxLength})`,
+          received: value
+        }
+      };
+    }
+    if (pattern && !pattern.test(value)) {
+      return {
+        success: false,
+        error: {
+          path,
+          message: `String does not match pattern ${pattern}`,
+          expected: `string(pattern: ${pattern})`,
+          received: value
+        }
+      };
+    }
+    return {
+      success: true,
+      data: value
+    };
+  }
+  _clone() {
+    const clone = new _StringValidator();
+    clone._options = {
+      ...this._options
+    };
+    clone._stringOptions = {
+      ...this._stringOptions
+    };
+    return clone;
+  }
+  /**
+   * @zh 设置最小长度
+   * @en Set minimum length
+   */
+  min(length) {
+    const clone = this._clone();
+    clone._stringOptions.minLength = length;
+    return clone;
+  }
+  /**
+   * @zh 设置最大长度
+   * @en Set maximum length
+   */
+  max(length) {
+    const clone = this._clone();
+    clone._stringOptions.maxLength = length;
+    return clone;
+  }
+  /**
+   * @zh 设置长度范围
+   * @en Set length range
+   */
+  length(min, max) {
+    const clone = this._clone();
+    clone._stringOptions.minLength = min;
+    clone._stringOptions.maxLength = max;
+    return clone;
+  }
+  /**
+   * @zh 设置正则模式
+   * @en Set regex pattern
+   */
+  regex(pattern) {
+    const clone = this._clone();
+    clone._stringOptions.pattern = pattern;
+    return clone;
+  }
+  /**
+   * @zh 邮箱格式验证
+   * @en Email format validation
+   */
+  email() {
+    return this.regex(/^[^\s@]+@[^\s@]+\.[^\s@]+$/);
+  }
+  /**
+   * @zh URL 格式验证
+   * @en URL format validation
+   */
+  url() {
+    return this.regex(/^https?:\/\/.+/);
+  }
+};
+__name(_StringValidator, "StringValidator");
+var StringValidator = _StringValidator;
+var _NumberValidator = class _NumberValidator extends BaseValidator {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "typeName", "number");
+    __publicField(this, "_numberOptions", {});
+  }
+  _validate(value, path) {
+    if (typeof value !== "number" || Number.isNaN(value)) {
+      return {
+        success: false,
+        error: {
+          path,
+          message: `Expected number, received ${typeof value}`,
+          expected: "number",
+          received: value
+        }
+      };
+    }
+    const { min, max, integer } = this._numberOptions;
+    if (integer && !Number.isInteger(value)) {
+      return {
+        success: false,
+        error: {
+          path,
+          message: "Expected integer",
+          expected: "integer",
+          received: value
+        }
+      };
+    }
+    if (min !== void 0 && value < min) {
+      return {
+        success: false,
+        error: {
+          path,
+          message: `Number must be >= ${min}`,
+          expected: `number(min: ${min})`,
+          received: value
+        }
+      };
+    }
+    if (max !== void 0 && value > max) {
+      return {
+        success: false,
+        error: {
+          path,
+          message: `Number must be <= ${max}`,
+          expected: `number(max: ${max})`,
+          received: value
+        }
+      };
+    }
+    return {
+      success: true,
+      data: value
+    };
+  }
+  _clone() {
+    const clone = new _NumberValidator();
+    clone._options = {
+      ...this._options
+    };
+    clone._numberOptions = {
+      ...this._numberOptions
+    };
+    return clone;
+  }
+  /**
+   * @zh 设置最小值
+   * @en Set minimum value
+   */
+  min(value) {
+    const clone = this._clone();
+    clone._numberOptions.min = value;
+    return clone;
+  }
+  /**
+   * @zh 设置最大值
+   * @en Set maximum value
+   */
+  max(value) {
+    const clone = this._clone();
+    clone._numberOptions.max = value;
+    return clone;
+  }
+  /**
+   * @zh 设置范围
+   * @en Set range
+   */
+  range(min, max) {
+    const clone = this._clone();
+    clone._numberOptions.min = min;
+    clone._numberOptions.max = max;
+    return clone;
+  }
+  /**
+   * @zh 要求为整数
+   * @en Require integer
+   */
+  int() {
+    const clone = this._clone();
+    clone._numberOptions.integer = true;
+    return clone;
+  }
+  /**
+   * @zh 要求为正数
+   * @en Require positive
+   */
+  positive() {
+    return this.min(0);
+  }
+  /**
+   * @zh 要求为负数
+   * @en Require negative
+   */
+  negative() {
+    return this.max(0);
+  }
+};
+__name(_NumberValidator, "NumberValidator");
+var NumberValidator = _NumberValidator;
+var _BooleanValidator = class _BooleanValidator extends BaseValidator {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "typeName", "boolean");
+  }
+  _validate(value, path) {
+    if (typeof value !== "boolean") {
+      return {
+        success: false,
+        error: {
+          path,
+          message: `Expected boolean, received ${typeof value}`,
+          expected: "boolean",
+          received: value
+        }
+      };
+    }
+    return {
+      success: true,
+      data: value
+    };
+  }
+  _clone() {
+    const clone = new _BooleanValidator();
+    clone._options = {
+      ...this._options
+    };
+    return clone;
+  }
+};
+__name(_BooleanValidator, "BooleanValidator");
+var BooleanValidator = _BooleanValidator;
+var _LiteralValidator = class _LiteralValidator extends BaseValidator {
+  constructor(literal2) {
+    super();
+    __publicField(this, "typeName");
+    __publicField(this, "_literal");
+    this._literal = literal2;
+    this.typeName = `literal(${JSON.stringify(literal2)})`;
+  }
+  _validate(value, path) {
+    if (value !== this._literal) {
+      return {
+        success: false,
+        error: {
+          path,
+          message: `Expected ${JSON.stringify(this._literal)}, received ${JSON.stringify(value)}`,
+          expected: this.typeName,
+          received: value
+        }
+      };
+    }
+    return {
+      success: true,
+      data: value
+    };
+  }
+  _clone() {
+    const clone = new _LiteralValidator(this._literal);
+    clone._options = {
+      ...this._options
+    };
+    return clone;
+  }
+};
+__name(_LiteralValidator, "LiteralValidator");
+var LiteralValidator = _LiteralValidator;
+var _AnyValidator = class _AnyValidator extends BaseValidator {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "typeName", "any");
+  }
+  _validate(value) {
+    return {
+      success: true,
+      data: value
+    };
+  }
+  _clone() {
+    const clone = new _AnyValidator();
+    clone._options = {
+      ...this._options
+    };
+    return clone;
+  }
+};
+__name(_AnyValidator, "AnyValidator");
+var AnyValidator = _AnyValidator;
+function string() {
+  return new StringValidator();
+}
+__name(string, "string");
+function number() {
+  return new NumberValidator();
+}
+__name(number, "number");
+function boolean() {
+  return new BooleanValidator();
+}
+__name(boolean, "boolean");
+function literal(value) {
+  return new LiteralValidator(value);
+}
+__name(literal, "literal");
+function any() {
+  return new AnyValidator();
+}
+__name(any, "any");
+
+// src/schema/composites.ts
+var _ObjectValidator = class _ObjectValidator extends BaseValidator {
+  constructor(shape) {
+    super();
+    __publicField(this, "typeName", "object");
+    __publicField(this, "_shape");
+    __publicField(this, "_objectOptions", {});
+    this._shape = shape;
+  }
+  _validate(value, path) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      return {
+        success: false,
+        error: {
+          path,
+          message: `Expected object, received ${Array.isArray(value) ? "array" : typeof value}`,
+          expected: "object",
+          received: value
+        }
+      };
+    }
+    const result = {};
+    const obj = value;
+    for (const [key, validator] of Object.entries(this._shape)) {
+      const fieldValue = obj[key];
+      const fieldPath = [
+        ...path,
+        key
+      ];
+      const fieldResult = validator.validate(fieldValue, fieldPath);
+      if (!fieldResult.success) {
+        return fieldResult;
+      }
+      result[key] = fieldResult.data;
+    }
+    if (this._objectOptions.strict) {
+      const knownKeys = new Set(Object.keys(this._shape));
+      for (const key of Object.keys(obj)) {
+        if (!knownKeys.has(key)) {
+          return {
+            success: false,
+            error: {
+              path: [
+                ...path,
+                key
+              ],
+              message: `Unknown key "${key}"`,
+              expected: "known key",
+              received: key
+            }
+          };
+        }
+      }
+    }
+    return {
+      success: true,
+      data: result
+    };
+  }
+  _clone() {
+    const clone = new _ObjectValidator(this._shape);
+    clone._options = {
+      ...this._options
+    };
+    clone._objectOptions = {
+      ...this._objectOptions
+    };
+    return clone;
+  }
+  /**
+   * @zh 严格模式（不允许额外字段）
+   * @en Strict mode (no extra fields allowed)
+   */
+  strict() {
+    const clone = this._clone();
+    clone._objectOptions.strict = true;
+    return clone;
+  }
+  /**
+   * @zh 部分模式（所有字段可选）
+   * @en Partial mode (all fields optional)
+   */
+  partial() {
+    const partialShape = {};
+    for (const [key, validator] of Object.entries(this._shape)) {
+      partialShape[key] = validator.optional();
+    }
+    return new _ObjectValidator(partialShape);
+  }
+  /**
+   * @zh 选择部分字段
+   * @en Pick specific fields
+   */
+  pick(...keys) {
+    const pickedShape = {};
+    for (const key of keys) {
+      pickedShape[key] = this._shape[key];
+    }
+    return new _ObjectValidator(pickedShape);
+  }
+  /**
+   * @zh 排除部分字段
+   * @en Omit specific fields
+   */
+  omit(...keys) {
+    const keySet = new Set(keys);
+    const omittedShape = {};
+    for (const [key, validator] of Object.entries(this._shape)) {
+      if (!keySet.has(key)) {
+        omittedShape[key] = validator;
+      }
+    }
+    return new _ObjectValidator(omittedShape);
+  }
+  /**
+   * @zh 扩展对象 Schema
+   * @en Extend object schema
+   */
+  extend(shape) {
+    const extendedShape = {
+      ...this._shape,
+      ...shape
+    };
+    return new _ObjectValidator(extendedShape);
+  }
+};
+__name(_ObjectValidator, "ObjectValidator");
+var ObjectValidator = _ObjectValidator;
+var _ArrayValidator = class _ArrayValidator extends BaseValidator {
+  constructor(element) {
+    super();
+    __publicField(this, "typeName", "array");
+    __publicField(this, "_element");
+    __publicField(this, "_arrayOptions", {});
+    this._element = element;
+  }
+  _validate(value, path) {
+    if (!Array.isArray(value)) {
+      return {
+        success: false,
+        error: {
+          path,
+          message: `Expected array, received ${typeof value}`,
+          expected: "array",
+          received: value
+        }
+      };
+    }
+    const { minLength, maxLength } = this._arrayOptions;
+    if (minLength !== void 0 && value.length < minLength) {
+      return {
+        success: false,
+        error: {
+          path,
+          message: `Array must have at least ${minLength} items`,
+          expected: `array(minLength: ${minLength})`,
+          received: value
+        }
+      };
+    }
+    if (maxLength !== void 0 && value.length > maxLength) {
+      return {
+        success: false,
+        error: {
+          path,
+          message: `Array must have at most ${maxLength} items`,
+          expected: `array(maxLength: ${maxLength})`,
+          received: value
+        }
+      };
+    }
+    const result = [];
+    for (let i = 0; i < value.length; i++) {
+      const itemPath = [
+        ...path,
+        String(i)
+      ];
+      const itemResult = this._element.validate(value[i], itemPath);
+      if (!itemResult.success) {
+        return itemResult;
+      }
+      result.push(itemResult.data);
+    }
+    return {
+      success: true,
+      data: result
+    };
+  }
+  _clone() {
+    const clone = new _ArrayValidator(this._element);
+    clone._options = {
+      ...this._options
+    };
+    clone._arrayOptions = {
+      ...this._arrayOptions
+    };
+    return clone;
+  }
+  /**
+   * @zh 设置最小长度
+   * @en Set minimum length
+   */
+  min(length) {
+    const clone = this._clone();
+    clone._arrayOptions.minLength = length;
+    return clone;
+  }
+  /**
+   * @zh 设置最大长度
+   * @en Set maximum length
+   */
+  max(length) {
+    const clone = this._clone();
+    clone._arrayOptions.maxLength = length;
+    return clone;
+  }
+  /**
+   * @zh 设置长度范围
+   * @en Set length range
+   */
+  length(min, max) {
+    const clone = this._clone();
+    clone._arrayOptions.minLength = min;
+    clone._arrayOptions.maxLength = max;
+    return clone;
+  }
+  /**
+   * @zh 要求非空数组
+   * @en Require non-empty array
+   */
+  nonempty() {
+    return this.min(1);
+  }
+};
+__name(_ArrayValidator, "ArrayValidator");
+var ArrayValidator = _ArrayValidator;
+var _TupleValidator = class _TupleValidator extends BaseValidator {
+  constructor(elements) {
+    super();
+    __publicField(this, "typeName", "tuple");
+    __publicField(this, "_elements");
+    this._elements = elements;
+  }
+  _validate(value, path) {
+    if (!Array.isArray(value)) {
+      return {
+        success: false,
+        error: {
+          path,
+          message: `Expected tuple, received ${typeof value}`,
+          expected: "tuple",
+          received: value
+        }
+      };
+    }
+    if (value.length !== this._elements.length) {
+      return {
+        success: false,
+        error: {
+          path,
+          message: `Expected tuple of length ${this._elements.length}, received length ${value.length}`,
+          expected: `tuple(length: ${this._elements.length})`,
+          received: value
+        }
+      };
+    }
+    const result = [];
+    for (let i = 0; i < this._elements.length; i++) {
+      const itemPath = [
+        ...path,
+        String(i)
+      ];
+      const itemResult = this._elements[i].validate(value[i], itemPath);
+      if (!itemResult.success) {
+        return itemResult;
+      }
+      result.push(itemResult.data);
+    }
+    return {
+      success: true,
+      data: result
+    };
+  }
+  _clone() {
+    const clone = new _TupleValidator(this._elements);
+    clone._options = {
+      ...this._options
+    };
+    return clone;
+  }
+};
+__name(_TupleValidator, "TupleValidator");
+var TupleValidator = _TupleValidator;
+var _UnionValidator = class _UnionValidator extends BaseValidator {
+  constructor(variants) {
+    super();
+    __publicField(this, "typeName");
+    __publicField(this, "_variants");
+    this._variants = variants;
+    this.typeName = `union(${variants.map((v) => v.typeName).join(" | ")})`;
+  }
+  _validate(value, path) {
+    const errors = [];
+    for (const variant of this._variants) {
+      const result = variant.validate(value, path);
+      if (result.success) {
+        return result;
+      }
+      errors.push(variant.typeName);
+    }
+    return {
+      success: false,
+      error: {
+        path,
+        message: `Expected one of: ${errors.join(", ")}`,
+        expected: this.typeName,
+        received: value
+      }
+    };
+  }
+  _clone() {
+    const clone = new _UnionValidator(this._variants);
+    clone._options = {
+      ...this._options
+    };
+    return clone;
+  }
+};
+__name(_UnionValidator, "UnionValidator");
+var UnionValidator = _UnionValidator;
+var _RecordValidator = class _RecordValidator extends BaseValidator {
+  constructor(valueValidator) {
+    super();
+    __publicField(this, "typeName", "record");
+    __publicField(this, "_valueValidator");
+    this._valueValidator = valueValidator;
+  }
+  _validate(value, path) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      return {
+        success: false,
+        error: {
+          path,
+          message: `Expected object, received ${Array.isArray(value) ? "array" : typeof value}`,
+          expected: "record",
+          received: value
+        }
+      };
+    }
+    const result = {};
+    const obj = value;
+    for (const [key, val] of Object.entries(obj)) {
+      const fieldPath = [
+        ...path,
+        key
+      ];
+      const fieldResult = this._valueValidator.validate(val, fieldPath);
+      if (!fieldResult.success) {
+        return fieldResult;
+      }
+      result[key] = fieldResult.data;
+    }
+    return {
+      success: true,
+      data: result
+    };
+  }
+  _clone() {
+    const clone = new _RecordValidator(this._valueValidator);
+    clone._options = {
+      ...this._options
+    };
+    return clone;
+  }
+};
+__name(_RecordValidator, "RecordValidator");
+var RecordValidator = _RecordValidator;
+var _EnumValidator = class _EnumValidator extends BaseValidator {
+  constructor(values) {
+    super();
+    __publicField(this, "typeName");
+    __publicField(this, "_values");
+    __publicField(this, "_valuesArray");
+    this._valuesArray = values;
+    this._values = new Set(values);
+    this.typeName = `enum(${values.map((v) => JSON.stringify(v)).join(", ")})`;
+  }
+  _validate(value, path) {
+    if (!this._values.has(value)) {
+      return {
+        success: false,
+        error: {
+          path,
+          message: `Expected one of: ${this._valuesArray.map((v) => JSON.stringify(v)).join(", ")}`,
+          expected: this.typeName,
+          received: value
+        }
+      };
+    }
+    return {
+      success: true,
+      data: value
+    };
+  }
+  _clone() {
+    const clone = new _EnumValidator(this._valuesArray);
+    clone._options = {
+      ...this._options
+    };
+    return clone;
+  }
+};
+__name(_EnumValidator, "EnumValidator");
+var EnumValidator = _EnumValidator;
+function object(shape) {
+  return new ObjectValidator(shape);
+}
+__name(object, "object");
+function array(element) {
+  return new ArrayValidator(element);
+}
+__name(array, "array");
+function tuple(elements) {
+  return new TupleValidator(elements);
+}
+__name(tuple, "tuple");
+function union(variants) {
+  return new UnionValidator(variants);
+}
+__name(union, "union");
+function record(valueValidator) {
+  return new RecordValidator(valueValidator);
+}
+__name(record, "record");
+function nativeEnum(values) {
+  return new EnumValidator(values);
+}
+__name(nativeEnum, "nativeEnum");
+
+// src/schema/index.ts
+var s = {
+  // Primitives
+  string,
+  number,
+  boolean,
+  literal,
+  any,
+  // Composites
+  object,
+  array,
+  tuple,
+  union,
+  record,
+  /**
+   * @zh 创建枚举验证器
+   * @en Create enum validator
+   *
+   * @example
+   * ```typescript
+   * const RoleSchema = s.enum(['admin', 'user', 'guest'] as const);
+   * type Role = s.infer<typeof RoleSchema>; // 'admin' | 'user' | 'guest'
+   * ```
+   */
+  enum: nativeEnum,
+  /**
+   * @zh 类型推断辅助（仅用于类型层面）
+   * @en Type inference helper (type-level only)
+   *
+   * @zh 这是一个类型辅助，用于从验证器推断类型
+   * @en This is a type helper to infer types from validators
+   */
+  infer: void 0
+};
+function parse(validator, value) {
+  const result = validator.validate(value);
+  if (!result.success) {
+    const pathStr = result.error.path.length > 0 ? ` at "${result.error.path.join(".")}"` : "";
+    throw new Error(`Validation failed${pathStr}: ${result.error.message}`);
+  }
+  return result.data;
+}
+__name(parse, "parse");
+function safeParse(validator, value) {
+  return validator.validate(value);
+}
+__name(safeParse, "safeParse");
+function createGuard(validator) {
+  return (value) => validator.is(value);
+}
+__name(createGuard, "createGuard");
+
+// src/distributed/adapters/RedisAdapter.ts
+var RELEASE_LOCK_SCRIPT = `
+if redis.call("get", KEYS[1]) == ARGV[1] then
+    return redis.call("del", KEYS[1])
+else
+    return 0
+end
+`;
+var EXTEND_LOCK_SCRIPT = `
+if redis.call("get", KEYS[1]) == ARGV[1] then
+    return redis.call("pexpire", KEYS[1], ARGV[2])
+else
+    return 0
+end
+`;
+var _RedisAdapter = class _RedisAdapter {
+  constructor(config) {
+    __publicField(this, "_config");
+    __publicField(this, "_client", null);
+    __publicField(this, "_subscriber", null);
+    __publicField(this, "_connected", false);
+    // 锁的 owner token（用于安全释放）
+    __publicField(this, "_lockTokens", /* @__PURE__ */ new Map());
+    // 事件处理器
+    __publicField(this, "_handlers", /* @__PURE__ */ new Map());
+    __publicField(this, "_messageHandler", null);
+    this._config = {
+      prefix: "dist:",
+      serverTtl: 30,
+      roomTtl: 0,
+      snapshotTtl: 86400,
+      channel: "distributed:events",
+      ...config,
+      factory: config.factory
+    };
+  }
+  // =========================================================================
+  // Key 生成器 | Key Generators
+  // =========================================================================
+  _key(type, id) {
+    return id ? `${this._config.prefix}${type}:${id}` : `${this._config.prefix}${type}`;
+  }
+  _serverKey(serverId) {
+    return this._key("server", serverId);
+  }
+  _roomKey(roomId) {
+    return this._key("room", roomId);
+  }
+  _snapshotKey(roomId) {
+    return this._key("snapshot", roomId);
+  }
+  _lockKey(key) {
+    return this._key("lock", key);
+  }
+  _serversSetKey() {
+    return this._key("servers");
+  }
+  _roomsSetKey() {
+    return this._key("rooms");
+  }
+  _serverRoomsKey(serverId) {
+    return this._key("server-rooms", serverId);
+  }
+  // =========================================================================
+  // 生命周期 | Lifecycle
+  // =========================================================================
+  async connect() {
+    if (this._connected) return;
+    this._client = await this._config.factory();
+    this._subscriber = this._client.duplicate();
+    this._messageHandler = (channel, message) => {
+      if (channel !== this._config.channel) return;
+      try {
+        const event = JSON.parse(message);
+        this._dispatchEvent(event);
+      } catch (error) {
+        console.error("[RedisAdapter] Failed to parse event:", error);
+      }
+    };
+    this._subscriber.on("message", this._messageHandler);
+    await this._subscriber.subscribe(this._config.channel);
+    this._connected = true;
+  }
+  async disconnect() {
+    if (!this._connected) return;
+    if (this._subscriber) {
+      if (this._messageHandler) {
+        this._subscriber.off("message", this._messageHandler);
+      }
+      await this._subscriber.unsubscribe(this._config.channel);
+      this._subscriber.disconnect();
+      this._subscriber = null;
+    }
+    if (this._client) {
+      await this._client.quit();
+      this._client = null;
+    }
+    this._handlers.clear();
+    this._lockTokens.clear();
+    this._connected = false;
+  }
+  isConnected() {
+    return this._connected;
+  }
+  _ensureConnected() {
+    if (!this._connected || !this._client) {
+      throw new Error("RedisAdapter is not connected");
+    }
+    return this._client;
+  }
+  // =========================================================================
+  // 服务器注册 | Server Registry
+  // =========================================================================
+  async registerServer(server) {
+    const client = this._ensureConnected();
+    const key = this._serverKey(server.serverId);
+    await client.hmset(key, "serverId", server.serverId, "address", server.address, "port", String(server.port), "roomCount", String(server.roomCount), "playerCount", String(server.playerCount), "capacity", String(server.capacity), "status", server.status, "lastHeartbeat", String(Date.now()), "metadata", JSON.stringify(server.metadata ?? {}));
+    await client.expire(key, this._config.serverTtl);
+    await client.sadd(this._serversSetKey(), server.serverId);
+    await this.publish({
+      type: "server:online",
+      serverId: server.serverId,
+      payload: server,
+      timestamp: Date.now()
+    });
+  }
+  async unregisterServer(serverId) {
+    const client = this._ensureConnected();
+    const key = this._serverKey(serverId);
+    await client.del(key);
+    await client.srem(this._serversSetKey(), serverId);
+    const roomIds = await client.smembers(this._serverRoomsKey(serverId));
+    for (const roomId of roomIds) {
+      await this.unregisterRoom(roomId);
+    }
+    await client.del(this._serverRoomsKey(serverId));
+    await this.publish({
+      type: "server:offline",
+      serverId,
+      payload: {
+        serverId
+      },
+      timestamp: Date.now()
+    });
+  }
+  async heartbeat(serverId) {
+    const client = this._ensureConnected();
+    const key = this._serverKey(serverId);
+    await client.hset(key, "lastHeartbeat", String(Date.now()));
+    await client.expire(key, this._config.serverTtl);
+  }
+  async getServers() {
+    const client = this._ensureConnected();
+    const serverIds = await client.smembers(this._serversSetKey());
+    const servers = [];
+    for (const serverId of serverIds) {
+      const server = await this.getServer(serverId);
+      if (server && server.status === "online") {
+        servers.push(server);
+      }
+    }
+    return servers;
+  }
+  async getServer(serverId) {
+    const client = this._ensureConnected();
+    const key = this._serverKey(serverId);
+    const data = await client.hgetall(key);
+    if (!data || !data.serverId) return null;
+    return {
+      serverId: data.serverId,
+      address: data.address,
+      port: parseInt(data.port, 10),
+      roomCount: parseInt(data.roomCount, 10),
+      playerCount: parseInt(data.playerCount, 10),
+      capacity: parseInt(data.capacity, 10),
+      status: data.status,
+      lastHeartbeat: parseInt(data.lastHeartbeat, 10),
+      metadata: data.metadata ? JSON.parse(data.metadata) : {}
+    };
+  }
+  async updateServer(serverId, updates) {
+    const client = this._ensureConnected();
+    const key = this._serverKey(serverId);
+    const args = [];
+    if (updates.address !== void 0) args.push("address", updates.address);
+    if (updates.port !== void 0) args.push("port", String(updates.port));
+    if (updates.roomCount !== void 0) args.push("roomCount", String(updates.roomCount));
+    if (updates.playerCount !== void 0) args.push("playerCount", String(updates.playerCount));
+    if (updates.capacity !== void 0) args.push("capacity", String(updates.capacity));
+    if (updates.status !== void 0) args.push("status", updates.status);
+    if (updates.metadata !== void 0) args.push("metadata", JSON.stringify(updates.metadata));
+    if (args.length > 0) {
+      await client.hmset(key, ...args);
+    }
+    if (updates.status === "draining") {
+      await this.publish({
+        type: "server:draining",
+        serverId,
+        payload: {
+          serverId
+        },
+        timestamp: Date.now()
+      });
+    }
+  }
+  // =========================================================================
+  // 房间注册 | Room Registry
+  // =========================================================================
+  async registerRoom(room) {
+    const client = this._ensureConnected();
+    const key = this._roomKey(room.roomId);
+    await client.hmset(key, "roomId", room.roomId, "roomType", room.roomType, "serverId", room.serverId, "serverAddress", room.serverAddress, "playerCount", String(room.playerCount), "maxPlayers", String(room.maxPlayers), "isLocked", room.isLocked ? "1" : "0", "metadata", JSON.stringify(room.metadata), "createdAt", String(room.createdAt), "updatedAt", String(room.updatedAt));
+    if (this._config.roomTtl > 0) {
+      await client.expire(key, this._config.roomTtl);
+    }
+    await client.sadd(this._roomsSetKey(), room.roomId);
+    await client.sadd(this._serverRoomsKey(room.serverId), room.roomId);
+    const roomCount = (await client.smembers(this._serverRoomsKey(room.serverId))).length;
+    await client.hset(this._serverKey(room.serverId), "roomCount", String(roomCount));
+    await this.publish({
+      type: "room:created",
+      serverId: room.serverId,
+      roomId: room.roomId,
+      payload: {
+        roomType: room.roomType
+      },
+      timestamp: Date.now()
+    });
+  }
+  async unregisterRoom(roomId) {
+    const client = this._ensureConnected();
+    const room = await this.getRoom(roomId);
+    if (!room) return;
+    const key = this._roomKey(roomId);
+    await client.del(key);
+    await client.srem(this._roomsSetKey(), roomId);
+    await client.srem(this._serverRoomsKey(room.serverId), roomId);
+    const roomCount = (await client.smembers(this._serverRoomsKey(room.serverId))).length;
+    await client.hset(this._serverKey(room.serverId), "roomCount", String(roomCount));
+    await this.deleteSnapshot(roomId);
+    await this.publish({
+      type: "room:disposed",
+      serverId: room.serverId,
+      roomId,
+      payload: {},
+      timestamp: Date.now()
+    });
+  }
+  async updateRoom(roomId, updates) {
+    const client = this._ensureConnected();
+    const room = await this.getRoom(roomId);
+    if (!room) return;
+    const key = this._roomKey(roomId);
+    const args = [];
+    if (updates.playerCount !== void 0) args.push("playerCount", String(updates.playerCount));
+    if (updates.maxPlayers !== void 0) args.push("maxPlayers", String(updates.maxPlayers));
+    if (updates.isLocked !== void 0) args.push("isLocked", updates.isLocked ? "1" : "0");
+    if (updates.metadata !== void 0) args.push("metadata", JSON.stringify(updates.metadata));
+    args.push("updatedAt", String(Date.now()));
+    if (args.length > 0) {
+      await client.hmset(key, ...args);
+    }
+    await this.publish({
+      type: "room:updated",
+      serverId: room.serverId,
+      roomId,
+      payload: updates,
+      timestamp: Date.now()
+    });
+    if (updates.isLocked !== void 0) {
+      await this.publish({
+        type: updates.isLocked ? "room:locked" : "room:unlocked",
+        serverId: room.serverId,
+        roomId,
+        payload: {},
+        timestamp: Date.now()
+      });
+    }
+  }
+  async getRoom(roomId) {
+    const client = this._ensureConnected();
+    const key = this._roomKey(roomId);
+    const data = await client.hgetall(key);
+    if (!data || !data.roomId) return null;
+    return {
+      roomId: data.roomId,
+      roomType: data.roomType,
+      serverId: data.serverId,
+      serverAddress: data.serverAddress,
+      playerCount: parseInt(data.playerCount, 10),
+      maxPlayers: parseInt(data.maxPlayers, 10),
+      isLocked: data.isLocked === "1",
+      metadata: data.metadata ? JSON.parse(data.metadata) : {},
+      createdAt: parseInt(data.createdAt, 10),
+      updatedAt: parseInt(data.updatedAt, 10)
+    };
+  }
+  async queryRooms(query) {
+    const client = this._ensureConnected();
+    const roomIds = await client.smembers(this._roomsSetKey());
+    let results = [];
+    for (const roomId of roomIds) {
+      const room = await this.getRoom(roomId);
+      if (room) results.push(room);
+    }
+    if (query.roomType) {
+      results = results.filter((r) => r.roomType === query.roomType);
+    }
+    if (query.hasSpace) {
+      results = results.filter((r) => r.playerCount < r.maxPlayers);
+    }
+    if (query.notLocked) {
+      results = results.filter((r) => !r.isLocked);
+    }
+    if (query.metadata) {
+      results = results.filter((r) => {
+        for (const [key, value] of Object.entries(query.metadata)) {
+          if (r.metadata[key] !== value) return false;
+        }
+        return true;
+      });
+    }
+    if (query.offset) {
+      results = results.slice(query.offset);
+    }
+    if (query.limit) {
+      results = results.slice(0, query.limit);
+    }
+    return results;
+  }
+  async findAvailableRoom(roomType) {
+    const rooms = await this.queryRooms({
+      roomType,
+      hasSpace: true,
+      notLocked: true,
+      limit: 1
+    });
+    return rooms[0] ?? null;
+  }
+  async getRoomsByServer(serverId) {
+    const client = this._ensureConnected();
+    const roomIds = await client.smembers(this._serverRoomsKey(serverId));
+    const rooms = [];
+    for (const roomId of roomIds) {
+      const room = await this.getRoom(roomId);
+      if (room) rooms.push(room);
+    }
+    return rooms;
+  }
+  // =========================================================================
+  // 房间状态 | Room State
+  // =========================================================================
+  async saveSnapshot(snapshot) {
+    const client = this._ensureConnected();
+    const key = this._snapshotKey(snapshot.roomId);
+    await client.set(key, JSON.stringify(snapshot));
+    await client.expire(key, this._config.snapshotTtl);
+  }
+  async loadSnapshot(roomId) {
+    const client = this._ensureConnected();
+    const key = this._snapshotKey(roomId);
+    const data = await client.get(key);
+    return data ? JSON.parse(data) : null;
+  }
+  async deleteSnapshot(roomId) {
+    const client = this._ensureConnected();
+    const key = this._snapshotKey(roomId);
+    await client.del(key);
+  }
+  // =========================================================================
+  // 发布/订阅 | Pub/Sub
+  // =========================================================================
+  async publish(event) {
+    const client = this._ensureConnected();
+    await client.publish(this._config.channel, JSON.stringify(event));
+  }
+  async subscribe(pattern, handler) {
+    if (!this._handlers.has(pattern)) {
+      this._handlers.set(pattern, /* @__PURE__ */ new Set());
+    }
+    this._handlers.get(pattern).add(handler);
+    return () => {
+      const handlers = this._handlers.get(pattern);
+      if (handlers) {
+        handlers.delete(handler);
+        if (handlers.size === 0) {
+          this._handlers.delete(pattern);
+        }
+      }
+    };
+  }
+  async sendToRoom(roomId, messageType, data, playerId) {
+    const room = await this.getRoom(roomId);
+    if (!room) return;
+    await this.publish({
+      type: "room:message",
+      serverId: room.serverId,
+      roomId,
+      payload: {
+        messageType,
+        data,
+        playerId
+      },
+      timestamp: Date.now()
+    });
+  }
+  _dispatchEvent(event) {
+    const wildcardHandlers = this._handlers.get("*");
+    if (wildcardHandlers) {
+      for (const handler of wildcardHandlers) {
+        try {
+          handler(event);
+        } catch (error) {
+          console.error("[RedisAdapter] Event handler error:", error);
+        }
+      }
+    }
+    const typeHandlers = this._handlers.get(event.type);
+    if (typeHandlers) {
+      for (const handler of typeHandlers) {
+        try {
+          handler(event);
+        } catch (error) {
+          console.error("[RedisAdapter] Event handler error:", error);
+        }
+      }
+    }
+  }
+  // =========================================================================
+  // 分布式锁 | Distributed Lock
+  // =========================================================================
+  async acquireLock(key, ttlMs) {
+    const client = this._ensureConnected();
+    const lockKey = this._lockKey(key);
+    const token = `${Date.now()}_${Math.random().toString(36).substring(2)}`;
+    const ttlSeconds = Math.ceil(ttlMs / 1e3);
+    const result = await client.set(lockKey, token, "NX", "EX", ttlSeconds);
+    if (result === "OK") {
+      this._lockTokens.set(key, token);
+      return true;
+    }
+    return false;
+  }
+  async releaseLock(key) {
+    const client = this._ensureConnected();
+    const lockKey = this._lockKey(key);
+    const token = this._lockTokens.get(key);
+    if (!token) return;
+    await client.eval(RELEASE_LOCK_SCRIPT, 1, lockKey, token);
+    this._lockTokens.delete(key);
+  }
+  async extendLock(key, ttlMs) {
+    const client = this._ensureConnected();
+    const lockKey = this._lockKey(key);
+    const token = this._lockTokens.get(key);
+    if (!token) return false;
+    const result = await client.eval(EXTEND_LOCK_SCRIPT, 1, lockKey, token, String(ttlMs));
+    return result === 1;
+  }
+};
+__name(_RedisAdapter, "RedisAdapter");
+var RedisAdapter = _RedisAdapter;
+function createRedisAdapter(config) {
+  return new RedisAdapter(config);
+}
+__name(createRedisAdapter, "createRedisAdapter");
+
+// src/distributed/routing/LoadBalancedRouter.ts
+var _LoadBalancedRouter = class _LoadBalancedRouter {
+  constructor(config = {}) {
+    __publicField(this, "_config");
+    __publicField(this, "_roundRobinIndex", 0);
+    this._config = {
+      strategy: config.strategy ?? "least-rooms",
+      preferLocal: config.preferLocal ?? true,
+      localPreferenceThreshold: config.localPreferenceThreshold ?? 0.8
+    };
+  }
+  /**
+   * @zh 选择最优服务器
+   * @en Select optimal server
+   *
+   * @param servers - 可用服务器列表 | Available servers
+   * @param localServerId - 本地服务器 ID | Local server ID
+   * @returns 最优服务器，如果没有可用服务器返回 null | Optimal server, or null if none available
+   */
+  selectServer(servers, localServerId) {
+    const availableServers = servers.filter((s2) => s2.status === "online" && s2.roomCount < s2.capacity);
+    if (availableServers.length === 0) {
+      return null;
+    }
+    if (this._config.preferLocal && localServerId) {
+      const localServer = availableServers.find((s2) => s2.serverId === localServerId);
+      if (localServer) {
+        const loadRatio = localServer.roomCount / localServer.capacity;
+        if (loadRatio < this._config.localPreferenceThreshold) {
+          return localServer;
+        }
+      }
+    }
+    switch (this._config.strategy) {
+      case "round-robin":
+        return this._selectRoundRobin(availableServers);
+      case "least-rooms":
+        return this._selectLeastRooms(availableServers);
+      case "least-players":
+        return this._selectLeastPlayers(availableServers);
+      case "random":
+        return this._selectRandom(availableServers);
+      case "weighted":
+        return this._selectWeighted(availableServers);
+      default:
+        return this._selectLeastRooms(availableServers);
+    }
+  }
+  /**
+   * @zh 选择创建房间的最优服务器
+   * @en Select optimal server for room creation
+   */
+  selectServerForCreation(servers, localServerId) {
+    return this.selectServer(servers, localServerId);
+  }
+  /**
+   * @zh 重置轮询索引
+   * @en Reset round-robin index
+   */
+  resetRoundRobin() {
+    this._roundRobinIndex = 0;
+  }
+  // =========================================================================
+  // 私有方法 | Private Methods
+  // =========================================================================
+  _selectRoundRobin(servers) {
+    const server = servers[this._roundRobinIndex % servers.length];
+    this._roundRobinIndex++;
+    return server;
+  }
+  _selectLeastRooms(servers) {
+    return servers.reduce((best, current) => current.roomCount < best.roomCount ? current : best);
+  }
+  _selectLeastPlayers(servers) {
+    return servers.reduce((best, current) => current.playerCount < best.playerCount ? current : best);
+  }
+  _selectRandom(servers) {
+    return servers[Math.floor(Math.random() * servers.length)];
+  }
+  _selectWeighted(servers) {
+    const weights = servers.map((s2) => ({
+      server: s2,
+      weight: (s2.capacity - s2.roomCount) / s2.capacity
+    }));
+    const totalWeight = weights.reduce((sum, w) => sum + w.weight, 0);
+    let random = Math.random() * totalWeight;
+    for (const { server, weight } of weights) {
+      random -= weight;
+      if (random <= 0) {
+        return server;
+      }
+    }
+    return servers[0];
+  }
+};
+__name(_LoadBalancedRouter, "LoadBalancedRouter");
+var LoadBalancedRouter = _LoadBalancedRouter;
+function createLoadBalancedRouter(config) {
+  return new LoadBalancedRouter(config);
+}
+__name(createLoadBalancedRouter, "createLoadBalancedRouter");
+
+export { AnyValidator, ArrayValidator, BooleanValidator, EnumValidator, LiteralValidator, LoadBalancedRouter, NumberValidator, ObjectValidator, RecordValidator, RedisAdapter, StringValidator, TupleValidator, UnionValidator, any, array, boolean, createGuard, createLoadBalancedRouter, createRedisAdapter, defineApi, defineApiWithSchema, defineHttp, defineMsg, defineMsgWithSchema, literal, nativeEnum, number, object, parse, record, s, safeParse, string, tuple, union };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map