@kokimoki/app 2.1.1 → 3.0.0

package/dist/kokimoki.min.js

@@ -1,3 +1,5 @@
+import i18next from 'i18next';
+import HttpBackend from 'i18next-http-backend';
 import require$$1 from 'path';
 import require$$2 from 'fs';
 import { useMemo, useRef, useSyncExternalStore, useCallback, useLayoutEffect, useEffect, useDebugValue } from 'react';
@@ -493,6 +495,12 @@ var EventEmitter$1 = /*@__PURE__*/getDefaultExportFromCjs(eventsExports);
  * @module map
  */
 
+/**
+ * @template K
+ * @template V
+ * @typedef {Map<K,V>} GlobalMap
+ */
+
 /**
  * Creates a new Map instance.
  *
@@ -628,6 +636,58 @@ const appendTo = (dest, src) => {
  */
 const from = Array.from;
 
+/**
+ * True iff condition holds on every element in the Array.
+ *
+ * @function
+ * @template {ArrayLike<any>} ARR
+ *
+ * @param {ARR} arr
+ * @param {ARR extends ArrayLike<infer S> ? ((value:S, index:number, arr:ARR) => boolean) : any} f
+ * @return {boolean}
+ */
+const every$1 = (arr, f) => {
+  for (let i = 0; i < arr.length; i++) {
+    if (!f(arr[i], i, arr)) {
+      return false
+    }
+  }
+  return true
+};
+
+/**
+ * True iff condition holds on some element in the Array.
+ *
+ * @function
+ * @template {ArrayLike<any>} ARR
+ *
+ * @param {ARR} arr
+ * @param {ARR extends ArrayLike<infer S> ? ((value:S, index:number, arr:ARR) => boolean) : never} f
+ * @return {boolean}
+ */
+const some = (arr, f) => {
+  for (let i = 0; i < arr.length; i++) {
+    if (f(arr[i], i, arr)) {
+      return true
+    }
+  }
+  return false
+};
+
+/**
+ * @template T
+ * @param {number} len
+ * @param {function(number, Array<T>):T} f
+ * @return {Array<T>}
+ */
+const unfold = (len, f) => {
+  const array = new Array(len);
+  for (let i = 0; i < len; i++) {
+    array[i] = f(i, array);
+  }
+  return array
+};
+
 const isArray$1 = Array.isArray;
 
 /**
@@ -743,8 +803,10 @@ const min$2 = (a, b) => a < b ? a : b;
 const max$3 = (a, b) => a > b ? a : b;
 
 /**
+ * Check whether n is negative, while considering the -0 edge case. While `-0 < 0` is false, this
+ * function returns true for -0,-1,,.. and returns false for 0,1,2,...
  * @param {number} n
- * @return {boolean} Wether n is negative. This function also differentiates between -0 and +0
+ * @return {boolean} Wether n is negative. This function also distinguishes between -0 and +0
  */
 const isNegativeZero = n => n !== 0 ? n < 0 : 1 / n < 0;
 
@@ -784,10 +846,19 @@ const BITS31 = 0x7FFFFFFF;
 
 
 const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
+const MIN_SAFE_INTEGER = Number.MIN_SAFE_INTEGER;
 
 /* c8 ignore next */
 const isInteger = Number.isInteger || (num => typeof num === 'number' && isFinite(num) && floor$2(num) === num);
 
