@evolu/common 7.4.1 → 8.0.0-next.0

package/dist/src/local-first/Storage.js

@@ -1,24 +1,45 @@
+/**
+ * Encrypted storage layer for local-first data.
+ *
+ * @module
+ */
 import { sha256 } from "@noble/hashes/sha2.js";
-import { firstInArray, isNonEmptyReadonlyArray, } from "../Array.js";
+import { firstInArray, isNonEmptyArray } from "../Array.js";
 import { assert } from "../Assert.js";
 import { concatBytes } from "../Buffer.js";
 import { decrement } from "../Number.js";
 import { err, ok } from "../Result.js";
 import { sql, SqliteValue } from "../Sqlite.js";
+import { Millis } from "../Time.js";
 import { Boolean, brand, Id, NonNegativeInt, nullOr, object, PositiveInt, record, String, } from "../Type.js";
+import { OwnerId, OwnerWriteKey } from "./Owner.js";
 import { systemColumnsWithId } from "./Schema.js";
-import { orderTimestampBytes } from "./Timestamp.js";
-export const fingerprintSize = NonNegativeInt.orThrow(12);
+import { createTimestamp, orderTimestampBytes, Timestamp, TimestampBytes, } from "./Timestamp.js";
+export const fingerprintSize = /*#__PURE__*/ NonNegativeInt.orThrow(12);
 /** A fingerprint of an empty range. */
-export const zeroFingerprint = new Uint8Array(fingerprintSize);
-export const InfiniteUpperBound = Symbol("InfiniteUpperBound");
+export const zeroFingerprint = /*#__PURE__*/ new Uint8Array(fingerprintSize);
+export const InfiniteUpperBound = /*#__PURE__*/ Symbol("evolu.local-first.Storage.InfiniteUpperBound");
 export const RangeType = {
     Fingerprint: 1,
     Skip: 0,
     Timestamps: 2,
 };
