@evolu/common 8.8.0 → 8.10.0

package/dist/src/Bytes.d.ts

@@ -0,0 +1,647 @@
+/**
+ * Bytes: `Uint8Array` helpers, the {@link Buffer} codec, and byte sizes.
+ *
+ * Sizes follow the same pattern as durations in Time.ts:
+ *
+ * - {@link ByteLength} is the canonical unit, a validated number of bytes.
+ * - {@link ByteSizeLiteral} is the human-readable form, such as `"10MiB"`,
+ *   validated at compile time and runtime.
+ * - {@link ByteSize} is what APIs accept: `ByteSizeLiteral | ByteLength`.
+ * - {@link byteSizeToByteLength} normalizes a `ByteSize` to a `ByteLength`.
+ * - {@link ByteLengthFromString} parses either form from text.
+ *
+ * Buffer-based decoding functions throw instead of returning {@link Result}.
+ * Result is not slow, but every successful decode would allocate one, and a
+ * protocol message decodes many values. Throwing is the safe bet for that hot
+ * path until benchmarks cover the alternatives. Callers convert a thrown error
+ * into a Result once, at the boundary, as `parseProtocolHeader` in Protocol.ts
+ * does.
+ *
+ * @module
+ */
+import { bytesToUtf8, utf8ToBytes } from "@noble/ciphers/utils.js";
+import { Digit, Digit1To9, type FiniteNumber, type JsonValue, NonNegativeInt, type PositiveInt, type TemplateLiteralType, type LiteralType, type UnionType, type Type, type TypeError, type UnionError } from "./Type.ts";
+export { bytesToHex, concatBytes, hexToBytes } from "@noble/ciphers/utils.js";
+export { bytesToUtf8, utf8ToBytes };
+/**
+ * Custom error for {@link Buffer}-related failures like premature end of data.
+ * Provides better stack traces for debugging binary protocol issues.
+ */
+export declare class BufferError extends Error {
+    constructor(message: string);
+}
+/**
+ * A Buffer is a dynamic, resizable container for binary data, optimized for
+ * scenarios where the final size is unknown. It grows exponentially (doubling
+ * its capacity) to minimize memory reallocations and uses `subarray` for
+ * efficient, copy-free data access in methods like `unwrap` and `shift`.
+ *
+ * ## Recommended Usage
+ *
+ * Create as few Buffers as possible—typically one main Buffer for the final
+ * output. Temporary Buffers are allowed when necessary (e.g., for
+ * variable-length headers), but avoid excessive allocations. Buffers can be
+ * reused within functions by leveraging `reset` to clear contents while
+ * preserving capacity, or `truncate` to adjust the length to a specific size,
+ * reducing the need for new allocations. Pass Buffers to `encode*` functions to
+ * append serialized data and use `decode*` functions to extract data.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertInstanceOf,
+ *   createBuffer,
+ *   createIdFromString,
+ *   IdBytes,
+ *   idBytesToId,
+ *   idBytesTypeValueLength,
+ *   idToIdBytes,
+ *   NonNegativeInt,
+ *   trySync,
+ *   decodeNonNegativeInt,
+ *   encodeNonNegativeInt,
+ * } from "@evolu/common";
+ *
+ * const buffer = createBuffer();
+ * const id = createIdFromString("buffer-example");
+ * encodeNonNegativeInt(buffer, NonNegativeInt.orThrow(300));
+ * buffer.extend(idToIdBytes(id));
+ *
+ * const decoder = createBuffer(buffer.unwrap());
+ * assertEqual(decodeNonNegativeInt(decoder), 300);
+ * const decodedId = idBytesToId(
+ *   IdBytes.orThrow(decoder.shiftN(idBytesTypeValueLength)),
+ * );
+ * assertEqual(decodedId, id);
+ * const result = trySync(() => decodeNonNegativeInt(decoder));
+ * assertErr(result);
+ * assertInstanceOf(result.error, Error);
+ * assertEqual(result.error.message, "Buffer parse ended prematurely");
+ * ```
+ *
+ * For more on exponential growth, see:
+ * https://blog.mozilla.org/nnethercote/2014/11/04/please-grow-your-buffers-exponentially
+ */
+export interface Buffer {
+    /** Returns the current capacity of the buffer. */
+    getCapacity: () => NonNegativeInt;
+    /** Returns the current number of bytes stored in the buffer. */
+    getLength: () => NonNegativeInt;
+    /**
+     * Appends binary data to the buffer, resizing if necessary. Throws if
+     * `arg.length` is not a non-negative safe integer.
+     */
+    extend: (arg: Uint8Array | ArrayLike<number>) => void;
+    /**
+     * Removes and returns the first byte. Throws an `Error` with message "Buffer
+     * parse ended prematurely" if the buffer is empty.
+     */
+    shift: () => NonNegativeInt;
+    /**
+     * Removes and returns the first `n` bytes. Throws an `Error` with message
+     * "Buffer parse ended prematurely" if fewer than `n` bytes remain.
+     */
+    shiftN: (n: NonNegativeInt) => Uint8Array;
+    /**
+     * Truncates the buffer to the specified length, discarding data from the end.
+     * Throws if the new length is greater than the current length.
+     */
+    truncate: (length: NonNegativeInt) => void;
+    /**
+     * Resets the buffer to its initial empty state, preserving its capacity.
+     *
+     * This allows efficient buffer reuse without reallocating memory. Use this
+     * when you want to clear the buffer and write new data, avoiding unnecessary
+     * allocations.
+     */
+    reset: () => void;
+    /**
+     * Returns a view of the buffer’s current data. Do not modify this array, as
+     * it directly alters the buffer’s internal state, potentially breaking
+     * subsequent operations.
+     */
+    unwrap: () => Uint8Array;
+}
+/** Creates a {@link Buffer} for efficient byte operations. */
+export declare const createBuffer: (arrayLike?: Uint8Array | ArrayLike<number>) => Buffer;
+/**
+ * Evolu uses MessagePack to handle finite numbers except for NonNegativeInt.
+ * For NonNegativeInt, Evolu provides more efficient encoding.
+ */
+export declare const encodeNumber: (buffer: Buffer, number: FiniteNumber) => void;
+export declare const decodeNumber: (buffer: Buffer) => FiniteNumber;
+/**
+ * Encodes an array of boolean flags into a single byte.
+ *
+ * Each element in the array corresponds to a bit (0-7). Array can have 0-8
+ * elements.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertEqual, createBuffer, encodeFlags } from "@evolu/common";
+ *
+ * const buffer = createBuffer();
+ * encodeFlags(buffer, [true, false, true]);
+ *
+ * assertEqual(buffer.unwrap(), new Uint8Array([0b101]));
+ * ```
+ */
+export declare const encodeFlags: (buffer: Buffer, flags: ReadonlyArray<boolean>) => void;
+/**
+ * Decodes a byte into an array of boolean flags.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertEqual,
+ *   createBuffer,
+ *   decodeFlags,
+ *   PositiveInt,
+ * } from "@evolu/common";
+ *
+ * const buffer = createBuffer([0b101]);
+ * const flags = decodeFlags(buffer, PositiveInt.orThrow(3));
+ *
+ * assertEqual(flags, [true, false, true]);
+ * assertEqual(buffer.getLength(), 0);
+ * ```
+ */
+export declare const decodeFlags: (buffer: Buffer, count: PositiveInt) => ReadonlyArray<boolean>;
+/**
+ * Encodes a non-negative integer into a variable-length integer format. It's
+ * more efficient than encoding via {@link encodeNumber}.
+ *
+ * https://en.wikipedia.org/wiki/Variable-length_quantity
+ */
+export declare const encodeNonNegativeInt: (buffer: Buffer, value: NonNegativeInt) => void;
+/**
+ * Decodes a non-negative integer from a variable-length integer format.
+ *
+ * https://en.wikipedia.org/wiki/Variable-length_quantity
+ */
+export declare const decodeNonNegativeInt: (buffer: Buffer) => NonNegativeInt;
+/** Encodes the length of an array-like value. */
+export declare const encodeLength: (buffer: Buffer, value: ArrayLike<unknown>) => void;
+/** Decodes an array-like value length. */
+export declare const decodeLength: typeof decodeNonNegativeInt;
+/** Encodes a length-prefixed UTF-8 string. */
+export declare const encodeString: (buffer: Buffer, value: string) => void;
+/** Decodes a length-prefixed UTF-8 string. */
+export declare const decodeString: (buffer: Buffer) => string;
+/** Incrementally encodes consecutive equal values using run-length encoding. */
+export interface RunLengthEncoder<T> {
+    readonly add: (value: T) => void;
+    readonly getLength: () => NonNegativeInt;
+    readonly unwrap: () => Uint8Array;
+}
+/** Creates an incremental run-length encoder. */
+export declare const createRunLengthEncoder: <T>(encodeValue: (buffer: Buffer, value: T) => void) => RunLengthEncoder<T>;
+/** Decodes a run-length encoded sequence. */
+export declare const decodeRle: <T>(buffer: Buffer, length: NonNegativeInt, decodeValue: () => T) => ReadonlyArray<T>;
+/**
+ * Encodes a {@link JsonValue} using the MessagePack format.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertEqual,
+ *   createBuffer,
+ *   encodeJsonValue,
+ *   JsonValue,
+ * } from "@evolu/common";
+ *
+ * const buffer = createBuffer();
+ * const value = JsonValue.orThrow({ name: "Ada" });
+ *
+ * encodeJsonValue(buffer, value);
+ *
+ * assertEqual(
+ *   buffer.unwrap(),
+ *   new Uint8Array([
+ *     0x81, 0xa4, 0x6e, 0x61, 0x6d, 0x65, 0xa3, 0x41, 0x64, 0x61,
+ *   ]),
+ * );
+ * ```
+ *
+ * Encoding is artificially limited to 1,000 nested arrays or objects to keep
+ * recursive encoding and decoding safe and symmetric. JSON data should not
+ * require such depth; flatten or split deeply nested data, or use a
+ * purpose-built serialization format.
+ */
+export declare const encodeJsonValue: (buffer: Buffer, value: JsonValue) => void;
+/**
+ * Decodes a {@link JsonValue} using the MessagePack format.
+ *
+ * Throws a {@link BufferError} without modifying the Buffer if the encoded value
+ * is malformed, truncated, unsupported, outside the JsonValue domain, or
+ * exceeds 1,000 nested arrays or objects.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertEqual,
+ *   createBuffer,
+ *   decodeJsonValue,
+ * } from "@evolu/common";
+ *
+ * const buffer = createBuffer([
+ *   0x81, 0xa4, 0x6e, 0x61, 0x6d, 0x65, 0xa3, 0x41, 0x64, 0x61,
+ * ]);
+ *
+ * assertEqual(decodeJsonValue(buffer), { name: "Ada" });
+ * assertEqual(buffer.unwrap(), new Uint8Array());
+ * ```
+ */
+export declare const decodeJsonValue: (buffer: Buffer) => JsonValue;
+/**
+ * Non-negative safe integer number of bytes.
+ *
+ * The canonical unit for sizes, as milliseconds are for time. APIs accept
+ * {@link ByteSize} and normalize it with {@link byteSizeToByteLength}. Parse text
+ * such as an environment variable with {@link ByteLengthFromString}. Negative
+ * zero is rejected so zero has one canonical representation.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertErr, assertOk, ByteLength } from "@evolu/common";
+ *
+ * assertOk(ByteLength.fromUnknown(0), 0);
+ * assertOk(ByteLength.fromUnknown(1024), 1024);
+ * assertErr(ByteLength.fromUnknown(-0));
+ * assertErr(ByteLength.fromUnknown(-1));
+ * assertErr(ByteLength.fromUnknown(1.5));
+ * ```
+ */
+export declare const ByteLength: import("./Type.ts").BrandType<import("./Type.ts").BrandType<import("./Type.ts").BrandType<import("./Type.ts").BrandType<import("./Type.ts").BrandType<Type<"Number", number, number, import("./Type.ts").TypeOfError<"Number">, null, import("./Type.ts").TypeOfError<"Number">, never, number, true>, "NonNaN", import("./Type.ts").NonNaNError>, "Finite", import("./Type.ts").FiniteError>, "Int", import("./Type.ts").IntError>, "NonNegative", import("./Type.ts").NonNegativeError>, "ByteLength", ByteLengthError>;
+export type ByteLength = typeof ByteLength.Output;
+/** Error returned when {@link ByteLength} rejects negative zero. */
+export interface ByteLengthError extends TypeError<"ByteLength"> {
+    readonly value: number;
+}
+/** Bytes: `"0B"` to `"1023B"`. See {@link ByteSizeLiteral}. */
+export declare const ByteSizeLiteralBytes: UnionType<readonly [
+    TemplateLiteralType<readonly [typeof Digit, "B"]>,
+    TemplateLiteralType<readonly [typeof Digit1To9, typeof Digit, "B"]>,
+    TemplateLiteralType<readonly [typeof Digit1To9, typeof Digit, typeof Digit, "B"]>,
+    TemplateLiteralType<readonly [
+        "10",
+        UnionType<readonly [LiteralType<"0">, LiteralType<"1">]>,
+        typeof Digit,
+        "B"
+    ]>,
+    TemplateLiteralType<readonly [
+        "102",
+        UnionType<readonly [
+            LiteralType<"0">,
+            LiteralType<"1">,
+            LiteralType<"2">,
+            LiteralType<"3">
+        ]>,
+        "B"
+    ]>
+]>;
+export type ByteSizeLiteralBytes = typeof ByteSizeLiteralBytes.Output;
+/**
+ * KiB: `"1KiB"` to `"1023KiB"` or `"1.5KiB"` to `"1023.5KiB"`. See
+ * {@link ByteSizeLiteral}.
+ */
+export declare const ByteSizeLiteralKiB: UnionType<readonly [
+    TemplateLiteralType<readonly [typeof Digit1To9, "KiB"]>,
+    TemplateLiteralType<readonly [typeof Digit1To9, typeof Digit, "KiB"]>,
+    TemplateLiteralType<readonly [typeof Digit1To9, typeof Digit, typeof Digit, "KiB"]>,
+    TemplateLiteralType<readonly [
+        "10",
+        UnionType<readonly [LiteralType<"0">, LiteralType<"1">]>,
+        typeof Digit,
+        "KiB"
+    ]>,
+    TemplateLiteralType<readonly [
+        "102",
+        UnionType<readonly [
+            LiteralType<"0">,
+            LiteralType<"1">,
+            LiteralType<"2">,
+            LiteralType<"3">
+        ]>,
+        "KiB"
+    ]>,
+    TemplateLiteralType<readonly [typeof Digit1To9, ".5KiB"]>,
+    TemplateLiteralType<readonly [typeof Digit1To9, typeof Digit, ".5KiB"]>,
+    TemplateLiteralType<readonly [typeof Digit1To9, typeof Digit, typeof Digit, ".5KiB"]>,
+    TemplateLiteralType<readonly [
+        "10",
+        UnionType<readonly [LiteralType<"0">, LiteralType<"1">]>,
+        typeof Digit,
+        ".5KiB"
+    ]>,
+    TemplateLiteralType<readonly [
+        "102",
+        UnionType<readonly [
+            LiteralType<"0">,
+            LiteralType<"1">,
+            LiteralType<"2">,
+            LiteralType<"3">
+        ]>,
+        ".5KiB"
+    ]>
+]>;
+export type ByteSizeLiteralKiB = typeof ByteSizeLiteralKiB.Output;
+/**
+ * MiB: `"1MiB"` to `"1023MiB"` or `"1.5MiB"` to `"1023.5MiB"`. See
+ * {@link ByteSizeLiteral}.
+ */
+export declare const ByteSizeLiteralMiB: UnionType<readonly [
+    TemplateLiteralType<readonly [typeof Digit1To9, "MiB"]>,
+    TemplateLiteralType<readonly [typeof Digit1To9, typeof Digit, "MiB"]>,
+    TemplateLiteralType<readonly [typeof Digit1To9, typeof Digit, typeof Digit, "MiB"]>,
+    TemplateLiteralType<readonly [
+        "10",
+        UnionType<readonly [LiteralType<"0">, LiteralType<"1">]>,
+        typeof Digit,
+        "MiB"
+    ]>,
+    TemplateLiteralType<readonly [
+        "102",
+        UnionType<readonly [
+            LiteralType<"0">,
+            LiteralType<"1">,
+            LiteralType<"2">,
+            LiteralType<"3">
+        ]>,
+        "MiB"
+    ]>,
+    TemplateLiteralType<readonly [typeof Digit1To9, ".5MiB"]>,
+    TemplateLiteralType<readonly [typeof Digit1To9, typeof Digit, ".5MiB"]>,
+    TemplateLiteralType<readonly [typeof Digit1To9, typeof Digit, typeof Digit, ".5MiB"]>,
+    TemplateLiteralType<readonly [
+        "10",
+        UnionType<readonly [LiteralType<"0">, LiteralType<"1">]>,
+        typeof Digit,
+        ".5MiB"
+    ]>,
+    TemplateLiteralType<readonly [
+        "102",
+        UnionType<readonly [
+            LiteralType<"0">,
+            LiteralType<"1">,
+            LiteralType<"2">,
+            LiteralType<"3">
+        ]>,
+        ".5MiB"
+    ]>
+]>;
+export type ByteSizeLiteralMiB = typeof ByteSizeLiteralMiB.Output;
+/**
+ * GiB: `"1GiB"` to `"1023GiB"` or `"1.5GiB"` to `"1023.5GiB"`. See
+ * {@link ByteSizeLiteral}.
+ */
+export declare const ByteSizeLiteralGiB: UnionType<readonly [
+    TemplateLiteralType<readonly [typeof Digit1To9, "GiB"]>,
+    TemplateLiteralType<readonly [typeof Digit1To9, typeof Digit, "GiB"]>,
+    TemplateLiteralType<readonly [typeof Digit1To9, typeof Digit, typeof Digit, "GiB"]>,
+    TemplateLiteralType<readonly [
+        "10",
+        UnionType<readonly [LiteralType<"0">, LiteralType<"1">]>,
+        typeof Digit,
+        "GiB"
+    ]>,
+    TemplateLiteralType<readonly [
+        "102",
+        UnionType<readonly [
+            LiteralType<"0">,
+            LiteralType<"1">,
+            LiteralType<"2">,
+            LiteralType<"3">
+        ]>,
+        "GiB"
+    ]>,
+    TemplateLiteralType<readonly [typeof Digit1To9, ".5GiB"]>,
+    TemplateLiteralType<readonly [typeof Digit1To9, typeof Digit, ".5GiB"]>,
+    TemplateLiteralType<readonly [typeof Digit1To9, typeof Digit, typeof Digit, ".5GiB"]>,
+    TemplateLiteralType<readonly [
+        "10",
+        UnionType<readonly [LiteralType<"0">, LiteralType<"1">]>,
+        typeof Digit,
+        ".5GiB"
+    ]>,
+    TemplateLiteralType<readonly [
+        "102",
+        UnionType<readonly [
+            LiteralType<"0">,
+            LiteralType<"1">,
+            LiteralType<"2">,
+            LiteralType<"3">
+        ]>,
+        ".5GiB"
+    ]>
+]>;
+export type ByteSizeLiteralGiB = typeof ByteSizeLiteralGiB.Output;
+/**
+ * TiB: `"1TiB"` to `"1023TiB"` or `"1.5TiB"` to `"1023.5TiB"`. See
+ * {@link ByteSizeLiteral}.
+ */
+export declare const ByteSizeLiteralTiB: UnionType<readonly [
+    TemplateLiteralType<readonly [typeof Digit1To9, "TiB"]>,
+    TemplateLiteralType<readonly [typeof Digit1To9, typeof Digit, "TiB"]>,
+    TemplateLiteralType<readonly [typeof Digit1To9, typeof Digit, typeof Digit, "TiB"]>,
+    TemplateLiteralType<readonly [
+        "10",
+        UnionType<readonly [LiteralType<"0">, LiteralType<"1">]>,
+        typeof Digit,
+        "TiB"
+    ]>,
+    TemplateLiteralType<readonly [
+        "102",
+        UnionType<readonly [
+            LiteralType<"0">,
+            LiteralType<"1">,
+            LiteralType<"2">,
+            LiteralType<"3">
+        ]>,
+        "TiB"
+    ]>,
+    TemplateLiteralType<readonly [typeof Digit1To9, ".5TiB"]>,
+    TemplateLiteralType<readonly [typeof Digit1To9, typeof Digit, ".5TiB"]>,
+    TemplateLiteralType<readonly [typeof Digit1To9, typeof Digit, typeof Digit, ".5TiB"]>,
+    TemplateLiteralType<readonly [
+        "10",
+        UnionType<readonly [LiteralType<"0">, LiteralType<"1">]>,
+        typeof Digit,
+        ".5TiB"
+    ]>,
+    TemplateLiteralType<readonly [
+        "102",
+        UnionType<readonly [
+            LiteralType<"0">,
+            LiteralType<"1">,
+            LiteralType<"2">,
+            LiteralType<"3">
+        ]>,
+        ".5TiB"
+    ]>
+]>;
+export type ByteSizeLiteralTiB = typeof ByteSizeLiteralTiB.Output;
+export type ByteSizeLiteral = ByteSizeLiteralBytes | ByteSizeLiteralKiB | ByteSizeLiteralMiB | ByteSizeLiteralGiB | ByteSizeLiteralTiB;
+/**
+ * Byte length literal Type with compile-time and runtime validation.
+ *
+ * Supported formats:
+ *
+ * - Bytes: `0B` to `1023B`
+ * - KiB: `1KiB` to `1023KiB` or `1.5KiB` to `1023.5KiB`
+ * - MiB: `1MiB` to `1023MiB` or `1.5MiB` to `1023.5MiB`
+ * - GiB: `1GiB` to `1023GiB` or `1.5GiB` to `1023.5GiB`
+ * - TiB: `1TiB` to `1023TiB` or `1.5TiB` to `1023.5TiB`
+ *
+ * Units are the binary ones defined by IEC, named kibibyte (`KiB`, 1024 bytes),
+ * mebibyte (`MiB`), gibibyte (`GiB`), and tebibyte (`TiB`), each 1024 times the
+ * previous. Memory, storage quotas, and caches are measured in them. The
+ * familiar `MB` is ambiguous: SI defines it as a million bytes, storage vendors
+ * use that meaning, and most software uses 1048576 instead, which is why a "1
+ * TB" drive shows as 931 "GB". `MiB` has only one meaning, so a literal never
+ * depends on a convention.
+ *
+ * Each unit is bounded below 1024, so equivalent representations are avoided:
+ * `1024KiB` must be written as `"1MiB"`. A half is the only decimal allowed,
+ * because it is the only single decimal digit that is exact in every binary
+ * unit; `1.1KiB` would be 1126.4 bytes. For other exact values, use
+ * {@link ByteLength} directly.
+ *
+ * See {@link ByteSize} for a type that also accepts {@link ByteLength}. Use
+ * {@link byteSizeToByteLength} to convert.
+ *
+ * Invalid values produce a {@link ByteSizeLiteralError}.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertFalse,
+ *   assertOk,
+ *   assertType,
+ *   ByteSizeLiteral,
+ * } from "@evolu/common";
+ *
+ * // The TypeScript type accepts valid spellings and rejects the rest.
+ * const literal: ByteSizeLiteral = "1023MiB";
+ * assertType<
+ *   Extract<ByteSizeLiteral, "1024KiB" | "1.1KiB" | "1MB">,
+ *   never
+ * >();
+ *
+ * // The runtime Type validates the same grammar.
+ * assertOk(ByteSizeLiteral.fromUnknown(literal), "1023MiB");
+ * assertFalse(ByteSizeLiteral.is("1024KiB"));
+ *
+ * const invalid = ByteSizeLiteral.fromUnknown("1MB");
+ * assertErr(invalid);
+ * assertEqual(invalid.error.type, "ByteSizeLiteral");
+ * assertEqual(
+ *   ByteSizeLiteral.formatError(invalid.error),
+ *   'The value "1MB" is not a byte-size literal. Use a value such as "512KiB" or "1MiB".',
+ * );
+ * ```
+ */
+export declare const ByteSizeLiteral: Type<"ByteSizeLiteral", ByteSizeLiteral, ByteSizeLiteral, ByteSizeLiteralError>;
+/** Error returned when {@link ByteSizeLiteral} rejects a value. */
+export interface ByteSizeLiteralError extends TypeError<"ByteSizeLiteral"> {
+    readonly value: unknown;
+    /**
+     * The underlying union failure, retained for diagnostics.
+     *
+     * With `{ errors: "all" }`, includes every failed alternative.
+     */
+    readonly cause: UnionError;
+}
+/**
+ * {@link ByteSizeLiteral} or {@link ByteLength}.
+ *
+ * Convenience input accepting a human-readable {@link ByteSizeLiteral} or a
+ * validated {@link ByteLength} for values that no literal expresses. APIs
+ * normalize it with {@link byteSizeToByteLength}.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertEqual,
+ *   ByteLength,
+ *   byteSizeToByteLength,
+ *   type ByteSize,
+ * } from "@evolu/common";
+ *
+ * const literal: ByteSize = "1MiB";
+ * const validated: ByteSize = ByteLength.orThrow(1000000);
+ *
+ * assertEqual(byteSizeToByteLength(literal), 1048576);
+ * assertEqual(byteSizeToByteLength(validated), 1000000);
+ * ```
+ */
+export type ByteSize = ByteSizeLiteral | ByteLength;
+/**
+ * Converts a {@link ByteSize} to a {@link ByteLength}. A {@link ByteLength} is
+ * returned unchanged.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertEqual, byteSizeToByteLength } from "@evolu/common";
+ *
+ * assertEqual(byteSizeToByteLength("0B"), 0);
+ * assertEqual(byteSizeToByteLength("2KiB"), 2048);
+ * assertEqual(byteSizeToByteLength("1GiB"), 1073741824);
+ * ```
+ */
+export declare const byteSizeToByteLength: (value: ByteSize) => ByteLength;
+/**
+ * Error returned when a string is neither a number of bytes nor a
+ * {@link ByteSizeLiteral}.
+ */
+export interface ByteLengthFromStringError extends TypeError<"ByteLengthFromString"> {
+    readonly value: string;
+}
+/**
+ * Transforms a number of bytes or a {@link ByteSizeLiteral} in text into a
+ * {@link ByteLength}.
+ *
+ * This is useful for inputs that carry sizes as text, such as environment
+ * variables and configuration files, where `"10MiB"` reads better than
+ * `"10485760"`. Encoding produces the number of bytes.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   ByteLengthFromString,
+ * } from "@evolu/common";
+ *
+ * assertOk(ByteLengthFromString.fromUnknown("10MiB"), 10485760);
+ * assertOk(ByteLengthFromString.fromUnknown("1048576"), 1048576);
+ * assertEqual(
+ *   ByteLengthFromString.to(ByteLengthFromString.orThrow("1KiB")),
+ *   "1024",
+ * );
+ *
+ * const invalid = ByteLengthFromString.fromUnknown("10MB");
+ * assertErr(invalid, { type: "ByteLengthFromString", value: "10MB" });
+ * assertEqual(
+ *   ByteLengthFromString.formatError(invalid.error),
+ *   'The value "10MB" is not a byte length. Use a number of bytes or a literal such as 10MiB.',
+ * );
+ * ```
+ */
+export declare const ByteLengthFromString: import("./Type.ts").TransformType<Type<"String", string, string, import("./Type.ts").TypeOfError<"String">, null, import("./Type.ts").TypeOfError<"String">, never, string, true>, import("./Type.ts").BrandType<import("./Type.ts").BrandType<import("./Type.ts").BrandType<import("./Type.ts").BrandType<import("./Type.ts").BrandType<Type<"Number", number, number, import("./Type.ts").TypeOfError<"Number">, null, import("./Type.ts").TypeOfError<"Number">, never, number, true>, "NonNaN", import("./Type.ts").NonNaNError>, "Finite", import("./Type.ts").FiniteError>, "Int", import("./Type.ts").IntError>, "NonNegative", import("./Type.ts").NonNegativeError>, "ByteLength", ByteLengthError>, "ByteLengthFromString", ByteLengthFromStringError, string>;
+//# sourceMappingURL=Bytes.d.ts.map

package/dist/src/Bytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Bytes.d.ts","sourceRoot":"","sources":["../../src/Bytes.ts"],"names":[],"mappings":"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"}