@evolu/common 8.0.0 → 8.2.0

package/dist/src/Type.d.ts

@@ -10,7 +10,7 @@ import type { RandomBytesDep } from "./Crypto.ts";
 import { type Thunk } from "./Function.ts";
 import { type Result } from "./Result.ts";
 import type { TimeDep } from "./Time.ts";
-import { type CompileTimeError, type Digit, type Digit1To9, type Int1To100, type IsUnion, type Literal, type Simplify, type ValueWithLength, type WidenLiteral } from "./Types.ts";
+import { type CompileTimeError, type IsUnion, type Literal, type Simplify, type ValueWithLength, type WidenLiteral } from "./Types.ts";
 /**
  * A runtime representation of a TypeScript type with typed structured errors.
  *
@@ -108,8 +108,8 @@ import { type CompileTimeError, type Digit, type Digit1To9, type Int1To100, type
  * normalized value, it uses a `null` prototype so every string key remains
  * ordinary data.
  *
- * Evolu Type expects TypeScript's `exactOptionalPropertyTypes` compiler option
- * to be enabled.
+ * Evolu Type requires TypeScript 7 or newer and expects the
+ * `exactOptionalPropertyTypes` compiler option to be enabled.
  *
  * Predefined Types intentionally use the names of corresponding JavaScript
  * built-ins because they represent those familiar value categories. If an
@@ -625,7 +625,7 @@ export interface TypeNode {
  */
 export declare const assertType: <T extends TypeNode>(type: T, value: unknown) => asserts value is T["Output"];
 /**
- * Creates localized copies of selected {@link Type | Types} for every locale.
+ * Localized copies of selected {@link Type} declarations for every locale.
  *
  * Each locale supplies one formatter for every Type that can own a formatted
  * error. Structural Types use their own formatter for structural failures and
@@ -988,6 +988,8 @@ type DeepestFromError<Operation> = DeepestFromOperation<Operation> extends (...a
     readonly error: infer Error extends TypeError;
 } ? Error : never : never;
 type TypeFromError<T extends TypeNode> = unknown extends T[typeof customFromSymbol] ? DeepestFromError<TypeFromOperation<T>> : [T[typeof customFromSymbol]] extends [never] ? NonRootErrors<T> : DeepestFromError<T[typeof customFromSymbol]>;
+declare const templateLiteralSyntaxSymbolType: unique symbol;
+declare const templateLiteralSyntaxSymbol: typeof templateLiteralSyntaxSymbolType;
 /** @group Base Types */
 export declare const Unknown: Type<"Unknown", unknown, unknown, never, null, never, never, unknown, true>;
 /** @group Base Types */
@@ -1178,7 +1180,7 @@ interface ObjectTagOutputByName {
     readonly ArrayBuffer: globalThis.ArrayBuffer;
 }
 /**
- * Creates a realm-neutral {@link Type} that trusts an object's reported tag.
+ * Realm-neutral {@link Type} trusting an object's reported tag.
  *
  * Predefined built-in tags expose their native Output type under the assumption
  * that trusted code does not forge their tags. They do not verify native
@@ -1227,7 +1229,7 @@ export declare const Uint8Array: Type<"Uint8Array", Uint8Array<ArrayBufferLike>,
  */
 export declare const ArrayBuffer: Type<"ArrayBuffer", ArrayBuffer, ArrayBuffer, ObjectTagError<"ArrayBuffer">, null, ObjectTagError<"ArrayBuffer">, never, ArrayBuffer, true>;
 /**
- * Creates a {@link Type} for instances of one constructor.
+ * Instance {@link Type} for one constructor.
  *
  * Membership uses the intrinsic prototype chain, so subclasses are accepted,
  * equivalent constructors from other realms are rejected, and custom
@@ -1286,11 +1288,32 @@ type InstanceConstructorCompileTimeError = CompileTimeError<"Type", "Constructor
  * primitive through `from.parent`. The expected value must have one exact
  * literal type. Validation uses `===`, so `-0` matches `0`.
  *
+ * In {@link templateLiteralParser}, use a string Literal Type when the literal
+ * should be decoded into the Output Tuple. Use a raw string when it should only
+ * frame the canonical string.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { literal } from "@evolu/common";
+ *
+ * const Ready = literal("ready");
+ *
+ * expectTypeOf<typeof Ready.Output>().toEqualTypeOf<"ready">();
+ * expectOk(Ready.fromUnknown("ready"), "ready");
+ * expectErr(Ready.fromUnknown("pending"), {
+ *   type: "Literal",
+ *   expected: "ready",
+ *   value: "pending",
+ * });
+ * ```
+ *
  * @group Unions
  */
 export declare const literal: <const Expected extends Literal>(expected: ValidateLiteral<Expected>) => LiteralType<Expected>;
 /** @group Unions */
 export interface LiteralType<Expected extends Literal> extends Type<"Literal", WidenLiteral<Expected>, Expected, LiteralError<Expected>, LiteralParent<Expected>, LiteralError<Expected> | LiteralParentErrors<Expected>, never, CanonicalInputSubset<WidenLiteral<Expected>, CanonicalInputForParent<LiteralParent<Expected>, Expected>>, IdentityEncodingForParent<LiteralParent<Expected>>> {
+    readonly [templateLiteralSyntaxSymbol]: true;
     readonly expected: Expected;
 }
 type LiteralParent<Expected extends Literal> = Expected extends string ? typeof String : Expected extends number ? typeof Number : Expected extends bigint ? typeof BigInt : Expected extends boolean ? typeof Boolean : null;
@@ -1373,7 +1396,7 @@ export declare function union<const Members extends AtLeastTwoReadonlyArray<Type
     readonly [Index in keyof Members]: ValidateUnionMember<Members[Index]>;
 }): UnionType<NormalizeUnionMembers<Members>>;
 /**
- * Shorthand for passing a {@link Type} and `undefined` to {@link union}.
+ * Union {@link Type} containing the supplied Type and `undefined`.
  *
  * This does not make an object property optional. It changes only the values
  * accepted when the property is present.
@@ -1382,13 +1405,13 @@ export declare function union<const Members extends AtLeastTwoReadonlyArray<Type
  */
 export declare const undefinedOr: <ValueType extends TypeNode>(type: ValidateUnionTypeMember<ValueType>) => UnionType<readonly [ValueType, typeof Undefined]>;
 /**
- * Shorthand for passing a {@link Type} and `null` to {@link union}.
+ * Union {@link Type} containing the supplied Type and `null`.
  *
  * @group Unions
  */
 export declare const nullOr: <ValueType extends TypeNode>(type: ValidateUnionTypeMember<ValueType>) => UnionType<readonly [ValueType, typeof Null]>;
 /**
- * Shorthand for passing a {@link Type}, `null`, and `undefined` to {@link union}.
+ * Union {@link Type} containing the supplied Type, `null`, and `undefined`.
  *
  * @group Unions
  */
@@ -1403,6 +1426,7 @@ type NormalizeUnionMembers<Members extends AtLeastTwoReadonlyArray<TypeNode | Li
 } extends infer Normalized extends AtLeastTwoReadonlyArray<TypeNode> ? Normalized : never;
 /** @group Unions */
 export interface UnionType<Members extends AtLeastTwoReadonlyArray<TypeNode>> extends Type<"Union", Members[number]["Input"], Members[number]["Output"], UnionTypeError<Members>, UnionInputParent<Members>, UnionTypeError<Members>, never, CanonicalInputOf<Members[number]>, AllTypesUseIdentityEncoding<Members[number]>> {
+    readonly [templateLiteralSyntaxSymbol]: true;
     readonly [reflectedTypesSymbol]?: Members[number];
     readonly members: Members;
 }
