@evolu/common 6.0.1-preview.29 → 6.0.1-preview.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evolu/common",
-  "version": "6.0.1-preview.29",
+  "version": "6.0.1-preview.30",
   "description": "TypeScript library and local-first framework",
   "keywords": [
     "evolu",

package/src/Buffer.ts

@@ -116,10 +116,10 @@ export const createBuffer = (
   let value = arrayLike
     ? new globalThis.Uint8Array(arrayLike)
     : new globalThis.Uint8Array(512);
-  let length = (arrayLike ? arrayLike.length : 0) as NonNegativeInt;
+  let length = NonNegativeInt.orThrow(arrayLike ? arrayLike.length : 0);
 
   const buffer: Buffer = {
-    getCapacity: () => value.length as NonNegativeInt,
+    getCapacity: () => NonNegativeInt.orThrow(value.length),
 
     getLength: () => length,
 
@@ -132,7 +132,7 @@ export const createBuffer = (
         value.set(oldValue);
       }
       value.set(arg, length);
-      length = (length + arg.length) as NonNegativeInt;
+      length = NonNegativeInt.orThrow(length + arg.length);
     },
 
     shift: () => {
@@ -142,7 +142,7 @@ export const createBuffer = (
       const first = value[0];
       value = value.subarray(1);
       length--;
-      return first as NonNegativeInt;
+      return NonNegativeInt.orThrow(first);
     },
 
     shiftN: (n) => {
@@ -151,7 +151,7 @@ export const createBuffer = (
       }
       const subarray = value.subarray(0, n);
       value = value.subarray(n);
-      length = (length - n) as NonNegativeInt;
+      length = NonNegativeInt.orThrow(length - n);
       return subarray;
     },
 
@@ -165,7 +165,7 @@ export const createBuffer = (
     },
 
     reset: () => {
-      length = 0 as NonNegativeInt;
+      length = NonNegativeInt.orThrow(0);
     },
 
     unwrap: () => value.subarray(0, length),

package/src/{CallbackRegistry.ts → Callbacks.ts}

@@ -4,46 +4,45 @@ import { Result } from "./Result.js";
 import { createId, Id } from "./Type.js";
 
 /**
- * A registry for one-time callback functions.
+ * Request-response correlation for callbacks across boundaries.
  *
  * Stores callbacks with unique IDs and executes them once with an optional
- * argument. Executed callbacks are automatically removed from the registry.
+ * argument. Executed callbacks are automatically removed.
  *
- * This is useful for correlating asynchronous operations across boundaries
- * where callback functions cannot be passed directly (e.g., web workers).
+ * This is useful for correlating asynchronous request-response operations
+ * across boundaries where callback functions cannot be passed directly (e.g.,
+ * web workers, message queues).
  *
  * The `execute` method intentionally does not use try-catch or {@link Result}
- * because it's the callback's responsibility to handle its own errors. The
- * registry is just a correlation mechanism and should not interfere with error
- * handling or debugging by masking the original error location.
+ * because it's the callback's responsibility to handle its own errors.
  *
  * ### Example
  *
  * ```ts
  * // No-argument callbacks
- * const registry = createCallbackRegistry(deps);
- * const id = registry.register(() => console.log("called"));
- * registry.execute(id);
+ * const callbacks = createCallbacks(deps);
+ * const id = callbacks.register(() => console.log("called"));
+ * callbacks.execute(id);
  *
  * // With argument callbacks
- * const stringRegistry = createCallbackRegistry<string>(deps);
- * const id = stringRegistry.register((value) => {
+ * const stringCallbacks = createCallbacks<string>(deps);
+ * const id = stringCallbacks.register((value) => {
  *   console.log(value);
  * });
- * stringRegistry.execute(id, "hello");
+ * stringCallbacks.execute(id, "hello");
  *
  * // Promise.withResolvers pattern
- * const promiseRegistry = createCallbackRegistry<string>(deps);
+ * const promiseCallbacks = createCallbacks<string>(deps);
  * const { promise, resolve } = Promise.withResolvers<string>();
- * const id = promiseRegistry.register(resolve);
- * promiseRegistry.execute(id, "resolved value");
+ * const id = promiseCallbacks.register(resolve);
+ * promiseCallbacks.execute(id, "resolved value");
  * await promise; // "resolved value"
  * ```
  *
  * @template T - The type of argument passed to callbacks (defaults to undefined
  *   for no-argument callbacks)
  */
-export interface CallbackRegistry<T = undefined> {
+export interface Callbacks<T = undefined> {
   /** Registers a callback function and returns a unique ID. */
   readonly register: (callback: (arg: T) => void) => CallbackId;
 
@@ -53,12 +52,13 @@ export interface CallbackRegistry<T = undefined> {
     : (id: CallbackId, arg: T) => undefined;
 }
 
+/** Unique identifier for a callback in {@link Callbacks}. */
 export type CallbackId = Id & Brand<"Callback">;
 
-/** Creates a new {@link CallbackRegistry} for one-time callback functions. */
-export const createCallbackRegistry = <T = undefined>(
+/** Creates a new {@link Callbacks}. */
+export const createCallbacks = <T = undefined>(
   deps: RandomBytesDep,
-): CallbackRegistry<T> => {
+): Callbacks<T> => {
   const callbackMap = new Map<CallbackId, (arg: T) => void>();
 
   return {
@@ -70,15 +70,14 @@ export const createCallbackRegistry = <T = undefined>(
 
     execute: (id: CallbackId, ...args: T extends undefined ? [] : [T]) => {
       const callback = callbackMap.get(id);
-      if (callback) {
-        callbackMap.delete(id);
-        if (args.length === 0) {
-          // Called without argument (undefined case)
-          (callback as () => void)();
-        } else {
-          callback(args[0]);
-        }
+      if (!callback) return;
+      callbackMap.delete(id);
+      if (args.length === 0) {
+        // Called without argument (undefined case)
+        (callback as () => void)();
+      } else {
+        callback(args[0]);
       }
     },
-  } as CallbackRegistry<T>;
+  } as Callbacks<T>;
 };

package/src/Crypto.ts

@@ -176,12 +176,12 @@ export const createSymmetricCrypto = (
  * https://bford.info/pub/sec/purb.pdf
  */
 export const padmePaddedLength = (length: NonNegativeInt): NonNegativeInt => {
-  if (length <= 0) return 0 as NonNegativeInt;
+  if (length <= 0) return NonNegativeInt.orThrow(0);
   const e = 31 - Math.clz32(length >>> 0);
   const s = 32 - Math.clz32(e >>> 0);
   const z = Math.max(0, e - s);
   const mask = (1 << z) - 1;
-  return ((length + mask) & ~mask) as NonNegativeInt;
+  return NonNegativeInt.orThrow((length + mask) & ~mask);
 };
 
 /**
@@ -189,7 +189,7 @@ export const padmePaddedLength = (length: NonNegativeInt): NonNegativeInt => {
  * {@link padmePaddedLength}.
  */
 export const padmePaddingLength = (length: NonNegativeInt): NonNegativeInt => {
-  return (padmePaddedLength(length) - length) as NonNegativeInt;
+  return NonNegativeInt.orThrow(padmePaddedLength(length) - length);
 };
 
 /**

package/src/Evolu/Db.ts

@@ -1,5 +1,5 @@
 import { isNonEmptyArray, NonEmptyReadonlyArray } from "../Array.js";
-import { CallbackId } from "../CallbackRegistry.js";
+import { CallbackId } from "../Callbacks.js";
 import { ConsoleConfig, ConsoleDep } from "../Console.js";
 import {
   createSymmetricCrypto,

package/src/Evolu/Evolu.ts

@@ -1,7 +1,7 @@
 import { pack } from "msgpackr";
 import { isNonEmptyArray, isNonEmptyReadonlyArray } from "../Array.js";
 import { assert, assertNonEmptyArray } from "../Assert.js";
-import { createCallbackRegistry } from "../CallbackRegistry.js";
+import { createCallbacks } from "../Callbacks.js";
 import { ConsoleDep } from "../Console.js";
 import { RandomBytesDep, SymmetricCryptoDecryptError } from "../Crypto.js";
 import { eqArrayNumber } from "../Eq.js";
@@ -549,9 +549,8 @@ const createEvoluInstance =
 
     const subscribedQueries = createSubscribedQueries(rowsStore);
     const loadingPromises = createLoadingPromises(subscribedQueries);
-    const onCompleteRegistry = createCallbackRegistry(deps);
-    const exportRegistry =
-      createCallbackRegistry<Uint8Array<ArrayBuffer>>(deps);
+    const onCompleteCallbacks = createCallbacks(deps);
+    const exportCallbacks = createCallbacks<Uint8Array<ArrayBuffer>>(deps);
 
     const dbWorker = deps.createDbWorker(dbConfig.name);
 
@@ -601,7 +600,7 @@ const createEvoluInstance =
           }
 
           for (const id of message.onCompleteIds) {
-            onCompleteRegistry.execute(id);
+            onCompleteCallbacks.execute(id);
           }
           break;
         }
@@ -628,13 +627,13 @@ const createEvoluInstance =
           if (message.reload) {
             deps.reloadApp(reloadUrl);
           } else {
-            onCompleteRegistry.execute(message.onCompleteId);
+            onCompleteCallbacks.execute(message.onCompleteId);
           }
           break;
         }
 
         case "onExport": {
-          exportRegistry.execute(
+          exportCallbacks.execute(
             message.onCompleteId,
             message.file as Uint8Array<ArrayBuffer>,
           );
@@ -748,11 +747,11 @@ const createEvoluInstance =
 
     const processMutationQueue = () => {
       const changes: Array<MutationChange> = [];
-      const onCompleteCallbacks = [];
+      const onCompletes = [];
 
       for (const [change, onComplete] of mutateMicrotaskQueue) {
         if (change !== null) changes.push(change);
-        if (onComplete) onCompleteCallbacks.push(onComplete);
+        if (onComplete) onCompletes.push(onComplete);
       }
 
       const queueLength = mutateMicrotaskQueue.length;
@@ -764,10 +763,7 @@ const createEvoluInstance =
         return;
       }
 
-      const onCompleteIds = onCompleteCallbacks.map(
-        onCompleteRegistry.register,
-      );
-
+      const onCompleteIds = onCompletes.map(onCompleteCallbacks.register);
       loadingPromises.releaseUnsubscribedOnMutation();
 
       if (!isNonEmptyArray(changes)) return;
@@ -846,7 +842,7 @@ const createEvoluInstance =
 
       resetAppOwner: (options) => {
         const { promise, resolve } = Promise.withResolvers<undefined>();
-        const onCompleteId = onCompleteRegistry.register(resolve);
+        const onCompleteId = onCompleteCallbacks.register(resolve);
         dbWorker.postMessage({
           type: "reset",
           onCompleteId,
@@ -857,7 +853,7 @@ const createEvoluInstance =
 
       restoreAppOwner: (mnemonic, options) => {
         const { promise, resolve } = Promise.withResolvers<undefined>();
-        const onCompleteId = onCompleteRegistry.register(resolve);
+        const onCompleteId = onCompleteCallbacks.register(resolve);
         dbWorker.postMessage({
           type: "reset",
           onCompleteId,
@@ -880,7 +876,7 @@ const createEvoluInstance =
       exportDatabase: () => {
         const { promise, resolve } =
           Promise.withResolvers<Uint8Array<ArrayBuffer>>();
-        const onCompleteId = exportRegistry.register(resolve);
+        const onCompleteId = exportCallbacks.register(resolve);
         dbWorker.postMessage({ type: "export", onCompleteId });
         return promise;
       },

package/src/Evolu/Owner.ts

@@ -73,7 +73,7 @@ export const ownerIdToOwnerIdBytes = (ownerId: OwnerId): OwnerIdBytes =>
 export const ownerIdBytesToOwnerId = (ownerIdBytes: OwnerIdBytes): OwnerId =>
   idBytesToId(ownerIdBytes as IdBytes) as OwnerId;
 
-export const ownerWriteKeyLength = 16 as NonNegativeInt;
+export const ownerWriteKeyLength = NonNegativeInt.orThrow(16);
 
 export const OwnerEncryptionKey = brand("OwnerEncryptionKey", EncryptionKey);
 export type OwnerEncryptionKey = typeof OwnerEncryptionKey.Type;

package/src/Evolu/Protocol.ts

@@ -325,7 +325,7 @@ export const defaultProtocolMessageRangesMaxSize =
 export type ProtocolMessage = Uint8Array & Brand<"ProtocolMessage">;
 
 /** Evolu Protocol version. */
-export const protocolVersion = 0 as NonNegativeInt;
+export const protocolVersion = NonNegativeInt.orThrow(0);
 
 export const MessageType = {
   /** Request message from initiator (client) to non-initiator (relay). */
@@ -525,7 +525,7 @@ export const createProtocolMessageForSync =
 
     splitRange(deps)(
       ownerIdBytes,
-      0 as NonNegativeInt,
+      NonNegativeInt.orThrow(0),
       size,
       InfiniteUpperBound,
       buffer,
@@ -628,7 +628,7 @@ export const createProtocolMessageBuffer = (
   const isWithinSizeLimits = () => getSize() <= totalMaxSize;
 
   const getSize = () =>
-    (getHeaderAndMessagesSize() + getRangesSize()) as PositiveInt;
+    PositiveInt.orThrow(getHeaderAndMessagesSize() + getRangesSize());
 
   const getHeaderAndMessagesSize = () =>
     buffers.header.getLength() +
@@ -726,7 +726,10 @@ export const createProtocolMessageBuffer = (
         buffers.ranges.timestamps.addInfinite();
       }
 
-      encodeNonNegativeInt(buffers.ranges.types, range.type as NonNegativeInt);
+      encodeNonNegativeInt(
+        buffers.ranges.types,
+        NonNegativeInt.orThrow(range.type),
+      );
 
       switch (range.type) {
         case RangeType.Skip:
@@ -781,7 +784,7 @@ export interface TimestampsBuffer {
 }
 
 export const createTimestampsBuffer = (): TimestampsBuffer => {
-  let count = 0 as NonNegativeInt;
+  let count = NonNegativeInt.orThrow(0);
   const countBuffer = createBuffer();
 
   const syncCount = () => {
@@ -848,9 +851,9 @@ const createRunLengthEncoder = <T>(
   encodeValue: (buffer: Buffer, value: T) => void,
 ): RunLengthEncoder<T> => {
   const buffer = createBuffer();
-  let previousLength = 0 as NonNegativeInt;
+  let previousLength = NonNegativeInt.orThrow(0);
   let previousValue = null as T | null;
-  let runLength = 0 as NonNegativeInt;
+  let runLength = NonNegativeInt.orThrow(0);
 
   return {
     add: (value) => {
@@ -859,7 +862,7 @@ const createRunLengthEncoder = <T>(
         buffer.truncate(previousLength);
       } else {
         previousValue = value;
-        runLength = 1 as NonNegativeInt;
+        runLength = NonNegativeInt.orThrow(1);
       }
       previousLength = buffer.getLength();
       encodeValue(buffer, value);
@@ -1255,7 +1258,7 @@ const sync =
     if (storageSize == null) return err(ProtocolErrorCode.SyncError);
 
     let prevUpperBound: RangeUpperBound | null = null;
-    let prevIndex = 0 as NonNegativeInt;
+    let prevIndex = NonNegativeInt.orThrow(0);
 
     let skip = false;
     let nonSkipRangeAdded = false;
@@ -1458,7 +1461,7 @@ const splitRange =
     upperBound: RangeUpperBound,
     buffer: ProtocolMessageBuffer,
   ): void => {
-    const itemCount = (upper - lower) as NonNegativeInt;
+    const itemCount = NonNegativeInt.orThrow(upper - lower);
     const buckets = computeBalancedBuckets(itemCount);
 
     if (!buckets.ok) {
@@ -1470,7 +1473,7 @@ const splitRange =
 
       deps.storage.iterate(
         ownerId,
-        0 as NonNegativeInt,
+        NonNegativeInt.orThrow(0),
         itemCount,
         (timestamp) => {
           range.timestamps.add(timestampBytesToTimestamp(timestamp));
@@ -1486,7 +1489,10 @@ const splitRange =
     const fingerprintRangesBuckets =
       lower === 0
         ? buckets.value
-        : [lower, ...buckets.value.map((b) => (b + lower) as NonNegativeInt)];
+        : [
+            lower,
+            ...buckets.value.map((b) => NonNegativeInt.orThrow(b + lower)),
+          ];
 
     const fingerprintRanges = deps.storage.fingerprintRanges(
       ownerId,
@@ -1510,7 +1516,7 @@ const decodeRanges = (buffer: Buffer): ReadonlyArray<Range> => {
   const rangesCount = decodeNonNegativeInt(buffer);
   if (rangesCount === 0) return [];
 
-  const timestampsCount = (rangesCount - 1) as NonNegativeInt;
+  const timestampsCount = NonNegativeInt.orThrow(rangesCount - 1);
   const timestamps = decodeTimestamps(buffer, timestampsCount);
   const rangeTypes: Array<RangeType> = [];
 
@@ -1845,7 +1851,7 @@ export const decodeNonNegativeInt = (buffer: Buffer): NonNegativeInt => {
 };
 
 export const encodeLength = (buffer: Buffer, value: ArrayLike<any>): void => {
-  encodeNonNegativeInt(buffer, value.length as NonNegativeInt);
+  encodeNonNegativeInt(buffer, NonNegativeInt.orThrow(value.length));
 };
 
 export const decodeLength = decodeNonNegativeInt;
@@ -1867,7 +1873,7 @@ export const encodeNodeId = (buffer: Buffer, nodeId: NodeId): void => {
 };
 
 export const decodeNodeId = (buffer: Buffer): NodeId => {
-  const bytes = buffer.shiftN(8 as NonNegativeInt);
+  const bytes = buffer.shiftN(NonNegativeInt.orThrow(8));
   return bytesToHex(bytes) as NodeId;
 };
 
@@ -1879,26 +1885,26 @@ export const ProtocolValueType = {
   // 0-19 small ints
 
   // SQLite types
-  String: 20 as NonNegativeInt,
-  Number: 21 as NonNegativeInt,
-  Null: 22 as NonNegativeInt,
-  Bytes: 23 as NonNegativeInt,
+  String: NonNegativeInt.orThrow(20),
+  Number: NonNegativeInt.orThrow(21),
+  Null: NonNegativeInt.orThrow(22),
+  Bytes: NonNegativeInt.orThrow(23),
   // We can add more types for other DBs or anything else later.
 
   // Optimized types
-  NonNegativeInt: 30 as NonNegativeInt,
+  NonNegativeInt: NonNegativeInt.orThrow(30),
 
   // String optimizations
-  EmptyString: 31 as NonNegativeInt, // 1 byte vs 2 bytes (50% reduction)
-  Base64Url: 32 as NonNegativeInt,
-  Id: 33 as NonNegativeInt,
-  Json: 34 as NonNegativeInt,
+  EmptyString: NonNegativeInt.orThrow(31), // 1 byte vs 2 bytes (50% reduction)
+  Base64Url: NonNegativeInt.orThrow(32),
+  Id: NonNegativeInt.orThrow(33),
+  Json: NonNegativeInt.orThrow(34),
 
   // new Date().toISOString()   - 24 bytes
   // encoded with fixed length  - 8 bytes
   // encode as NonNegativeInt   - 6 bytes (additional 25% reduction)
-  DateIsoWithNonNegativeTime: 35 as NonNegativeInt,
-  DateIsoWithNegativeTime: 36 as NonNegativeInt, // 9 bytes
+  DateIsoWithNonNegativeTime: NonNegativeInt.orThrow(35),
+  DateIsoWithNegativeTime: NonNegativeInt.orThrow(36), // 9 bytes
 
   // TODO: Operations (from 40)
   // Increment, Decrement, Patch, whatever.

package/src/Evolu/Relay.ts

@@ -38,8 +38,8 @@ export interface RelayConfig extends ConsoleConfig, StorageConfig {
    * Optional callback to check if an {@link OwnerId} is allowed to access the
    * relay. If this callback is not provided, all owners are allowed.
    *
-   * If provided, the callback receives the OwnerId and should return a
-   * {@link MaybeAsync} boolean: `true` to allow access, or `false` to deny.
+   * The callback receives the {@link OwnerId} and returns a {@link MaybeAsync}
+   * boolean: `true` to allow access, or `false` to deny.
    *
    * The callback can be synchronous (for SQLite or in-memory checks) or
    * asynchronous (for calling remote APIs).
@@ -55,7 +55,8 @@ export interface RelayConfig extends ConsoleConfig, StorageConfig {
    * Owners specify which relays to connect to via {@link OwnerTransport}. In
    * WebSocket-based implementations, this check occurs before accepting the
    * connection, with the OwnerId typically extracted from the URL Path (e.g.,
-   * `ws://localhost:4000/<ownerId>`).
+   * `ws://localhost:4000/<ownerId>`). The relay requires the URL to be in the
+   * correct format for OwnerId extraction.
    *
    * ### Example
    *
@@ -211,17 +212,15 @@ export const createRelaySqliteStorage =
               storedBytes + incomingBytes,
             );
 
-            if (config.isOwnerWithinQuota) {
-              const withinQuotaResult = config.isOwnerWithinQuota(
-                ownerId,
-                newStoredBytes,
-              );
-              const isWithinQuota = isAsync(withinQuotaResult)
-                ? await withinQuotaResult
-                : withinQuotaResult;
-              if (!isWithinQuota) {
-                return err({ type: "StorageQuotaError", ownerId });
-              }
+            const withinQuotaResult = config.isOwnerWithinQuota(
+              ownerId,
+              newStoredBytes,
+            );
+            const isWithinQuota = isAsync(withinQuotaResult)
+              ? await withinQuotaResult
+              : withinQuotaResult;
+            if (!isWithinQuota) {
+              return err({ type: "StorageQuotaError", ownerId });
             }
 
             return deps.sqlite.transaction(() => {

package/src/Evolu/Storage.ts

@@ -29,13 +29,12 @@ import { orderTimestampBytes, Timestamp, TimestampBytes } from "./Timestamp.js";
 
 export interface StorageConfig {
   /**
-   * Optional callback to check if an {@link OwnerId} is within their quota for
-   * the requested write. If this callback is not provided, all writes are
-   * allowed regardless of size.
+   * Callback called before an attempt to write, to check if an {@link OwnerId}
+   * has sufficient quota for the write.
    *
-   * If provided, the callback receives the OwnerId and the number of bytes
-   * required for the write, and should return a {@link MaybeAsync} boolean:
-   * `true` to allow the write, or `false` to deny it due to quota limits.
+   * The callback receives the {@link OwnerId} and the number of bytes required
+   * for the write, and returns a {@link MaybeAsync} boolean: `true` to allow the
+   * write, or `false` to deny it due to quota limits.
    *
    * The callback can be synchronous (for SQLite or in-memory checks) or
    * asynchronous (for calling remote APIs).
@@ -58,7 +57,7 @@ export interface StorageConfig {
    * };
    * ```
    */
-  readonly isOwnerWithinQuota?: (
+  readonly isOwnerWithinQuota: (
     ownerId: OwnerId,
     requiredBytes: PositiveInt,
   ) => MaybeAsync<boolean>;
@@ -183,7 +182,7 @@ export interface StorageQuotaError extends BaseOwnerError {
  */
 export type Fingerprint = Uint8Array & Brand<"Fingerprint">;
 
-export const fingerprintSize = 12 as NonNegativeInt;
+export const fingerprintSize = NonNegativeInt.orThrow(12);
 
 /** A fingerprint of an empty range. */
 export const zeroFingerprint = new Uint8Array(fingerprintSize) as Fingerprint;
@@ -425,7 +424,7 @@ export const createBaseSqliteStorage =
         }
 
         for (let i = 0; i < result.value.rows.length; i++) {
-          const index = (begin + 1 + i) as NonNegativeInt;
+          const index = NonNegativeInt.orThrow(begin + 1 + i);
           if (!callback(result.value.rows[i].t, index)) return;
         }
       },
@@ -1153,7 +1152,7 @@ const randomSkiplistLevel = (deps: RandomDep): PositiveInt => {
   ) {
     level += 1;
   }
-  return level as PositiveInt;
+  return PositiveInt.orThrow(level);
 };
 
 /**
@@ -1294,7 +1293,7 @@ const findLowerBound =
     if (!count.ok) return count;
 
     // `decrement` converts a count to an index.
-    return ok(decrement(count.value) as NonNegativeInt);
+    return ok(NonNegativeInt.orThrow(decrement(count.value)));
   };
 
 const getTimestampCount =

package/src/Evolu/Sync.ts

@@ -9,10 +9,10 @@ import {
 } from "../Crypto.js";
 import { eqArrayNumber } from "../Eq.js";
 import { createTransferableError, TransferableError } from "../Error.js";
-import { constFalse } from "../Function.js";
+import { constFalse, constTrue } from "../Function.js";
 import { objectToEntries } from "../Object.js";
 import { RandomDep } from "../Random.js";
-import { createRefCountedResourceManager } from "../RefCountedResourceManager.js";
+import { createResources } from "../Resources.js";
 import { err, ok, Result } from "../Result.js";
 import { sql, SqliteDep, SqliteError, SqliteValue } from "../Sqlite.js";
 import { AbortError, createMutex } from "../Task.js";
@@ -253,7 +253,7 @@ export const createSync =
       });
     };
 
-    const transports = createRefCountedResourceManager<
+    const transports = createResources<
       WebSocket,
       TransportKey,
       OwnerTransport,
@@ -451,6 +451,7 @@ const createClientStorage =
   }): Result<ClientStorage, SqliteError> => {
     const sqliteStorageBase = createBaseSqliteStorage(deps)({
       onStorageError: config.onError,
+      isOwnerWithinQuota: constTrue, // Clients don't have quota limits
     });
 
     // TODO: Mutex per OwnerId

package/src/Evolu/Timestamp.ts

@@ -147,6 +147,7 @@ export const maxNodeId = "ffffffffffffffff" as NodeId;
  * - 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
  *

package/src/Instances.ts

@@ -38,7 +38,7 @@ export interface Instances<K extends string, T extends Disposable>
   readonly delete: (key: K) => boolean;
 }
 
-/** Creates an {@link Instances} manager. */
+/** Creates an {@link Instances}. */
 export const createInstances = <
   K extends string,
   T extends Disposable,

package/src/Number.ts

@@ -59,15 +59,15 @@ export const computeBalancedBuckets = (
   numberOfItems: NonNegativeInt,
 
   /** Default: 16 */
-  numberOfBuckets = 16 as PositiveInt,
+  numberOfBuckets = PositiveInt.orThrow(16),
 
   /** Default: 2 */
-  minNumberOfItemsPerBucket = 2 as PositiveInt,
+  minNumberOfItemsPerBucket = PositiveInt.orThrow(2),
 ): Result<NonEmptyReadonlyArray<PositiveInt>, PositiveInt> => {
   const minRequiredItems = numberOfBuckets * minNumberOfItemsPerBucket;
 
   if (numberOfItems < minRequiredItems)
-    return err(minRequiredItems as PositiveInt);
+    return err(PositiveInt.orThrow(minRequiredItems));
 
   const indexes: Array<PositiveInt> = [];
   const itemsPerBucket = Math.floor(numberOfItems / numberOfBuckets);
@@ -78,7 +78,7 @@ export const computeBalancedBuckets = (
     const hasExtraItem = i < extraItems;
     const itemsInThisBucket = itemsPerBucket + (hasExtraItem ? 1 : 0);
     bucketBoundary += itemsInThisBucket;
-    indexes.push(bucketBoundary as PositiveInt);
+    indexes.push(PositiveInt.orThrow(bucketBoundary));
   }
 
   assertNonEmptyReadonlyArray(indexes);