+/**
+ * Utility module to work with strings.
+ *
+ * @module string
+ */
+
+const fromCharCode = String.fromCharCode;
+
 /**
  * @param {string} s
  * @return {string}
@@ -813,7 +884,7 @@ const fromCamelCase = (s, separator) => trimLeft(s.replace(fromCamelCaseRegex, m
 
 /**
  * @param {string} str
- * @return {Uint8Array}
+ * @return {Uint8Array<ArrayBuffer>}
  */
 const _encodeUtf8Polyfill = str => {
   const encodedString = unescape(encodeURIComponent(str));
@@ -830,7 +901,7 @@ const utf8TextEncoder = /** @type {TextEncoder} */ (typeof TextEncoder !== 'unde
 
 /**
  * @param {string} str
- * @return {Uint8Array}
+ * @return {Uint8Array<ArrayBuffer>}
  */
 const _encodeUtf8Native = str => utf8TextEncoder.encode(str);
 
@@ -855,6 +926,12 @@ if (utf8TextDecoder && utf8TextDecoder.decode(new Uint8Array()).length === 1) {
   utf8TextDecoder = null;
 }
 
+/**
+ * @param {string} source
+ * @param {number} n
+ */
+const repeat = (source, n) => unfold(n, () => source).join('');
+
 /**
  * Efficient schema-less binary encoding with support for variable length encoding.
  *
@@ -924,7 +1001,7 @@ const length = encoder => {
  *
  * @function
  * @param {Encoder} encoder
- * @return {Uint8Array} The created ArrayBuffer.
+ * @return {Uint8Array<ArrayBuffer>} The created ArrayBuffer.
  */
 const toUint8Array = encoder => {
   const uint8arr = new Uint8Array(length(encoder));
@@ -1165,6 +1242,14 @@ const isFloat32 = num => {
   return floatTestBed.getFloat32(0) === num
 };
 
+/**
+ * @typedef {Array<AnyEncodable>} AnyEncodableArray
+ */
+
+/**
+ * @typedef {undefined|null|number|bigint|boolean|string|{[k:string]:AnyEncodable}|AnyEncodableArray|Uint8Array} AnyEncodable
+ */
+
 /**
  * Encode data with efficient binary format.
  *
@@ -1200,7 +1285,7 @@ const isFloat32 = num => {
  *          lib0/encoding.js
  *
  * @param {Encoder} encoder
- * @param {undefined|null|number|bigint|boolean|string|Object<string,any>|Array<any>|Uint8Array} data
+ * @param {AnyEncodable} data
  */
 const writeAny = (encoder, data) => {
   switch (typeof data) {
@@ -1554,16 +1639,17 @@ const errorIntegerOutOfRange = create$3('Integer out of Range');
 
 /**
  * A Decoder handles the decoding of an Uint8Array.
+ * @template {ArrayBufferLike} [Buf=ArrayBufferLike]
  */
 class Decoder {
   /**
-   * @param {Uint8Array} uint8Array Binary data to decode
+   * @param {Uint8Array<Buf>} uint8Array Binary data to decode
    */
   constructor (uint8Array) {
     /**
      * Decoding target.
      *
-     * @type {Uint8Array}
+     * @type {Uint8Array<Buf>}
      */
     this.arr = uint8Array;
     /**
@@ -1577,8 +1663,9 @@ class Decoder {
 
 /**
  * @function
- * @param {Uint8Array} uint8Array
- * @return {Decoder}
+ * @template {ArrayBufferLike} Buf
+ * @param {Uint8Array<Buf>} uint8Array
+ * @return {Decoder<Buf>}
  */
 const createDecoder = uint8Array => new Decoder(uint8Array);
 
@@ -1596,9 +1683,10 @@ const hasContent = decoder => decoder.pos !== decoder.arr.length;
  *            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.
  *
  * @function
- * @param {Decoder} decoder The decoder instance
+ * @template {ArrayBufferLike} Buf
+ * @param {Decoder<Buf>} decoder The decoder instance
  * @param {number} len The length of bytes to read
- * @return {Uint8Array}
+ * @return {Uint8Array<Buf>}
  */
 const readUint8Array = (decoder, len) => {
   const view = new Uint8Array(decoder.arr.buffer, decoder.pos + decoder.arr.byteOffset, len);
@@ -1613,8 +1701,9 @@ const readUint8Array = (decoder, len) => {
  *            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.
  *
  * @function
- * @param {Decoder} decoder
- * @return {Uint8Array}
+ * @template {ArrayBufferLike} Buf
+ * @param {Decoder<Buf>} decoder
+ * @return {Uint8Array<Buf>}
  */
 const readVarUint8Array = decoder => readUint8Array(decoder, readVarUint(decoder));
 
@@ -2070,12 +2159,38 @@ try {
 /* c8 ignore next */
 const varStorage = _localStorage;
 
+const EqualityTraitSymbol = Symbol('Equality');
+
 /**
- * Utility functions for working with EcmaScript objects.
+ * @typedef {{ [EqualityTraitSymbol]:(other:EqualityTrait)=>boolean }} EqualityTrait
+ */
+
+/**
+ *
+ * Utility function to compare any two objects.
  *
- * @module object
+ * Note that it is expected that the first parameter is more specific than the latter one.
+ *
+ * @example js
+ *     class X { [traits.EqualityTraitSymbol] (other) { return other === this }  }
+ *     class X2 { [traits.EqualityTraitSymbol] (other) { return other === this }, x2 () { return 2 }  }
+ *     // this is fine
+ *     traits.equals(new X2(), new X())
+ *     // this is not, because the left type is less specific than the right one
+ *     traits.equals(new X(), new X2())
+ *
+ * @template {EqualityTrait} T
+ * @param {NoInfer<T>} a
+ * @param {T} b
+ * @return {boolean}
  */
+const equals = (a, b) => a === b || !!a?.[EqualityTraitSymbol]?.(b) || false;
 
+/**
+ * @param {any} o
+ * @return {o is { [k:string]:any }}
+ */
+const isObject$2 = o => typeof o === 'object';
 
 /**
  * Object.assign
@@ -2144,7 +2259,7 @@ const hasProperty = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key)
  * @param {Object<string,any>} b
  * @return {boolean}
  */
-const equalFlat = (a, b) => a === b || (size(a) === size(b) && every(a, (val, key) => (val !== undefined || hasProperty(b, key)) && b[key] === val));
+const equalFlat = (a, b) => a === b || (size(a) === size(b) && every(a, (val, key) => (val !== undefined || hasProperty(b, key)) && equals(b[key], val)));
 
 /**
  * Make an object immutable. This hurts performance and is usually not needed if you perform good
@@ -2203,6 +2318,88 @@ const callAll = (fs, args, i = 0) => {
  */
 const id = a => a;
 
+/* c8 ignore start */
+
+/**
+ * @param {any} a
+ * @param {any} b
+ * @return {boolean}
+ */
+const equalityDeep = (a, b) => {
+  if (a === b) {
+    return true
+  }
+  if (a == null || b == null || (a.constructor !== b.constructor && (a.constructor || Object) !== (b.constructor || Object))) {
+    return false
+  }
+  if (a[EqualityTraitSymbol] != null) {
+    return a[EqualityTraitSymbol](b)
+  }
+  switch (a.constructor) {
+    case ArrayBuffer:
+      a = new Uint8Array(a);
+      b = new Uint8Array(b);
+    // eslint-disable-next-line no-fallthrough
+    case Uint8Array: {
+      if (a.byteLength !== b.byteLength) {
+        return false
+      }
+      for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i]) {
+          return false
+        }
+      }
+      break
+    }
+    case Set: {
+      if (a.size !== b.size) {
+        return false
+      }
+      for (const value of a) {
+        if (!b.has(value)) {
+          return false
+        }
+      }
+      break
+    }
+    case Map: {
+      if (a.size !== b.size) {
+        return false
+      }
+      for (const key of a.keys()) {
+        if (!b.has(key) || !equalityDeep(a.get(key), b.get(key))) {
+          return false
+        }
+      }
+      break
+    }
+    case undefined:
+    case Object:
+      if (size(a) !== size(b)) {
+        return false
+      }
+      for (const key in a) {
+        if (!hasProperty(a, key) || !equalityDeep(a[key], b[key])) {
+          return false
+        }
+      }
+      break
+    case Array:
+      if (a.length !== b.length) {
+        return false
+      }
+      for (let i = 0; i < a.length; i++) {
+        if (!equalityDeep(a[i], b[i])) {
+          return false
+        }
+      }
+      break
+    default:
+      return false
+  }
+  return true
+};
+
 /**
  * @template V
  * @template {V} OPTS
@@ -2297,94 +2494,1308 @@ const hasConf = (name) =>
   hasParam('--' + name) || getVariable(name) !== null;
 
 /* c8 ignore next */
-hasConf('production');
+const production = hasConf('production');
 
 /* c8 ignore next 2 */
 const forceColor = isNode &&
   isOneOf(process.env.FORCE_COLOR, ['true', '1', '2']);
 
-/* c8 ignore start */
+/* c8 ignore start */
+/**
+ * Color is enabled by default if the terminal supports it.
+ *
+ * Explicitly enable color using `--color` parameter
+ * Disable color using `--no-color` parameter or using `NO_COLOR=1` environment variable.
+ * `FORCE_COLOR=1` enables color and takes precedence over all.
+ */
+const supportsColor = forceColor || (
+  !hasParam('--no-colors') && // @todo deprecate --no-colors
+  !hasConf('no-color') &&
+  (!isNode || process.stdout.isTTY) && (
+    !isNode ||
+    hasParam('--color') ||
+    getVariable('COLORTERM') !== null ||
+    (getVariable('TERM') || '').includes('color')
+  )
+);
+/* c8 ignore stop */
+
+/**
+ * Utility functions to work with buffers (Uint8Array).
+ *
+ * @module buffer
+ */
+
+
+/**
+ * @param {number} len
+ */
+const createUint8ArrayFromLen = len => new Uint8Array(len);
+
+/**
+ * Copy the content of an Uint8Array view to a new ArrayBuffer.
+ *
+ * @param {Uint8Array} uint8Array
+ * @return {Uint8Array}
+ */
+const copyUint8Array = uint8Array => {
+  const newBuf = createUint8ArrayFromLen(uint8Array.byteLength);
+  newBuf.set(uint8Array);
+  return newBuf
+};
+
+/**
+ * Working with value pairs.
+ *
+ * @module pair
+ */
+
+/**
+ * @template L,R
+ */
+class Pair {
+  /**
+   * @param {L} left
+   * @param {R} right
+   */
+  constructor (left, right) {
+    this.left = left;
+    this.right = right;
+  }
+}
+
+/**
+ * @template L,R
+ * @param {L} left
+ * @param {R} right
+ * @return {Pair<L,R>}
+ */
+const create$1 = (left, right) => new Pair(left, right);
+
+/**
+ * Fast Pseudo Random Number Generators.
+ *
+ * Given a seed a PRNG generates a sequence of numbers that cannot be reasonably predicted.
+ * Two PRNGs must generate the same random sequence of numbers if  given the same seed.
+ *
+ * @module prng
+ */
+
+
+/**
+ * Generates a single random bool.
+ *
+ * @param {PRNG} gen A random number generator.
+ * @return {Boolean} A random boolean
+ */
+const bool = gen => (gen.next() >= 0.5);
+
+/**
+ * Generates a random integer with 53 bit resolution.
+ *
+ * @param {PRNG} gen A random number generator.
+ * @param {Number} min The lower bound of the allowed return values (inclusive).
+ * @param {Number} max The upper bound of the allowed return values (inclusive).
+ * @return {Number} A random integer on [min, max]
+ */
+const int53 = (gen, min, max) => floor$2(gen.next() * (max + 1 - min) + min);
+
+/**
+ * Generates a random integer with 32 bit resolution.
+ *
+ * @param {PRNG} gen A random number generator.
+ * @param {Number} min The lower bound of the allowed return values (inclusive).
+ * @param {Number} max The upper bound of the allowed return values (inclusive).
+ * @return {Number} A random integer on [min, max]
+ */
+const int32 = (gen, min, max) => floor$2(gen.next() * (max + 1 - min) + min);
+
+/**
+ * @deprecated
+ * Optimized version of prng.int32. It has the same precision as prng.int32, but should be preferred when
+ * openaring on smaller ranges.
+ *
+ * @param {PRNG} gen A random number generator.
+ * @param {Number} min The lower bound of the allowed return values (inclusive).
+ * @param {Number} max The upper bound of the allowed return values (inclusive). The max inclusive number is `binary.BITS31-1`
+ * @return {Number} A random integer on [min, max]
+ */
+const int31 = (gen, min, max) => int32(gen, min, max);
+
+/**
+ * @param {PRNG} gen
+ * @return {string} A single letter (a-z)
+ */
+const letter = gen => fromCharCode(int31(gen, 97, 122));
+
+/**
+ * @param {PRNG} gen
+ * @param {number} [minLen=0]
+ * @param {number} [maxLen=20]
+ * @return {string} A random word (0-20 characters) without spaces consisting of letters (a-z)
+ */
+const word = (gen, minLen = 0, maxLen = 20) => {
+  const len = int31(gen, minLen, maxLen);
+  let str = '';
+  for (let i = 0; i < len; i++) {
+    str += letter(gen);
+  }
+  return str
+};
+
+/**
+ * Returns one element of a given array.
+ *
+ * @param {PRNG} gen A random number generator.
+ * @param {Array<T>} array Non empty Array of possible values.
+ * @return {T} One of the values of the supplied Array.
+ * @template T
+ */
+const oneOf = (gen, array) => array[int31(gen, 0, array.length - 1)];
+/* c8 ignore stop */
+
+/**
+ * @experimental WIP
+ *
+ * Simple & efficient schemas for your data.
+ */
+
+
+/**
+ * @typedef {string|number|bigint|boolean|null|undefined|symbol} Primitive
+ */
+
+/**
+ * @typedef {{ [k:string|number|symbol]: any }} AnyObject
+ */
+
+/**
+ * @template T
+ * @typedef {T extends Schema<infer X> ? X : T} Unwrap
+ */
+
+/**
+ * @template T
+ * @typedef {T extends Schema<infer X> ? X : T} TypeOf
+ */
+
+/**
+ * @template {readonly unknown[]} T
+ * @typedef {T extends readonly [Schema<infer First>, ...infer Rest] ? [First, ...UnwrapArray<Rest>] : [] } UnwrapArray
+ */
+
+/**
+ * @template T
+ * @typedef {T extends Schema<infer S> ? Schema<S> : never} CastToSchema
+ */
+
+/**
+ * @template {unknown[]} Arr
+ * @typedef {Arr extends [...unknown[], infer L] ? L : never} TupleLast
+ */
+
+/**
+ * @template {unknown[]} Arr
+ * @typedef {Arr extends [...infer Fs, unknown] ? Fs : never} TuplePop
+ */
+
+/**
+ * @template {readonly unknown[]} T
+ * @typedef {T extends []
+ *   ? {}
+ *   : T extends [infer First]
+ *   ? First
+ *   : T extends [infer First, ...infer Rest]
+ *   ? First & Intersect<Rest>
+ *   : never
+ * } Intersect
+ */
+
+const schemaSymbol = Symbol('0schema');
+
+class ValidationError {
+  constructor () {
+    /**
+     * Reverse errors
+     * @type {Array<{ path: string?, expected: string, has: string, message: string? }>}
+     */
+    this._rerrs = [];
+  }
+
+  /**
+   * @param {string?} path
+   * @param {string} expected
+   * @param {string} has
+   * @param {string?} message
+   */
+  extend (path, expected, has, message = null) {
+    this._rerrs.push({ path, expected, has, message });
+  }
+
+  toString () {
+    const s = [];
+    for (let i = this._rerrs.length - 1; i > 0; i--) {
+      const r = this._rerrs[i];
+      /* c8 ignore next */
+      s.push(repeat(' ', (this._rerrs.length - i) * 2) + `${r.path != null ? `[${r.path}] ` : ''}${r.has} doesn't match ${r.expected}. ${r.message}`);
+    }
+    return s.join('\n')
+  }
+}
+
+/**
+ * @param {any} a
+ * @param {any} b
+ * @return {boolean}
+ */
+const shapeExtends = (a, b) => {
+  if (a === b) return true
+  if (a == null || b == null || a.constructor !== b.constructor) return false
+  if (a[EqualityTraitSymbol]) return equals(a, b) // last resort: check equality (do this before array and obj check which don't implement the equality trait)
+  if (isArray$1(a)) {
+    return every$1(a, aitem =>
+      some(b, bitem => shapeExtends(aitem, bitem))
+    )
+  } else if (isObject$2(a)) {
+    return every(a, (aitem, akey) =>
+      shapeExtends(aitem, b[akey])
+    )
+  }
+  /* c8 ignore next */
+  return false
+};
+
+/**
+ * @template T
+ * @implements {equalityTraits.EqualityTrait}
+ */
+class Schema {
+  // this.shape must not be defined on Schema. Otherwise typecheck on metatypes (e.g. $$object) won't work as expected anymore
+  /**
+   * If true, the more things are added to the shape the more objects this schema will accept (e.g.
+   * union). By default, the more objects are added, the the fewer objects this schema will accept.
+   * @protected
+   */
+  static _dilutes = false
+
+  /**
+   * @param {Schema<any>} other
+   */
+  extends (other) {
+    let [a, b] = [/** @type {any} */(this).shape, /** @type {any} */ (other).shape];
+    if (/** @type {typeof Schema<any>} */ (this.constructor)._dilutes) [b, a] = [a, b];
+    return shapeExtends(a, b)
+  }
+
+  /**
+   * Overwrite this when necessary. By default, we only check the `shape` property which every shape
+   * should have.
+   * @param {Schema<any>} other
+   */
+  equals (other) {
+    // @ts-ignore
+    return this.constructor === other.constructor && equalityDeep(this.shape, other.shape)
+  }
+
+  [schemaSymbol] () { return true }
+
+  /**
+   * @param {object} other
+   */
+  [EqualityTraitSymbol] (other) {
+    return this.equals(/** @type {any} */ (other))
+  }
+
+  /**
+   * Use `schema.validate(obj)` with a typed parameter that is already of typed to be an instance of
+   * Schema. Validate will check the structure of the parameter and return true iff the instance
+   * really is an instance of Schema.
+   *
+   * @param {T} o
+   * @return {boolean}
+   */
+  validate (o) {
+    return this.check(o)
+  }
+
+  /* c8 ignore start */
+  /**
+   * Similar to validate, but this method accepts untyped parameters.
+   *
+   * @param {any} _o
+   * @param {ValidationError} [_err]
+   * @return {_o is T}
+   */
+  check (_o, _err) {
+    methodUnimplemented();
+  }
+  /* c8 ignore stop */
+
+  /**
+   * @type {Schema<T?>}
+   */
+  get nullable () {
+    // @ts-ignore
+    return $union(this, $null)
+  }
+
+  /**
+   * @type {$Optional<Schema<T>>}
+   */
+  get optional () {
+    return new $Optional(/** @type {Schema<T>} */ (this))
+  }
+
+  /**
+   * Cast a variable to a specific type. Returns the casted value, or throws an exception otherwise.
+   * Use this if you know that the type is of a specific type and you just want to convince the type
+   * system.
+   *
+   * **Do not rely on these error messages!**
+   * Performs an assertion check only if not in a production environment.
+   *
+   * @template OO
+   * @param {OO} o
+   * @return {Extract<OO, T> extends never ? T : (OO extends Array<never> ? T : Extract<OO,T>)}
+   */
+  cast (o) {
+    assert(o, this);
+    return /** @type {any} */ (o)
+  }
+
+  /**
+   * EXPECTO PATRONUM!! 🪄
+   * This function protects against type errors. Though it may not work in the real world.
+   *
+   * "After all this time?"
+   * "Always." - Snape, talking about type safety
+   *
+   * Ensures that a variable is a a specific type. Returns the value, or throws an exception if the assertion check failed.
+   * Use this if you know that the type is of a specific type and you just want to convince the type
+   * system.
+   *
+   * Can be useful when defining lambdas: `s.lambda(s.$number, s.$void).expect((n) => n + 1)`
+   *
+   * **Do not rely on these error messages!**
+   * Performs an assertion check if not in a production environment.
+   *
+   * @param {T} o
+   * @return {o extends T ? T : never}
+   */
+  expect (o) {
+    assert(o, this);
+    return o
+  }
+}
+
+/**
+ * @template {(new (...args:any[]) => any) | ((...args:any[]) => any)} Constr
+ * @typedef {Constr extends ((...args:any[]) => infer T) ? T : (Constr extends (new (...args:any[]) => any) ? InstanceType<Constr> : never)} Instance
+ */
+
+/**
+ * @template {(new (...args:any[]) => any) | ((...args:any[]) => any)} C
+ * @extends {Schema<Instance<C>>}
+ */
+class $ConstructedBy extends Schema {
+  /**
+   * @param {C} c
+   * @param {((o:Instance<C>)=>boolean)|null} check
+   */
+  constructor (c, check) {
+    super();
+    this.shape = c;
+    this._c = check;
+  }
+
+  /**
+   * @param {any} o
+   * @param {ValidationError} [err]
+   * @return {o is C extends ((...args:any[]) => infer T) ? T : (C extends (new (...args:any[]) => any) ? InstanceType<C> : never)} o
+   */
+  check (o, err = undefined) {
+    const c = o?.constructor === this.shape && (this._c == null || this._c(o));
+    /* c8 ignore next */
+    !c && err?.extend(null, this.shape.name, o?.constructor.name, o?.constructor !== this.shape ? 'Constructor match failed' : 'Check failed');
+    return c
+  }
+}
+
+/**
+ * @template {(new (...args:any[]) => any) | ((...args:any[]) => any)} C
+ * @param {C} c
+ * @param {((o:Instance<C>) => boolean)|null} check
+ * @return {CastToSchema<$ConstructedBy<C>>}
+ */
+const $constructedBy = (c, check = null) => new $ConstructedBy(c, check);
+$constructedBy($ConstructedBy);
+
+/**
+ * Check custom properties on any object. You may want to overwrite the generated Schema<any>.
+ *
+ * @extends {Schema<any>}
+ */
+class $Custom extends Schema {
+  /**
+   * @param {(o:any) => boolean} check
+   */
+  constructor (check) {
+    super();
+    /**
+     * @type {(o:any) => boolean}
+     */
+    this.shape = check;
+  }
+
+  /**
+   * @param {any} o
+   * @param {ValidationError} err
+   * @return {o is any}
+   */
+  check (o, err) {
+    const c = this.shape(o);
+    /* c8 ignore next */
+    !c && err?.extend(null, 'custom prop', o?.constructor.name, 'failed to check custom prop');
+    return c
+  }
+}
+
+/**
+ * @param {(o:any) => boolean} check
+ * @return {Schema<any>}
+ */
+const $custom = (check) => new $Custom(check);
+$constructedBy($Custom);
+
+/**
+ * @template {Primitive} T
+ * @extends {Schema<T>}
+ */
+class $Literal extends Schema {
+  /**
+   * @param {Array<T>} literals
+   */
+  constructor (literals) {
+    super();
+    this.shape = literals;
+  }
+
+  /**
+   *
+   * @param {any} o
+   * @param {ValidationError} [err]
+   * @return {o is T}
+   */
+  check (o, err) {
+    const c = this.shape.some(a => a === o);
+    /* c8 ignore next */
+    !c && err?.extend(null, this.shape.join(' | '), o.toString());
+    return c
+  }
+}
+
+/**
+ * @template {Primitive[]} T
+ * @param {T} literals
+ * @return {CastToSchema<$Literal<T[number]>>}
+ */
+const $literal = (...literals) => new $Literal(literals);
+const $$literal = $constructedBy($Literal);
+
+/**
+ * @template {Array<string|Schema<string|number>>} Ts
+ * @typedef {Ts extends [] ? `` : (Ts extends [infer T] ? (Unwrap<T> extends (string|number) ? Unwrap<T> : never) : (Ts extends [infer T1, ...infer Rest] ? `${Unwrap<T1> extends (string|number) ? Unwrap<T1> : never}${Rest extends Array<string|Schema<string|number>> ? CastStringTemplateArgsToTemplate<Rest> : never}` : never))} CastStringTemplateArgsToTemplate
+ */
+
+/**
+ * @param {string} str
+ * @return {string}
+ */
+const _regexEscape = /** @type {any} */ (RegExp).escape || /** @type {(str:string) => string} */ (str =>
+  str.replace(/[().|&,$^[\]]/g, s => '\\' + s)
+);
+
+/**
+ * @param {string|Schema<any>} s
+ * @return {string[]}
+ */
+const _schemaStringTemplateToRegex = s => {
+  if ($string.check(s)) {
+    return [_regexEscape(s)]
+  }
+  if ($$literal.check(s)) {
+    return /** @type {Array<string|number>} */ (s.shape).map(v => v + '')
+  }
+  if ($$number.check(s)) {
+    return ['[+-]?\\d+.?\\d*']
+  }
+  if ($$string.check(s)) {
+    return ['.*']
+  }
+  if ($$union.check(s)) {
+    return s.shape.map(_schemaStringTemplateToRegex).flat(1)
+  }
+  /* c8 ignore next 2 */
+  // unexpected schema structure (only supports unions and string in literal types)
+  unexpectedCase();
+};
+
+/**
+ * @template {Array<string|Schema<string|number>>} T
+ * @extends {Schema<CastStringTemplateArgsToTemplate<T>>}
+ */
+class $StringTemplate extends Schema {
+  /**
+   * @param {T} shape
+   */
+  constructor (shape) {
+    super();
+    this.shape = shape;
+    this._r = new RegExp('^' + shape.map(_schemaStringTemplateToRegex).map(opts => `(${opts.join('|')})`).join('') + '$');
+  }
+
+  /**
+   * @param {any} o
+   * @param {ValidationError} [err]
+   * @return {o is CastStringTemplateArgsToTemplate<T>}
+   */
+  check (o, err) {
+    const c = this._r.exec(o) != null;
+    /* c8 ignore next */
+    !c && err?.extend(null, this._r.toString(), o.toString(), 'String doesn\'t match string template.');
+    return c
+  }
+}
+$constructedBy($StringTemplate);
+
+const isOptionalSymbol = Symbol('optional');
+/**
+ * @template {Schema<any>} S
+ * @extends Schema<Unwrap<S>|undefined>
+ */
+class $Optional extends Schema {
+  /**
+   * @param {S} shape
+   */
+  constructor (shape) {
+    super();
+    this.shape = shape;
+  }
+
+  /**
+   * @param {any} o
+   * @param {ValidationError} [err]
+   * @return {o is (Unwrap<S>|undefined)}
+   */
+  check (o, err) {
+    const c = o === undefined || this.shape.check(o);
+    /* c8 ignore next */
+    !c && err?.extend(null, 'undefined (optional)', '()');
+    return c
+  }
+
+  get [isOptionalSymbol] () { return true }
+}
+const $$optional = $constructedBy($Optional);
+
+/**
+ * @extends Schema<never>
+ */
+class $Never extends Schema {
+  /**
+   * @param {any} _o
+   * @param {ValidationError} [err]
+   * @return {_o is never}
+   */
+  check (_o, err) {
+    /* c8 ignore next */
+    err?.extend(null, 'never', typeof _o);
+    return false
+  }
+}
+$constructedBy($Never);
+
+/**
+ * @template {{ [key: string|symbol|number]: Schema<any> }} S
+ * @typedef {{ [Key in keyof S as S[Key] extends $Optional<Schema<any>> ? Key : never]?: S[Key] extends $Optional<Schema<infer Type>> ? Type : never } & { [Key in keyof S as S[Key] extends $Optional<Schema<any>> ? never : Key]: S[Key] extends Schema<infer Type> ? Type : never }} $ObjectToType
+ */
+
+/**
+ * @template {{[key:string|symbol|number]: Schema<any>}} S
+ * @extends {Schema<$ObjectToType<S>>}
+ */
+let $Object$3 = class $Object extends Schema {
+  /**
+   * @param {S} shape
+   * @param {boolean} partial
+   */
+  constructor (shape, partial = false) {
+    super();
+    /**
+     * @type {S}
+     */
+    this.shape = shape;
+    this._isPartial = partial;
+  }
+
+  static _dilutes = true
+
+  /**
+   * @type {Schema<Partial<$ObjectToType<S>>>}
+   */
+  get partial () {
+    return new $Object(this.shape, true)
+  }
+
+  /**
+   * @param {any} o
+   * @param {ValidationError} err
+   * @return {o is $ObjectToType<S>}
+   */
+  check (o, err) {
+    if (o == null) {
+      /* c8 ignore next */
+      err?.extend(null, 'object', 'null');
+      return false
+    }
+    return every(this.shape, (vv, vk) => {
+      const c = (this._isPartial && !hasProperty(o, vk)) || vv.check(o[vk], err);
+      !c && err?.extend(vk.toString(), vv.toString(), typeof o[vk], 'Object property does not match');
+      return c
+    })
+  }
+};
+
+/**
+ * @template S
+ * @typedef {Schema<{ [Key in keyof S as S[Key] extends $Optional<Schema<any>> ? Key : never]?: S[Key] extends $Optional<Schema<infer Type>> ? Type : never } & { [Key in keyof S as S[Key] extends $Optional<Schema<any>> ? never : Key]: S[Key] extends Schema<infer Type> ? Type : never }>} _ObjectDefToSchema
+ */
+
+// I used an explicit type annotation instead of $ObjectToType, so that the user doesn't see the
+// weird type definitions when inspecting type definions.
+/**
+ * @template {{ [key:string|symbol|number]: Schema<any> }} S
+ * @param {S} def
+ * @return {_ObjectDefToSchema<S> extends Schema<infer S> ? Schema<{ [K in keyof S]: S[K] }> : never}
+ */
+const $object = def => /** @type {any} */ (new $Object$3(def));
+const $$object = $constructedBy($Object$3);
+/**
+ * @type {Schema<{[key:string]: any}>}
+ */
+const $objectAny = $custom(o => o != null && (o.constructor === Object || o.constructor == null));
+
+/**
+ * @template {Schema<string|number|symbol>} Keys
+ * @template {Schema<any>} Values
+ * @extends {Schema<{ [key in Unwrap<Keys>]: Unwrap<Values> }>}
+ */
+class $Record extends Schema {
+  /**
+   * @param {Keys} keys
+   * @param {Values} values
+   */
+  constructor (keys, values) {
+    super();
+    this.shape = {
+      keys, values
+    };
+  }
+
+  /**
+   * @param {any} o
+   * @param {ValidationError} err
+   * @return {o is { [key in Unwrap<Keys>]: Unwrap<Values> }}
+   */
+  check (o, err) {
+    return o != null && every(o, (vv, vk) => {
+      const ck = this.shape.keys.check(vk, err);
+      /* c8 ignore next */
+      !ck && err?.extend(vk + '', 'Record', typeof o, ck ? 'Key doesn\'t match schema' : 'Value doesn\'t match value');
+      return ck && this.shape.values.check(vv, err)
+    })
+  }
+}
+
+/**
+ * @template {Schema<string|number|symbol>} Keys
+ * @template {Schema<any>} Values
+ * @param {Keys} keys
+ * @param {Values} values
+ * @return {CastToSchema<$Record<Keys,Values>>}
+ */
+const $record = (keys, values) => new $Record(keys, values);
+const $$record = $constructedBy($Record);
+
+/**
+ * @template {Schema<any>[]} S
+ * @extends {Schema<{ [Key in keyof S]: S[Key] extends Schema<infer Type> ? Type : never }>}
+ */
+class $Tuple extends Schema {
+  /**
+   * @param {S} shape
+   */
+  constructor (shape) {
+    super();
+    this.shape = shape;
+  }
+
+  /**
+   * @param {any} o
+   * @param {ValidationError} err
+   * @return {o is { [K in keyof S]: S[K] extends Schema<infer Type> ? Type : never }}
+   */
+  check (o, err) {
+    return o != null && every(this.shape, (vv, vk) => {
+      const c = /** @type {Schema<any>} */ (vv).check(o[vk], err);
+      /* c8 ignore next */
+      !c && err?.extend(vk.toString(), 'Tuple', typeof vv);
+      return c
+    })
+  }
+}
+
+/**
+ * @template {Array<Schema<any>>} T
+ * @param {T} def
+ * @return {CastToSchema<$Tuple<T>>}
+ */
+const $tuple = (...def) => new $Tuple(def);
+$constructedBy($Tuple);
+
+/**
+ * @template {Schema<any>} S
+ * @extends {Schema<Array<S extends Schema<infer T> ? T : never>>}
+ */
+class $Array extends Schema {
+  /**
+   * @param {Array<S>} v
+   */
+  constructor (v) {
+    super();
+    /**
+     * @type {Schema<S extends Schema<infer T> ? T : never>}
+     */
+    this.shape = v.length === 1 ? v[0] : new $Union(v);
+  }
+
+  /**
+   * @param {any} o
+   * @param {ValidationError} [err]
+   * @return {o is Array<S extends Schema<infer T> ? T : never>} o
+   */
+  check (o, err) {
+    const c = isArray$1(o) && every$1(o, oi => this.shape.check(oi));
+    /* c8 ignore next */
+    !c && err?.extend(null, 'Array', '');
+    return c
+  }
+}
+
+/**
+ * @template {Array<Schema<any>>} T
+ * @param {T} def
+ * @return {Schema<Array<T extends Array<Schema<infer S>> ? S : never>>}
+ */
+const $array = (...def) => new $Array(def);
+const $$array = $constructedBy($Array);
+/**
+ * @type {Schema<Array<any>>}
+ */
+const $arrayAny = $custom(o => isArray$1(o));
+
+/**
+ * @template T
+ * @extends {Schema<T>}
+ */
+class $InstanceOf extends Schema {
+  /**
+   * @param {new (...args:any) => T} constructor
+   * @param {((o:T) => boolean)|null} check
+   */
+  constructor (constructor, check) {
+    super();
+    this.shape = constructor;
+    this._c = check;
+  }
+
+  /**
+   * @param {any} o
+   * @param {ValidationError} err
+   * @return {o is T}
+   */
+  check (o, err) {
+    const c = o instanceof this.shape && (this._c == null || this._c(o));
+    /* c8 ignore next */
+    !c && err?.extend(null, this.shape.name, o?.constructor.name);
+    return c
+  }
+}
+
+/**
+ * @template T
+ * @param {new (...args:any) => T} c
+ * @param {((o:T) => boolean)|null} check
+ * @return {Schema<T>}
+ */
+const $instanceOf = (c, check = null) => new $InstanceOf(c, check);
+$constructedBy($InstanceOf);
+
+const $$schema = $instanceOf(Schema);
+
+/**
+ * @template {Schema<any>[]} Args
+ * @typedef {(...args:UnwrapArray<TuplePop<Args>>)=>Unwrap<TupleLast<Args>>} _LArgsToLambdaDef
+ */
+
+/**
+ * @template {Array<Schema<any>>} Args
+ * @extends {Schema<_LArgsToLambdaDef<Args>>}
+ */
+class $Lambda extends Schema {
+  /**
+   * @param {Args} args
+   */
+  constructor (args) {
+    super();
+    this.len = args.length - 1;
+    this.args = $tuple(...args.slice(-1));
+    this.res = args[this.len];
+  }
+
+  /**
+   * @param {any} f
+   * @param {ValidationError} err
+   * @return {f is _LArgsToLambdaDef<Args>}
+   */
+  check (f, err) {
+    const c = f.constructor === Function && f.length <= this.len;
+    /* c8 ignore next */
+    !c && err?.extend(null, 'function', typeof f);
+    return c
+  }
+}
+const $$lambda = $constructedBy($Lambda);
+
+/**
+ * @type {Schema<Function>}
+ */
+const $function = $custom(o => typeof o === 'function');
+
+/**
+ * @template {Array<Schema<any>>} T
+ * @extends {Schema<Intersect<UnwrapArray<T>>>}
+ */
+class $Intersection extends Schema {
+  /**
+   * @param {T} v
+   */
+  constructor (v) {
+    super();
+    /**
+     * @type {T}
+     */
+    this.shape = v;
+  }
+
+  /**
+   * @param {any} o
+   * @param {ValidationError} [err]
+   * @return {o is Intersect<UnwrapArray<T>>}
+   */
+  check (o, err) {
+    // @ts-ignore
+    const c = every$1(this.shape, check => check.check(o, err));
+    /* c8 ignore next */
+    !c && err?.extend(null, 'Intersectinon', typeof o);
+    return c
+  }
+}
+$constructedBy($Intersection, o => o.shape.length > 0); // Intersection with length=0 is considered "any"
+
+/**
+ * @template S
+ * @extends {Schema<S>}
+ */
+class $Union extends Schema {
+  static _dilutes = true
+
+  /**
+   * @param {Array<Schema<S>>} v
+   */
+  constructor (v) {
+    super();
+    this.shape = v;
+  }
+
+  /**
+   * @param {any} o
+   * @param {ValidationError} [err]
+   * @return {o is S}
+   */
+  check (o, err) {
+    const c = some(this.shape, (vv) => vv.check(o, err));
+    err?.extend(null, 'Union', typeof o);
+    return c
+  }
+}
+
+/**
+ * @template {Array<any>} T
+ * @param {T} schemas
+ * @return {CastToSchema<$Union<Unwrap<ReadSchema<T>>>>}
+ */
+const $union = (...schemas) => schemas.findIndex($s => $$union.check($s)) >= 0
+  ? $union(...schemas.map($s => $($s)).map($s => $$union.check($s) ? $s.shape : [$s]).flat(1))
+  : (schemas.length === 1
+      ? schemas[0]
+      : new $Union(schemas));
+const $$union = /** @type {Schema<$Union<any>>} */ ($constructedBy($Union));
+
+const _t = () => true;
+/**
+ * @type {Schema<any>}
+ */
+const $any = $custom(_t);
+const $$any = /** @type {Schema<Schema<any>>} */ ($constructedBy($Custom, o => o.shape === _t));
+
+/**
+ * @type {Schema<bigint>}
+ */
+const $bigint = $custom(o => typeof o === 'bigint');
+const $$bigint = /** @type {Schema<Schema<BigInt>>} */ ($custom(o => o === $bigint));
+
+/**
+ * @type {Schema<symbol>}
+ */
+const $symbol = $custom(o => typeof o === 'symbol');
+/** @type {Schema<Schema<Symbol>>} */ ($custom(o => o === $symbol));
+
+/**
+ * @type {Schema<number>}
+ */
+const $number = $custom(o => typeof o === 'number');
+const $$number = /** @type {Schema<Schema<number>>} */ ($custom(o => o === $number));
+
+/**
+ * @type {Schema<string>}
+ */
+const $string = $custom(o => typeof o === 'string');
+const $$string = /** @type {Schema<Schema<string>>} */ ($custom(o => o === $string));
+
+/**
+ * @type {Schema<boolean>}
+ */
+const $boolean = $custom(o => typeof o === 'boolean');
+const $$boolean = /** @type {Schema<Schema<Boolean>>} */ ($custom(o => o === $boolean));
+
+/**
+ * @type {Schema<undefined>}
+ */
+const $undefined = $literal(undefined);
+/** @type {Schema<Schema<undefined>>} */ ($constructedBy($Literal, o => o.shape.length === 1 && o.shape[0] === undefined));
+
+/**
+ * @type {Schema<void>}
+ */
+$literal(undefined);
+
+const $null = $literal(null);
+const $$null = /** @type {Schema<Schema<null>>} */ ($constructedBy($Literal, o => o.shape.length === 1 && o.shape[0] === null));
+
+$constructedBy(Uint8Array);
+/** @type {Schema<Schema<Uint8Array>>} */ ($constructedBy($ConstructedBy, o => o.shape === Uint8Array));
+
+/**
+ * @type {Schema<Primitive>}
+ */
+const $primitive = $union($number, $string, $null, $undefined, $bigint, $boolean, $symbol);
+
+/**
+ * @typedef {JSON[]} JSONArray
+ */
+/**
+ * @typedef {Primitive|JSONArray|{ [key:string]:JSON }} JSON
+ */
+/**
+ * @type {Schema<null|number|string|boolean|JSON[]|{[key:string]:JSON}>}
+ */
+(() => {
+  const $jsonArr = /** @type {$Array<$any>} */ ($array($any));
+  const $jsonRecord = /** @type {$Record<$string,$any>} */ ($record($string, $any));
+  const $json = $union($number, $string, $null, $boolean, $jsonArr, $jsonRecord);
+  $jsonArr.shape = $json;
+  $jsonRecord.shape.values = $json;
+  return $json
+})();
+
+/**
+ * @template {any} IN
+ * @typedef {IN extends Schema<any> ? IN
+ *   : (IN extends string|number|boolean|null ? Schema<IN>
+ *     : (IN extends new (...args:any[])=>any ? Schema<InstanceType<IN>>
+ *       : (IN extends any[] ? Schema<{ [K in keyof IN]: Unwrap<ReadSchema<IN[K]>> }[number]>
+   *       : (IN extends object ? (_ObjectDefToSchema<{[K in keyof IN]:ReadSchema<IN[K]>}> extends Schema<infer S> ? Schema<{ [K in keyof S]: S[K] }> : never)
+   *         : never)
+ *         )
+ *       )
+ *     )
+ * } ReadSchemaOld
+ */
+
+/**
+ * @template {any} IN
+ * @typedef {[Extract<IN,Schema<any>>,Extract<IN,string|number|boolean|null>,Extract<IN,new (...args:any[])=>any>,Extract<IN,any[]>,Extract<Exclude<IN,Schema<any>|string|number|boolean|null|(new (...args:any[])=>any)|any[]>,object>] extends [infer Schemas, infer Primitives, infer Constructors, infer Arrs, infer Obj]
+ *   ? Schema<
+ *       (Schemas extends Schema<infer S> ? S : never)
+ *     | Primitives
+ *     | (Constructors extends new (...args:any[])=>any ? InstanceType<Constructors> : never)
+ *     | (Arrs extends any[] ? { [K in keyof Arrs]: Unwrap<ReadSchema<Arrs[K]>> }[number] : never)
+ *     | (Obj extends object ? Unwrap<(_ObjectDefToSchema<{[K in keyof Obj]:ReadSchema<Obj[K]>}> extends Schema<infer S> ? Schema<{ [K in keyof S]: S[K] }> : never)> : never)>
+ *   : never
+ * } ReadSchema
+ */
+
+/**
+ * @typedef {ReadSchema<{x:42}|{y:99}|Schema<string>|[1,2,{}]>} Q
+ */
+
+/**
+ * @template IN
+ * @param {IN} o
+ * @return {ReadSchema<IN>}
+ */
+const $ = o => {
+  if ($$schema.check(o)) {
+    return /** @type {any} */ (o)
+  } else if ($objectAny.check(o)) {
+    /**
+     * @type {any}
+     */
+    const o2 = {};
+    for (const k in o) {
+      o2[k] = $(o[k]);
+    }
+    return /** @type {any} */ ($object(o2))
+  } else if ($arrayAny.check(o)) {
+    return /** @type {any} */ ($union(...o.map($)))
+  } else if ($primitive.check(o)) {
+    return /** @type {any} */ ($literal(o))
+  } else if ($function.check(o)) {
+    return /** @type {any} */ ($constructedBy(/** @type {any} */ (o)))
+  }
+  /* c8 ignore next */
+  unexpectedCase();
+};
+
+/* c8 ignore start */
+/**
+ * Assert that a variable is of this specific type.
+ * The assertion check is only performed in non-production environments.
+ *
+ * @type {<T>(o:any,schema:Schema<T>) => asserts o is T}
+ */
+const assert = production
+  ? () => {}
+  : (o, schema) => {
+      const err = new ValidationError();
+      if (!schema.check(o, err)) {
+        throw create$3(`Expected value to be of type ${schema.constructor.name}.\n${err.toString()}`)
+      }
+    };
+/* c8 ignore end */
+
+/**
+ * @template In
+ * @template Out
+ * @typedef {{ if: Schema<In>, h: (o:In,state?:any)=>Out }} Pattern
+ */
+
+/**
+ * @template {Pattern<any,any>} P
+ * @template In
+ * @typedef {ReturnType<Extract<P,Pattern<In extends number ? number : (In extends string ? string : In),any>>['h']>} PatternMatchResult
+ */
+
+/**
+ * @todo move this to separate library
+ * @template {any} [State=undefined]
+ * @template {Pattern<any,any>} [Patterns=never]
+ */
+class PatternMatcher {
+  /**
+   * @param {Schema<State>} [$state]
+   */
+  constructor ($state) {
+    /**
+     * @type {Array<Patterns>}
+     */
+    this.patterns = [];
+    this.$state = $state;
+  }
+
+  /**
+   * @template P
+   * @template R
+   * @param {P} pattern
+   * @param {(o:NoInfer<Unwrap<ReadSchema<P>>>,s:State)=>R} handler
+   * @return {PatternMatcher<State,Patterns|Pattern<Unwrap<ReadSchema<P>>,R>>}
+   */
+  if (pattern, handler) {
+    // @ts-ignore
+    this.patterns.push({ if: $(pattern), h: handler });
+    // @ts-ignore
+    return this
+  }
+
+  /**
+   * @template R
+   * @param {(o:any,s:State)=>R} h
+   */
+  else (h) {
+    return this.if($any, h)
+  }
+
+  /**
+   * @return {State extends undefined
+   *   ? <In extends Unwrap<Patterns['if']>>(o:In,state?:undefined)=>PatternMatchResult<Patterns,In>
+   *   : <In extends Unwrap<Patterns['if']>>(o:In,state:State)=>PatternMatchResult<Patterns,In>}
+   */
+  done () {
+    // @ts-ignore
+    return /** @type {any} */ (o, s) => {
+      for (let i = 0; i < this.patterns.length; i++) {
+        const p = this.patterns[i];
+        if (p.if.check(o)) {
+          // @ts-ignore
+          return p.h(o, s)
+        }
+      }
+      throw create$3('Unhandled pattern')
+    }
+  }
+}
+
 /**
- * Color is enabled by default if the terminal supports it.
- *
- * Explicitly enable color using `--color` parameter
- * Disable color using `--no-color` parameter or using `NO_COLOR=1` environment variable.
- * `FORCE_COLOR=1` enables color and takes precedence over all.
+ * @template [State=undefined]
+ * @param {State} [state]
+ * @return {PatternMatcher<State extends undefined ? undefined : Unwrap<ReadSchema<State>>>}
  */
-const supportsColor = forceColor || (
-  !hasParam('--no-colors') && // @todo deprecate --no-colors
-  !hasConf('no-color') &&
-  (!isNode || process.stdout.isTTY) && (
-    !isNode ||
-    hasParam('--color') ||
-    getVariable('COLORTERM') !== null ||
-    (getVariable('TERM') || '').includes('color')
-  )
-);
-/* c8 ignore stop */
+const match = state => new PatternMatcher(/** @type {any} */ (state));
 
 /**
- * Utility functions to work with buffers (Uint8Array).
+ * Helper function to generate a (non-exhaustive) sample set from a gives schema.
  *
- * @module buffer
+ * @type {<T>(o:T,gen:prng.PRNG)=>T}
  */
-
+const _random = /** @type {any} */ (match(/** @type {Schema<prng.PRNG>} */ ($any))
+  .if($$number, (_o, gen) => int53(gen, MIN_SAFE_INTEGER, MAX_SAFE_INTEGER))
+  .if($$string, (_o, gen) => word(gen))
+  .if($$boolean, (_o, gen) => bool(gen))
+  .if($$bigint, (_o, gen) => BigInt(int53(gen, MIN_SAFE_INTEGER, MAX_SAFE_INTEGER)))
+  .if($$union, (o, gen) => random(gen, oneOf(gen, o.shape)))
+  .if($$object, (o, gen) => {
+    /**
+     * @type {any}
+     */
+    const res = {};
+    for (const k in o.shape) {
+      let prop = o.shape[k];
+      if ($$optional.check(prop)) {
+        if (bool(gen)) { continue }
+        prop = prop.shape;
+      }
+      res[k] = _random(prop, gen);
+    }
+    return res
+  })
+  .if($$array, (o, gen) => {
+    const arr = [];
+    const n = int32(gen, 0, 42);
+    for (let i = 0; i < n; i++) {
+      arr.push(random(gen, o.shape));
+    }
+    return arr
+  })
+  .if($$literal, (o, gen) => {
+    return oneOf(gen, o.shape)
+  })
+  .if($$null, (o, gen) => {
+    return null
+  })
+  .if($$lambda, (o, gen) => {
+    const res = random(gen, o.res);
+    return () => res
+  })
+  .if($$any, (o, gen) => random(gen, oneOf(gen, [
+    $number, $string, $null, $undefined, $bigint, $boolean,
+    $array($number),
+    $record($union('a', 'b', 'c'), $number)
+  ])))
+  .if($$record, (o, gen) => {
+    /**
+     * @type {any}
+     */
+    const res = {};
+    const keysN = int53(gen, 0, 3);
+    for (let i = 0; i < keysN; i++) {
+      const key = random(gen, o.shape.keys);
+      const val = random(gen, o.shape.values);
+      res[key] = val;
+    }
+    return res
+  })
+  .done());
 
 /**
- * @param {number} len
+ * @template S
+ * @param {prng.PRNG} gen
+ * @param {S} schema
+ * @return {Unwrap<ReadSchema<S>>}
  */
-const createUint8ArrayFromLen = len => new Uint8Array(len);
+const random = (gen, schema) => /** @type {any} */ (_random($(schema), gen));
+
+/* eslint-env browser */
+
 
+/* c8 ignore start */
 /**
- * Copy the content of an Uint8Array view to a new ArrayBuffer.
- *
- * @param {Uint8Array} uint8Array
- * @return {Uint8Array}
+ * @type {Document}
  */
-const copyUint8Array = uint8Array => {
-  const newBuf = createUint8ArrayFromLen(uint8Array.byteLength);
-  newBuf.set(uint8Array);
-  return newBuf
-};
+const doc = /** @type {Document} */ (typeof document !== 'undefined' ? document : {});
 
 /**
- * Working with value pairs.
- *
- * @module pair
+ * @type {$.Schema<DocumentFragment>}
  */
+$custom(el => el.nodeType === DOCUMENT_FRAGMENT_NODE);
+
+/** @type {DOMParser} */ (typeof DOMParser !== 'undefined' ? new DOMParser() : null);
 
 /**
- * @template L,R
+ * @type {$.Schema<Element>}
  */
-class Pair {
-  /**
-   * @param {L} left
-   * @param {R} right
-   */
-  constructor (left, right) {
-    this.left = left;
-    this.right = right;
-  }
-}
+$custom(el => el.nodeType === ELEMENT_NODE);
 
 /**
- * @template L,R
- * @param {L} left
- * @param {R} right
- * @return {Pair<L,R>}
+ * @type {$.Schema<Text>}
  */
-const create$1 = (left, right) => new Pair(left, right);
-
-/* eslint-env browser */
-
-
-/** @type {DOMParser} */ (typeof DOMParser !== 'undefined' ? new DOMParser() : null);
+$custom(el => el.nodeType === TEXT_NODE);
 
 /**
  * @param {Map<string,string>} m
  * @return {string}
  */
 const mapToStyleString = m => map(m, (value, key) => `${key}:${value};`).join('');
+
+const ELEMENT_NODE = doc.ELEMENT_NODE;
+const TEXT_NODE = doc.TEXT_NODE;
+const DOCUMENT_NODE = doc.DOCUMENT_NODE;
+const DOCUMENT_FRAGMENT_NODE = doc.DOCUMENT_FRAGMENT_NODE;
+
+/**
+ * @type {$.Schema<Node>}
+ */
+$custom(el => el.nodeType === DOCUMENT_NODE);
 /* c8 ignore stop */
 
 /**
@@ -5047,17 +6458,21 @@ const cleanupTransactions = (transactionCleanups, i) => {
             // sort events by path length so that top-level events are fired first.
             events
               .sort((event1, event2) => event1.path.length - event2.path.length);
-            // We don't need to check for events.length
-            // because we know it has at least one element
-            callEventHandlerListeners(type._dEH, events, transaction);
+            fs.push(() => {
+              // We don't need to check for events.length
+              // because we know it has at least one element
+              callEventHandlerListeners(type._dEH, events, transaction);
+            });
+          }
+        });
+        fs.push(() => doc.emit('afterTransaction', [transaction, doc]));
+        fs.push(() => {
+          if (transaction._needFormattingCleanup) {
+            cleanupYTextAfterTransaction(transaction);
           }
         });
       });
-      fs.push(() => doc.emit('afterTransaction', [transaction, doc]));
       callAll(fs, []);
-      if (transaction._needFormattingCleanup) {
-        cleanupYTextAfterTransaction(transaction);
-      }
     } finally {
       // Replace deleted items with ItemDeleted / GC.
       // This is where content is actually remove from the Yjs Doc.
@@ -5619,7 +7034,7 @@ class YEvent {
      */
     this._changes = null;
     /**
-     * @type {null | Map<string, { action: 'add' | 'update' | 'delete', oldValue: any, newValue: any }>}
+     * @type {null | Map<string, { action: 'add' | 'update' | 'delete', oldValue: any }>}
      */
     this._keys = null;
     /**
@@ -5662,7 +7077,7 @@ class YEvent {
   }
 
   /**
-   * @type {Map<string, { action: 'add' | 'update' | 'delete', oldValue: any, newValue: any }>}
+   * @type {Map<string, { action: 'add' | 'update' | 'delete', oldValue: any }>}
    */
   get keys () {
     if (this._keys === null) {
@@ -9037,12 +10452,10 @@ class YXmlElement extends YXmlFragment {
     const el = new YXmlElement(this.nodeName);
     const attrs = this.getAttributes();
     forEach$2(attrs, (value, key) => {
-      if (typeof value === 'string') {
-        el.setAttribute(key, value);
-      }
+      el.setAttribute(key, /** @type {any} */ (value));
     });
     // @ts-ignore
-    el.insert(0, this.toArray().map(item => item instanceof AbstractType ? item.clone() : item));
+    el.insert(0, this.toArray().map(v => v instanceof AbstractType ? v.clone() : v));
     return el
   }
 
@@ -11436,6 +12849,330 @@ class KokimokiAiService {
     }
 }
 
+let _kmEnv;
+/**
+ * Parses and returns the Kokimoki environment configuration.
+ *
+ * The environment is injected into the HTML by @kokimoki/kit as a JSON script tag
+ * with id `kokimoki-env`. In production, placeholder values are replaced by the server.
+ *
+ * @returns The parsed KokimokiEnv object
+ * @throws Error if the kokimoki-env element is not found
+ *
+ * @example
+ * ```typescript
+ * import { getKmEnv } from '@kokimoki/app';
+ *
+ * const env = getKmEnv();
+ * console.log(env.dev); // true in development
+ * console.log(env.assets); // CDN URL in production
+ *
+ * // Cast i18n to your app's type if needed
+ * const i18n = env.i18n as typeof i18nResources;
+ * ```
+ */
+function getKmEnv() {
+    if (_kmEnv) {
+        return _kmEnv;
+    }
+    const element = document.getElementById("kokimoki-env");
+    if (!element) {
+        throw new Error("kokimoki-env element not found. Ensure the app is built with @kokimoki/kit.");
+    }
+    _kmEnv = JSON.parse(element.textContent);
+    return _kmEnv;
+}
+
+/**
+ * Kokimoki i18n Service
+ *
+ * Provides translation loading via HTTP backend. Both development and production
+ * use HTTP to load translations consistently.
+ *
+ * In development, translations are served by @kokimoki/kit's dev server middleware.
+ * In production, translations are served from the assets CDN.
+ *
+ * **Key Features:**
+ * - Pre-configured i18next instance creation
+ * - Consistent HTTP-based loading in dev and prod
+ * - URL resolution for translation namespaces
+ * - AI-powered translation requests
+ *
+ * Access via `kmClient.i18n`
+ *
+ * @example
+ * ```typescript
+ * // Setup with React
+ * import { initReactI18next } from 'react-i18next';
+ *
+ * export const i18n = kmClient.i18n.createI18n({
+ *   use: [initReactI18next]
+ * });
+ *
+ * // Initialize with primary language
+ * await kmClient.i18n.init('en');
+ *
+ * // Request AI translation for another language
+ * const result = await kmClient.i18n.requestTranslation('de');
+ * // Then poll getTranslationStatus('de') until available
+ * ```
+ */
+class KokimokiI18nService {
+    client;
+    initPromise = null;
+    instance = null;
+    options = {};
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Create and configure an i18next instance.
+     *
+     * This sets up the instance with plugins but does NOT initialize it.
+     * Call `init(lng)` to initialize with a specific language.
+     *
+     * @param options - Configuration options (plugins, fallback, defaultNS)
+     * @returns Configured i18next instance (not yet initialized)
+     *
+     * @example
+     * ```typescript
+     * // With React
+     * import { initReactI18next } from 'react-i18next';
+     *
+     * export const i18n = kmClient.i18n.createI18n({
+     *   use: [initReactI18next]
+     * });
+     *
+     * // Later, when you know the language:
+     * await kmClient.i18n.init('en');
+     *
+     * // Then in components:
+     * const { t } = useTranslation('game');
+     * ```
+     */
+    createI18n(options) {
+        const env = getKmEnv();
+        const namespaces = env.i18nNamespaces ?? [];
+        if (namespaces.length === 0) {
+            console.warn("[KokimokiI18n] No i18n namespaces found. Make sure i18n is configured in @kokimoki/kit plugin.");
+        }
+        this.options = options ?? {};
+        this.instance = i18next.createInstance();
+        // Apply plugins
+        if (options?.use) {
+            for (const plugin of options.use) {
+                this.instance.use(plugin);
+            }
+        }
+        // Add HTTP backend
+        this.instance.use(HttpBackend);
+        return this.instance;
+    }
+    /**
+     * Initialize the i18next instance with a specific language.
+     *
+     * Must call `createI18n()` first to set up the instance.
+     *
+     * @param lng - The language code to initialize with (e.g., 'en', 'de')
+     * @returns Promise that resolves when i18n is ready
+     *
+     * @example
+     * ```typescript
+     * // Create instance first
+     * const i18n = kmClient.i18n.createI18n({ use: [initReactI18next] });
+     *
+     * // Then initialize when you know the language
+     * await kmClient.i18n.init('en');
+     * ```
+     */
+    async init(lng) {
+        if (!this.instance) {
+            throw new Error("Call createI18n() before init()");
+        }
+        if (this.initPromise) {
+            return this.initPromise;
+        }
+        const env = getKmEnv();
+        const namespaces = env.i18nNamespaces ?? [];
+        const fallbackLng = this.options.fallbackLng ?? lng;
+        const defaultNS = this.options.defaultNS;
+        this.initPromise = this.instance.init({
+            lng,
+            fallbackLng,
+            ns: namespaces,
+            defaultNS,
+            backend: {
+                loadPath: (lng, ns) => this.getNamespaceUrl(lng, ns),
+            },
+            interpolation: {
+                escapeValue: false,
+            },
+        });
+        return this.initPromise;
+    }
+    /**
+     * Get the URL for a translation namespace.
+     *
+     * Returns the appropriate URL based on environment:
+     * - Development: `/__kokimoki/i18n/{lng}/{ns}.json`
+     * - Production: `{assets}/km-i18n/{lng}/{ns}.json`
+     *
+     * @param lng - Language code (e.g., 'en', 'et', 'de')
+     * @param ns - Namespace (e.g., 'ui', 'game', 'setup')
+     * @returns Full URL to the translation JSON file
+     *
+     * @example
+     * ```typescript
+     * const url = kmClient.i18n.getNamespaceUrl('en', 'game');
+     * // Dev: "/__kokimoki/i18n/en/game.json"
+     * // Prod: "https://cdn.kokimoki.com/build-123/km-i18n/en/game.json"
+     * ```
+     */
+    getNamespaceUrl(lng, ns) {
+        const env = getKmEnv();
+        if (env.dev) {
+            // Development: use kit plugin's middleware
+            return `/__kokimoki/i18n/${lng}/${ns}.json`;
+        }
+        // Production: use assets CDN with configured i18n path
+        const i18nPath = env.i18nPath ?? 'km-i18n';
+        return `${env.assets}/${i18nPath}/${lng}/${ns}.json`;
+    }
+    /**
+     * Get the list of available namespaces.
+     *
+     * @returns Array of namespace names configured in @kokimoki/kit
+     */
+    getNamespaces() {
+        return getKmEnv().i18nNamespaces ?? [];
+    }
+    /**
+     * Get the list of available languages.
+     *
+     * @returns Array of language codes configured in @kokimoki/kit
+     */
+    getLanguages() {
+        return getKmEnv().i18nLanguages ?? [];
+    }
+    /**
+     * Get the status of all languages that have been requested for AI translation.
+     *
+     * Only available in production. In development, returns an empty array.
+     *
+     * @returns Promise with array of language statuses
+     *
+     * @example
+     * ```typescript
+     * const { languages } = await kmClient.i18n.getAllLanguagesStatus();
+     * // [{ lng: 'de', status: 'available' }, { lng: 'fr', status: 'processing' }]
+     * ```
+     */
+    async getAllLanguagesStatus() {
+        const env = getKmEnv();
+        if (env.dev) {
+            return { languages: [] };
+        }
+        const res = await fetch(`${this.client.apiUrl}/i18n`, {
+            method: "GET",
+            headers: this.client.apiHeaders,
+        });
+        return await res.json();
+    }
+    /**
+     * Get the translation status for a specific language.
+     *
+     * Returns the overall status and per-namespace status for the given language.
+     * In development, returns 'available' for local languages and 'not_available' for others.
+     * In production, queries the API for the actual status.
+     *
+     * @param lng - Target language code (e.g., 'de', 'fr', 'es')
+     * @returns Promise with translation status
+     *
+     * @example
+     * ```typescript
+     * const status = await kmClient.i18n.getTranslationStatus('de');
+     * if (status.status === 'available') {
+     *   // All translations ready, can switch language
+     *   i18next.changeLanguage('de');
+     * } else if (status.status === 'processing') {
+     *   // Show loading indicator
+     * } else {
+     *   // Request translation
+     *   await kmClient.i18n.requestTranslation('de');
+     * }
+     * ```
+     */
+    async getTranslationStatus(lng) {
+        const env = getKmEnv();
+        if (env.dev) {
+            // In dev, only local languages are available
+            const localLanguages = this.getLanguages();
+            const namespaces = this.getNamespaces();
+            const isLocal = localLanguages.includes(lng);
+            const status = isLocal ? "available" : "not_available";
+            return {
+                status,
+                namespaces: Object.fromEntries(namespaces.map((ns) => [ns, status])),
+            };
+        }
+        const res = await fetch(`${this.client.apiUrl}/i18n/${encodeURIComponent(lng)}/status`, {
+            method: "GET",
+            headers: this.client.apiHeaders,
+        });
+        return await res.json();
+    }
+    /**
+     * Request AI translation for a target language.
+     *
+     * Triggers background AI translation jobs for all namespaces that are not yet available.
+     * Uses the build's configured primary language as the source.
+     *
+     * In development, returns 'already_available' for local languages and throws an error for others.
+     * In production, triggers the API to start translation.
+     *
+     * @param lng - Target language code (e.g., 'de', 'fr', 'es')
+     * @returns Promise with the result of the request
+     *
+     * @example
+     * ```typescript
+     * const result = await kmClient.i18n.requestTranslation('de');
+     *
+     * if (result.status === 'started') {
+     *   // Translation started, poll for status
+     *   const checkStatus = async () => {
+     *     const status = await kmClient.i18n.getTranslationStatus('de');
+     *     if (status.status === 'available') {
+     *       i18next.changeLanguage('de');
+     *     } else if (status.status === 'processing') {
+     *       setTimeout(checkStatus, 2000);
+     *     }
+     *   };
+     *   checkStatus();
+     * } else if (result.status === 'already_available') {
+     *   // Already translated, switch immediately
+     *   i18next.changeLanguage('de');
+     * }
+     * ```
+     */
+    async requestTranslation(lng) {
+        const env = getKmEnv();
+        if (env.dev) {
+            // In dev, only local languages are available
+            const localLanguages = this.getLanguages();
+            if (localLanguages.includes(lng)) {
+                return { status: "already_available" };
+            }
+            // AI translation not available in dev mode
+            throw new Error(`AI translation not available in dev mode. Add local translations for '${lng}' in src/i18n/${lng}/`);
+        }
+        const res = await fetch(`${this.client.apiUrl}/i18n/${encodeURIComponent(lng)}/translate`, {
+            method: "POST",
+            headers: this.client.apiHeaders,
+        });
+        return await res.json();
+    }
+}
+
 /**
  * Kokimoki Leaderboard Service
  *
@@ -12128,16 +13865,16 @@ var functionApply = Function.prototype.apply;
 /** @type {import('./reflectApply')} */
 var reflectApply$1 = typeof Reflect !== 'undefined' && Reflect && Reflect.apply;
 
-var bind$4 = functionBind;
+var bind$5 = functionBind;
 
 var $apply$2 = functionApply;
 var $call$2 = functionCall;
 var $reflectApply = reflectApply$1;
 
 /** @type {import('./actualApply')} */
-var actualApply$1 = $reflectApply || bind$4.call($call$2, $apply$2);
+var actualApply$1 = $reflectApply || bind$5.call($call$2, $apply$2);
 
-var bind$3 = functionBind;
+var bind$4 = functionBind;
 var $TypeError$4 = requireType();
 
 var $call$1 = functionCall;
@@ -12148,7 +13885,7 @@ var callBindApplyHelpers = function callBindBasic(args) {
 	if (args.length < 1 || typeof args[0] !== 'function') {
 		throw new $TypeError$4('a function is required');
 	}
-	return $actualApply(bind$3, $call$1, args);
+	return $actualApply(bind$4, $call$1, args);
 };
 
 var callBind$2 = callBindApplyHelpers;
@@ -12206,21 +13943,12 @@ var getProto$4 = reflectGetProto
 			}
 			: null;
 
-var hasown;
-var hasRequiredHasown;
-
-function requireHasown () {
-	if (hasRequiredHasown) return hasown;
-	hasRequiredHasown = 1;
-
-	var call = Function.prototype.call;
-	var $hasOwn = Object.prototype.hasOwnProperty;
-	var bind = functionBind;
+var call = Function.prototype.call;
+var $hasOwn = Object.prototype.hasOwnProperty;
+var bind$3 = functionBind;
 
-	/** @type {import('.')} */
-	hasown = bind.call(call, $hasOwn);
-	return hasown;
-}
+/** @type {import('.')} */
+var hasown = bind$3.call(call, $hasOwn);
 
 var undefined$1;
 
@@ -12463,7 +14191,7 @@ var LEGACY_ALIASES = {
 };
 
 var bind$2 = functionBind;
-var hasOwn$1 = requireHasown();
+var hasOwn$1 = hasown;
 var $concat = bind$2.call($call, Array.prototype.concat);
 var $spliceApply = bind$2.call($apply$1, Array.prototype.splice);
 var $replace = bind$2.call($call, String.prototype.replace);
@@ -12662,7 +14390,7 @@ var isArguments = supportsStandardArguments ? isStandardArguments : isLegacyArgu
 
 var callBound$3 = callBound$5;
 var hasToStringTag$3 = shams();
-var hasOwn = requireHasown();
+var hasOwn = hasown;
 var gOPD$2 = gopd$1;
 
 /** @type {import('.')} */
@@ -15056,7 +16784,7 @@ const createHandlerDefault = (isInitializing, addPropListener, removePropListene
     removePropListener(prop);
     const deleted = Reflect.deleteProperty(target, prop);
     if (deleted) {
-      notifyUpdate(["delete", [prop], prevValue]);
+      notifyUpdate(createOp == null ? void 0 : createOp("delete", prop, prevValue));
     }
     return deleted;
   },
@@ -15073,10 +16801,11 @@ const createHandlerDefault = (isInitializing, addPropListener, removePropListene
     const nextValue = !proxyStateMap.has(value) && canProxy(value) ? proxy(value) : value;
     addPropListener(prop, nextValue);
     Reflect.set(target, prop, nextValue, receiver);
-    notifyUpdate(["set", [prop], value, prevValue]);
+    notifyUpdate(createOp == null ? void 0 : createOp("set", prop, value, prevValue));
     return true;
   }
 });
+const createOpDefault = (type, prop, ...args) => [type, [prop], ...args];
 const proxyStateMap = /* @__PURE__ */ new WeakMap();
 const refSet = /* @__PURE__ */ new WeakSet();
 const snapCache = /* @__PURE__ */ new WeakMap();
@@ -15087,6 +16816,7 @@ let newProxy = (target, handler) => new Proxy(target, handler);
 let canProxy = canProxyDefault;
 let createSnapshot = createSnapshotDefault;
 let createHandler = createHandlerDefault;
+let createOp;
 function proxy(baseObject = {}) {
   if (!isObject(baseObject)) {
     throw new Error("object required");
@@ -15117,8 +16847,11 @@ function proxy(baseObject = {}) {
     return version;
   };
   const createPropListener = (prop) => (op, nextVersion) => {
-    const newOp = [...op];
-    newOp[1] = [prop, ...newOp[1]];
+    let newOp;
+    if (op) {
+      newOp = [...op];
+      newOp[1] = [prop, ...newOp[1]];
+    }
     notifyUpdate(newOp, nextVersion);
   };
   const propProxyStates = /* @__PURE__ */ new Map();
@@ -15205,7 +16938,9 @@ function subscribe(proxyObject, callback, notifyInSync) {
   const addListener = proxyState[2];
   let isListenerActive = false;
   const listener = (op) => {
-    ops.push(op);
+    if (op) {
+      ops.push(op);
+    }
     if (notifyInSync) {
       callback(ops.splice(0));
       return;
@@ -15238,6 +16973,15 @@ function ref(obj) {
   refSet.add(obj);
   return obj;
 }
+function unstable_enableOp(enabled = true) {
+  if (enabled === true) {
+    createOp = createOpDefault;
+  } else if (enabled === false) {
+    createOp = void 0;
+  } else {
+    createOp = enabled;
+  }
+}
 
 const parseProxyOps = (ops) => {
     const indexed = new Set();
@@ -16211,6 +17955,7 @@ class KokimokiClient extends EventEmitter$1 {
     _clientTokenKey = "KM_TOKEN";
     _editorContext;
     _ai;
+    _i18n;
     _storage;
     _leaderboard;
     constructor(host, appId, code = "") {
@@ -16224,6 +17969,7 @@ class KokimokiClient extends EventEmitter$1 {
         this._apiUrl = `http${secure ? "s" : ""}://${this.host}`;
         // Initialize modules
         this._ai = new KokimokiAiService(this);
+        this._i18n = new KokimokiI18nService(this);
         this._storage = new KokimokiStorageService(this);
         this._leaderboard = new KokimokiLeaderboardService(this);
         // Set up ping interval
@@ -16733,6 +18479,44 @@ class KokimokiClient extends EventEmitter$1 {
             clearInterval(this._pingInterval);
         }
     }
+    /**
+     * Waits for all subscriptions to be fully joined.
+     *
+     * This is useful when you need to ensure all stores have completed their initial
+     * synchronization before proceeding (e.g., before running tests or taking snapshots).
+     *
+     * @param timeout - Maximum time to wait in milliseconds (default: 5000ms).
+     * @returns A promise that resolves when all subscriptions are joined, or when timeout is reached.
+     *
+     * @example
+     * ```ts
+     * // Wait for all stores to sync before starting game
+     * await client.waitForSubscriptions();
+     *
+     * // Wait with custom timeout
+     * await client.waitForSubscriptions(10000);
+     * ```
+     */
+    async waitForSubscriptions(timeout = 5000) {
+        const checkInterval = 10;
+        const maxChecks = Math.ceil(timeout / checkInterval);
+        return new Promise((resolve) => {
+            let checks = 0;
+            const intervalId = setInterval(() => {
+                let allJoined = true;
+                for (const subscription of this._subscriptionsByName.values()) {
+                    if (!subscription.joined) {
+                        allJoined = false;
+                        break;
+                    }
+                }
+                if (allJoined || ++checks >= maxChecks) {
+                    clearInterval(intervalId);
+                    resolve();
+                }
+            }, checkInterval);
+        });
+    }
     /**
      * Gets the internal room hash identifier for a store.
      *
@@ -16824,6 +18608,15 @@ class KokimokiClient extends EventEmitter$1 {
         }
         return this._ai;
     }
+    /**
+     * Access i18n URL resolution and translation loading utilities.
+     */
+    get i18n() {
+        if (!this._i18n) {
+            throw new Error("I18n client not initialized");
+        }
+        return this._i18n;
+    }
     /**
      * Access file upload and management for media files, images, and user-generated content.
      */
@@ -17154,7 +18947,14 @@ function subscribeKey(proxyObject, key, callback, notifyInSync) {
 }
 
 let currentCleanups;
+let didWarnDeprecation = false;
 function watch(callback, options) {
+  if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && !didWarnDeprecation) {
+    console.warn(
+      "[DEPRECATED] The `watch` util is no longer maintained. Please migrate to [valtio-reactive](https://github.com/valtiojs/valtio-reactive)."
+    );
+    didWarnDeprecation = true;
+  }
   let alive = true;
   const cleanups = /* @__PURE__ */ new Set();
   const subscriptions = /* @__PURE__ */ new Map();
@@ -17210,7 +19010,7 @@ function watch(callback, options) {
   return cleanup;
 }
 
-const DEVTOOLS = Symbol();
+const DEVTOOLS = /* @__PURE__ */ Symbol();
 function devtools(proxyObject, options) {
   const { enabled, name = "", ...rest } = options || {};
   let extension;
@@ -17224,10 +19024,11 @@ function devtools(proxyObject, options) {
     }
     return;
   }
+  unstable_enableOp();
   let isTimeTraveling = false;
   const devtools2 = extension.connect({ name, ...rest });
-  const unsub1 = subscribe(proxyObject, (ops) => {
-    const action = ops.filter(([_, path]) => path[0] !== DEVTOOLS).map(([op, path]) => `${op}:${path.map(String).join(".")}`).join(", ");
+  const unsub1 = subscribe(proxyObject, (unstable_ops) => {
+    const action = unstable_ops.filter(([_, path]) => path[0] !== DEVTOOLS).map(([op, path]) => `${op}:${path.map(String).join(".")}`).join(", ");
     if (!action) {
       return;
     }
@@ -17288,7 +19089,7 @@ function devtools(proxyObject, options) {
   };
 }
 
-const DUMMY_SYMBOL = Symbol();
+const DUMMY_SYMBOL = /* @__PURE__ */ Symbol();
 function useProxy(proxy, options) {
   const snapshot = useSnapshot(proxy, options);
   snapshot[DUMMY_SYMBOL];
@@ -17303,5 +19104,5 @@ function useProxy(proxy, options) {
   });
 }
 
-export { KokimokiClient, KokimokiStore, derive, devtools, proxy, ref, snapshot, subscribe, subscribeKey, underive, useProxy, useSnapshot, watch };
+export { KokimokiClient, KokimokiStore, derive, devtools, getKmEnv, proxy, ref, snapshot, subscribe, subscribeKey, underive, useProxy, useSnapshot, watch };
 //# sourceMappingURL=kokimoki.min.js.map