@evolu/common 7.4.1 → 8.0.0-next.1

package/dist/src/Type.js

@@ -1,9 +1,14 @@
+/**
+ * Runtime type validation, parsing, and branded types.
+ *
+ * @module
+ */
 import { utf8ToBytes } from "@noble/ciphers/utils.js";
 import { sha256 } from "@noble/hashes/sha2.js";
 import * as bip39 from "@scure/bip39";
 import { wordlist } from "@scure/bip39/wordlists/english.js";
-import { pack } from "msgpackr";
-import { isPlainObject } from "./Object.js";
+import { exhaustiveCheck } from "./Function.js";
+import { isFunction, isPlainObject } from "./Object.js";
 import { hasNodeBuffer } from "./Platform.js";
 import { err, getOrNull, getOrThrow, ok, trySync } from "./Result.js";
 import { safelyStringifyUnknownValue } from "./String.js";
@@ -11,7 +16,7 @@ const EvoluTypeSymbol = Symbol("evolu.Type");
 /**
  * Checks if the given value is an {@link Type}.
  *
- * @category Utilities
+ * @group Utilities
  */
 export const isType = (value) => typeof value === "object" && value !== null && EvoluTypeSymbol in value;
 const createType = (name, definition) => ({
@@ -36,9 +41,8 @@ const createType = (name, definition) => ({
             if (result.ok) {
                 return { value: result.value };
             }
-            cachedStandardSchemaFormatTypeError ??= createFormatTypeError();
             return {
-                issues: typeErrorToStandardSchemaIssues(result.error, cachedStandardSchemaFormatTypeError),
+                issues: typeErrorToStandardSchemaIssues(result.error),
             };
         },
         types: {
@@ -61,7 +65,7 @@ const createType = (name, definition) => ({
  * );
  * ```
  *
- * @category Utilities
+ * @group Utilities
  */
 export const createTypeErrorFormatter = (format) => (error) => format({ ...error, value: safelyStringifyUnknownValue(error.value) });
 /**
@@ -85,7 +89,7 @@ export const createTypeErrorFormatter = (format) => (error) => format({ ...error
  * );
  * ```
  *
- * @category Base Factories
+ * @group Base factories
  */
 export const base = (name, fromUnknown) => createType(name, {
     fromUnknown,
@@ -104,52 +108,66 @@ export const base = (name, fromUnknown) => createType(name, {
  *   createBaseTypeErrorFormatter<StringError>();
  * ```
  *
- * @category Utilities
+ * @group Utilities
  */
 export const createBaseTypeErrorFormatter = () => createTypeErrorFormatter((error) => `A value ${error.value} is not a ${error.type.toLowerCase()}.`);
-/** @category Base Types */
-export const Unknown = base("Unknown", ok);
+/** @group Base Types */
+export const Unknown = /*#__PURE__*/ base("Unknown", ok);
 /**
- * @category Base Types
- * @category String
+ * @group Base Types
+ * @group String
  */
-export const String = base("String", (value) => typeof value === "string"
+export const String = /*#__PURE__*/ base("String", (value) => typeof value === "string"
     ? ok(value)
     : err({ type: "String", value }));
-export const formatStringError = createBaseTypeErrorFormatter();
-/** @category Base Types */
-export const Number = base("Number", (value) => typeof value === "number"
+export const formatStringError = 
+/*#__PURE__*/ createBaseTypeErrorFormatter();
+/** @group Base Types */
+export const Number = /*#__PURE__*/ base("Number", (value) => typeof value === "number"
     ? ok(value)
     : err({ type: "Number", value }));
-export const formatNumberError = createBaseTypeErrorFormatter();
-/** @category Base Types */
-export const BigInt = base("BigInt", (value) => typeof value === "bigint"
+export const formatNumberError = 
+/*#__PURE__*/ createBaseTypeErrorFormatter();
+/** @group Base Types */
+export const BigInt = /*#__PURE__*/ base("BigInt", (value) => typeof value === "bigint"
     ? ok(value)
     : err({ type: "BigInt", value }));
-export const formatBigIntError = createBaseTypeErrorFormatter();
-/** @category Base Types */
-export const Boolean = base("Boolean", (value) => typeof value === "boolean"
+export const formatBigIntError = 
+/*#__PURE__*/ createBaseTypeErrorFormatter();
+/** @group Base Types */
+export const Boolean = /*#__PURE__*/ base("Boolean", (value) => typeof value === "boolean"
     ? ok(value)
     : err({ type: "Boolean", value }));
-export const formatBooleanError = createBaseTypeErrorFormatter();
-/** @category Base Types */
-export const Undefined = base("Undefined", (value) => value === undefined
+export const formatBooleanError = 
+/*#__PURE__*/ createBaseTypeErrorFormatter();
+/** @group Base Types */
+export const Undefined = /*#__PURE__*/ base("Undefined", (value) => value === undefined
     ? ok(value)
     : err({ type: "Undefined", value }));
-export const formatUndefinedError = createBaseTypeErrorFormatter();
-/** @category Base Types */
-export const Null = base("Null", (value) => value === null ? ok(value) : err({ type: "Null", value }));
-export const formatNullError = createBaseTypeErrorFormatter();
-/** @category Base Types */
-export const Function = base("Function", (value) => typeof value === "function"
+export const formatUndefinedError = 
+/*#__PURE__*/ createBaseTypeErrorFormatter();
+/** @group Base Types */
+export const Null = /*#__PURE__*/ base("Null", (value) => value === null ? ok(value) : err({ type: "Null", value }));
+export const formatNullError = 
+/*#__PURE__*/ createBaseTypeErrorFormatter();
+/** @group Base Types */
+export const Function = /*#__PURE__*/ base("Function", (value) => isFunction(value)
     ? ok(value)
     : err({ type: "Function", value }));
-export const formatFunctionError = createBaseTypeErrorFormatter();
-/** @category Base Types */
-export const Uint8Array = base("Uint8Array", (value) => value instanceof globalThis.Uint8Array
+export const formatFunctionError = 
+/*#__PURE__*/ createBaseTypeErrorFormatter();
+/** @group Base Types */
+export const Uint8Array = /*#__PURE__*/ base("Uint8Array", (value) => Object.prototype.toString.call(value) === "[object Uint8Array]"
     ? ok(value)
     : err({ type: "Uint8Array", value }));
-export const formatUint8ArrayError = createBaseTypeErrorFormatter();
+export const formatUint8ArrayError = 
+/*#__PURE__*/ createBaseTypeErrorFormatter();
+/** @group Base Types */
+export const ArrayBuffer = /*#__PURE__*/ base("ArrayBuffer", (value) => Object.prototype.toString.call(value) === "[object ArrayBuffer]"
+    ? ok(value)
+    : err({ type: "ArrayBuffer", value }));
+export const formatArrayBufferError = 
+/*#__PURE__*/ createBaseTypeErrorFormatter();
 /**
  * `instanceof` {@link Type}.
  *
@@ -168,7 +186,7 @@ export const formatUint8ArrayError = createBaseTypeErrorFormatter();
  * const error = UserInstance.from({}); // err
  * ```
  *
- * @category Base Factories
+ * @group Base factories
  */
 export const instanceOf = (ctor) => ({
     ...base("InstanceOf", (value) => value instanceof ctor
@@ -176,13 +194,14 @@ export const instanceOf = (ctor) => ({
         : err({ type: "InstanceOf", value, ctor: ctor.name })),
     ctor,
 });
-export const formatInstanceOfError = createTypeErrorFormatter((error) => `The value ${error.value} is not an instance of ${error.ctor}.`);
+export const formatInstanceOfError = 
+/*#__PURE__*/ createTypeErrorFormatter((error) => `The value ${error.value} is not an instance of ${error.ctor}.`);
 /**
  * JavaScript Date.
  *
- * @category Base Types
+ * @group Base Types
  */
-export const Date = instanceOf(globalThis.Date);
+export const Date = /*#__PURE__*/ instanceOf(globalThis.Date);
 /**
  * Validates that an unknown value is an Evolu {@link Type} (i.e., satisfies
  * `AnyType`).
@@ -195,13 +214,14 @@ export const Date = instanceOf(globalThis.Date);
  * ```
  */
 // TODO: Rename to TypeInstance or something like that.
-export const EvoluType = base("EvoluType", (value) => isType(value)
+export const EvoluType = /*#__PURE__*/ base("EvoluType", (value) => isType(value)
     ? ok(value)
     : err({
         type: "EvoluType",
         value,
     }));
-export const formatIsTypeError = createTypeErrorFormatter((error) => `Value ${error.value} is not a valid Evolu Type.`);
+export const formatIsTypeError = 
+/*#__PURE__*/ createTypeErrorFormatter((error) => `Value ${error.value} is not a valid Evolu Type.`);
 export function brand(name, parent, refine) {
     const fromUnknown = refine
         ? (value) => {
@@ -232,12 +252,13 @@ export function brand(name, parent, refine) {
 /**
  * A three-letter ISO 4217 currency code (e.g., USD, EUR).
  *
- * @category String
+ * @group String
  */
-export const CurrencyCode = brand("CurrencyCode", String, (value) => /^[A-Z]{3}$/.test(value)
+export const CurrencyCode = /*#__PURE__*/ brand("CurrencyCode", String, (value) => /^[A-Z]{3}$/.test(value)
     ? ok(value)
     : err({ type: "CurrencyCode", value }));
-export const formatCurrencyCodeError = createTypeErrorFormatter((error) => `Invalid currency code: ${error.value}.`);
+export const formatCurrencyCodeError = 
+/*#__PURE__*/ createTypeErrorFormatter((error) => `Invalid currency code: ${error.value}.`);
 /**
  * ISO 8601 date-time string.
  *
@@ -257,9 +278,9 @@ export const formatCurrencyCodeError = createTypeErrorFormatter((error) => `Inva
  * const error = DateIso.from("10000-01-01T00:00:00.000Z"); // err
  * ```
  *
- * @category String
+ * @group String
  */
-export const DateIso = brand("DateIso", String, (value) => {
+export const DateIso = /*#__PURE__*/ brand("DateIso", String, (value) => {
     if (value.length !== 24) {
         return err({ type: "DateIso", value });
     }
@@ -274,7 +295,8 @@ export const DateIso = brand("DateIso", String, (value) => {
     }
     return ok(value);
 });
-export const formatDateIsoError = createTypeErrorFormatter((error) => `The value ${error.value} is not a valid ISO 8601 date string.`);
+export const formatDateIsoError = 
+/*#__PURE__*/ createTypeErrorFormatter((error) => `The value ${error.value} is not a valid ISO 8601 date string.`);
 export const dateToDateIso = (value) => DateIso.fromParent(value.toISOString());
 export const dateIsoToDate = (value) => new globalThis.Date(value);
 /**
@@ -291,25 +313,28 @@ export const dateIsoToDate = (value) => new globalThis.Date(value);
  * type TrimmedNonEmptyString = typeof TrimmedNonEmptyString.Type;
  * ```
  *
- * @category String
+ * @group String
  */
 export const trimmed = (parent) => brand("Trimmed", parent, (value) => value.trim().length === value.length
     ? ok(value)
     : err({ type: "Trimmed", value }));
-export const formatTrimmedError = createTypeErrorFormatter((error) => `The value ${error.value} must be trimmed.`);
+export const formatTrimmedError = 
+/*#__PURE__*/ createTypeErrorFormatter((error) => `The value ${error.value} must be trimmed.`);
 /**
  * Trimmed string
  *
  * - Use `TrimmedString.is` to check if an unknown value is trimmed.
  * - Use `TrimmedString.from` to check if a string is trimmed.
  *
- * @category String
+ * @group String
  */
-export const TrimmedString = trimmed(String);
+export const TrimmedString = /*#__PURE__*/ trimmed(String);
 export const trim = (value) => value.trim();
 /**
  * Minimum length.
  *
+ * Use numeric literal, not expression. See {@link BrandFactory}.
+ *
  * ### Example
  *
  * ```ts
@@ -317,14 +342,17 @@ export const trim = (value) => value.trim();
  * const NonEmptyString = minLength(1)(String);
  * ```
  *
- * @category String
- * @category Array
+ * @group String
+ * @group Array
  */
 export const minLength = (min) => (parent) => brand(`MinLength${min}`, parent, (value) => value.length >= min ? ok(value) : err({ type: "MinLength", value, min }));
-export const formatMinLengthError = createTypeErrorFormatter((error) => `The value ${error.value} does not meet the minimum length of ${error.min}.`);
+export const formatMinLengthError = 
+/*#__PURE__*/ createTypeErrorFormatter((error) => `The value ${error.value} does not meet the minimum length of ${error.min}.`);
 /**
  * Maximum length.
  *
+ * Use numeric literal, not expression. See {@link BrandFactory}.
+ *
  * ### Example
  *
  * ```ts
@@ -332,14 +360,17 @@ export const formatMinLengthError = createTypeErrorFormatter((error) => `The val
  * const String100 = maxLength(100)(String);
  * ```
  *
- * @category String
- * @category Array
+ * @group String
+ * @group Array
  */
 export const maxLength = (max) => (parent) => brand(`MaxLength${max}`, parent, (value) => value.length <= max ? ok(value) : err({ type: "MaxLength", value, max }));
-export const formatMaxLengthError = createTypeErrorFormatter((error) => `The value ${error.value} exceeds the maximum length of ${error.max}.`);
+export const formatMaxLengthError = 
+/*#__PURE__*/ createTypeErrorFormatter((error) => `The value ${error.value} exceeds the maximum length of ${error.max}.`);
 /**
  * Exact length.
  *
+ * Use numeric literal, not expression. See {@link BrandFactory}.
+ *
  * ### Example
  *
  * ```ts
@@ -347,33 +378,36 @@ export const formatMaxLengthError = createTypeErrorFormatter((error) => `The val
  * const Length1String = length(1)(String);
  * ```
  *
- * @category String
- * @category Array
+ * @group String
+ * @group Array
  */
 export const length = (exact) => (parent) => brand(`Length${exact}`, parent, (value) => value.length === exact
     ? ok(value)
     : err({ type: "Length", value, exact }));
-export const formatLengthError = createTypeErrorFormatter((error) => `The value ${error.value} does not have the required length of ${error.exact}.`);
-/** @category String */
-export const NonEmptyString = minLength(1)(String);
-/** @category String */
-export const String100 = maxLength(100)(String);
-/** @category String */
-export const String1000 = maxLength(1000)(String);
-/** @category String */
-export const NonEmptyString100 = minLength(1)(String100);
-/** @category String */
-export const NonEmptyString1000 = minLength(1)(String1000);
-/** @category String */
-export const NonEmptyTrimmedString = minLength(1)(TrimmedString);
-/** @category String */
-export const TrimmedString100 = maxLength(100)(TrimmedString);
-/** @category String */
-export const TrimmedString1000 = maxLength(1000)(TrimmedString);
-/** @category String */
-export const NonEmptyTrimmedString100 = minLength(1)(TrimmedString100);
-/** @category String */
-export const NonEmptyTrimmedString1000 = minLength(1)(TrimmedString1000);
+export const formatLengthError = 
+/*#__PURE__*/ createTypeErrorFormatter((error) => `The value ${error.value} does not have the required length of ${error.exact}.`);
+/** @group String */
+export const NonEmptyString = /*#__PURE__*/ minLength(1)(String);
+/** @group String */
+export const String100 = /*#__PURE__*/ maxLength(100)(String);
+/** @group String */
+export const String1000 = /*#__PURE__*/ maxLength(1000)(String);
+/** @group String */
+export const NonEmptyString100 = /*#__PURE__*/ minLength(1)(String100);
+/** @group String */
+export const NonEmptyString1000 = /*#__PURE__*/ minLength(1)(String1000);
+/** @group String */
+export const NonEmptyTrimmedString = /*#__PURE__*/ minLength(1)(TrimmedString);
+/** @group String */
+export const TrimmedString100 = /*#__PURE__*/ maxLength(100)(TrimmedString);
+/** @group String */
+export const TrimmedString1000 = /*#__PURE__*/ maxLength(1000)(TrimmedString);
+/** @group String */
+export const NonEmptyTrimmedString100 = 
+/*#__PURE__*/ minLength(1)(TrimmedString100);
+/** @group String */
+export const NonEmptyTrimmedString1000 = 
+/*#__PURE__*/ minLength(1)(TrimmedString1000);
 /**
  * The mnemonic, also known as a "seed phrase," is a set of 12 words in a
  * specific order chosen from a predefined list (BIP39). It provides a
@@ -381,12 +415,13 @@ export const NonEmptyTrimmedString1000 = minLength(1)(TrimmedString1000);
  * safely on the user's device using cryptographically secure random number
  * generation, ensuring it remains private and unique.
  *
- * @category String
+ * @group String
  */
-export const Mnemonic = brand("Mnemonic", NonEmptyTrimmedString, (value) => bip39.validateMnemonic(value, wordlist)
+export const Mnemonic = /*#__PURE__*/ brand("Mnemonic", NonEmptyTrimmedString, (value) => bip39.validateMnemonic(value, wordlist)
     ? ok(value)
     : err({ type: "Mnemonic", value }));
-export const formatMnemonicError = createTypeErrorFormatter((error) => `Invalid BIP39 mnemonic: ${error.value}.`);
+export const formatMnemonicError = 
+/*#__PURE__*/ createTypeErrorFormatter((error) => `Invalid BIP39 mnemonic: ${error.value}.`);
 /**
  * String matching a regular expression.
  *
@@ -396,7 +431,7 @@ export const formatMnemonicError = createTypeErrorFormatter((error) => `Invalid
  * const Alphanumeric = regex("Alphanumeric", /^[a-z0-9]+$/i)(String);
  * ```
  *
- * @category String
+ * @group String
  */
 export const regex = (name, pattern) => {
     // Clone the regex to avoid shared state.
@@ -410,7 +445,8 @@ export const regex = (name, pattern) => {
             : err({ type: "Regex", name, value, pattern });
     });
 };
-export const formatRegexError = createTypeErrorFormatter((error) => `The value ${error.value} does not match the pattern for ${error.name}: ${error.pattern}.`);
+export const formatRegexError = 
+/*#__PURE__*/ createTypeErrorFormatter((error) => `The value ${error.value} does not match the pattern for ${error.name}: ${error.pattern}.`);
 /**
  * URL-safe string.
  *
@@ -436,18 +472,18 @@ export const formatRegexError = createTypeErrorFormatter((error) => `The value $
  * }
  * ```
  *
- * @category String
+ * @group String
  */
-export const UrlSafeString = regex("UrlSafeString", /^[A-Za-z0-9_-]+$/)(String);
+export const UrlSafeString = /*#__PURE__*/ regex("UrlSafeString", /^[A-Za-z0-9_-]+$/)(String);
 /**
  * Base64Url without padding.
  *
  * Encode with {@link uint8ArrayToBase64Url}, decode with
  * {@link base64UrlToUint8Array}.
  *
- * @category String
+ * @group String
  */
-export const Base64Url = brand("Base64Url", String, (value) => {
+export const Base64Url = /*#__PURE__*/ brand("Base64Url", String, (value) => {
     // Round-trip validation ensures consistency across different base64url
     // implementations (Node.js Buffer, native browser API, manual fallback).
     // Only strings that decode and encode identically are accepted.
@@ -462,7 +498,8 @@ export const Base64Url = brand("Base64Url", String, (value) => {
         ? ok(value)
         : err({ type: "Base64Url", value });
 });
-export const formatBase64UrlError = createTypeErrorFormatter((error) => `The value ${error.value} is not a valid Base64Url string.`);
+export const formatBase64UrlError = 
+/*#__PURE__*/ createTypeErrorFormatter((error) => `The value ${error.value} is not a valid Base64Url string.`);
 const base64UrlOptions = { alphabet: "base64url", omitPadding: true };
 /** Encodes a Uint8Array to a {@link Base64Url} string. */
 export const uint8ArrayToBase64Url = hasNodeBuffer
@@ -500,29 +537,30 @@ export const base64UrlToUint8Array = hasNodeBuffer
                 return globalThis.Uint8Array.from(binaryString, (c) => c.charCodeAt(0));
             };
 /**
- * Simple alphanumeric string for naming in file systems, URLs, and identifiers.
+ * Alphanumeric string for naming in file systems, URLs, and identifiers.
  *
  * Uses the same safe alphabet as {@link UrlSafeString} (letters, digits, `-`,
- * `_`). See `UrlSafeString` for details.
+ * `_`).
  *
  * The string must be between 1 and 64 characters.
  *
  * ### Example
  *
  * ```ts
- * const result = SimpleName.from("data-report-123");
+ * const result = Name.from("data-report-123");
  * if (result.ok) {
- *   console.log("Valid SimpleName string:", result.value);
+ *   console.log("Valid Name string:", result.value);
  * } else {
- *   console.error("Invalid SimpleName string:", result.error);
+ *   console.error("Invalid Name string:", result.error);
  * }
  * ```
  *
- * @category String
+ * @group String
  */
-export const SimpleName = brand("SimpleName", UrlSafeString, (value) => value.length >= 1 && value.length <= 64
+export const Name = /*#__PURE__*/ brand("Name", UrlSafeString, (value) => value.length >= 1 && value.length <= 64
     ? ok(value)
-    : err({ type: "SimpleName", value }));
+    : err({ type: "Name", value }));
+export const testName = /*#__PURE__*/ Name.orThrow("Name");
 /**
  * Trimmed string between 8 and 64 characters, branded as `SimplePassword`.
  *
@@ -545,9 +583,10 @@ export const SimpleName = brand("SimpleName", UrlSafeString, (value) => value.le
  * //   |> brand("SimplePassword", %)
  * ```
  *
- * @category String
+ * @group String
  */
-export const SimplePassword = brand("SimplePassword", minLength(8)(maxLength(64)(TrimmedString)));
+export const SimplePassword = /*#__PURE__*/ brand("SimplePassword", 
+/*#__PURE__*/ minLength(8)(/*#__PURE__*/ maxLength(64)(TrimmedString)));
 export const formatSimplePasswordError = (formatTypeError) => createTypeErrorFormatter((error) => `Invalid password: ${formatTypeError(error.parentError)}`);
 /**
  * Evolu Id: 16 bytes encoded as a 22‑character Base64Url string.
@@ -565,19 +604,19 @@ export const formatSimplePasswordError = (formatTypeError) => createTypeErrorFor
  * copied (logs, URLs, exports); only use it when you explicitly want insertion
  * locality for very large write‑heavy tables and accept timestamp exposure.
  *
- * ### Future
+ * ## Future
  *
  * A possible hybrid masked‑time approach (`timestamp ^ H(cluster_id, timestamp
  *
  * > > N)`) could provide locality without exposing raw creation time. See
  * > > https://brooker.co.za/blog/2025/10/22/uuidv7.html
  *
- * @category String
+ * @group String
  */
-export const Id = brand("Id", String, (value) => value.length === 22 && Base64Url.fromParent(value).ok
+export const Id = /*#__PURE__*/ brand("Id", String, (value) => value.length === 22 && Base64Url.fromParent(value).ok
     ? ok(value)
     : err({ type: "Id", value }));
-export const formatIdError = createTypeErrorFormatter((error) => `The value ${error.value} is not a valid Id.`);
+export const formatIdError = /*#__PURE__*/ createTypeErrorFormatter((error) => `The value ${error.value} is not a valid Id.`);
 /**
  * Creates a random {@link Id}. This is the recommended default.
  *
@@ -626,7 +665,7 @@ export const createId = (deps) => {
  * external string from the generated {@link Id}. If you need to preserve the
  * original external ID, store it in a separate column.
  *
- * @category String
+ * @group String
  */
 export const createIdFromString = (value) => {
     const hash = sha256(utf8ToBytes(value));
@@ -661,7 +700,7 @@ export const createIdAsUuidv7 = (deps) => {
     id[5] = globalThis.Number(timestamp & 0xffn);
     id[6] = (id[6] & 0x0f) | 0x70;
     id[8] = (id[8] & 0x3f) | 0x80;
-    return id;
+    return uint8ArrayToBase64Url(id);
 };
 /**
  * Creates a branded {@link Id} Type for a table's primary key.
@@ -676,7 +715,7 @@ export const createIdAsUuidv7 = (deps) => {
  * type TodoId = typeof TodoId.Type;
  * ```
  *
- * @category String
+ * @group String
  */
 export const id = (table) => {
     const fromUnknown = (value) => {
@@ -697,9 +736,11 @@ export const id = (table) => {
         table,
     };
 };
-export const formatTableIdError = createTypeErrorFormatter((error) => `Invalid Id for table ${error.table}: ${error.value}.`);
+export const formatTableIdError = 
+/*#__PURE__*/ createTypeErrorFormatter((error) => `Invalid Id for table ${error.table}: ${error.value}.`);
 /** Binary representation of an {@link Id}. */
-export const IdBytes = brand("IdBytes", length(16)(Uint8Array));
+export const IdBytes = /*#__PURE__*/ brand("IdBytes", 
+/*#__PURE__*/ length(16)(Uint8Array));
 export const idBytesTypeValueLength = 16;
 export const idToIdBytes = (id) => 
 // Id is Base64Url (validated by Id.from), cast is safe
@@ -719,10 +760,11 @@ uint8ArrayToBase64Url(idBytes);
  * const errorResult = PositiveNumber.from(-5); // err
  * ```
  *
- * @category Number
+ * @group Number
  */
 export const positive = (parent) => brand("Positive", parent, (value) => value > 0 ? ok(value) : err({ type: "Positive", value }));
-export const formatPositiveError = createTypeErrorFormatter((error) => `The value ${error.value} must be positive (> 0).`);
+export const formatPositiveError = 
+/*#__PURE__*/ createTypeErrorFormatter((error) => `The value ${error.value} must be positive (> 0).`);
 /**
  * Negative number (< 0).
  *
@@ -732,10 +774,11 @@ export const formatPositiveError = createTypeErrorFormatter((error) => `The valu
  * const NegativeNumber = negative(Number);
  * ```
  *
- * @category Number
+ * @group Number
  */
 export const negative = (parent) => brand("Negative", parent, (value) => value < 0 ? ok(value) : err({ type: "Negative", value }));
-export const formatNegativeError = createTypeErrorFormatter((error) => `The value ${error.value} must be negative (< 0).`);
+export const formatNegativeError = 
+/*#__PURE__*/ createTypeErrorFormatter((error) => `The value ${error.value} must be negative (< 0).`);
 /**
  * Non-positive number (≤ 0).
  *
@@ -745,12 +788,13 @@ export const formatNegativeError = createTypeErrorFormatter((error) => `The valu
  * const NonPositiveNumber = nonPositive(Number);
  * ```
  *
- * @category Number
+ * @group Number
  */
 export const nonPositive = (parent) => brand("NonPositive", parent, (value) => value <= 0
     ? ok(value)
     : err({ type: "NonPositive", value }));
-export const formatNonPositiveError = createTypeErrorFormatter((error) => `The value ${error.value} must be non-positive (≤ 0).`);
+export const formatNonPositiveError = 
+/*#__PURE__*/ createTypeErrorFormatter((error) => `The value ${error.value} must be non-positive (≤ 0).`);
 /**
  * Non-negative number (≥ 0).
  *
@@ -760,133 +804,156 @@ export const formatNonPositiveError = createTypeErrorFormatter((error) => `The v
  * const NonNegativeNumber = nonNegative(Number);
  * ```
  *
- * @category Number
+ * @group Number
  */
 export const nonNegative = (parent) => brand("NonNegative", parent, (value) => value >= 0
     ? ok(value)
     : err({ type: "NonNegative", value }));
-export const formatNonNegativeError = createTypeErrorFormatter((error) => `The value ${error.value} must be non-negative (≥ 0).`);
+export const formatNonNegativeError = 
+/*#__PURE__*/ createTypeErrorFormatter((error) => `The value ${error.value} must be non-negative (≥ 0).`);
 /**
  * Non-negative number (≥ 0).
  *
- * @category Number
+ * @group Number
  */
-export const NonNegativeNumber = nonNegative(Number);
+export const NonNegativeNumber = /*#__PURE__*/ nonNegative(Number);
 /**
  * Positive number (> 0).
  *
- * @category Number
+ * @group Number
  */
-export const PositiveNumber = positive(NonNegativeNumber);
+export const PositiveNumber = /*#__PURE__*/ positive(NonNegativeNumber);
 /**
  * Non-positive number (≤ 0).
  *
- * @category Number
+ * @group Number
  */
-export const NonPositiveNumber = nonPositive(Number);
+export const NonPositiveNumber = /*#__PURE__*/ nonPositive(Number);
 /**
  * Negative number (< 0).
  *
- * @category Number
+ * @group Number
  */
-export const NegativeNumber = negative(NonPositiveNumber);
+export const NegativeNumber = /*#__PURE__*/ negative(NonPositiveNumber);
 /**
  * Integer within the safe range of JavaScript numbers.
  *
  * ### Example
  *
  * ```ts
- * const Int = int(Number);
+ * const Int = safeInt(Number);
  * ```
  *
- * @category Number
+ * Note: This helper was previously named `int`. A Next.js regression produced
+ * runtime `int is not defined`, so we keep the implementation under the
+ * `safeInt` alias.
+ *
+ * @group Number
  */
-export const int = (parent) => brand("Int", parent, (value) => globalThis.Number.isSafeInteger(value)
+const safeInt = (parent) => brand("Int", parent, (value) => globalThis.Number.isSafeInteger(value)
     ? ok(value)
     : err({ type: "Int", value }));
-export const formatIntError = createTypeErrorFormatter((error) => `The value ${error.value} must be an integer.`);
+export const formatIntError = /*#__PURE__*/ createTypeErrorFormatter((error) => `The value ${error.value} must be an integer.`);
 /**
  * Integer within the safe range of JavaScript numbers.
  *
- * @category Number
+ * @group Number
  */
-export const Int = int(Number);
+export const Int = /*#__PURE__*/ safeInt(Number);
 /**
  * Non-negative integer (≥ 0).
  *
- * @category Number
+ * @group Number
  */
-export const NonNegativeInt = nonNegative(Int);
+export const NonNegativeInt = /*#__PURE__*/ nonNegative(Int);
+/** Minimum {@link NonNegativeInt} value (0). */
+export const zeroNonNegativeInt = /*#__PURE__*/ NonNegativeInt.orThrow(0);
 /**
  * Positive integer (> 0).
  *
- * @category Number
+ * @group Number
  */
-export const PositiveInt = positive(NonNegativeInt);
-/** Maximum safe positive integer value for practically infinite operations. */
-export const maxPositiveInt = PositiveInt.orThrow(globalThis.Number.MAX_SAFE_INTEGER);
+export const PositiveInt = /*#__PURE__*/ positive(NonNegativeInt);
+/** {@link PositiveInt} value 1. */
+export const onePositiveInt = /*#__PURE__*/ PositiveInt.orThrow(1);
+/** Maximum {@link PositiveInt} value (MAX_SAFE_INTEGER). */
+export const maxPositiveInt = /*#__PURE__*/ PositiveInt.orThrow(globalThis.Number.MAX_SAFE_INTEGER);
 /**
  * Non-positive integer (≤ 0).
  *
- * @category Number
+ * @group Number
  */
-export const NonPositiveInt = nonPositive(Int);
+export const NonPositiveInt = /*#__PURE__*/ nonPositive(Int);
 /**
  * Negative integer (< 0).
  *
- * @category Number
+ * @group Number
  */
-export const NegativeInt = negative(NonPositiveInt);
+export const NegativeInt = /*#__PURE__*/ negative(NonPositiveInt);
 /**
  * Number greater than a specified value.
  *
- * @category Number
+ * Use numeric literal, not expression. See {@link BrandFactory}.
+ *
+ * @group Number
  */
 export const greaterThan = (min) => (parent) => brand(`GreaterThan${min}`, parent, (value) => value > min ? ok(value) : err({ type: "GreaterThan", value, min }));
-export const formatGreaterThanError = createTypeErrorFormatter((error) => `The value ${error.value} is not > ${error.min}.`);
+export const formatGreaterThanError = 
+/*#__PURE__*/ createTypeErrorFormatter((error) => `The value ${error.value} is not > ${error.min}.`);
 /**
  * Number less than a specified value.
  *
- * @category Number
+ * Use numeric literal, not expression. See {@link BrandFactory}.
+ *
+ * @group Number
  */
 export const lessThan = (max) => (parent) => brand(`LessThan${max}`, parent, (value) => value < max ? ok(value) : err({ type: "LessThan", value, max }));
-export const formatLessThanError = createTypeErrorFormatter((error) => `The value ${error.value} is not < ${error.max}.`);
+export const formatLessThanError = 
+/*#__PURE__*/ createTypeErrorFormatter((error) => `The value ${error.value} is not < ${error.max}.`);
 /**
  * Number ≥ a specified value.
  *
- * @category Number
+ * Use numeric literal, not expression. See {@link BrandFactory}.
+ *
+ * @group Number
  */
 export const greaterThanOrEqualTo = (min) => (parent) => brand(`GreaterThanOrEqualTo${min}`, parent, (value) => value >= min
     ? ok(value)
     : err({ type: "GreaterThanOrEqualTo", value, min }));
-export const formatGreaterThanOrEqualToError = createTypeErrorFormatter((error) => `The value ${error.value} is not >= ${error.min}.`);
+export const formatGreaterThanOrEqualToError = 
+/*#__PURE__*/ createTypeErrorFormatter((error) => `The value ${error.value} is not >= ${error.min}.`);
 /**
  * Number ≤ a specified value.
  *
- * @category Number
+ * Use numeric literal, not expression. See {@link BrandFactory}.
+ *
+ * @group Number
  */
 export const lessThanOrEqualTo = (max) => (parent) => brand(`LessThanOrEqualTo${max}`, parent, (value) => value <= max ? ok(value) : err({ type: "LessThanOrEqualTo", value, max }));
-export const formatLessThanOrEqualToError = createTypeErrorFormatter((error) => `The value ${error.value} is not <= ${error.max}.`);
+export const formatLessThanOrEqualToError = 
+/*#__PURE__*/ createTypeErrorFormatter((error) => `The value ${error.value} is not <= ${error.max}.`);
 /**
  * Number that is not NaN.
  *
- * @category Number
+ * @group Number
  */
 export const nonNaN = (parent) => brand("NonNaN", parent, (value) => !globalThis.Number.isNaN(value)
     ? ok(value)
     : err({ type: "NonNaN", value }));
-export const formatNonNaNError = createTypeErrorFormatter(() => `The value must not be NaN.`);
-/** @category Number */
-export const NonNaNNumber = nonNaN(Number);
+export const formatNonNaNError = 
+/*#__PURE__*/ createTypeErrorFormatter(() => `The value must not be NaN.`);
+/** @group Number */
+export const NonNaNNumber = /*#__PURE__*/ nonNaN(Number);
 /**
  * Finite number.
  *
- * @category Number
+ * @group Number
  */
 export const finite = (parent) => brand("Finite", parent, (value) => globalThis.Number.isFinite(value)
     ? ok(value)
     : err({ type: "Finite", value }));
-export const formatFiniteError = createTypeErrorFormatter((error) => `The value ${error.value} must be finite.`);
+export const formatFiniteError = 
+/*#__PURE__*/ createTypeErrorFormatter((error) => `The value ${error.value} must be finite.`);
 /**
  * Finite number.
  *
@@ -898,21 +965,26 @@ export const formatFiniteError = createTypeErrorFormatter((error) => `The value
  * finite (e.g., `Infinity`, `-Infinity`, or `NaN`). Using `FiniteNumber` helps
  * prevent these unexpected behaviors when working with JSON serialization.
  *
- * @category Number
+ * @group Number
  */
-export const FiniteNumber = finite(Number);
+export const FiniteNumber = /*#__PURE__*/ finite(Number);
 /**
  * Number that is a multiple of a divisor.
  *
- * @category Number
+ * Use numeric literal, not expression. See {@link BrandFactory}.
+ *
+ * @group Number
  */
 export const multipleOf = (divisor) => (parent) => brand(`MultipleOf${divisor}`, parent, (value) => value % divisor === 0
     ? ok(value)
     : err({ type: "MultipleOf", value, divisor }));
-export const formatMultipleOfError = createTypeErrorFormatter((error) => `The value ${error.value} is not a multiple of ${error.divisor}.`);
+export const formatMultipleOfError = 
+/*#__PURE__*/ createTypeErrorFormatter((error) => `The value ${error.value} is not a multiple of ${error.divisor}.`);
 /**
  * Number within a range, inclusive.
  *
+ * Use numeric literal, not expression. See {@link BrandFactory}.
+ *
  * ### Example
  *
  * ```ts
@@ -921,12 +993,13 @@ export const formatMultipleOfError = createTypeErrorFormatter((error) => `The va
  * const errorResult = Between1And10.from(11); // err
  * ```
  *
- * @category Number
+ * @group Number
  */
 export const between = (min, max) => (parent) => brand(`Between${min}-${max}`, parent, (value) => value >= min && value <= max
     ? ok(value)
     : err({ type: "Between", value, min, max }));
-export const formatBetweenError = createTypeErrorFormatter((error) => `The value ${error.value} is not between ${error.min} and ${error.max}, inclusive.`);
+export const formatBetweenError = 
+/*#__PURE__*/ createTypeErrorFormatter((error) => `The value ${error.value} is not between ${error.min} and ${error.max}, inclusive.`);
 /**
  * Literal {@link Type}.
  *
@@ -942,7 +1015,7 @@ export const formatBetweenError = createTypeErrorFormatter((error) => `The value
  *
  * TODO: Add JsonValue
  *
- * @category Base Factories
+ * @group Base factories
  */
 export const literal = (expected) => {
     const fromUnknown = (value) => value === expected
@@ -956,11 +1029,12 @@ export const literal = (expected) => {
         expected,
     };
 };
-export const formatLiteralError = createTypeErrorFormatter((error) => `The value ${error.value} is not strictly equal to the expected literal: ${globalThis.String(error.expected)}.`);
+export const formatLiteralError = 
+/*#__PURE__*/ createTypeErrorFormatter((error) => `The value ${error.value} is not strictly equal to the expected literal: ${globalThis.String(error.expected)}.`);
 /**
  * Array of a specific {@link Type}.
  *
- * Usage:
+ * ### Example
  *
  * ```ts
  * const NumberArray = array(Number);
@@ -969,8 +1043,8 @@ export const formatLiteralError = createTypeErrorFormatter((error) => `The value
  * const result2 = NumberArray.from(["a", "b"]); // err(...)
  * ```
  *
- * @category Base Factories
- * @category Array
+ * @group Base factories
+ * @group Array
  */
 export const array = (element) => {
     const fromUnknown = (value) => {
@@ -1043,7 +1117,7 @@ export const formatArrayError = (formatTypeError) => createTypeErrorFormatter((e
  * const result2 = NumberSet.from(new Set(["a", "b"])); // err(...)
  * ```
  *
- * @category Base Factories
+ * @group Base factories
  */
 export const set = (element) => {
     const fromUnknown = (value) => {
@@ -1128,8 +1202,8 @@ export const formatSetError = (formatTypeError) => createTypeErrorFormatter((err
  * StringToNumberRecord.from({ a: "x", b: 2 });
  * ```
  *
- * @category Base Factories
- * @category Object
+ * @group Base factories
+ * @group Object
  */
 export const record = (keyType, valueType) => {
     const fromUnknown = (value) => {
@@ -1375,6 +1449,9 @@ export const formatObjectWithRecordError = (formatTypeError) => createTypeErrorF
             return `Invalid value at index key ${error.reason.key}: ${formatTypeError(error.reason.error)}`;
     }
 });
+export function typed(tag, props) {
+    return object({ type: literal(tag), ...props });
+}
 export function union(...args) {
     /**
      * Good First Issue:
@@ -1420,6 +1497,75 @@ export const formatUnionError = (formatTypeError) => createTypeErrorFormatter((e
     return `Value ${error.value} does not match any member of the union.\nErrors:\n${formattedErrors}`;
 });
 export const isUnionType = (t) => t.name === "Union" && Array.isArray(t.members);
+/**
+ * Creates a {@link Type} for {@link Result} values.
+ *
+ * Use for validating serialized Results from storage, APIs, or message passing.
+ *
+ * ### Example
+ *
+ * ```ts
+ * const SyncResponse = result(
+ *   object({ timestamp: NonNegativeInt }),
+ *   typed("SyncError", { message: String }),
+ * );
+ *
+ * // Validate response from worker or API
+ * const validated = SyncResponse.from(JSON.parse(message));
+ * if (!validated.ok) return validated; // validation error
+ * // validated.value is Result<{ timestamp }, SyncError>
+ * ```
+ *
+ * @group Composite factories
+ */
+export const result = (okType, errType) => union(object({ ok: literal(true), value: okType }), object({ ok: literal(false), error: errType }));
+/**
+ * A {@link result} type for `Result<unknown, unknown>`.
+ *
+ * Useful for serializing Results where the value and error types are unknown.
+ *
+ * @group Composite factories
+ */
+export const UnknownResult = /*#__PURE__*/ result(Unknown, Unknown);
+/**
+ * Creates a {@link Type} for {@link NextResult} with three outcomes.
+ *
+ * Validates results where the producer responds with:
+ *
+ * - `Ok<A>` — produced a value
+ * - `Err<Done<D>>` — completed normally with a done value
+ * - `Err<E>` — failed with an error
+ *
+ * ### Example
+ *
+ * ```ts
+ * const MyNextResult = nextResult(Item, MyError, Summary);
+ *
+ * const validated = MyNextResult.fromUnknown(data);
+ * if (!validated.ok) return validated;
+ *
+ * const result = validated.value;
+ * if (result.ok) {
+ *   console.log(result.value);
+ * } else if (result.error.type === "Done") {
+ *   console.log("Done:", result.error.done);
+ * } else {
+ *   console.error(result.error);
+ * }
+ * ```
+ *
+ * @group Composite factories
+ */
+export const nextResult = (valueType, errorType, doneType) => result(valueType, union(errorType, typed("Done", { done: doneType })));
+/**
+ * A {@link nextResult} type for `NextResult<unknown, unknown, unknown>`.
+ *
+ * Useful for checking if a value is a {@link NextResult} via
+ * `UnknownNextResult.is(value)`.
+ *
+ * @group Composite factories
+ */
+export const UnknownNextResult = /*#__PURE__*/ nextResult(Unknown, Unknown, Unknown);
 /**
  * Recursive {@link Type}.
  *
@@ -1453,7 +1599,7 @@ export const isUnionType = (t) => t.name === "Union" && Array.isArray(t.members)
  * );
  * ```
  *
- * @category Base Factories
+ * @group Base factories
  */
 export const recursive = (create) => {
     let type;
@@ -1494,7 +1640,7 @@ export const recursive = (create) => {
  * NullOrString.from(42); // err(...)
  * ```
  *
- * @category Base Factories
+ * @group Base factories
  */
 export const nullOr = (type) => union(Null, type);
 /**
@@ -1509,7 +1655,7 @@ export const nullOr = (type) => union(Null, type);
  * UndefinedOrString.from(42); // err(...)
  * ```
  *
- * @category Base Factories
+ * @group Base factories
  */
 export const undefinedOr = (type) => union(Undefined, type);
 /**
@@ -1528,7 +1674,7 @@ export const undefinedOr = (type) => union(Undefined, type);
  * NullishOrString.from(42); // err(...)
  * ```
  *
- * @category Base Factories
+ * @group Base factories
  */
 export const nullishOr = (type) => union(Undefined, Null, type);
 /**
@@ -1545,7 +1691,7 @@ export const nullishOr = (type) => union(Undefined, Null, type);
  * const error = NameAndAge.from(["Alice", -10]); // err
  * ```
  *
- * @category Base Factories
+ * @group Base factories
  */
 export const tuple = (...elements) => {
     const fromUnknown = (value) => {
@@ -1631,42 +1777,44 @@ export const formatTupleError = (formatTypeError) => createTypeErrorFormatter((e
  *
  * https://www.sqlite.org/c3ref/int64.html
  *
- * @category Number
+ * @group Number
  */
-export const Int64 = brand("Int64", BigInt, (value) => value >= -9223372036854775808n && value <= 9223372036854775807n
+export const Int64 = /*#__PURE__*/ brand("Int64", BigInt, (value) => value >= -9223372036854775808n && value <= 9223372036854775807n
     ? ok(value)
     : err({ type: "Int64", value }));
-export const formatInt64Error = createTypeErrorFormatter((error) => `The value ${error.value} is not a valid 64-bit signed integer (Int64).`);
+export const formatInt64Error = 
+/*#__PURE__*/ createTypeErrorFormatter((error) => `The value ${error.value} is not a valid 64-bit signed integer (Int64).`);
 /**
  * Stringified {@link Int64}.
  *
- * @category String
+ * @group String
  */
-export const Int64String = brand("Int64", NonEmptyTrimmedString, (value) => trySync(() => {
+export const Int64String = /*#__PURE__*/ brand("Int64", NonEmptyTrimmedString, (value) => trySync(() => {
     const maybeInt = globalThis.BigInt(value);
     Int64.orThrow(maybeInt);
     return value;
 }, () => ({ type: "Int64String", value })));
-export const formatInt64StringError = createTypeErrorFormatter((error) => `The value ${error.value} is not a valid Int64 string.`);
+export const formatInt64StringError = 
+/*#__PURE__*/ createTypeErrorFormatter((error) => `The value ${error.value} is not a valid Int64 string.`);
 /**
  * JSON-compatible value: string, {@link FiniteNumber}, boolean, null,
  * {@link JsonArray}, or {@link JsonObject}.
  *
- * @category Base Types
+ * @group Base Types
  */
-export const JsonValue = recursive(() => union(String, FiniteNumber, Boolean, Null, JsonArray, JsonObject));
+export const JsonValue = /*#__PURE__*/ recursive(() => union(String, FiniteNumber, Boolean, Null, JsonArray, JsonObject));
 /**
  * JSON-compatible array of {@link JsonValue} elements.
  *
- * @category Array
+ * @group Array
  */
-export const JsonArray = array(JsonValue);
+export const JsonArray = /*#__PURE__*/ array(JsonValue);
 /**
  * JSON-compatible object with string keys and {@link JsonValue} values.
  *
- * @category Object
+ * @group Object
  */
-export const JsonObject = record(String, JsonValue);
+export const JsonObject = /*#__PURE__*/ record(String, JsonValue);
 export const parseJson = (value) => trySync(() => JSON.parse(value), (error) => ({
     type: `Json`,
     value,
@@ -1682,15 +1830,16 @@ export const parseJson = (value) => trySync(() => JSON.parse(value), (error) =>
  * const error = Json.from("invalid json"); // err
  * ```
  *
- * @category String
+ * @group String
  */
-export const Json = brand("Json", String, (value) => {
+export const Json = /*#__PURE__*/ brand("Json", String, (value) => {
     const result = parseJson(value);
     if (!result.ok)
         return result;
     return ok(value);
 });
-export const formatJsonError = createTypeErrorFormatter((error) => `Invalid JSON: ${error.value}. Error: ${error.message}`);
+export const formatJsonError = 
+/*#__PURE__*/ createTypeErrorFormatter((error) => `Invalid JSON: ${error.value}. Error: ${error.message}`);
 export const jsonValueToJson = (value) => JSON.stringify(value);
 export const jsonToJsonValue = (value) => JSON.parse(value);
 /**
@@ -1713,7 +1862,7 @@ export const jsonToJsonValue = (value) => JSON.parse(value);
  *   name: NonEmptyString100,
  *   age: FiniteNumber,
  * });
- * type Person = typeof Person.Type;
+ * interface Person extends InferType<typeof Person> {}
  *
  * const [PersonJson, personToPersonJson, personJsonToPerson] = json(
  *   Person,
@@ -1738,11 +1887,7 @@ export const json = (type, name) => {
             return validationResult;
         return ok(value);
     });
-    return [
-        BrandedJsonType,
-        jsonValueToJson,
-        jsonToJsonValue,
-    ];
+    return [BrandedJsonType, jsonValueToJson, jsonToJsonValue];
 };
 /**
  * Optional {@link Type}.
@@ -1799,7 +1944,7 @@ export const isOptionalType = (x) => typeof x === "object" && x != null && "name
  * PartialUser.from({ age: -5 });
  * ```
  *
- * @category Object
+ * @group Object
  */
 export const partial = (props) => {
     const optionalProps = {};
@@ -1816,7 +1961,7 @@ export const partial = (props) => {
  * entirely, or set it to `null`, or set it to the non-null member of the
  * union.
  *
- * @category Object
+ * @group Object
  */
 export const nullableToOptional = (props) => {
     const transformedProps = {};
@@ -1836,9 +1981,9 @@ export const nullableToOptional = (props) => {
 /**
  * Create a new `object` {@link Type} by omitting some keys.
  *
- * @category Object
+ * @group Object
  */
-export function omit(objectType, ...keys) {
+export const omit = (objectType, ...keys) => {
     const newProps = {};
     for (const key in objectType.props) {
         if (!keys.includes(key)) {
@@ -1847,18 +1992,7 @@ export function omit(objectType, ...keys) {
         }
     }
     return object(newProps);
-}
-export const maxMutationSize = 655360;
-/**
- * Evolu has to limit the maximum mutation size. Otherwise, sync couldn't use
- * the `maxProtocolMessageRangesSize`. The max size is 640KB in bytes, measured
- * via MessagePack. Evolu Protocol DbChange will be smaller thanks to various
- * optimizations.
- */
-export const validMutationSize = (type) => brand("ValidMutationSize", type, (value) => pack(value).byteLength <= maxMutationSize
-    ? ok(value)
-    : err({ type: "ValidMutationSize", value }));
-export const formatValidMutationSizeError = createTypeErrorFormatter((error) => `The mutation size exceeds the maximum limit of ${maxMutationSize} bytes. The provided mutation has a size of ${pack(error.value).byteLength} bytes.`);
+};
 /**
  * Formats Evolu Type errors into user-friendly messages.
  *
@@ -1937,7 +2071,7 @@ export const formatValidMutationSizeError = createTypeErrorFormatter((error) =>
  * };
  * ```
  *
- * @category Utilities
+ * @group Utilities
  */
 export const createFormatTypeError = (extraFormatter) => {
     const formatTypeError = (error) => {
@@ -1962,6 +2096,8 @@ export const createFormatTypeError = (extraFormatter) => {
                 return formatFunctionError(error);
             case "Uint8Array":
                 return formatUint8ArrayError(error);
+            case "ArrayBuffer":
+                return formatArrayBufferError(error);
             case "InstanceOf":
                 return formatInstanceOfError(error);
             case "EvoluType":
@@ -2020,8 +2156,6 @@ export const createFormatTypeError = (extraFormatter) => {
                 return formatInt64StringError(error);
             case "Json":
                 return formatJsonError(error);
-            case "ValidMutationSize":
-                return formatValidMutationSizeError(error);
             // Composite Types
             case "SimplePassword":
                 return formatSimplePasswordError(formatTypeError)(error);
@@ -2052,82 +2186,78 @@ export const createFormatTypeError = (extraFormatter) => {
  * Converts an Evolu {@link TypeError} to Standard Schema V1 issues format.
  *
  * This function recursively converts Evolu's typed errors into the Standard
- * Schema issue format with proper path tracking for nested structures.
+ * Schema issue format with proper path tracking for nested structures. The
+ * `message` field contains the JSON-serialized typed error, which users can
+ * deserialize and format using appropriate {@link TypeErrorFormatter}s.
  *
- * @category Utilities
+ * @group Utilities
  */
-export const typeErrorToStandardSchemaIssues = (error, formatTypeError, path = []) => {
+export const typeErrorToStandardSchemaIssues = (error, path = []) => {
     if (error.type === "Array") {
         const arrayError = error;
         if (arrayError.reason.kind === "NotArray") {
-            return [{ message: formatTypeError(error), path }];
+            return [{ message: JSON.stringify(error), path }];
         }
-        return typeErrorToStandardSchemaIssues(arrayError.reason.error, formatTypeError, [...path, arrayError.reason.index]);
+        return typeErrorToStandardSchemaIssues(arrayError.reason.error, [...path, arrayError.reason.index]);
     }
     if (error.type === "Set") {
         const setError = error;
         if (setError.reason.kind === "NotSet") {
-            return [{ message: formatTypeError(error), path }];
+            return [{ message: JSON.stringify(error), path }];
         }
-        return typeErrorToStandardSchemaIssues(setError.reason.error, formatTypeError, [...path, setError.reason.index]);
+        return typeErrorToStandardSchemaIssues(setError.reason.error, [...path, setError.reason.index]);
     }
     if (error.type === "Object") {
         const objectError = error;
         if (objectError.reason.kind === "NotObject" ||
             objectError.reason.kind === "ExtraKeys") {
-            return [{ message: formatTypeError(error), path }];
+            return [{ message: JSON.stringify(error), path }];
         }
         const issues = [];
         for (const [key, propError] of Object.entries(objectError.reason.errors)) {
-            issues.push(...typeErrorToStandardSchemaIssues(propError, formatTypeError, [...path, key]));
+            issues.push(...typeErrorToStandardSchemaIssues(propError, [...path, key]));
         }
         return issues;
     }
     if (error.type === "ObjectWithRecord") {
         const objectWithRecordError = error;
         if (objectWithRecordError.reason.kind === "NotObject") {
-            return [{ message: formatTypeError(error), path }];
+            return [{ message: JSON.stringify(error), path }];
         }
         if (objectWithRecordError.reason.kind === "IndexKey" ||
             objectWithRecordError.reason.kind === "IndexValue") {
-            return typeErrorToStandardSchemaIssues(objectWithRecordError.reason.error, formatTypeError, [...path, objectWithRecordError.reason.key]);
+            return typeErrorToStandardSchemaIssues(objectWithRecordError.reason.error, [...path, objectWithRecordError.reason.key]);
         }
         const issues = [];
         for (const [key, propError] of Object.entries(objectWithRecordError.reason.errors)) {
-            issues.push(...typeErrorToStandardSchemaIssues(propError, formatTypeError, [...path, key]));
+            issues.push(...typeErrorToStandardSchemaIssues(propError, [...path, key]));
         }
         return issues;
     }
     if (error.type === "Record") {
         const recordError = error;
         if (recordError.reason.kind === "NotRecord") {
-            return [{ message: formatTypeError(error), path }];
+            return [{ message: JSON.stringify(error), path }];
         }
-        return typeErrorToStandardSchemaIssues(recordError.reason.error, formatTypeError, [...path, recordError.reason.key]);
+        return typeErrorToStandardSchemaIssues(recordError.reason.error, [...path, recordError.reason.key]);
     }
     if (error.type === "Tuple") {
         const tupleError = error;
         if (tupleError.reason.kind === "InvalidLength") {
-            return [{ message: formatTypeError(error), path }];
+            return [{ message: JSON.stringify(error), path }];
         }
-        return typeErrorToStandardSchemaIssues(tupleError.reason.error, formatTypeError, [...path, tupleError.reason.index]);
+        return typeErrorToStandardSchemaIssues(tupleError.reason.error, [...path, tupleError.reason.index]);
     }
     if (error.type === "Union") {
         const unionError = error;
-        return unionError.errors.flatMap((err) => typeErrorToStandardSchemaIssues(err, formatTypeError, path));
+        return unionError.errors.flatMap((err) => typeErrorToStandardSchemaIssues(err, path));
     }
     if (error.type === "Brand") {
         const brandError = error;
         if ("parentError" in brandError) {
-            return typeErrorToStandardSchemaIssues(brandError.parentError, formatTypeError, path);
+            return typeErrorToStandardSchemaIssues(brandError.parentError, path);
         }
-        return [{ message: formatTypeError(error), path }];
+        return [{ message: JSON.stringify(error), path }];
     }
-    return [{ message: formatTypeError(error), path }];
+    return [{ message: JSON.stringify(error), path }];
 };
-/**
- * Shared formatter cache for Standard Schema integration - avoids circular
- * dependency by lazily creating the formatter on first use rather than during
- * module initialization.
- */
-let cachedStandardSchemaFormatTypeError;