@evolu/common 8.4.0 → 8.6.0

package/src/local-first/Owner.ts

@@ -1,6 +1,4 @@
 /**
- * ## Intro
- *
  * Cryptographic identities that define ownership, encryption, sync, and
  * deletion boundaries for Evolu data.
  *
@@ -11,15 +9,15 @@
  *
  * Individual changes in an append-only local-first history can only be marked
  * as deleted. An entire owner, however, can be removed from devices and relays
- * together with all of its data. The AppOwner must remain because it coordinates
- * the deletion of other owners across devices.
+ * together with all of its data. The AppOwner must remain because it
+ * coordinates the deletion of other owners across devices.
  *
  * Choose an owner by how its data should live and be shared:
  *
  * - {@link AppOwner} coordinates sync and persists for the lifetime of the app
  *   identity.
- * - {@link ShardOwner} partitions application data so it can be synced and
- *   deleted independently.
+ * - {@link ShardOwner} partitions application data so it can be synced and deleted
+ *   independently.
  * - {@link SharedOwner} grants collaborative read and write access.
  * - {@link SharedReadonlyOwner} grants read-only access to shared data.
  *
@@ -62,8 +60,8 @@ import { TimestampBytes } from "./Timestamp.ts";
 /**
  * {@link Owner} without a {@link OwnerWriteKey}.
  *
- * @see {@link createSharedReadonlyOwner}
  * @group Core
+ * @see {@link createSharedReadonlyOwner}
  */
 export interface ReadonlyOwner {
   readonly id: OwnerId;
@@ -427,9 +425,9 @@ export type OwnerTransport = OwnerWebSocketTransport;
  * Legitimate clients will be properly configured with valid credentials, so
  * automatic retry is OK.
  *
+ * @group Transport
  * @see {@link createOwnerWebSocketTransport}
  * @see {@link parseOwnerIdFromOwnerWebSocketTransportUrl}
- * @group Transport
  */
 export interface OwnerWebSocketTransport extends Typed<"WebSocket"> {
   readonly url: string;
@@ -448,6 +446,8 @@ export interface OwnerWebSocketTransport extends Typed<"WebSocket"> {
  * ```ts
  * import {
  *   AppName,
+ *   assertEqual,
+ *   assertTrue,
  *   createAppOwner,
  *   createEvolu,
  *   createOwnerWebSocketTransport,
@@ -473,8 +473,8 @@ export interface OwnerWebSocketTransport extends Typed<"WebSocket"> {
  *   },
  * );
  *
- * expect(createTodoEvolu).toBeTypeOf("function");
- * expect(transport).toEqual({
+ * assertTrue(typeof createTodoEvolu === "function");
+ * assertEqual(transport, {
  *   type: "WebSocket",
  *   url: `wss://relay.evolu.dev?ownerId=${appOwner.id}`,
  * });
@@ -501,6 +501,7 @@ export const createOwnerWebSocketTransport = (config: {
  *
  * ```ts
  * import {
+ *   assertEqual,
  *   createAppOwner,
  *   createOwnerSecret,
  *   createRandomBytes,
@@ -513,12 +514,14 @@ export const createOwnerWebSocketTransport = (config: {
  * );
  * const url = `/sync?ownerId=${appOwner.id}`;
  *
- * expect(parseOwnerIdFromOwnerWebSocketTransportUrl(url)).toBe(
+ * assertEqual(
+ *   parseOwnerIdFromOwnerWebSocketTransportUrl(url),
  *   appOwner.id,
  * );
- * expect(
+ * assertEqual(
  *   parseOwnerIdFromOwnerWebSocketTransportUrl("/sync?ownerId=invalid"),
- * ).toBeNull();
+ *   null,
+ * );
  * ```
  *
  * @group Transport
@@ -553,7 +556,8 @@ export interface OwnerUsage {
    *
    * Measures only {@link EncryptedDbChange} data and excludes {@link Storage}
    * implementation overhead such as indexes and skip-list columns. This makes
-   * the measurement consistent across storage implementations and suitable for:
+   * the measurement consistent across storage implementations and suitable
+   * for:
    *
    * - **Predictable measurement** - same data = same byte count across all
    *   instances

package/src/local-first/Protocol.ts

@@ -178,7 +178,11 @@
  */
 
 import { Packr } from "msgpackr";
-import { isNonEmptyArray, type NonEmptyReadonlyArray } from "../Array.ts";
+import {
+  createMutableArray,
+  isNonEmptyArray,
+  type NonEmptyReadonlyArray,
+} from "../Array.ts";
 import { assert, assertNonNullable } from "../Assert.ts";
 import type { Brand } from "../Brand.ts";
 import {
@@ -692,11 +696,16 @@ export const createProtocolMessageBuffer = (
    * approach, contributions are welcome.
    */
   const safeMargins = {
-    remainingRange: fingerprintSize + 10, // bytes: range type + possible increased count varint
-    timestamp: 30, // bytes: max millis + max count + NodeId
-    dbChangeLength: 8, // bytes: maximum encoded DbChange length varint
-    splitRange: 800, // bytes: worst case is around 650 bytes
-    timestampsRange: 50, // bytes: range type + its upperBound + possible increased count varint
+    // bytes: range type + possible increased count varint
+    remainingRange: fingerprintSize + 10,
+    // bytes: max millis + max count + NodeId
+    timestamp: 30,
+    // bytes: maximum encoded DbChange length varint
+    dbChangeLength: 8,
+    // bytes: worst case is around 650 bytes
+    splitRange: 800,
+    // bytes: range type + its upperBound + possible increased count varint
+    timestampsRange: 50,
   };
 
   const addMessageSafeMargin =
@@ -972,7 +981,7 @@ export const applyProtocolMessageAsClient =
       );
 
       if (messageType === MessageType.Response) {
-        const errorCode = input.shift() as ProtocolErrorCode;
+        const errorCode = input.shift();
         if (errorCode !== ProtocolErrorCode.NoError) {
           switch (errorCode) {
             case ProtocolErrorCode.WriteKeyError:
@@ -1318,7 +1327,7 @@ const decodeMessages = (
 ): ReadonlyArray<EncryptedCrdtMessage> => {
   const timestamps = decodeTimestamps(buffer);
 
-  const messages = new Array<EncryptedCrdtMessage>(timestamps.length);
+  const messages = createMutableArray<EncryptedCrdtMessage>(timestamps.length);
   for (let i = 0; i < timestamps.length; i++) {
     const timestamp = timestamps[i];
     const changeLength = decodeLength(buffer);
@@ -1441,21 +1450,19 @@ const sync =
 
           if (eqArrayNumber(range.fingerprint, ourFingerprint)) {
             skipRange(range);
+          } else if (output.canSplitRange()) {
+            coalesceSkipsBeforeAdd();
+            splitRange(deps)(
+              ownerIdBytes,
+              lower,
+              upper,
+              currentUpperBound,
+              output,
+            );
           } else {
-            if (output.canSplitRange()) {
-              coalesceSkipsBeforeAdd();
-              splitRange(deps)(
-                ownerIdBytes,
-                lower,
-                upper,
-                currentUpperBound,
-                output,
-              );
-            } else {
-              return addFingerprintForRemainingRange(upper)
-                ? ok(true)
-                : err(ProtocolErrorCode.SyncError);
-            }
+            return addFingerprintForRemainingRange(upper)
+              ? ok(true)
+              : err(ProtocolErrorCode.SyncError);
           }
           break;
         }
@@ -1635,7 +1642,7 @@ const decodeRanges = (buffer: Buffer): ReadonlyArray<Range> => {
   const timestampsCount = NonNegativeInt.orThrow(rangesCount - 1);
   const timestamps = decodeTimestamps(buffer, timestampsCount);
 
-  const rangeTypes = new Array<RangeType>(rangesCount);
+  const rangeTypes = createMutableArray<RangeType>(rangesCount);
 
   for (let i = 0; i < rangesCount; i++) {
     const rangeType = decodeNonNegativeInt(buffer);
@@ -1650,7 +1657,7 @@ const decodeRanges = (buffer: Buffer): ReadonlyArray<Range> => {
     }
   }
 
-  const ranges = new Array<Range>(rangesCount);
+  const ranges = createMutableArray<Range>(rangesCount);
 
   for (let i = 0; i < rangesCount; i++) {
     const upperBound =
@@ -1700,7 +1707,7 @@ const decodeTimestamps = (
 
   let previousMillis = 0 as Millis;
 
-  const millises = new Array<Millis>(length);
+  const millises = createMutableArray<Millis>(length);
   for (let i = 0; i < length; i++) {
     const deltaMillis = decodeNonNegativeInt(buffer);
     const millis = Millis.fromUnknown(previousMillis + deltaMillis);
@@ -1717,7 +1724,7 @@ const decodeTimestamps = (
 
   const nodeIds = decodeRle(buffer, length, (): NodeId => decodeNodeId(buffer));
 
-  const timestamps = new Array<Timestamp>(length);
+  const timestamps = createMutableArray<Timestamp>(length);
   for (let i = 0; i < length; i++) {
     timestamps[i] = {
       millis: millises[i],
@@ -1734,7 +1741,7 @@ export const decodeRle = <T>(
   length: NonNegativeInt,
   decodeValue: () => T,
 ): ReadonlyArray<T> => {
-  const values = new Array<T>(length);
+  const values = createMutableArray<T>(length);
   let index = 0;
   while (index < length) {
     const value = decodeValue();
@@ -1807,13 +1814,13 @@ export const decodeNumber = (buffer: Buffer): number => {
  * ### Example
  *
  * ```ts
- * import { createBuffer } from "@evolu/common";
+ * import { assertEqual, createBuffer } from "@evolu/common";
  * import { encodeFlags } from "@evolu/common/local-first";
  *
  * const buffer = createBuffer();
  * encodeFlags(buffer, [true, false, true]);
  *
- * expect(buffer.unwrap()).toEqual(new Uint8Array([0b101]));
+ * assertEqual(buffer.unwrap(), new Uint8Array([0b101]));
  * ```
  */
 export const encodeFlags = (
@@ -1835,14 +1842,14 @@ export const encodeFlags = (
  * ### Example
  *
  * ```ts
- * import { createBuffer, PositiveInt } from "@evolu/common";
+ * import { assertEqual, createBuffer, PositiveInt } from "@evolu/common";
  * import { decodeFlags } from "@evolu/common/local-first";
  *
  * const buffer = createBuffer([0b101]);
  * const flags = decodeFlags(buffer, PositiveInt.orThrow(3));
  *
- * expect(flags).toEqual([true, false, true]);
- * expect(buffer.getLength()).toBe(0);
+ * assertEqual(flags, [true, false, true]);
+ * assertEqual(buffer.getLength(), 0);
  * ```
  */
 export const decodeFlags = (
@@ -1851,7 +1858,7 @@ export const decodeFlags = (
 ): ReadonlyArray<boolean> => {
   const byte = buffer.shift();
   const length = globalThis.Math.min(count, 8);
-  const flags = new Array<boolean>(length);
+  const flags = createMutableArray<boolean>(length);
   for (let i = 0; i < length; i++) {
     flags[i] = (byte & (1 << i)) !== 0;
   }
@@ -2088,7 +2095,8 @@ export const ProtocolValueType = {
   NonNegativeInt: /*#__PURE__*/ NonNegativeInt.orThrow(30),
 
   // String optimizations
-  EmptyString: /*#__PURE__*/ NonNegativeInt.orThrow(31), // 1 byte vs 2 bytes (50% reduction)
+  // 1 byte vs 2 bytes (50% reduction)
+  EmptyString: /*#__PURE__*/ NonNegativeInt.orThrow(31),
   Base64Url: /*#__PURE__*/ NonNegativeInt.orThrow(32),
   Id: /*#__PURE__*/ NonNegativeInt.orThrow(33),
   Json: /*#__PURE__*/ NonNegativeInt.orThrow(34),
@@ -2097,7 +2105,8 @@ export const ProtocolValueType = {
   // encoded with fixed length  - 8 bytes
   // encode as NonNegativeInt   - 6 bytes (additional 25% reduction)
   DateIsoWithNonNegativeTime: /*#__PURE__*/ NonNegativeInt.orThrow(35),
-  DateIsoWithNegativeTime: /*#__PURE__*/ NonNegativeInt.orThrow(36), // 9 bytes
+  // 9 bytes
+  DateIsoWithNegativeTime: /*#__PURE__*/ NonNegativeInt.orThrow(36),
 
   // TODO: Operations (from 40)
   // Increment, Decrement, Patch, whatever.
@@ -2109,6 +2118,7 @@ export const encodeSqliteValue = (buffer: Buffer, value: SqliteValue): void => {
     return;
   }
 
+  // oxlint-disable-next-line typescript/switch-exhaustiveness-check -- The remaining SqliteValue is Uint8Array and is encoded after the switch.
   switch (typeof value) {
     case "string": {
       if (value === "") {

package/src/local-first/Query.ts

@@ -21,6 +21,7 @@ import {
   TableNode,
   ValueNode,
 } from "kysely";
+import { createMutableArray } from "../Array.ts";
 import type { Brand } from "../Brand.ts";
 import { createRandomBytes } from "../Crypto.ts";
 import type { ReadonlyRecord } from "../Object.ts";
@@ -40,6 +41,7 @@ export type { NotNull as KyselyNotNull } from "kysely";
  *
  * ```ts
  * import {
+ *   assertType,
  *   createQueryBuilder,
  *   id,
  *   NonEmptyTrimmedString100,
@@ -55,11 +57,12 @@ export type { NotNull as KyselyNotNull } from "kysely";
  * const allTodos = createQuery((db) => db.selectFrom("todo").selectAll());
  *
  * type AllTodosRow = typeof allTodos.Row;
- * expectTypeOf<typeof allTodos>().toExtend<Query<typeof Schema>>();
- * expectTypeOf<AllTodosRow["id"]>().toEqualTypeOf<TodoId>();
- * expectTypeOf<
- *   AllTodosRow["title"]
- * >().toEqualTypeOf<NonEmptyTrimmedString100 | null>();
+ * assertType<
+ *   true,
+ *   typeof allTodos extends Query<typeof Schema> ? true : false
+ * >();
+ * assertType<TodoId, AllTodosRow["id"]>();
+ * assertType<NonEmptyTrimmedString100 | null, AllTodosRow["title"]>();
  * ```
  */
 export type Query<
@@ -77,6 +80,7 @@ export type Query<
      *
      * ```ts
      * import {
+     *   assertType,
      *   createQueryBuilder,
      *   id,
      *   type InferRow,
@@ -92,9 +96,7 @@ export type Query<
      * );
      *
      * type AllTodosRow = typeof allTodos.Row;
-     * expectTypeOf<AllTodosRow>().toEqualTypeOf<
-     *   InferRow<typeof allTodos>
-     * >();
+     * assertType<InferRow<typeof allTodos>, AllTodosRow>();
      * ```
      */
     Row: R;
@@ -106,8 +108,10 @@ export type InferRow<T extends Query> =
 export interface Row {
   readonly [key: string]:
     | SqliteValue
-    | Row // for evoluJsonObjectFrom
-    | ReadonlyArray<Row>; // for evoluJsonArrayFrom
+    // for evoluJsonObjectFrom
+    | Row
+    // for evoluJsonArrayFrom
+    | ReadonlyArray<Row>;
 }
 
 /**
@@ -123,6 +127,7 @@ export interface Row {
  *
  * ```ts
  * import {
+ *   assertType,
  *   createQueryBuilder,
  *   evoluJsonArrayFrom,
  *   id,
@@ -154,10 +159,13 @@ export interface Row {
  *     ]),
  * );
  *
- * expectTypeOf<(typeof people.Row.pets)[number]>().toEqualTypeOf<{
- *   petId: typeof Schema.pet.id.Output;
- *   name: NonEmptyTrimmedString100 | null;
- * }>();
+ * assertType<
+ *   {
+ *     petId: typeof Schema.pet.id.Output;
+ *     name: NonEmptyTrimmedString100 | null;
+ *   },
+ *   (typeof people.Row.pets)[number]
+ * >();
  * ```
  */
 export const evoluJsonArrayFrom = <O>(
@@ -182,6 +190,7 @@ export const evoluJsonArrayFrom = <O>(
  *
  * ```ts
  * import {
+ *   assertType,
  *   createQueryBuilder,
  *   evoluJsonObjectFrom,
  *   id,
@@ -215,10 +224,13 @@ export const evoluJsonArrayFrom = <O>(
  *     ]),
  * );
  *
- * expectTypeOf<typeof people.Row.favoritePet>().toEqualTypeOf<{
- *   petId: typeof Schema.pet.id.Output;
- *   name: NonEmptyTrimmedString100 | null;
- * } | null>();
+ * assertType<
+ *   {
+ *     petId: typeof Schema.pet.id.Output;
+ *     name: NonEmptyTrimmedString100 | null;
+ *   } | null,
+ *   typeof people.Row.favoritePet
+ * >();
  * ```
  */
 export const evoluJsonObjectFrom = <O>(
@@ -241,6 +253,7 @@ export const evoluJsonObjectFrom = <O>(
  *
  * ```ts
  * import {
+ *   assertType,
  *   createQueryBuilder,
  *   evoluJsonBuildObject,
  *   id,
@@ -271,11 +284,14 @@ export const evoluJsonObjectFrom = <O>(
  *     ]),
  * );
  *
- * expectTypeOf<typeof people.Row.name>().toEqualTypeOf<{
- *   first: NonEmptyTrimmedString100 | null;
- *   last: NonEmptyTrimmedString100 | null;
- *   full: string;
- * }>();
+ * assertType<
+ *   {
+ *     first: NonEmptyTrimmedString100 | null;
+ *     last: NonEmptyTrimmedString100 | null;
+ *     full: string;
+ *   },
+ *   typeof people.Row.name
+ * >();
  * ```
  */
 export const evoluJsonBuildObject = <
@@ -455,7 +471,7 @@ const getSqliteJsonObjectArgs = (
 export const parseSqliteJsonArray = <T>(
   arr: ReadonlyArray<T>,
 ): ReadonlyArray<T> => {
-  const result = new Array<T>(arr.length);
+  const result = createMutableArray<T>(arr.length);
   for (let i = 0; i < arr.length; ++i) {
     result[i] = parse(arr[i]) as T;
   }

package/src/local-first/Relay.ts

@@ -79,6 +79,9 @@ export interface RelayConfig extends StorageConfig {
    * ```ts
    * import {
    *   AppName,
+   *   assertEqual,
+   *   assertTrue,
+   *   assertType,
    *   createAppOwner,
    *   createEvolu,
    *   createOwnerWebSocketTransport,
@@ -107,7 +110,10 @@ export interface RelayConfig extends StorageConfig {
    *     transports: [transport],
    *   },
    * );
-   * expectTypeOf(createTodoEvolu).toExtend<AnyTask>();
+   * assertType<
+   *   true,
+   *   typeof createTodoEvolu extends AnyTask ? true : false
+   * >();
    *
    * // Relay: accept owners allowed by the app's access policy.
    * type IsOwnerAllowed = NonNullable<RelayConfig["isOwnerAllowed"]>;
@@ -115,12 +121,13 @@ export interface RelayConfig extends StorageConfig {
    * const isOwnerAllowed: IsOwnerAllowed = (ownerId, { signal }) =>
    *   !signal.aborted && allowedOwnerIds.has(ownerId);
    *
-   * expect(
-   *   isOwnerAllowed(appOwner.id, {
+   * assertEqual(
+   *   await isOwnerAllowed(appOwner.id, {
    *     signal: new AbortController().signal,
    *   }),
-   * ).toBe(true);
-   * expect(transport.url).toContain(`ownerId=${appOwner.id}`);
+   *   true,
+   * );
+   * assertTrue(transport.url.includes(`ownerId=${appOwner.id}`));
    * ```
    */
   readonly isOwnerAllowed?: (
@@ -305,7 +312,7 @@ export const createRelaySqliteStorage =
           where "ownerId" = ${ownerId} and "timestamp" = ${timestamp};
         `);
 
-        const row = result.rows[0];
+        const row = result.rows.at(0);
         assert(row, "Every timestamp must have a change");
         return row.change;
       },

package/src/local-first/Schema.ts

@@ -62,6 +62,8 @@ export type AnyStandardSchemaV1 = StandardSchemaV1<any, any>;
  * ```ts
  * import * as z from "zod";
  * import {
+ *   assertOk,
+ *   assertTrue,
  *   id,
  *   NonEmptyTrimmedString100,
  *   nullOr,
@@ -79,7 +81,7 @@ export type AnyStandardSchemaV1 = StandardSchemaV1<any, any>;
  *     isCompleted: nullOr(SqliteBoolean),
  *   },
  * };
- * expectOk(Schema.todo.title.fromUnknown("Write docs"), "Write docs");
+ * assertOk(Schema.todo.title.fromUnknown("Write docs"), "Write docs");
  *
  * // Zod, or another Standard Schema library
  * const ZodSchema = {
@@ -89,7 +91,7 @@ export type AnyStandardSchemaV1 = StandardSchemaV1<any, any>;
  *     isCompleted: z.union([z.literal(0), z.literal(1)]).nullable(),
  *   },
  * };
- * expect(ZodSchema.todo.title.safeParse("Write docs").success).toBe(true);
+ * assertTrue(ZodSchema.todo.title.safeParse("Write docs").success);
  * ```
  */
 export type EvoluSchema = ReadonlyRecord<
@@ -238,6 +240,7 @@ export interface MutationOptions {
    *
    * ```ts
    * import {
+   *   assertEqual,
    *   createAppOwner,
    *   createOwnerSecret,
    *   createRandomBytes,
@@ -263,7 +266,7 @@ export interface MutationOptions {
    *   createOwnerSecret({ randomBytes }),
    * );
    *
-   * const insertOwnedRows = (evolu: Evolu<typeof Schema>): void => {
+   * const _insertOwnedRows = (evolu: Evolu<typeof Schema>): void => {
    *   // Partition app data by project.
    *   evolu.insert(
    *     "task",
@@ -279,8 +282,8 @@ export interface MutationOptions {
    *   );
    * };
    *
-   * expect(projectOwner.type).toBe("ShardOwner");
-   * expect(sharedOwner.type).toBe("SharedOwner");
+   * assertEqual(projectOwner.type, "ShardOwner");
+   * assertEqual(sharedOwner.type, "SharedOwner");
    * ```
    */
   readonly ownerId?: OwnerId;
@@ -448,6 +451,8 @@ export const evoluSchemaToSqliteSchema = <S extends EvoluSchema>(
  *
  * ```ts
  * import {
+ *   assertTrue,
+ *   assertType,
  *   createQueryBuilder,
  *   id,
  *   NonEmptyTrimmedString100,
@@ -471,12 +476,15 @@ export const evoluSchemaToSqliteSchema = <S extends EvoluSchema>(
  *   db.selectFrom("todo").select(["id", "title", "isCompleted"]),
  * );
  *
- * expectTypeOf<typeof todosQuery.Row>().toEqualTypeOf<{
- *   id: TodoId;
- *   title: NonEmptyTrimmedString100 | null;
- *   isCompleted: SqliteBoolean | null;
- * }>();
- * expect(todosQuery).toBeTypeOf("string");
+ * assertType<
+ *   {
+ *     id: TodoId;
+ *     title: NonEmptyTrimmedString100 | null;
+ *     isCompleted: SqliteBoolean | null;
+ *   },
+ *   typeof todosQuery.Row
+ * >();
+ * assertTrue(typeof todosQuery === "string");
  * ```
  */
 export const createQueryBuilder = <S extends EvoluSchema>(

package/src/local-first/Shared.ts

@@ -324,7 +324,9 @@ export const initSharedWorker =
                 const tenantLease = await run.ok(
                   unabortable(tenantsByName.acquire(message)),
                 );
-                tenantLease.resource.addInstance(message, tenantLease.release);
+                tenantLease.resource.addInstance(message, () => {
+                  tenantLease.release();
+                });
                 return ok();
               });
               break;
@@ -479,7 +481,7 @@ const createEvoluTenant =
       new Map<EvoluInstanceId, EvoluInstance>(),
       async (instancesById) => {
         await using disposer = new AsyncDisposableStack();
-        for (const instance of [...instancesById.values()]) {
+        for (const instance of instancesById.values()) {
           disposer.use(instance);
         }
       },

package/src/local-first/Storage.ts

@@ -70,6 +70,7 @@ export interface StorageConfig {
    *
    * ```ts
    * import {
+   *   assertEqual,
    *   createAppOwner,
    *   createOwnerSecret,
    *   createRandomBytes,
@@ -87,12 +88,13 @@ export interface StorageConfig {
    *     ownerId === appOwner.id && requiredBytes <= maxBytes,
    * };
    *
-   * expect(
+   * assertEqual(
    *   await relayStorageConfig.isOwnerWithinQuota(
    *     appOwner.id,
    *     PositiveInt.orThrow(2048),
    *   ),
-   * ).toBe(false);
+   *   false,
+   * );
    * ```
    */
   readonly isOwnerWithinQuota: (

package/src/local-first/Timestamp.ts

@@ -93,7 +93,7 @@ export const maxCounter = 65535 as Counter;
  * yet they will think they are synced. This is extremely rare and can be
  * resolved by resetting one device to generate a new NodeId.
  */
-export const NodeId = /*#__PURE__*/ regex("NodeId", /^[a-f0-9]{16}$/)(String);
+export const NodeId = /*#__PURE__*/ regex("NodeId", /^[a-f0-9]{16}$/u)(String);
 export type NodeId = typeof NodeId.Output;
 
 export const minNodeId = "0000000000000000" as NodeId;