@@ -1447,6 +1471,256 @@ type InfallibleTypeNode = TypeNode & {
 interface UnionErrorValue<Error extends TypeError, MemberError extends UnionMemberError<Error> = UnionMemberError<Error>> extends TypeError<"Union"> {
     readonly errors: NonEmptyReadonlyArray<MemberError>;
 }
+/**
+ * Template literal {@link Type} for validation and parsing.
+ *
+ * Parses and creates structured strings.
+ *
+ * Accepts the same template parts as {@link templateLiteral}: fixed string
+ * literals and Types canonically encoded as strings. Instead of keeping Output
+ * as a string, fixed literals define the framing and Output is a readonly Tuple
+ * of the decoded Type parts. `to` encodes that Tuple back into the canonical
+ * string represented by the parent Type. At least one Type part is required.
+ *
+ * When every capture uses identity encoding, the parent Output is the exact
+ * TypeScript template literal type. A transforming capture makes it nominal;
+ * create such strings with `to` or validate them with the parent Type.
+ *
+ * Deterministic framing is a core correctness guarantee. It preserves
+ * reversibility and keeps capture boundaries unambiguous. Different capture
+ * Tuples must never encode to the same string. The parser provides predictable
+ * parsing without pathological backtracking and decodes each capture once, so
+ * adversarial input cannot trigger exponential parser work. Fixed-width captures
+ * may be adjacent, but only one variable-width capture is allowed. Declarations
+ * that could join UTF-16 surrogate halves across parts are rejected during
+ * construction.
+ *
+ * Keep capture unions reasonably small to avoid excessive compiler work.
+ *
+ * TypeScript template literal types can describe a fixed number of digit
+ * positions, but not an arbitrarily long sequence of digits. Such grammars use
+ * branded Types such as {@link DecimalString}; `templateLiteralParser` preserves
+ * that exactness by requiring a validated branded capture when encoding.
+ *
+ * ### Example
+ *
+ * A template literal Type defines both a canonical string representation and
+ * the structured data decoded from it:
+ *
+ * ```ts
+ * import { templateLiteralParser, union } from "@evolu/common";
+ *
+ * const Language = union("en", "cs");
+ * const Region = union("US", "CZ");
+ *
+ * // Define a Type for "en-US" | "en-CZ" | "cs-US" | "cs-CZ".
+ * const SupportedLocale = templateLiteralParser(Language, "-", Region);
+ *
+ * // Output is the decoded language and region.
+ * type SupportedLocale = typeof SupportedLocale.Output;
+ * expectTypeOf<SupportedLocale>().toEqualTypeOf<
+ *   readonly ["en" | "cs", "US" | "CZ"]
+ * >();
+ *
+ * // The parent Output is the canonical locale string.
+ * type SupportedLocaleLiteral = typeof SupportedLocale.parent.Output;
+ * expectTypeOf<SupportedLocaleLiteral>().toEqualTypeOf<
+ *   "en-US" | "en-CZ" | "cs-US" | "cs-CZ"
+ * >();
+ *
+ * // Parse an unknown string into structured data.
+ * const result = SupportedLocale.fromUnknown("cs-CZ");
+ * assert(result.ok);
+ * const locale = result.value;
+ * expectTypeOf(locale).toEqualTypeOf<SupportedLocale>();
+ * expect(locale).toEqual(["cs", "CZ"]);
+ * expectErr(SupportedLocale.fromUnknown("cs/CZ"), {
+ *   type: "TemplateLiteral",
+ *   value: "cs/CZ",
+ * });
+ *
+ * // Encode structured data into its canonical string.
+ * const localeLiteral = SupportedLocale.to(locale);
+ * expectTypeOf(localeLiteral).toEqualTypeOf<SupportedLocaleLiteral>();
+ * expect(localeLiteral).toBe("cs-CZ");
+ *
+ * // Validate a string configuration value.
+ * const configValue: unknown = "cs-CZ";
+ * assert(SupportedLocale.parent.is(configValue));
+ * expectTypeOf(configValue).toEqualTypeOf<SupportedLocaleLiteral>();
+ * expect(SupportedLocale.parent.is("fr-CZ")).toBe(false);
+ * ```
+ *
+ * `SupportedLocale` is structured data for application code.
+ * `SupportedLocaleLiteral` is its canonical representation for configuration
+ * and other APIs that require a string, such as URL parameters, environment
+ * variables, and storage keys.
+ *
+ * Use branded captures for strings that TypeScript template literal types
+ * cannot express exactly, such as arbitrary-length canonical decimals:
+ *
+ * ```ts
+ * import {
+ *   NonNegativeDecimalString,
+ *   templateLiteralParser,
+ * } from "@evolu/common";
+ *
+ * const DecimalText = templateLiteralParser(
+ *   "decimal:",
+ *   NonNegativeDecimalString,
+ * );
+ *
+ * // DecimalText.to requires a validated NonNegativeDecimalString.
+ * const zero = NonNegativeDecimalString.orThrow("0");
+ *
+ * expectOk(DecimalText.fromUnknown("decimal:0"), [zero]);
+ * expect(DecimalText.to([zero])).toBe("decimal:0");
+ * ```
+ *
+ * Capture Types (the Type arguments passed to `templateLiteralParser`) can use
+ * transformations to decode substrings into non-string data:
+ *
+ * ```ts
+ * import {
+ *   Int64FromInt64String,
+ *   templateLiteralParser,
+ * } from "@evolu/common";
+ *
+ * const ItemId = templateLiteralParser("item-", Int64FromInt64String);
+ * type ItemId = typeof ItemId.Output;
+ * type ItemIdLiteral = typeof ItemId.parent.Output;
+ *
+ * // Decode the string into structured data.
+ * const result = ItemId.fromUnknown("item-42");
+ * assert(result.ok);
+ * const itemId = result.value;
+ * expectTypeOf(itemId).toEqualTypeOf<ItemId>();
+ * expect(itemId).toEqual([42n]);
+ *
+ * // Encode the structured data into its canonical string.
+ * const itemIdLiteral = ItemId.to(itemId);
+ * expectTypeOf(itemIdLiteral).toEqualTypeOf<ItemIdLiteral>();
+ * expect(itemIdLiteral).toBe("item-42");
+ *
+ * // TypeScript cannot prove from the literal alone that "42" is a valid Int64 encoding.
+ * // @ts-expect-error Validate it with ItemId.parent or create it with ItemId.to.
+ * const invalidItemIdLiteral: ItemIdLiteral = "item-42";
+ * ```
+ *
+ * Fixed-width captures can be adjacent:
+ *
+ * ```ts
+ * import { templateLiteralParser, union } from "@evolu/common";
+ *
+ * const Digit = union("0", "1", "2", "3", "4", "5", "6", "7", "8", "9");
+ * const TwoDigits = templateLiteralParser(Digit, Digit);
+ * type TwoDigits = typeof TwoDigits.Output;
+ * type TwoDigitsLiteral = typeof TwoDigits.parent.Output;
+ *
+ * const twoDigits: TwoDigits = ["4", "2"];
+ * const twoDigitsLiteral: TwoDigitsLiteral = "42";
+ * // @ts-expect-error TwoDigitsLiteral requires exactly two digits.
+ * const threeDigitsLiteral: TwoDigitsLiteral = "123";
+ *
+ * expectOk(TwoDigits.from.parent(twoDigitsLiteral), twoDigits);
+ * expect(TwoDigits.to(twoDigits)).toBe(twoDigitsLiteral);
+ * ```
+ *
+ * TypeScript rejects multiple variable-width captures because their encoded
+ * boundaries would be ambiguous:
+ *
+ * ```ts
+ * import { String, templateLiteralParser } from "@evolu/common";
+ *
+ * // @ts-expect-error At most one Type capture can have a variable-width string representation.
+ * templateLiteralParser(String, ":", String);
+ * ```
+ *
+ * This restriction keeps encoding reversible: different capture Tuples must
+ * never produce the same string. A delimiter alone is not enough because it can
+ * also occur inside a capture. Some formats could provide stronger guarantees,
+ * such as captures that exclude a delimiter; support for those can be added
+ * when concrete use cases justify the additional framing rules.
+ *
+ * @group Template literals
+ */
+export declare const templateLiteralParser: <const Parts extends TemplateLiteralParts>(...parts: { readonly [Index in keyof Parts]: ValidateTemplateLiteralPart<Parts[Index]>; } & TemplateLiteralValidation<Parts>) => TemplateLiteralParserType<Parts>;
+/** @group Template literals */
+export interface TemplateLiteralParserType<Parts extends TemplateLiteralParts> extends Type<"TemplateLiteral", string, TemplateLiteralCaptureTuple<Parts>["Output"], never, TemplateLiteralType<Parts>, InferErrors<TemplateLiteralType<Parts>>, never, TemplateLiteralStringOutput<Parts>, false> {
+    readonly [templateLiteralSyntaxSymbol]: true;
+    readonly [reflectedTypesSymbol]?: TemplateLiteralCaptureTuple<Parts>;
+    readonly output: TemplateLiteralCaptureTuple<Parts>;
+    readonly parts: Parts;
+}
+/** @group Template literals */
+export interface TemplateLiteralType<Parts extends TemplateLiteralParts> extends Type<"TemplateLiteral", string, TemplateLiteralStringOutput<Parts>, TemplateLiteralParseError<Parts>, typeof String, TypeOfError<"String"> | TemplateLiteralParseError<Parts>, never, TemplateLiteralStringOutput<Parts>, true> {
+    readonly [templateLiteralSyntaxSymbol]: true;
+    readonly [reflectedTypesSymbol]?: TemplateLiteralCaptureTuple<Parts>;
+    readonly output: TemplateLiteralCaptureTuple<Parts>;
+    readonly parts: Parts;
+}
+/**
+ * Template literal {@link Type} for validation.
+ *
+ * Creates a canonical string Type from fixed strings and string-encoded Types.
+ *
+ * Use this factory when Output should remain a string. Switch to
+ * {@link templateLiteralParser} when the individual Type parts should be
+ * decoded into a Tuple.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { templateLiteral, union } from "@evolu/common";
+ *
+ * const Language = union("en", "cs");
+ * const Region = union("US", "CZ");
+ * const Locale = templateLiteral(Language, "-", Region);
+ *
+ * expectTypeOf<typeof Locale.Output>().toEqualTypeOf<
+ *   "en-US" | "en-CZ" | "cs-US" | "cs-CZ"
+ * >();
+ * expectOk(Locale.fromUnknown("cs-CZ"), "cs-CZ");
+ * expect(Locale.is("fr-CZ")).toBe(false);
+ * ```
+ *
+ * @group Template literals
+ */
+export declare const templateLiteral: <const Parts extends TemplateLiteralParts>(...parts: { readonly [Index in keyof Parts]: ValidateTemplateLiteralPart<Parts[Index]>; } & TemplateLiteralValidation<Parts>) => TemplateLiteralType<Parts>;
+type TemplateLiteralParseError<Parts extends TemplateLiteralParts> = TransformError<"TemplateLiteral", TemplateLiteralIsFrameless<Parts> extends true ? never : TemplateLiteralError, TemplateLiteralCaptureTupleError<Parts>>;
+type TemplateLiteralCaptureTupleError<Parts extends TemplateLiteralParts> = TupleElementsError<TemplateLiteralCaptureFromStringError<TemplateLiteralCaptureTypes<Parts>[number]>>;
+type TemplateLiteralCaptureFromStringError<T extends TypeNode> = T extends TypeNode ? string extends RootType<T>["Output"] ? TypeFromError<T> : InferErrors<T> : never;
+/** @group Template literals */
+export interface TemplateLiteralError extends TypeError<"TemplateLiteral"> {
+    readonly value: string;
+}
+declare const templateLiteralStringBrandSymbol: unique symbol;
+interface TemplateLiteralStringBrand<Parts extends TemplateLiteralParts> {
+    readonly [templateLiteralStringBrandSymbol]: Parts;
+}
+type TemplateLiteralPart = string | TypeNode;
+type TemplateLiteralParts = NonEmptyReadonlyArray<TemplateLiteralPart>;
+type TemplateLiteralValidation<Parts extends TemplateLiteralParts> = number extends Parts["length"] ? readonly [ValidationFailure<TemplateLiteralPartsTupleError>] : IsUnion<Parts["length"]> extends true ? readonly [ValidationFailure<TemplateLiteralPartsTupleError>] : [Extract<Parts[number], TypeNode>] extends [never] ? readonly [ValidationFailure<TemplateLiteralCaptureRequiredError>] : TemplateLiteralHasAmbiguousCaptures<Parts> extends true ? readonly [ValidationFailure<TemplateLiteralAmbiguousCapturesError>] : unknown;
+type TemplateLiteralPartsTupleError = CompileTimeError<"TemplateLiteral", "Parts must use one concrete finite non-empty tuple.">;
+type TemplateLiteralCaptureRequiredError = CompileTimeError<"TemplateLiteral", "At least one part must be a Type capture.">;
+type TemplateLiteralAmbiguousCapturesError = CompileTimeError<"TemplateLiteral", "At most one Type capture can have a variable-width string representation.">;
+type TemplateLiteralCaptureTypes<Parts extends ReadonlyArray<TemplateLiteralPart>, Captures extends ReadonlyArray<TypeNode> = readonly []> = Parts extends readonly [infer Head, ...infer Tail] ? TemplateLiteralCaptureTypes<Extract<Tail, ReadonlyArray<TemplateLiteralPart>>, Head extends TypeNode ? readonly [...Captures, Head] : Captures> : Extract<Captures, NonEmptyReadonlyArray<TypeNode>>;
+type TemplateLiteralCaptureTuple<Parts extends TemplateLiteralParts> = TupleType<TemplateLiteralCaptureTypes<Parts>>;
+type TemplateLiteralCanonicalInput<Parts extends ReadonlyArray<TemplateLiteralPart>, Input extends string = ""> = Parts extends readonly [infer Head, ...infer Tail] ? TemplateLiteralCanonicalInput<Extract<Tail, ReadonlyArray<TemplateLiteralPart>>, `${Input}${TemplateLiteralPartCanonicalInput<Extract<Head, TemplateLiteralPart>>}`> : Input;
+type TemplateLiteralStringOutput<Parts extends TemplateLiteralParts> = AllTypesUseIdentityEncoding<Extract<Parts[number], TypeNode>> extends true ? TemplateLiteralCanonicalInput<Parts> : TemplateLiteralCanonicalInput<Parts> & TemplateLiteralStringBrand<Parts>;
+type TemplateLiteralPartCanonicalInput<Part extends TemplateLiteralPart> = Part extends string ? Part : Part extends TypeNode ? Extract<CanonicalInputOf<Part>, string> : never;
+type ValidateTemplateLiteralPart<Part extends TemplateLiteralPart> = IsUnion<Part> extends false ? Part extends string ? ValidateLiteral<Part> : Part extends ConcreteTypeNode ? IsTemplateLiteralPartType<Part> extends true ? Part : TemplateLiteralPartCompileTimeError : TemplateLiteralPartCompileTimeError : TemplateLiteralPartCompileTimeError;
+type IsTemplateLiteralPartType<T extends TypeNode> = [
+    CanonicalInputOf<T>
+] extends [never] ? false : [CanonicalInputOf<T>] extends [string] ? true : false;
+type TemplateLiteralPartCompileTimeError = CompileTimeError<"TemplateLiteral", "Part must be a raw string literal or a Type canonically encoded as a string.">;
+type TemplateLiteralHasAmbiguousCaptures<Parts extends ReadonlyArray<TemplateLiteralPart>, VariableCaptures extends ReadonlyArray<unknown> = readonly []> = Parts extends readonly [infer Head, ...infer Tail] ? Head extends TypeNode ? [TemplateLiteralTypeWidth<Head>] extends [null] ? VariableCaptures extends readonly [unknown] ? true : TemplateLiteralHasAmbiguousCaptures<Extract<Tail, ReadonlyArray<TemplateLiteralPart>>, readonly [unknown]> : TemplateLiteralHasAmbiguousCaptures<Extract<Tail, ReadonlyArray<TemplateLiteralPart>>, VariableCaptures> : TemplateLiteralHasAmbiguousCaptures<Extract<Tail, ReadonlyArray<TemplateLiteralPart>>, VariableCaptures> : false;
+type TemplateLiteralTypeWidth<T extends TypeNode> = T extends LiteralType<infer Expected extends string> ? TemplateLiteralStringWidth<Expected> : T extends UnionType<infer Members> ? NormalizeTemplateLiteralWidth<TemplateLiteralTypeWidth<Members[number]>> : T extends TemplateLiteralParserType<infer Parts> ? TemplateLiteralPartsWidth<Parts> : T extends TemplateLiteralType<infer Parts> ? TemplateLiteralPartsWidth<Parts> : T["parent"] extends infer Parent extends TypeNode ? TemplateLiteralTypeWidth<Parent> : null;
+type NormalizeTemplateLiteralWidth<Width> = IsUnion<Width> extends true ? null : Width extends ReadonlyArray<unknown> ? Width : null;
+type TemplateLiteralPartsWidth<Parts extends ReadonlyArray<TemplateLiteralPart>, Width extends ReadonlyArray<unknown> = readonly []> = Parts extends readonly [infer Head, ...infer Tail] ? TemplateLiteralPartWidth<Extract<Head, TemplateLiteralPart>> extends infer PartWidth ? [PartWidth] extends [ReadonlyArray<unknown>] ? TemplateLiteralPartsWidth<Extract<Tail, ReadonlyArray<TemplateLiteralPart>>, readonly [...Width, ...PartWidth]> : null : never : Width;
+type TemplateLiteralPartWidth<Part extends TemplateLiteralPart> = Part extends string ? TemplateLiteralStringWidth<Part> : Part extends TypeNode ? TemplateLiteralTypeWidth<Part> : never;
+type TemplateLiteralIsFrameless<Parts extends ReadonlyArray<TemplateLiteralPart>, HasVariableCapture extends boolean = false> = Parts extends readonly [infer Head, ...infer Tail] ? TemplateLiteralPartWidth<Extract<Head, TemplateLiteralPart>> extends infer Width ? [Width] extends [null] ? HasVariableCapture extends true ? false : TemplateLiteralIsFrameless<Extract<Tail, ReadonlyArray<TemplateLiteralPart>>, true> : [Width] extends [readonly []] ? TemplateLiteralIsFrameless<Extract<Tail, ReadonlyArray<TemplateLiteralPart>>, HasVariableCapture> : false : false : HasVariableCapture;
+type TemplateLiteralStringWidth<Value extends string, Width extends ReadonlyArray<unknown> = readonly []> = string extends Value ? null : Value extends "" ? Width : Value extends `${infer _CodePoint}${infer Tail}` ? TemplateLiteralStringWidth<Tail, readonly [...Width, unknown]> : null;
 /**
  * Branded {@link Type}.
  *
@@ -1800,7 +2074,7 @@ export interface CapitalizedError extends TypeError<"Capitalized"> {
 export declare const CapitalizedString: BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "Capitalized", CapitalizedError>;
 export type CapitalizedString = typeof CapitalizedString.Output;
 /**
- * Adds a {@link Brand} requiring a string without surrounding whitespace.
+ * String {@link Brand} without surrounding whitespace.
  *
  * @group String
  */
@@ -1829,7 +2103,7 @@ export type TrimmedString = typeof TrimmedString.Output;
  */
 export declare const trim: (value: string) => TrimmedString;
 /**
- * Adds a {@link Brand} requiring a value to have at least `min` items.
+ * Minimum-length {@link Brand} requiring a value to have at least `min` items.
  *
  * @group String
  * @group Collection
@@ -1857,7 +2131,7 @@ export interface MinLengthError<Min extends number = number> extends TypeError<`
 export declare const NonEmptyTrimmedString: BrandType<BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "Trimmed", TrimmedError>, "MinLength1", MinLengthError<1>>;
 export type NonEmptyTrimmedString = typeof NonEmptyTrimmedString.Output;
 /**
- * Adds a {@link Brand} requiring a value to have at most `max` items.
+ * Maximum-length {@link Brand} requiring a value to have at most `max` items.
  *
  * @group String
  * @group Collection
@@ -1883,7 +2157,7 @@ export type NonEmptyTrimmedString100 = typeof NonEmptyTrimmedString100.Output;
 export declare const NonEmptyTrimmedString1000: BrandType<BrandType<BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "Trimmed", TrimmedError>, "MinLength1", MinLengthError<1>>, "MaxLength1000", MaxLengthError<1000>>;
 export type NonEmptyTrimmedString1000 = typeof NonEmptyTrimmedString1000.Output;
 /**
- * Adds a {@link Brand} requiring a value to have exactly `exact` items.
+ * Exact-length {@link Brand} requiring a value to have exactly `exact` items.
  *
  * @group String
  * @group Collection
@@ -1895,7 +2169,7 @@ export interface LengthError<Exact extends number = number> extends TypeError<`L
     readonly exact: Exact;
 }
 /**
- * Creates a string {@link Brand} that must match a regular expression.
+ * String {@link Brand} constrained by a regular expression.
  *
  * ### Example
  *
@@ -2061,7 +2335,7 @@ export declare const createIdFromString: <B extends string = never>(value: strin
  */
 export declare const createIdAsUuidv7: <B extends string = never>(deps: RandomBytesDep & TimeDep, ..._validation: IdBrandValidation<B>) => CreatedId<B>;
 /**
- * A table-specific {@link Id} Type.
+ * Table-specific {@link Id} Type.
  *
  * @group String
  */
@@ -2118,7 +2392,7 @@ export interface Int64StringError extends TypeError<"Int64String"> {
  */
 export declare const Int64FromInt64String: TransformType<BrandType<BrandType<BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "Trimmed", TrimmedError>, "MinLength1", MinLengthError<1>>, "Int64String", Int64StringError>, BrandType<Type<"BigInt", bigint, bigint, TypeOfError<"BigInt">, null, TypeOfError<"BigInt">, never, bigint, true>, "Int64", Int64Error>, "Int64FromInt64String", never, string & Brand<"Trimmed"> & Brand<"MinLength1"> & Brand<"Int64String">>;
 /**
- * Adds a {@link Brand} requiring a number greater than or equal to zero.
+ * Number {@link Brand} requiring a value greater than or equal to zero.
  *
  * @group Number
  */
@@ -2135,7 +2409,7 @@ export interface NonNegativeError extends TypeError<"NonNegative"> {
 export declare const NonNegativeNumber: BrandType<Type<"Number", number, number, TypeOfError<"Number">, null, TypeOfError<"Number">, never, number, true>, "NonNegative", NonNegativeError>;
 export type NonNegativeNumber = typeof NonNegativeNumber.Output;
 /**
- * Adds a {@link Brand} requiring a number greater than zero.
+ * Number {@link Brand} requiring a value greater than zero.
  *
  * @group Number
  */
@@ -2155,7 +2429,7 @@ export interface PositiveError extends TypeError<"Positive"> {
 export declare const PositiveNumber: BrandType<BrandType<Type<"Number", number, number, TypeOfError<"Number">, null, TypeOfError<"Number">, never, number, true>, "NonNegative", NonNegativeError>, "Positive", PositiveError>;
 export type PositiveNumber = typeof PositiveNumber.Output;
 /**
- * Adds a {@link Brand} requiring a number less than or equal to zero.
+ * Number {@link Brand} requiring a value less than or equal to zero.
  *
  * @group Number
  */
@@ -2172,7 +2446,7 @@ export interface NonPositiveError extends TypeError<"NonPositive"> {
 export declare const NonPositiveNumber: BrandType<Type<"Number", number, number, TypeOfError<"Number">, null, TypeOfError<"Number">, never, number, true>, "NonPositive", NonPositiveError>;
 export type NonPositiveNumber = typeof NonPositiveNumber.Output;
 /**
- * Adds a {@link Brand} requiring a number less than zero.
+ * Number {@link Brand} requiring a value less than zero.
  *
  * @group Number
  */
@@ -2192,7 +2466,7 @@ export interface NegativeError extends TypeError<"Negative"> {
 export declare const NegativeNumber: BrandType<BrandType<Type<"Number", number, number, TypeOfError<"Number">, null, TypeOfError<"Number">, never, number, true>, "NonPositive", NonPositiveError>, "Negative", NegativeError>;
 export type NegativeNumber = typeof NegativeNumber.Output;
 /**
- * Adds a {@link Brand} requiring a number other than `NaN`.
+ * Number {@link Brand} requiring a value other than `NaN`.
  *
  * @group Number
  */
@@ -2214,7 +2488,7 @@ export interface NonNaNError extends TypeError<"NonNaN"> {
 export declare const NonNaNNumber: BrandType<Type<"Number", number, number, TypeOfError<"Number">, null, TypeOfError<"Number">, never, number, true>, "NonNaN", NonNaNError>;
 export type NonNaNNumber = typeof NonNaNNumber.Output;
 /**
- * Adds a {@link Brand} requiring a finite number.
+ * Number {@link Brand} requiring a finite value.
  *
  * @group Number
  */
@@ -2237,6 +2511,13 @@ export type FiniteNumber = typeof FiniteNumber.Output;
  */
 export declare const NonNegativeFiniteNumber: BrandType<BrandType<BrandType<Type<"Number", number, number, TypeOfError<"Number">, null, TypeOfError<"Number">, never, number, true>, "NonNaN", NonNaNError>, "Finite", FiniteError>, "NonNegative", NonNegativeError>;
 export type NonNegativeFiniteNumber = typeof NonNegativeFiniteNumber.Output;
+/**
+ * Positive {@link FiniteNumber}.
+ *
+ * @group Number
+ */
+export declare const PositiveFiniteNumber: BrandType<BrandType<BrandType<BrandType<Type<"Number", number, number, TypeOfError<"Number">, null, TypeOfError<"Number">, never, number, true>, "NonNaN", NonNaNError>, "Finite", FiniteError>, "NonNegative", NonNegativeError>, "Positive", PositiveError>;
+export type PositiveFiniteNumber = typeof PositiveFiniteNumber.Output;
 /**
  * Safe integer {@link Brand}.
  *
@@ -2278,12 +2559,6 @@ export type Int = typeof Int.Output;
  */
 export declare const NonNegativeInt: BrandType<BrandType<BrandType<BrandType<Type<"Number", number, number, TypeOfError<"Number">, null, TypeOfError<"Number">, never, number, true>, "NonNaN", NonNaNError>, "Finite", FiniteError>, "Int", IntError>, "NonNegative", NonNegativeError>;
 export type NonNegativeInt = typeof NonNegativeInt.Output;
-/**
- * 0-100 as a literal, or any already-validated {@link NonNegativeInt}.
- *
- * @group Number
- */
-export type Int0To100OrNonNegativeInt = 0 | Int1To100 | NonNegativeInt;
 /**
  * Minimum {@link NonNegativeInt} value.
  *
@@ -2300,12 +2575,6 @@ export declare const zeroNonNegativeInt: number & Brand<"NonNaN"> & Brand<"Finit
  */
 export declare const PositiveInt: BrandType<BrandType<BrandType<BrandType<BrandType<Type<"Number", number, number, TypeOfError<"Number">, null, TypeOfError<"Number">, never, number, true>, "NonNaN", NonNaNError>, "Finite", FiniteError>, "Int", IntError>, "NonNegative", NonNegativeError>, "Positive", PositiveError>;
 export type PositiveInt = typeof PositiveInt.Output;
-/**
- * 1-100 as a literal, or any already-validated {@link PositiveInt}.
- *
- * @group Number
- */
-export type Int1To100OrPositiveInt = Int1To100 | PositiveInt;
 /**
  * Minimum {@link PositiveInt} value.
  *
@@ -2336,7 +2605,7 @@ export type NonPositiveInt = typeof NonPositiveInt.Output;
 export declare const NegativeInt: BrandType<BrandType<BrandType<BrandType<BrandType<Type<"Number", number, number, TypeOfError<"Number">, null, TypeOfError<"Number">, never, number, true>, "NonNaN", NonNaNError>, "Finite", FiniteError>, "Int", IntError>, "NonPositive", NonPositiveError>, "Negative", NegativeError>;
 export type NegativeInt = typeof NegativeInt.Output;
 /**
- * Adds a {@link Brand} requiring a number greater than `min`.
+ * Number {@link Brand} requiring a value greater than `min`.
  *
  * @group Number
  */
@@ -2347,7 +2616,7 @@ export interface GreaterThanError<Min extends number = number> extends TypeError
     readonly min: Min;
 }
 /**
- * Adds a {@link Brand} requiring a number greater than or equal to `min`.
+ * Number {@link Brand} requiring a value greater than or equal to `min`.
  *
  * @group Number
  */
@@ -2358,7 +2627,7 @@ export interface GreaterThanOrEqualToError<Min extends number = number> extends
     readonly min: Min;
 }
 /**
- * Adds a {@link Brand} requiring a number less than `max`.
+ * Number {@link Brand} requiring a value less than `max`.
  *
  * @group Number
  */
@@ -2376,7 +2645,7 @@ export interface LessThanError<Max extends number = number> extends TypeError<`L
 export declare const Age: BrandType<BrandType<BrandType<BrandType<BrandType<BrandType<Type<"Number", number, number, TypeOfError<"Number">, null, TypeOfError<"Number">, never, number, true>, "NonNaN", NonNaNError>, "Finite", FiniteError>, "Int", IntError>, "NonNegative", NonNegativeError>, "LessThan200", LessThanError<200>>, "Age", never>;
 export type Age = typeof Age.Output;
 /**
- * Adds a {@link Brand} requiring a number less than or equal to `max`.
+ * Number {@link Brand} requiring a value less than or equal to `max`.
  *
  * @group Number
  */
@@ -2396,59 +2665,148 @@ export interface LessThanOrEqualToError<Max extends number = number> extends Typ
 export declare const Ratio: BrandType<BrandType<BrandType<BrandType<BrandType<Type<"Number", number, number, TypeOfError<"Number">, null, TypeOfError<"Number">, never, number, true>, "NonNaN", NonNaNError>, "Finite", FiniteError>, "NonNegative", NonNegativeError>, "LessThanOrEqualTo1", LessThanOrEqualToError<1>>, "Ratio", never>;
 export type Ratio = typeof Ratio.Output;
 /**
- * Canonical string representation of a positive base-10 decimal.
+ * Canonical string representation of a signed base-10 decimal value.
+ *
+ * Use this Type when a decimal value must remain exact instead of being
+ * converted to an IEEE-754 number. Equivalent values have one accepted
+ * representation, so leading zeroes, trailing fractional zeroes, `-0`, plus
+ * signs, and exponent notation are rejected.
+ *
+ * The decoded value remains a string. Arithmetic requires an explicit decimal
+ * or fixed-point representation.
+ *
+ * TypeScript template literal types can describe a fixed number of digit
+ * positions, but not the arbitrarily long integer and fractional parts accepted
+ * here. `DecimalString` therefore uses a {@link Brand} so its TypeScript type
+ * does not accept strings that have not been validated.
  *
- * Each value has one spelling: leading zeroes, trailing fractional zeroes,
- * signs, and exponent notation are rejected. This preserves exact decimal
- * meaning without representing the value as an IEEE-754 number.
+ * Use these predefined Types or their corresponding factories to add sign
+ * constraints to compatible decimal string Types:
+ *
+ * - {@link NonNegativeDecimalString} / {@link nonNegativeDecimalString}
+ * - {@link PositiveDecimalString} / {@link positiveDecimalString}
+ * - {@link NonPositiveDecimalString} / {@link nonPositiveDecimalString}
+ * - {@link NegativeDecimalString} / {@link negativeDecimalString}
  *
  * ### Example
  *
  * ```ts
- * import { PositiveDecimalString } from "@evolu/common";
+ * import { DecimalString } from "@evolu/common";
  *
- * expectOk(PositiveDecimalString.fromUnknown("0.3"), "0.3");
- * expectOk(PositiveDecimalString.fromUnknown("25"), "25");
+ * expectOk(DecimalString.fromUnknown("-10.25"), "-10.25");
+ * expectOk(DecimalString.fromUnknown("0"), "0");
+ * expectOk(DecimalString.fromUnknown("10.25"), "10.25");
  *
- * expectErr(PositiveDecimalString.fromUnknown("0.30"), {
- *   type: "PositiveDecimalString",
- *   value: "0.30",
+ * expectErr(DecimalString.fromUnknown("10.250"), {
+ *   type: "DecimalString",
+ *   value: "10.250",
  * });
  * ```
  *
  * @group Number
  */
-export declare const PositiveDecimalString: BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "PositiveDecimalString", PositiveDecimalStringError>;
-export type PositiveDecimalString = typeof PositiveDecimalString.Output;
+export declare const DecimalString: BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "DecimalString", DecimalStringError>;
+export type DecimalString = typeof DecimalString.Output;
+/** @group Number */
+export interface DecimalStringError extends TypeError<"DecimalString"> {
+    readonly value: string;
+}
+/**
+ * {@link DecimalString} Brand requiring a value greater than or equal to zero.
+ *
+ * @group Number
+ */
+export declare const nonNegativeDecimalString: BrandFactory<"NonNegativeDecimalString", DecimalString, NonNegativeDecimalStringError>;
+/** @group Number */
+export interface NonNegativeDecimalStringError extends TypeError<"NonNegativeDecimalString"> {
+    readonly value: string;
+}
+/**
+ * Non-negative {@link DecimalString}.
+ *
+ * @group Number
+ */
+export declare const NonNegativeDecimalString: BrandType<BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "DecimalString", DecimalStringError>, "NonNegativeDecimalString", NonNegativeDecimalStringError>;
+export type NonNegativeDecimalString = typeof NonNegativeDecimalString.Output;
+/**
+ * {@link DecimalString} Brand requiring a value greater than zero.
+ *
+ * @group Number
+ */
+export declare const positiveDecimalString: BrandFactory<"PositiveDecimalString", DecimalString, PositiveDecimalStringError>;
 /** @group Number */
 export interface PositiveDecimalStringError extends TypeError<"PositiveDecimalString"> {
     readonly value: string;
 }
-type ValidateMultipleOfDivisor<Divisor extends string> = IsUnion<Divisor> extends false ? string extends Divisor ? InvalidMultipleOfDivisor<Divisor> : IsCanonicalPositiveDecimalString<Divisor> extends true ? Divisor : InvalidMultipleOfDivisor<Divisor> : InvalidMultipleOfDivisor<Divisor>;
-type IsCanonicalPositiveDecimalString<Value extends string> = Value extends `${infer Integer}.${infer Fraction}` ? IsCanonicalNonNegativeIntegerString<Integer> extends true ? IsCanonicalPositiveFractionString<Fraction> : false : IsCanonicalPositiveIntegerString<Value>;
-type IsCanonicalNonNegativeIntegerString<Value extends string> = Value extends "0" ? true : IsCanonicalPositiveIntegerString<Value>;
-type IsCanonicalPositiveIntegerString<Value extends string> = Value extends `${Digit1To9}${infer Rest}` ? IsDecimalDigits<Rest> : false;
-type IsCanonicalPositiveFractionString<Value extends string> = Value extends `${infer Rest}${Digit1To9}` ? IsDecimalDigits<Rest> : false;
-type IsDecimalDigits<Value extends string> = Value extends "" ? true : Value extends `${Digit}${infer Rest}` ? IsDecimalDigits<Rest> : false;
-type InvalidMultipleOfDivisor<Divisor extends string> = Divisor & Readonly<Record<MultipleOfDivisorError, never>>;
-type MultipleOfDivisorError = CompileTimeError<"MultipleOf", 'Divisor must be one canonical positive decimal string literal such as "0.1".'>;
 /**
- * Adds a {@link Brand} requiring a number to be a multiple of an exact decimal
- * `divisor`.
+ * Positive {@link DecimalString}.
+ *
+ * Also satisfies {@link NonNegativeDecimalString}, so it can be used wherever a
+ * non-negative decimal string is required.
+ *
+ * @group Number
+ */
+export declare const PositiveDecimalString: BrandType<BrandType<BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "DecimalString", DecimalStringError>, "NonNegativeDecimalString", NonNegativeDecimalStringError>, "PositiveDecimalString", PositiveDecimalStringError>;
+export type PositiveDecimalString = typeof PositiveDecimalString.Output;
+/**
+ * {@link DecimalString} Brand requiring a value less than or equal to zero.
+ *
+ * @group Number
+ */
+export declare const nonPositiveDecimalString: BrandFactory<"NonPositiveDecimalString", DecimalString, NonPositiveDecimalStringError>;
+/** @group Number */
+export interface NonPositiveDecimalStringError extends TypeError<"NonPositiveDecimalString"> {
+    readonly value: string;
+}
+/**
+ * Non-positive {@link DecimalString}.
+ *
+ * @group Number
+ */
+export declare const NonPositiveDecimalString: BrandType<BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "DecimalString", DecimalStringError>, "NonPositiveDecimalString", NonPositiveDecimalStringError>;
+export type NonPositiveDecimalString = typeof NonPositiveDecimalString.Output;
+/**
+ * {@link DecimalString} Brand requiring a value less than zero.
+ *
+ * @group Number
+ */
+export declare const negativeDecimalString: BrandFactory<"NegativeDecimalString", DecimalString, NegativeDecimalStringError>;
+/** @group Number */
+export interface NegativeDecimalStringError extends TypeError<"NegativeDecimalString"> {
+    readonly value: string;
+}
+/**
+ * Negative {@link DecimalString}.
+ *
+ * Also satisfies {@link NonPositiveDecimalString}, so it can be used wherever a
+ * non-positive decimal string is required.
+ *
+ * @group Number
+ */
+export declare const NegativeDecimalString: BrandType<BrandType<BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "DecimalString", DecimalStringError>, "NonPositiveDecimalString", NonPositiveDecimalStringError>, "NegativeDecimalString", NegativeDecimalStringError>;
+export type NegativeDecimalString = typeof NegativeDecimalString.Output;
+/**
+ * Number {@link Brand} requiring an exact decimal multiple of `divisor`.
  *
- * The literal divisor is validated against {@link PositiveDecimalString} and
- * encoded in the resulting Brand name. A runtime string cannot define this Type
- * because its exact value is not available to TypeScript for that name.
- * Validation does not round: `"0.1"` accepts `0.3`, but rejects `0.1 + 0.2`
- * because that expression evaluates to `0.30000000000000004`.
+ * The divisor must be one canonical positive decimal string literal because its
+ * exact value is encoded in the resulting Brand name. The declaration is
+ * validated at compile time and is never converted to an IEEE-754 number.
+ *
+ * Validation treats each finite Number as its canonical decimal representation
+ * and checks exact base-10 divisibility. It does not use floating-point
+ * remainder, apply a tolerance, or round to the divisor's precision.
  *
  * ### Example
  *
  * ```ts
- * import { FiniteNumber, multipleOf } from "@evolu/common";
+ * import { FiniteNumber, multipleOf, type Brand } from "@evolu/common";
  *
  * const Tenths = multipleOf("0.1")(FiniteNumber);
  *
+ * expectTypeOf<typeof Tenths.Output>().toEqualTypeOf<
+ *   FiniteNumber & Brand<"MultipleOf0.1">
+ * >();
+ *
  * expectOk(Tenths.fromUnknown(0.3), 0.3);
  * expectErr(Tenths.fromUnknown(0.31), {
  *   type: "MultipleOf0.1",
@@ -2465,8 +2823,16 @@ export interface MultipleOfError<Divisor extends string = string> extends TypeEr
     readonly value: number;
     readonly divisor: Divisor;
 }
+type ValidateMultipleOfDivisor<Divisor extends string> = IsUnion<Divisor> extends false ? string extends Divisor ? InvalidMultipleOfDivisor<Divisor> : IsCanonicalPositiveDecimalString<Divisor> extends true ? Divisor : InvalidMultipleOfDivisor<Divisor> : InvalidMultipleOfDivisor<Divisor>;
+type IsCanonicalPositiveDecimalString<Value extends string> = Value extends `${infer Integer}.${infer Fraction}` ? IsCanonicalNonNegativeIntegerString<Integer> extends true ? IsCanonicalPositiveFractionString<Fraction> : false : IsCanonicalPositiveIntegerString<Value>;
+type IsCanonicalNonNegativeIntegerString<Value extends string> = Value extends "0" ? true : IsCanonicalPositiveIntegerString<Value>;
+type IsCanonicalPositiveIntegerString<Value extends string> = Value extends `${Digit1To9}${infer Rest}` ? IsDecimalDigits<Rest> : false;
+type IsCanonicalPositiveFractionString<Value extends string> = Value extends `${infer Rest}${Digit1To9}` ? IsDecimalDigits<Rest> : false;
+type IsDecimalDigits<Value extends string> = Value extends "" ? true : Value extends `${Digit}${infer Rest}` ? IsDecimalDigits<Rest> : false;
+type InvalidMultipleOfDivisor<Divisor extends string> = Divisor & Readonly<Record<MultipleOfDivisorError, never>>;
+type MultipleOfDivisorError = CompileTimeError<"MultipleOf", 'Divisor must be one canonical positive decimal string literal such as "0.1".'>;
 /**
- * Adds a {@link Brand} requiring a number to be within an inclusive range.
+ * Number {@link Brand} requiring a value within an inclusive range.
  *
  * @group Number
  */
@@ -2837,6 +3203,55 @@ interface TupleItemsErrorValue<Error extends TypeError, IncludeStructuralIssues
         readonly issues: NonEmptyReadonlyArray<(true extends IncludeStructuralIssues ? TupleStructuralIssue : never) | TupleElementIssue<Error>>;
     };
 }
+/**
+ * Decimal digit from `"0"` to `"9"`.
+ *
+ * @group String
+ */
+export declare const Digit: UnionType<readonly [LiteralType<"0">, LiteralType<"1">, LiteralType<"2">, LiteralType<"3">, LiteralType<"4">, LiteralType<"5">, LiteralType<"6">, LiteralType<"7">, LiteralType<"8">, LiteralType<"9">]>;
+export type Digit = typeof Digit.Output;
+/**
+ * Decimal digit from `"1"` to `"9"`.
+ *
+ * @group String
+ */
+export declare const Digit1To9: UnionType<readonly [LiteralType<"1">, LiteralType<"2">, LiteralType<"3">, LiteralType<"4">, LiteralType<"5">, LiteralType<"6">, LiteralType<"7">, LiteralType<"8">, LiteralType<"9">]>;
+export type Digit1To9 = typeof Digit1To9.Output;
+/**
+ * Decimal string from `"1"` to `"6"`.
+ *
+ * @group String
+ */
+export declare const Digit1To6: UnionType<readonly [LiteralType<"1">, LiteralType<"2">, LiteralType<"3">, LiteralType<"4">, LiteralType<"5">, LiteralType<"6">]>;
+export type Digit1To6 = typeof Digit1To6.Output;
+/**
+ * Decimal string from `"1"` to `"23"`.
+ *
+ * @group String
+ */
+export declare const Digit1To23: UnionType<readonly [UnionType<readonly [LiteralType<"1">, LiteralType<"2">, LiteralType<"3">, LiteralType<"4">, LiteralType<"5">, LiteralType<"6">, LiteralType<"7">, LiteralType<"8">, LiteralType<"9">]>, TemplateLiteralType<readonly ["1", UnionType<readonly [LiteralType<"0">, LiteralType<"1">, LiteralType<"2">, LiteralType<"3">, LiteralType<"4">, LiteralType<"5">, LiteralType<"6">, LiteralType<"7">, LiteralType<"8">, LiteralType<"9">]>]>, TemplateLiteralType<readonly ["2", UnionType<readonly [LiteralType<"0">, LiteralType<"1">, LiteralType<"2">, LiteralType<"3">]>]>]>;
+export type Digit1To23 = typeof Digit1To23.Output;
+/**
+ * Decimal string from `"1"` to `"51"`.
+ *
+ * @group String
+ */
+export declare const Digit1To51: UnionType<readonly [UnionType<readonly [LiteralType<"1">, LiteralType<"2">, LiteralType<"3">, LiteralType<"4">, LiteralType<"5">, LiteralType<"6">, LiteralType<"7">, LiteralType<"8">, LiteralType<"9">]>, TemplateLiteralType<readonly [UnionType<readonly [LiteralType<"1">, LiteralType<"2">, LiteralType<"3">, LiteralType<"4">]>, UnionType<readonly [LiteralType<"0">, LiteralType<"1">, LiteralType<"2">, LiteralType<"3">, LiteralType<"4">, LiteralType<"5">, LiteralType<"6">, LiteralType<"7">, LiteralType<"8">, LiteralType<"9">]>]>, TemplateLiteralType<readonly ["5", UnionType<readonly [LiteralType<"0">, LiteralType<"1">]>]>]>;
+export type Digit1To51 = typeof Digit1To51.Output;
+/**
+ * Decimal string from `"1"` to `"99"`.
+ *
+ * @group String
+ */
+export declare const Digit1To99: UnionType<readonly [UnionType<readonly [LiteralType<"1">, LiteralType<"2">, LiteralType<"3">, LiteralType<"4">, LiteralType<"5">, LiteralType<"6">, LiteralType<"7">, LiteralType<"8">, LiteralType<"9">]>, TemplateLiteralType<readonly [UnionType<readonly [LiteralType<"1">, LiteralType<"2">, LiteralType<"3">, LiteralType<"4">, LiteralType<"5">, LiteralType<"6">, LiteralType<"7">, LiteralType<"8">, LiteralType<"9">]>, UnionType<readonly [LiteralType<"0">, LiteralType<"1">, LiteralType<"2">, LiteralType<"3">, LiteralType<"4">, LiteralType<"5">, LiteralType<"6">, LiteralType<"7">, LiteralType<"8">, LiteralType<"9">]>]>]>;
+export type Digit1To99 = typeof Digit1To99.Output;
+/**
+ * Decimal string from `"1"` to `"59"`.
+ *
+ * @group String
+ */
+export declare const Digit1To59: UnionType<readonly [UnionType<readonly [LiteralType<"1">, LiteralType<"2">, LiteralType<"3">, LiteralType<"4">, LiteralType<"5">, LiteralType<"6">, LiteralType<"7">, LiteralType<"8">, LiteralType<"9">]>, TemplateLiteralType<readonly [UnionType<readonly [LiteralType<"1">, LiteralType<"2">, LiteralType<"3">, LiteralType<"4">, LiteralType<"5">]>, UnionType<readonly [LiteralType<"0">, LiteralType<"1">, LiteralType<"2">, LiteralType<"3">, LiteralType<"4">, LiteralType<"5">, LiteralType<"6">, LiteralType<"7">, LiteralType<"8">, LiteralType<"9">]>]>]>;
+export type Digit1To59 = typeof Digit1To59.Output;
 type PlainObjectError = ObjectError<Readonly<Record<never, never>>, ObjectPropertyAccessError | ObjectExcessPropertyError>;
 /**
  * A {@link Type} for readonly plain objects with unknown property values.
@@ -3448,7 +3863,7 @@ type ObjectUnknownPropertyErrors<Error extends TypeError, RestError extends Type
 type ObjectRestFromUnknownError<Rest extends ObjectRecordTypeNode | undefined> = Rest extends ObjectRecordTypeNode ? ObjectPropertyAccessError | RecordEntriesErrorValue<TypeOfError<"String">, InferErrors<Rest["value"]>, never> : ObjectExcessPropertyError;
 type ObjectRestFromParentError<Rest extends ObjectRecordTypeNode | undefined> = Rest extends ObjectRecordTypeNode ? RecordEntriesError<never, TypeFromError<Rest["value"]>, never> : never;
 /**
- * Creates an {@link object} Type with every property optional.
+ * Object {@link Type} with every property optional.
  *
  * No property is required, but every present property must still satisfy its
  * Type.
@@ -3473,7 +3888,8 @@ export type PartialObjectProps<Props extends ObjectProps> = {
     readonly [Key in keyof Props]: Props[Key] extends OptionalProperty<TypeNode> ? Props[Key] : Props[Key] extends TypeNode ? OptionalProperty<Props[Key]> : never;
 };
 /**
- * Makes every property whose Union Type includes {@link Null} optional.
+ * Object {@link Type} making every property whose Union Type includes
+ * {@link Null} optional.
  *
  * The property retains its original Union Type, so consumers may omit it, set
  * it to `null`, or provide any other member of that Union. Properties without
@@ -3504,7 +3920,7 @@ export type NullableToOptionalProps<Props extends ObjectProps> = {
     readonly [Key in keyof Props]: Props[Key] extends OptionalProperty<TypeNode> ? Props[Key] : Props[Key] extends UnionType<infer Members> ? typeof Null extends Members[number] ? OptionalProperty<Props[Key]> : Props[Key] : Props[Key];
 };
 /**
- * Creates an {@link object} Type without the selected declared properties.
+ * Object {@link Type} without the selected declared properties.
  *
  * @group Objects
  */
@@ -3515,7 +3931,7 @@ type ValidateOmitKeys<Keys extends ReadonlyArray<PropertyKey>> = number extends
 type OmitKeysTupleError = CompileTimeError<"Type", "Omitted keys must use one concrete finite tuple.">;
 type OmitKeyConcreteTypeError = CompileTimeError<"Type", "Each omitted key must be one concrete property key.">;
 /**
- * Creates a {@link Type} for {@link Result} values.
+ * {@link Result} {@link Type} for typed success and error values.
  *
  * Use this to validate Results crossing a storage, worker, API, or other
  * serialization boundary. The operation returns an outer validation Result. Its
@@ -3715,7 +4131,7 @@ type ConcreteTypedTagError = CompileTimeError<"Type", "Tag must be one concrete
 type TypedValidationError<Props extends ObjectProps> = "type" extends keyof Props ? TypedTypePropertyError : ObjectValidationError<Props>;
 type TypedTypePropertyError = CompileTimeError<"Type", 'Additional properties must not declare the reserved "type" property.'>;
 /**
- * Creates a {@link Type} for a producer's value, error, or done {@link Result}.
+ * Producer-result {@link Type} for value, error, or done outcomes.
  *
  * The three outcomes are `Ok<Value>`, `Err<Error>`, and `Err<Typed<"Done"> & {
  * done: Done }>`. This keeps normal completion distinct from failure while
@@ -4212,7 +4628,7 @@ export declare const jsonValueToJson: (value: JsonValue) => Json;
  */
 export declare const JsonValueFromJson: TransformType<BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "Json", JsonError>, JsonValueType, "JsonValueFromJson", never, string & Brand<"Json">>;
 /**
- * Creates a branded {@link Json} Type and total conversions for another Type.
+ * Branded {@link Json} Type and total conversions for another Type.
  *
  * Use this factory when a domain value must be stored as JSON text while its
  * exact Type remains visible to TypeScript, such as a JSON column in an Evolu