-export const DbChangeValues = record(String, SqliteValue);
-export const ValidDbChangeValues = brand("ValidDbChangeValues", DbChangeValues, (value) => {
+/** Test helper for creating a simple {@link CrdtMessage}. */
+export const testCreateCrdtMessage = (id, millis, name) => ({
+    timestamp: createTimestamp({
+        millis: Millis.orThrow(millis),
+        counter: 0,
+    }),
+    change: DbChange.orThrow({
+        table: "testTable",
+        id,
+        values: { name },
+        isInsert: true,
+        isDelete: false,
+    }),
+});
+export const DbChangeValues = /*#__PURE__*/ record(String, SqliteValue);
+export const ValidDbChangeValues = /*#__PURE__*/ brand("ValidDbChangeValues", DbChangeValues, (value) => {
     const invalidColumns = systemColumnsWithId.filter((key) => key in value);
     if (invalidColumns.length > 0)
         return err({
@@ -32,12 +53,12 @@ export const ValidDbChangeValues = brand("ValidDbChangeValues", DbChangeValues,
  * A DbChange is a change to a table row. Together with a unique
  * {@link Timestamp}, it forms a {@link CrdtMessage}.
  */
-export const DbChange = object({
+export const DbChange = /*#__PURE__*/ object({
     table: String,
     id: Id,
     values: ValidDbChangeValues,
     isInsert: Boolean,
-    isDelete: nullOr(Boolean),
+    isDelete: /*#__PURE__*/ nullOr(Boolean),
 });
 /**
  * Creates a {@link BaseSqliteStorage} implementation.
@@ -52,124 +73,80 @@ export const DbChange = object({
  * doesn't persist between requests. While not extensively tested in all these
  * environments yet, the stateless design should work well across them.
  */
-export const createBaseSqliteStorage = (deps) => (config) => {
-    return {
-        insertTimestamp: (ownerId, timestamp, strategy) => {
-            const level = randomSkiplistLevel(deps);
-            return insertTimestamp(deps)(ownerId, timestamp, level, strategy);
-        },
-        getExistingTimestamps: (ownerIdBytes, timestampsBytes) => {
-            const concatenatedTimestamps = concatBytes(...timestampsBytes);
-            const result = deps.sqlite.exec(sql `
-          with recursive
-            split_timestamps(timestampBytes, pos) as (
-              select
-                substr(${concatenatedTimestamps}, 1, 16),
-                17 as pos
-              union all
-              select
-                substr(${concatenatedTimestamps}, pos, 16),
-                pos + 16
-              from split_timestamps
-              where pos <= length(${concatenatedTimestamps})
-            )
-          select s.timestampBytes
-          from
-            split_timestamps s
-            join evolu_timestamp t
-              on t.ownerId = ${ownerIdBytes} and s.timestampBytes = t.t;
-        `);
-            if (!result.ok)
-                return result;
-            return ok(result.value.rows.map((row) => row.timestampBytes));
-        },
-        getSize: (ownerId) => {
-            const size = getSize(deps)(ownerId);
-            if (!size.ok) {
-                config.onStorageError(size.error);
-                return null;
-            }
-            return size.value;
-        },
-        fingerprint: (ownerId, begin, end) => {
-            assertBeginEnd(begin, end);
-            const result = fingerprint(deps)(ownerId, begin, end);
-            if (!result.ok) {
-                config.onStorageError(result.error);
-                return null;
-            }
-            return result.value;
-        },
-        fingerprintRanges: (ownerId, buckets, upperBound) => {
-            const ranges = fingerprintRanges(deps)(ownerId, buckets, upperBound);
-            if (!ranges.ok) {
-                config.onStorageError(ranges.error);
-                return null;
-            }
-            return ranges.value;
-        },
-        findLowerBound: (ownerId, begin, end, upperBound) => {
-            const lowerBound = findLowerBound(deps)(ownerId, begin, end, upperBound);
-            if (!lowerBound.ok) {
-                config.onStorageError(lowerBound.error);
-                return null;
-            }
-            return lowerBound.value;
-        },
-        iterate: (ownerId, begin, end, callback) => {
-            assertBeginEnd(begin, end);
-            const length = end - begin;
-            if (length === 0)
-                return;
-            // This is much faster than SQL limit with offset.
-            const first = getTimestampByIndex(deps)(ownerId, begin);
-            if (!first.ok) {
-                config.onStorageError(first.error);
-                return;
-            }
-            if (!callback(first.value, begin))
-                return;
-            if (length === 1)
-                return;
-            /**
-             * TODO: In rare cases, we might overfetch a lot of rows here, but we
-             * don't have real usage numbers yet. Fetching one row at a time would
-             * probably be slower in almost all cases. In the future, we should
-             * fetch in chunks (e.g., 1,000 rows at a time). For now, consider
-             * logging unused rows to gather data and calculate an average, then use
-             * that information to determine an optimal chunk size. Before
-             * implementing chunking, be sure to run performance tests (including
-             * fetching one by one).
-             */
-            const result = deps.sqlite.exec(sql `
-          select t
-          from evolu_timestamp
-          where ownerId = ${ownerId} and t > ${first.value}
-          order by t
-          limit ${length - 1};
-        `);
-            if (!result.ok) {
-                config.onStorageError(result.error);
+export const createBaseSqliteStorage = (deps) => ({
+    insertTimestamp: (ownerId, timestamp, strategy) => {
+        const level = randomSkiplistLevel(deps);
+        insertTimestamp(deps)(ownerId, timestamp, level, strategy);
+    },
+    getExistingTimestamps: (ownerIdBytes, timestampsBytes) => {
+        const concatenatedTimestamps = concatBytes(...timestampsBytes);
+        const result = deps.sqlite.exec(sql `
+      with recursive
+        split_timestamps(timestampBytes, pos) as (
+          select
+            substr(${concatenatedTimestamps}, 1, 16),
+            17 as pos
+          union all
+          select
+            substr(${concatenatedTimestamps}, pos, 16),
+            pos + 16
+          from split_timestamps
+          where pos <= length(${concatenatedTimestamps})
+        )
+      select s.timestampBytes
+      from
+        split_timestamps s
+        join evolu_timestamp t
+          on t.ownerId = ${ownerIdBytes} and s.timestampBytes = t.t;
+    `);
+        return result.rows.map((row) => row.timestampBytes);
+    },
+    getSize: getSize(deps),
+    fingerprint: (ownerId, begin, end) => {
+        assertBeginEnd(begin, end);
+        return fingerprint(deps)(ownerId, begin, end);
+    },
+    fingerprintRanges: fingerprintRanges(deps),
+    findLowerBound: (ownerId, begin, end, upperBound) => findLowerBound(deps)(ownerId, begin, end, upperBound),
+    iterate: (ownerId, begin, end, callback) => {
+        assertBeginEnd(begin, end);
+        const length = end - begin;
+        if (length === 0)
+            return;
+        // This is much faster than SQL limit with offset.
+        const first = getTimestampByIndex(deps)(ownerId, begin);
+        if (!callback(first, begin))
+            return;
+        if (length === 1)
+            return;
+        /**
+         * TODO: In rare cases, we might overfetch a lot of rows here, but we don't
+         * have real usage numbers yet. Fetching one row at a time would probably be
+         * slower in almost all cases. In the future, we should fetch in chunks
+         * (e.g., 1,000 rows at a time). For now, consider logging unused rows to
+         * gather data and calculate an average, then use that information to
+         * determine an optimal chunk size. Before implementing chunking, be sure to
+         * run performance tests (including fetching one by one).
+         */
+        const result = deps.sqlite.exec(sql `
+      select t
+      from evolu_timestamp
+      where ownerId = ${ownerId} and t > ${first}
+      order by t
+      limit ${length - 1};
+    `);
+        for (let i = 0; i < result.rows.length; i++) {
+            const index = NonNegativeInt.orThrow(begin + 1 + i);
+            if (!callback(result.rows[i].t, index))
                 return;
-            }
-            for (let i = 0; i < result.value.rows.length; i++) {
-                const index = NonNegativeInt.orThrow(begin + 1 + i);
-                if (!callback(result.value.rows[i].t, index))
-                    return;
-            }
-        },
-        deleteOwner: (ownerId) => {
-            const result = deps.sqlite.exec(sql `
-          delete from evolu_timestamp where ownerId = ${ownerId};
-        `);
-            if (!result.ok) {
-                config.onStorageError(result.error);
-                return false;
-            }
-            return true;
-        },
-    };
-};
+        }
+    },
+    deleteOwner: (ownerId) => {
+        deps.sqlite.exec(sql `
+      delete from evolu_timestamp where ownerId = ${ownerId};
+    `);
+    },
+});
 const assertBeginEnd = (begin, end) => {
     assert(begin <= end, "invalid begin or end");
 };
@@ -233,11 +210,8 @@ export const createBaseSqliteStorageTables = (deps) => {
       strict;
     `,
     ]) {
-        const result = deps.sqlite.exec(query);
-        if (!result.ok)
-            return result;
+        deps.sqlite.exec(query);
     }
-    return ok();
 };
 /**
  * Determines the insertion strategy for a timestamp based on its position
@@ -772,11 +746,8 @@ const insertTimestamp = (deps) => (ownerId, timestamp, level, strategy) => {
             break;
     }
     for (const query of queries) {
-        const result = deps.sqlite.exec(query);
-        if (!result.ok)
-            return result;
+        deps.sqlite.exec(query);
     }
-    return ok();
 };
 export const timestampBytesToFingerprint = (timestamp) => {
     const hash = sha256(timestamp).slice(0, fingerprintSize);
@@ -870,14 +841,12 @@ const getSize = (deps) => (ownerId) => {
       select sum(c) as size
       from sc;
     `);
-    if (!result.ok)
-        return result;
-    return ok(result.value.rows[0].size);
+    return result.rows[0].size;
 };
 const findLowerBound = (deps) => (ownerId, begin, end, upperBound) => {
     assertBeginEnd(begin, end);
     if (end === 0 || begin === end || upperBound === InfiniteUpperBound) {
-        return ok(end);
+        return end;
     }
     const result = deps.sqlite.exec(sql.prepared `
       select t
@@ -886,16 +855,12 @@ const findLowerBound = (deps) => (ownerId, begin, end, upperBound) => {
       order by t
       limit 1;
     `);
-    if (!result.ok)
-        return result;
-    if (result.value.rows.length === 0) {
-        return ok(end);
+    if (result.rows.length === 0) {
+        return end;
     }
-    const count = getTimestampCount(deps)(ownerId, result.value.rows[0].t);
-    if (!count.ok)
-        return count;
+    const count = getTimestampCount(deps)(ownerId, result.rows[0].t);
     // `decrement` converts a count to an index.
-    return ok(NonNegativeInt.orThrow(decrement(count.value)));
+    return NonNegativeInt.orThrow(decrement(count));
 };
 const getTimestampCount = (deps) => (ownerId, timestamp) => {
     const result = deps.sqlite.exec(sql.prepared `
@@ -939,9 +904,7 @@ const getTimestampCount = (deps) => (ownerId, timestamp) => {
       select sum(tc) as count
       from sc;
     `);
-    if (!result.ok)
-        return result;
-    return ok(result.value.rows[0].count);
+    return result.rows[0].count;
 };
 /**
  * TODO: We reuse {@link fingerprintRanges}, which returns upper bound, which we
@@ -950,19 +913,13 @@ const getTimestampCount = (deps) => (ownerId, timestamp) => {
 const fingerprint = (deps) => (ownerId, begin, end) => {
     // There is no need to fingerprint an empty range.
     if (end - begin === 0) {
-        return ok(zeroFingerprint);
+        return zeroFingerprint;
     }
     if (begin === 0) {
-        const result = fingerprintRanges(deps)(ownerId, [end]);
-        if (!result.ok)
-            return result;
-        return ok(result.value[0].fingerprint);
+        return fingerprintRanges(deps)(ownerId, [end])[0].fingerprint;
     }
     // We should have a param to skip the first result.
-    const result = fingerprintRanges(deps)(ownerId, [begin, end]);
-    if (!result.ok)
-        return result;
-    return ok(result.value[1].fingerprint);
+    return fingerprintRanges(deps)(ownerId, [begin, end])[1].fingerprint;
 };
 /**
  * First, check this: https://logperiodic.com/rbsr.html#tree-friendly-functions
@@ -1084,9 +1041,7 @@ const fingerprintRanges = (deps) => (ownerId, buckets, upperBound = InfiniteUppe
       select b, cast(h1 as text) as h1, cast(h2 as text) as h2
       from c3;
     `);
-    if (!result.ok)
-        return result;
-    const fingerprintRanges = result.value.rows.map((row, i, arr) => ({
+    const fingerprintRanges = result.rows.map((row, i, arr) => ({
         type: RangeType.Fingerprint,
         upperBound: i === arr.length - 1 ? upperBound : row.b,
         fingerprint: sqliteFingerprintToFingerprint([
@@ -1094,7 +1049,7 @@ const fingerprintRanges = (deps) => (ownerId, buckets, upperBound = InfiniteUppe
             row.h2,
         ]),
     }));
-    return ok(fingerprintRanges);
+    return fingerprintRanges;
 };
 // XOR in SQLite
 const x = (a, b) => sql.raw(`(${a} | ${b}) - (${a} & ${b})`);
@@ -1170,9 +1125,7 @@ export const getTimestampByIndex = (deps) => (ownerId, index) => {
       from fi
       where ic == ${index + 1};
     `);
-    if (!result.ok)
-        return result;
-    return ok(result.value.rows[0].pt);
+    return result.rows[0].pt;
 };
 /** Retrieves usage information for an owner from the evolu_usage table. */
 export const getOwnerUsage = (deps) => (ownerIdBytes, initialTimestamp) => {
@@ -1181,16 +1134,14 @@ export const getOwnerUsage = (deps) => (ownerIdBytes, initialTimestamp) => {
       from evolu_usage
       where ownerId = ${ownerIdBytes};
     `);
-    if (!result.ok)
-        return result;
-    if (!isNonEmptyReadonlyArray(result.value.rows)) {
+    if (!isNonEmptyArray(result.rows)) {
         return ok({
             storedBytes: null,
             firstTimestamp: initialTimestamp,
             lastTimestamp: initialTimestamp,
         });
     }
-    const row = firstInArray(result.value.rows);
+    const row = firstInArray(result.rows);
     assert(row.firstTimestamp, "not null");
     assert(row.lastTimestamp, "not null");
     return ok({
@@ -1206,7 +1157,7 @@ export const getOwnerUsage = (deps) => (ownerIdBytes, initialTimestamp) => {
  * processing messages.
  */
 export const updateOwnerUsage = (deps) => (ownerIdBytes, storedBytes, firstTimestamp, lastTimestamp) => {
-    const result = deps.sqlite.exec(sql `
+    deps.sqlite.exec(sql `
       insert into evolu_usage
         ("ownerId", "storedBytes", "firstTimestamp", "lastTimestamp")
       values
@@ -1217,7 +1168,4 @@ export const updateOwnerUsage = (deps) => (ownerIdBytes, storedBytes, firstTimes
           firstTimestamp = ${firstTimestamp},
           lastTimestamp = ${lastTimestamp};
     `);
-    if (!result.ok)
-        return result;
-    return ok();
 };

package/dist/src/local-first/Timestamp.d.ts

@@ -1,8 +1,14 @@
-import { RandomBytesDep } from "../Crypto.js";
-import { Order } from "../Order.js";
-import { Result } from "../Result.js";
-import { TimeDep } from "../Time.js";
-import { DateIso, InferType } from "../Type.js";
+/**
+ * Hybrid logical clock timestamps for CRDT ordering.
+ *
+ * @module
+ */
+import type { RandomBytesDep } from "../Crypto.js";
+import type { Order } from "../Order.js";
+import type { Result } from "../Result.js";
+import type { TimeDep } from "../Time.js";
+import { Millis } from "../Time.js";
+import type { DateIso, InferType, Typed } from "../Type.js";
 export interface TimestampConfig {
     /**
      * Maximum physical clock drift allowed in ms.
@@ -11,38 +17,21 @@ export interface TimestampConfig {
      */
     readonly maxDrift: number;
 }
+/** Default value for {@link TimestampConfig.maxDrift}. */
+export declare const defaultTimestampMaxDrift: number;
 export interface TimestampConfigDep {
     readonly timestampConfig: TimestampConfig;
 }
 export type TimestampError = TimestampDriftError | TimestampCounterOverflowError | TimestampTimeOutOfRangeError;
-export interface TimestampDriftError {
-    readonly type: "TimestampDriftError";
+export interface TimestampDriftError extends Typed<"TimestampDriftError"> {
     readonly next: Millis;
     readonly now: Millis;
 }
-export interface TimestampCounterOverflowError {
-    readonly type: "TimestampCounterOverflowError";
+export interface TimestampCounterOverflowError extends Typed<"TimestampCounterOverflowError"> {
 }
-export interface TimestampTimeOutOfRangeError {
-    readonly type: "TimestampTimeOutOfRangeError";
+export interface TimestampTimeOutOfRangeError extends Typed<"TimestampTimeOutOfRangeError"> {
 }
-/**
- * Millis is a timestamp in milliseconds, like `Date.now()`, but limited to the
- * maximum value representable in 6 bytes (281474976710655) minus 1 (reserved
- * for infinity). This enables more efficient binary serialization, saving 2
- * bytes compared to the typical 8-byte (64-bit) timestamp representation.
- *
- * This limit is enforced to prevent data corruption. If a device's clock
- * exceeds this range, Evolu will stop saving data until the clock is
- * corrected.
- *
- * `new Date(281474976710654).toString()` = Tue Aug 02 10889 07:31:49
- */
-export declare const Millis: import("../Type.js").BrandType<import("../Type.js").BrandType<import("../Type.js").Type<"Brand", number & import("../Brand.js").Brand<"Int"> & import("../Brand.js").Brand<"NonNegative">, number, import("../Type.js").NonNegativeError, number & import("../Brand.js").Brand<"Int">, import("../Type.js").IntError | import("../Type.js").NumberError>, `LessThanOrEqualTo${number}`, import("../Type.js").LessThanOrEqualToError<number>, import("../Type.js").NonNegativeError | import("../Type.js").IntError | import("../Type.js").NumberError>, "Millis", import("../Type.js").BrandWithoutRefineError<"Millis", import("../Type.js").NonNegativeError | import("../Type.js").IntError | import("../Type.js").NumberError | import("../Type.js").LessThanOrEqualToError<number>>, never>;
-export type Millis = typeof Millis.Type;
-export declare const minMillis: Millis;
-export declare const maxMillis: Millis;
-export declare const Counter: import("../Type.js").BrandType<import("../Type.js").BrandType<import("../Type.js").Type<"Brand", number & import("../Brand.js").Brand<"Int"> & import("../Brand.js").Brand<"NonNegative">, number, import("../Type.js").NonNegativeError, number & import("../Brand.js").Brand<"Int">, import("../Type.js").IntError | import("../Type.js").NumberError>, "LessThanOrEqualTo65535", import("../Type.js").LessThanOrEqualToError<65535>, import("../Type.js").NonNegativeError | import("../Type.js").IntError | import("../Type.js").NumberError>, "Counter", import("../Type.js").BrandWithoutRefineError<"Counter", import("../Type.js").NonNegativeError | import("../Type.js").IntError | import("../Type.js").NumberError | import("../Type.js").LessThanOrEqualToError<65535>>, never>;
+export declare const Counter: import("../Type.js").BrandType<import("../Type.js").BrandType<import("../Type.js").Type<"Brand", number & import("../Brand.js").Brand<"Int"> & import("../Brand.js").Brand<"NonNegative">, number, import("../Type.js").NonNegativeError, number & import("../Brand.js").Brand<"Int">, import("../Type.js").NumberError | import("../Type.js").IntError>, "LessThanOrEqualTo65535", import("../Type.js").LessThanOrEqualToError<65535>, import("../Type.js").NumberError | import("../Type.js").NonNegativeError | import("../Type.js").IntError>, "Counter", import("../Type.js").BrandWithoutRefineError<"Counter", import("../Type.js").NumberError | import("../Type.js").NonNegativeError | import("../Type.js").IntError | import("../Type.js").LessThanOrEqualToError<65535>>, never>;
 export type Counter = typeof Counter.Type;
 export declare const minCounter: Counter;
 export declare const maxCounter: Counter;
@@ -81,7 +70,7 @@ export declare const maxNodeId: NodeId;
  * Timestamps serve as globally unique, causally ordered identifiers for CRDT
  * messages in Evolu's sync protocol.
  *
- * ### Why Hybrid Logical Clocks
+ * ## Why Hybrid Logical Clocks
  *
  * Evolu uses Hybrid Logical Clocks (HLC), which combine physical time (millis)
  * with a logical counter. This hybrid approach preserves causality like logical
@@ -106,14 +95,14 @@ export declare const maxNodeId: NodeId;
  * configuration protects against buggy clocks and prevents problematic
  * future-dated entries from propagating through the network.
  *
- * ### References
+ * ## References
  *
  * - https://muratbuffalo.blogspot.com/2014/07/hybrid-logical-clocks.html
  * - https://sergeiturukin.com/2017/06/26/hybrid-logical-clocks.html
  * - https://jaredforsyth.com/posts/hybrid-logical-clocks/
  * - https://willowprotocol.org/more/timestamps_really/index.html
  *
- * ### Privacy Considerations
+ * ## Privacy Considerations
  *
  * Timestamps are metadata visible to relays and collaborators. While it can be
  * considered a privacy leak, let us explain why it's necessary, and how to
@@ -130,17 +119,21 @@ export declare const maxNodeId: NodeId;
  * 2. Periodically and randomly flush messages to sync tables
  *
  * **Trade-off:** It breaks real-time collaboration.
+ *
+ * Another technique is generating fake random activity (dummy messages) to mask
+ * real usage patterns. This preserves real-time collaboration but increases
+ * storage and bandwidth usage.
  */
 export declare const Timestamp: import("../Type.js").ObjectType<{
-    millis: import("../Type.js").BrandType<import("../Type.js").BrandType<import("../Type.js").Type<"Brand", number & import("../Brand.js").Brand<"Int"> & import("../Brand.js").Brand<"NonNegative">, number, import("../Type.js").NonNegativeError, number & import("../Brand.js").Brand<"Int">, import("../Type.js").IntError | import("../Type.js").NumberError>, `LessThanOrEqualTo${number}`, import("../Type.js").LessThanOrEqualToError<number>, import("../Type.js").NonNegativeError | import("../Type.js").IntError | import("../Type.js").NumberError>, "Millis", import("../Type.js").BrandWithoutRefineError<"Millis", import("../Type.js").NonNegativeError | import("../Type.js").IntError | import("../Type.js").NumberError | import("../Type.js").LessThanOrEqualToError<number>>, never>;
-    counter: import("../Type.js").BrandType<import("../Type.js").BrandType<import("../Type.js").Type<"Brand", number & import("../Brand.js").Brand<"Int"> & import("../Brand.js").Brand<"NonNegative">, number, import("../Type.js").NonNegativeError, number & import("../Brand.js").Brand<"Int">, import("../Type.js").IntError | import("../Type.js").NumberError>, "LessThanOrEqualTo65535", import("../Type.js").LessThanOrEqualToError<65535>, import("../Type.js").NonNegativeError | import("../Type.js").IntError | import("../Type.js").NumberError>, "Counter", import("../Type.js").BrandWithoutRefineError<"Counter", import("../Type.js").NonNegativeError | import("../Type.js").IntError | import("../Type.js").NumberError | import("../Type.js").LessThanOrEqualToError<65535>>, never>;
+    millis: import("../Type.js").BrandType<import("../Type.js").BrandType<import("../Type.js").Type<"Brand", number & import("../Brand.js").Brand<"Int"> & import("../Brand.js").Brand<"NonNegative">, number, import("../Type.js").NonNegativeError, number & import("../Brand.js").Brand<"Int">, import("../Type.js").NumberError | import("../Type.js").IntError>, "LessThan281474976710655", import("../Type.js").LessThanError<281474976710655>, import("../Type.js").NumberError | import("../Type.js").NonNegativeError | import("../Type.js").IntError>, "Millis", import("../Type.js").BrandWithoutRefineError<"Millis", import("../Type.js").NumberError | import("../Type.js").LessThanError<281474976710655> | import("../Type.js").NonNegativeError | import("../Type.js").IntError>, never>;
+    counter: import("../Type.js").BrandType<import("../Type.js").BrandType<import("../Type.js").Type<"Brand", number & import("../Brand.js").Brand<"Int"> & import("../Brand.js").Brand<"NonNegative">, number, import("../Type.js").NonNegativeError, number & import("../Brand.js").Brand<"Int">, import("../Type.js").NumberError | import("../Type.js").IntError>, "LessThanOrEqualTo65535", import("../Type.js").LessThanOrEqualToError<65535>, import("../Type.js").NumberError | import("../Type.js").NonNegativeError | import("../Type.js").IntError>, "Counter", import("../Type.js").BrandWithoutRefineError<"Counter", import("../Type.js").NumberError | import("../Type.js").NonNegativeError | import("../Type.js").IntError | import("../Type.js").LessThanOrEqualToError<65535>>, never>;
     nodeId: import("../Type.js").BrandType<import("../Type.js").Type<"String", string, string, import("../Type.js").StringError, string, import("../Type.js").StringError>, "NodeId", import("../Type.js").RegexError<"NodeId">, import("../Type.js").StringError>;
 }>;
 export interface Timestamp extends InferType<typeof Timestamp> {
 }
 /** Equality function for comparing {@link Timestamp}. */
 export declare const eqTimestamp: import("../Eq.js").Eq<{
-    readonly millis: number & import("../Brand.js").Brand<"Int"> & import("../Brand.js").Brand<"NonNegative"> & import("../Brand.js").Brand<`LessThanOrEqualTo${number}`> & import("../Brand.js").Brand<"Millis">;
+    readonly millis: number & import("../Brand.js").Brand<"Int"> & import("../Brand.js").Brand<"NonNegative"> & import("../Brand.js").Brand<"LessThan281474976710655"> & import("../Brand.js").Brand<"Millis">;
     readonly counter: number & import("../Brand.js").Brand<"Int"> & import("../Brand.js").Brand<"NonNegative"> & import("../Brand.js").Brand<"LessThanOrEqualTo65535"> & import("../Brand.js").Brand<"Counter">;
     readonly nodeId: string & import("../Brand.js").Brand<"NodeId">;
 }>;
@@ -149,7 +142,7 @@ export declare const createInitialTimestamp: (deps: RandomBytesDep) => Timestamp
 export declare const sendTimestamp: (deps: TimeDep & TimestampConfigDep) => (timestamp: Timestamp) => Result<Timestamp, TimestampDriftError | TimestampCounterOverflowError | TimestampTimeOutOfRangeError>;
 export declare const receiveTimestamp: (deps: TimeDep & TimestampConfigDep) => (local: Timestamp, remote: Timestamp) => Result<Timestamp, TimestampDriftError | TimestampCounterOverflowError | TimestampTimeOutOfRangeError>;
 /** Sortable bytes representation of {@link Timestamp}. */
-export declare const TimestampBytes: import("../Type.js").BrandType<import("../Type.js").Type<"Uint8Array", Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>, import("../Type.js").Uint8ArrayError, Uint8Array<ArrayBufferLike>, import("../Type.js").Uint8ArrayError>, "TimestampBytes", import("../Type.js").BrandWithoutRefineError<"TimestampBytes", import("../Type.js").Uint8ArrayError>, never>;
+export declare const TimestampBytes: import("../Type.js").BrandType<import("../Type.js").BrandType<import("../Type.js").Type<"Uint8Array", Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>, import("../Type.js").Uint8ArrayError, Uint8Array<ArrayBufferLike>, import("../Type.js").Uint8ArrayError>, "Length16", import("../Type.js").LengthError<16>, import("../Type.js").Uint8ArrayError>, "TimestampBytes", import("../Type.js").BrandWithoutRefineError<"TimestampBytes", import("../Type.js").Uint8ArrayError | import("../Type.js").LengthError<16>>, never>;
 export type TimestampBytes = typeof TimestampBytes.Type;
 export declare const timestampBytesLength: number & import("../Brand.js").Brand<"Int"> & import("../Brand.js").Brand<"NonNegative">;
 export declare const timestampToTimestampBytes: (timestamp: Timestamp) => TimestampBytes;

package/dist/src/local-first/Timestamp.d.ts.map

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