@evolu/common 8.7.0 → 8.8.0

package/dist/src/{Buffer.d.ts → Binary.d.ts}

@@ -10,8 +10,10 @@
  *
  * @module
  */
-import type { JsonValue, NonNegativeInt } from "./Type.ts";
-export { bytesToHex, bytesToUtf8, concatBytes, hexToBytes, utf8ToBytes, } from "@noble/ciphers/utils.js";
+import { bytesToUtf8, utf8ToBytes } from "@noble/ciphers/utils.js";
+import type { FiniteNumber, JsonValue, NonNegativeInt, PositiveInt } 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.
@@ -39,9 +41,9 @@ export declare class BufferError extends Error {
  *
  * ```ts
  * import {
- *   assert,
  *   assertEqual,
  *   assertErr,
+ *   assertInstanceOf,
  *   createBuffer,
  *   createIdFromString,
  *   IdBytes,
@@ -50,11 +52,9 @@ export declare class BufferError extends Error {
  *   idToIdBytes,
  *   NonNegativeInt,
  *   trySync,
- * } from "@evolu/common";
- * import {
  *   decodeNonNegativeInt,
  *   encodeNonNegativeInt,
- * } from "@evolu/common/local-first";
+ * } from "@evolu/common";
  *
  * const buffer = createBuffer();
  * const id = createIdFromString("buffer-example");
@@ -69,11 +69,8 @@ export declare class BufferError extends Error {
  * assertEqual(decodedId, id);
  * const result = trySync(() => decodeNonNegativeInt(decoder));
  * assertErr(result);
- * assert(
- *   result.error instanceof Error &&
- *     result.error.message === "Buffer parse ended prematurely",
- *   "Expected the premature-buffer-end error.",
- * );
+ * assertInstanceOf(result.error, Error);
+ * assertEqual(result.error.message, "Buffer parse ended prematurely");
  * ```
  *
  * For more on exponential growth, see:
@@ -121,6 +118,82 @@ export interface Buffer {
 }
 /** 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.
  *
@@ -178,4 +251,4 @@ export declare const encodeJsonValue: (buffer: Buffer, value: JsonValue) => void
  * ```
  */
 export declare const decodeJsonValue: (buffer: Buffer) => JsonValue;
-//# sourceMappingURL=Buffer.d.ts.map
+//# sourceMappingURL=Binary.d.ts.map

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

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

package/dist/src/{Buffer.js → Binary.js}

@@ -10,7 +10,9 @@
  *
  * @module
  */
-export { bytesToHex, bytesToUtf8, concatBytes, hexToBytes, utf8ToBytes, } from "@noble/ciphers/utils.js";
+import { bytesToUtf8, utf8ToBytes } from "@noble/ciphers/utils.js";
+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.
@@ -26,9 +28,7 @@ export class BufferError extends Error {
 export const createBuffer = (arrayLike) => {
     const initialLength = arrayLike?.length ?? 0;
     assertNonNegativeInt(initialLength, "arrayLike.length");
-    let value = arrayLike
-        ? new globalThis.Uint8Array(arrayLike)
-        : new globalThis.Uint8Array(512);
+    let value = arrayLike ? new Uint8Array(arrayLike) : new Uint8Array(512);
     let length = initialLength;
     const buffer = {
         getCapacity: () => value.length,
@@ -41,7 +41,7 @@ export const createBuffer = (arrayLike) => {
             if (value.length < targetSize) {
                 const oldValue = value;
                 const newCapacity = Math.max(value.length * 2, targetSize);
-                value = new globalThis.Uint8Array(newCapacity);
+                value = new Uint8Array(newCapacity);
                 value.set(oldValue);
             }
             value.set(arg, length);
@@ -74,23 +74,207 @@ export const createBuffer = (arrayLike) => {
     };
     return buffer;
 };
+/**
+ * Evolu uses MessagePack to handle finite numbers except for NonNegativeInt.
+ * For NonNegativeInt, Evolu provides more efficient encoding.
+ */
+export const encodeNumber = (buffer, number) => {
+    encodeJsonValue(buffer, number);
+};
+export const decodeNumber = (buffer) => {
+    const value = decodeJsonValue(buffer);
+    if (typeof value !== "number") {
+        throw new BufferError("Expected an encoded number.");
+    }
+    return value;
+};
+/**
+ * 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 const encodeFlags = (buffer, flags) => {
+    let byte = 0;
+    for (let i = 0; i < flags.length && i < 8; i++) {
+        if (flags[i]) {
+            byte |= 1 << i;
+        }
+    }
+    buffer.extend([byte]);
+};
+/**
+ * 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 const decodeFlags = (buffer, count) => {
+    const byte = buffer.shift();
+    const length = Math.min(count, 8);
+    // oxlint-disable-next-line unicorn/no-new-array -- Preallocation is intentional in this decoding hot path.
+    const flags = new Array(length);
+    for (let i = 0; i < length; i++) {
+        flags[i] = (byte & (1 << i)) !== 0;
+    }
+    return flags;
+};
+/**
+ * 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 const encodeNonNegativeInt = (buffer, value) => {
+    if (value === 0) {
+        buffer.extend([0]);
+        return;
+    }
+    let remaining = BigInt(value);
+    const bytes = [];
+    while (remaining !== 0n) {
+        const byte = Number(remaining & 127n);
+        bytes.push(byte);
+        remaining >>= 7n;
+    }
+    for (let i = 0; i < bytes.length - 1; i++) {
+        bytes[i] |= 128;
+    }
+    buffer.extend(bytes);
+};
+/**
+ * Decodes a non-negative integer from a variable-length integer format.
+ *
+ * https://en.wikipedia.org/wiki/Variable-length_quantity
+ */
+export const decodeNonNegativeInt = (buffer) => {
+    let result = 0n;
+    let shift = 0n;
+    let byte = 0;
+    // 8 is the smallest required count
+    for (let byteCount = 0; byteCount < 8; byteCount++) {
+        byte = buffer.shift();
+        result |= BigInt(byte & 127) << shift;
+        if ((byte & 128) === 0)
+            break;
+        shift += 7n;
+    }
+    if ((byte & 128) !== 0) {
+        throw new BufferError("Variable-length quantity must terminate within 8 bytes.");
+    }
+    const value = Number(result);
+    assertNonNegativeInt(value, "Decoded integer");
+    return value;
+};
+/** Encodes the length of an array-like value. */
+export const encodeLength = (buffer, value) => {
+    assertNonNegativeInt(value.length, "Array-like length");
+    encodeNonNegativeInt(buffer, value.length);
+};
+/** Decodes an array-like value length. */
+export const decodeLength = decodeNonNegativeInt;
+/** Encodes a length-prefixed UTF-8 string. */
+export const encodeString = (buffer, value) => {
+    const bytes = utf8ToBytes(value);
+    encodeLength(buffer, bytes);
+    buffer.extend(bytes);
+};
+/** Decodes a length-prefixed UTF-8 string. */
+export const decodeString = (buffer) => {
+    const length = decodeLength(buffer);
+    const bytes = buffer.shiftN(length);
+    return bytesToUtf8(bytes);
+};
+/** Creates an incremental run-length encoder. */
+export const createRunLengthEncoder = (encodeValue) => {
+    const buffer = createBuffer();
+    let previousLength = 0;
+    let previousValue = null;
+    let runLength = 0;
+    return {
+        add: (value) => {
+            if (Object.is(value, previousValue)) {
+                runLength++;
+                buffer.truncate(previousLength);
+            }
+            else {
+                previousValue = value;
+                runLength = 1;
+            }
+            previousLength = buffer.getLength();
+            encodeValue(buffer, value);
+            encodeNonNegativeInt(buffer, runLength);
+        },
+        getLength: () => buffer.getLength(),
+        unwrap: () => buffer.unwrap(),
+    };
+};
+/** Decodes a run-length encoded sequence. */
+export const decodeRle = (buffer, length, decodeValue) => {
+    // oxlint-disable-next-line unicorn/no-new-array -- Preallocation is intentional in this decoding hot path.
+    const values = new Array(length);
+    let index = 0;
+    while (index < length) {
+        const value = decodeValue();
+        const runLength = decodeNonNegativeInt(buffer);
+        // Prevent infinite loop on malformed input.
+        if (runLength === 0) {
+            throw new BufferError("Invalid RLE encoding: runLength must be positive");
+        }
+        const remaining = length - index;
+        // Prevent CPU/memory amplification via oversized runLength.
+        if (runLength > remaining) {
+            throw new BufferError(`Invalid RLE encoding: runLength ${runLength} exceeds remaining ${remaining}`);
+        }
+        for (let i = 0; i < runLength; i++) {
+            values[index] = value;
+            index++;
+        }
+    }
+    return values;
+};
 const jsonKeyCacheSize = 4096;
 const maxCachedJsonKeyByteLength = 32;
 const maxJsonNestingDepth = 1_000;
-let jsonEncoderTarget = new globalThis.Uint8Array(8192);
-let jsonEncoderTargetView = new globalThis.DataView(jsonEncoderTarget.buffer);
+let jsonEncoderTarget = new Uint8Array(8192);
+let jsonEncoderTargetView = new DataView(jsonEncoderTarget.buffer);
 let jsonEncoderPosition = 0;
 let jsonEncoderDepth = 0;
 let jsonEncoderIsActive = false;
-const emptyJsonDecoderSource = new globalThis.Uint8Array(0);
-const emptyJsonDecoderView = new globalThis.DataView(emptyJsonDecoderSource.buffer);
+const emptyJsonDecoderSource = new Uint8Array(0);
+const emptyJsonDecoderView = new DataView(emptyJsonDecoderSource.buffer);
 let jsonDecoderSource = emptyJsonDecoderSource;
 let jsonDecoderView = emptyJsonDecoderView;
 let jsonDecoderPosition = 0;
 let jsonDecoderDepth = 0;
-const jsonStringFromCharCode = globalThis.String.fromCharCode;
+const jsonStringFromCharCode = String.fromCharCode;
 // Cache only short keys and use a fixed table to bound retained memory.
-const jsonKeyCache = globalThis.Array.from({ length: jsonKeyCacheSize }, () => undefined);
+const jsonKeyCache = Array.from({ length: jsonKeyCacheSize }, () => undefined);
 /**
  * Encodes a {@link JsonValue} using the MessagePack format.
  *
@@ -165,7 +349,7 @@ export const encodeJsonValue = (buffer, value) => {
 export const decodeJsonValue = (buffer) => {
     const source = buffer.unwrap();
     jsonDecoderSource = source;
-    jsonDecoderView = new globalThis.DataView(source.buffer, source.byteOffset, source.byteLength);
+    jsonDecoderView = new DataView(source.buffer, source.byteOffset, source.byteLength);
     jsonDecoderPosition = 0;
     try {
         const value = decodeJsonValueFromSource();
@@ -195,7 +379,7 @@ const encodeJsonValueToTarget = (value) => {
             encodeJsonStringToTarget(value);
             return;
         case "number": {
-            if (globalThis.Object.is(value, -0)) {
+            if (Object.is(value, -0)) {
                 ensureJsonEncoderCapacity(9);
                 jsonEncoderTarget[jsonEncoderPosition++] = 0xcb;
                 jsonEncoderTargetView.setFloat64(jsonEncoderPosition, value);
@@ -225,9 +409,7 @@ const encodeJsonValueToTarget = (value) => {
                 }
                 return;
             }
-            if (globalThis.Number.isInteger(value) &&
-                value >= -0x80000000 &&
-                value < 0) {
+            if (Number.isInteger(value) && value >= -0x80000000 && value < 0) {
                 if (value >= -0x20) {
                     writeJsonEncoderByte(0x100 + value);
                 }
@@ -264,7 +446,7 @@ const encodeJsonValueToTarget = (value) => {
                 throw new BufferError(`JSON nesting exceeds the maximum depth of ${maxJsonNestingDepth}.`);
             }
             jsonEncoderDepth++;
-            if (globalThis.Array.isArray(value)) {
+            if (Array.isArray(value)) {
                 const array = value;
                 const length = array.length;
                 writeJsonCollectionHeader(length, 0x90, 0xdc, 0xdd);
@@ -274,7 +456,7 @@ const encodeJsonValueToTarget = (value) => {
                 return;
             }
             const object = value;
-            const keys = globalThis.Object.keys(object);
+            const keys = Object.keys(object);
             writeJsonCollectionHeader(keys.length, 0x80, 0xde, 0xdf);
             for (const key of keys) {
                 encodeJsonStringToTarget(key);
@@ -380,12 +562,12 @@ const ensureJsonEncoderCapacity = (additionalLength) => {
     assertNonNegativeInt(requiredLength, "Encoded JSON value length");
     if (requiredLength <= jsonEncoderTarget.length)
         return;
-    const newCapacity = globalThis.Math.max(jsonEncoderTarget.length * 2, requiredLength);
+    const newCapacity = Math.max(jsonEncoderTarget.length * 2, requiredLength);
     assertNonNegativeInt(newCapacity, "JSON encoder capacity");
     const oldTarget = jsonEncoderTarget;
-    jsonEncoderTarget = new globalThis.Uint8Array(newCapacity);
+    jsonEncoderTarget = new Uint8Array(newCapacity);
     jsonEncoderTarget.set(oldTarget.subarray(0, jsonEncoderPosition));
-    jsonEncoderTargetView = new globalThis.DataView(jsonEncoderTarget.buffer);
+    jsonEncoderTargetView = new DataView(jsonEncoderTarget.buffer);
 };
 const assertMessagePackLength = (length, name) => {
     if (length > 0xffffffff) {
@@ -461,7 +643,7 @@ const decodeJsonFloat = (byteLength) => {
         ? jsonDecoderView.getFloat32(jsonDecoderPosition)
         : jsonDecoderView.getFloat64(jsonDecoderPosition);
     jsonDecoderPosition += byteLength;
-    if (!globalThis.Number.isFinite(value)) {
+    if (!Number.isFinite(value)) {
         throw new BufferError("A decoded JSON number must be finite.");
     }
     return value;
@@ -685,7 +867,7 @@ const decodeJsonMap = (length) => {
         }
         const entryValue = decodeJsonValueFromSource();
         if (key === "__proto__") {
-            globalThis.Object.defineProperty(value, key, {
+            Object.defineProperty(value, key, {
                 value: entryValue,
                 configurable: true,
                 enumerable: true,
@@ -765,7 +947,7 @@ const assertJsonDecoderHasRemainingBytes = (requiredBytes) => {
     }
 };
 const assertNonNegativeInt = (value, name) => {
-    if (!globalThis.Number.isSafeInteger(value) || value < 0) {
+    if (!Number.isSafeInteger(value) || value < 0) {
         throw new BufferError(`${name} must be a non-negative safe integer.`);
     }
 };

package/dist/src/Console.d.ts

@@ -326,7 +326,7 @@ export declare const createConsole: ({ name, level, output, path, formatter, }?:
  *
  * const output = createNativeConsoleOutput();
  *
- * assertType<ConsoleOutput, typeof output>();
+ * assertType<typeof output, ConsoleOutput>();
  * assertEqual(typeof output.write, "function");
  * ```
  */
@@ -371,15 +371,7 @@ export declare const createNativeConsoleOutput: () => ConsoleOutput;
  * assertType(Data, nested);
  * assertEqual(nested, ["+1.500s [relay] [db]", "opened"]);
  *
- * const localTimestamp = new globalThis.Date(
- *   2026,
- *   0,
- *   28,
- *   14,
- *   30,
- *   15,
- *   123,
- * ).getTime();
+ * const localTimestamp = new Date(2026, 0, 28, 14, 30, 15, 123).getTime();
  * const formatAbsolute = createConsoleFormatter({
  *   time: testCreateTime({ startAt: Millis.orThrow(localTimestamp) }),
  * })({ timestampFormat: "absolute" });

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

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

package/dist/src/Console.js

@@ -71,14 +71,16 @@ export const createConsole = ({ name = "", level = "log", output = createNativeC
  *
  * const output = createNativeConsoleOutput();
  *
- * assertType<ConsoleOutput, typeof output>();
+ * assertType<typeof output, ConsoleOutput>();
  * assertEqual(typeof output.write, "function");
  * ```
  */
 export const createNativeConsoleOutput = () => ({
     write: (entry, formatter) => {
         const args = formatter ? formatter(entry) : entry.args;
-        globalThis.console[entry.method](...args);
+        // oxlint-disable-next-line evolu/no-unnecessary-global-this -- Write to the global object console even if a realm lexical binding shadows it.
+        const nativeConsole = globalThis.console;
+        nativeConsole[entry.method](...args);
     },
 });
 /**
@@ -121,15 +123,7 @@ export const createNativeConsoleOutput = () => ({
  * assertType(Data, nested);
  * assertEqual(nested, ["+1.500s [relay] [db]", "opened"]);
  *
- * const localTimestamp = new globalThis.Date(
- *   2026,
- *   0,
- *   28,
- *   14,
- *   30,
- *   15,
- *   123,
- * ).getTime();
+ * const localTimestamp = new Date(2026, 0, 28, 14, 30, 15, 123).getTime();
  * const formatAbsolute = createConsoleFormatter({
  *   time: testCreateTime({ startAt: Millis.orThrow(localTimestamp) }),
  * })({ timestampFormat: "absolute" });
@@ -156,7 +150,7 @@ export const createConsoleFormatter = ({ time = createTime() } = {}) => (config
                 timestamp = formatMillisAsClockTime(now);
                 break;
             case "iso":
-                timestamp = new globalThis.Date(now).toISOString();
+                timestamp = new Date(now).toISOString();
                 break;
         }
         const path = entry.path.length > 0 ? entry.path.map((p) => `[${p}]`).join(" ") : "";

package/dist/src/Crypto.d.ts

@@ -49,10 +49,10 @@ export interface RandomBytes {
      * const seed = randomBytes.create(64);
      * const custom = randomBytes.create(48);
      *
-     * assertType<Entropy16, typeof nonce16>();
-     * assertType<Entropy24, typeof nonce24>();
-     * assertType<Entropy32, typeof key>();
-     * assertType<Entropy64, typeof seed>();
+     * assertType<typeof nonce16, Entropy16>();
+     * assertType<typeof nonce24, Entropy24>();
+     * assertType<typeof key, Entropy32>();
+     * assertType<typeof seed, Entropy64>();
      * assertEqual(custom.length, 48);
      * ```
      */
@@ -127,7 +127,7 @@ export type XChaCha20Poly1305Ciphertext = typeof XChaCha20Poly1305Ciphertext.Out
  *   randomBytes: createRandomBytes(),
  * })(plaintext, encryptionKey);
  *
- * assertType<XChaCha20Poly1305Ciphertext, typeof ciphertext>();
+ * assertType<typeof ciphertext, XChaCha20Poly1305Ciphertext>();
  * assertEqual(nonce.length, 24);
  * ```
  *

package/dist/src/Crypto.js

@@ -85,7 +85,7 @@ export const XChaCha20Poly1305Ciphertext = /*#__PURE__*/ brand("XChaCha20Poly130
  *   randomBytes: createRandomBytes(),
  * })(plaintext, encryptionKey);
  *
- * assertType<XChaCha20Poly1305Ciphertext, typeof ciphertext>();
+ * assertType<typeof ciphertext, XChaCha20Poly1305Ciphertext>();
  * assertEqual(nonce.length, 24);
  * ```
  *