@evolu/common 8.0.0-next.2 → 8.0.0-next.4

package/src/Task.ts

@@ -12,7 +12,7 @@ import {
   type NonEmptyReadonlyArray,
 } from "./Array.js";
 import type { assertNotAborted } from "./Assert.js";
-import { assert } from "./Assert.js";
+import { assert, assertNotDisposed } from "./Assert.js";
 import { type Console, type ConsoleDep, createConsole } from "./Console.js";
 import type { RandomBytes, RandomBytesDep } from "./Crypto.js";
 import { createRandomBytes } from "./Crypto.js";
@@ -43,7 +43,6 @@ import {
   Id,
   type InferType,
   maxPositiveInt,
-  type Name,
   NonNegativeInt,
   object,
   onePositiveInt,
@@ -327,13 +326,13 @@ import {
  * ### Example
  *
  * ```ts
- * await using stack = new AsyncDisposableStack();
+ * await using disposer = new AsyncDisposableStack();
  *
  * const fooResult = await run(createFoo());
  * if (!fooResult.ok) return fooResult;
- * const foo = stack.use(fooResult.value);
+ * const foo = disposer.use(fooResult.value);
  *
- * stack.defer(async () => {
+ * disposer.defer(async () => {
  *   await foo.close();
  * });
  * stack.adopt(session, async (session) => {
@@ -761,9 +760,9 @@ export interface Run<D = unknown> extends AsyncDisposable {
    *   (config: Config): Task<void, InitError, CreateDbDep> =>
    *   async (run) => {
    *     const { createDb } = run.deps;
-   *     await using stack = new AsyncDisposableStack();
+   *     await using disposer = new AsyncDisposableStack();
    *
-   *     const db = stack.use(await run.orThrow(startApp()));
+   *     const db = disposer.use(await run.orThrow(startApp()));
    *     if (!db.ok) return db;
    *
    *     const runWithDb = run.addDeps({ db: db.value });
@@ -2025,7 +2024,7 @@ export const retry =
     task: Task<T, E, D>,
     schedule: Schedule<Output, E>,
     {
-      retryable = lazyTrue as Predicate<E>,
+      retryable = lazyTrue,
       onRetry,
     }: RetryOptions<E, Output> = {},
   ): Task<T, RetryError<E>, D> =>
@@ -2145,7 +2144,7 @@ export const repeat =
     task: Task<T, E, D>,
     schedule: Schedule<Output, T>,
     {
-      repeatable = lazyTrue as Predicate<T>,
+      repeatable = lazyTrue,
       onRepeat,
     }: RepeatOptions<T, Output> = {},
   ): Task<T, E, D> =>
@@ -2340,36 +2339,43 @@ export interface Gate<D = unknown> extends Disposable {
  * @group Concurrency primitives
  */
 export const createGate = <D = unknown>(): Gate<D> => {
+  using disposer = new DisposableStack();
   let isOpen = false;
-  let disposed = false;
   let deferred = createDeferred<void>();
 
+  disposer.defer(() => {
+    deferred[Symbol.dispose]();
+  });
+
+  const disposables = disposer.move();
+
   return {
     wait: (run) => {
-      if (disposed) return err(deferredDisposedError);
+      if (disposables.disposed) return err(deferredDisposedError);
       if (isOpen) return ok();
       return run(deferred.task);
     },
 
     open: () => {
-      if (disposed || isOpen) return;
+      assertNotDisposed(disposables);
+      if (isOpen) return;
       isOpen = true;
       deferred.resolve(ok());
     },
 
     close: () => {
-      if (disposed || !isOpen) return;
+      assertNotDisposed(disposables);
+      if (!isOpen) return;
       isOpen = false;
       deferred = createDeferred<void>();
     },
 
-    isOpen: () => isOpen,
-
-    [Symbol.dispose]: () => {
-      if (disposed) return;
-      disposed = true;
-      deferred[Symbol.dispose]();
+    isOpen: () => {
+      assertNotDisposed(disposables);
+      return isOpen;
     },
+
+    [Symbol.dispose]: () => disposables.dispose(),
   };
 };
 
@@ -2483,10 +2489,26 @@ export const createSemaphore = (permits: Concurrency): Semaphore => {
     readonly resolve: Callback<Result<void, AbortError>>;
   }
 
+  using disposer = new DisposableStack();
   const fibers = new Set<Fiber>();
   const waiters: Array<Waiter> = [];
   let taken = zeroNonNegativeInt;
-  let disposed = false;
+
+  disposer.defer(() => {
+    using disposer = new DisposableStack();
+    for (const fiber of fibers) {
+      disposer.adopt(fiber, (fiber) => {
+        fiber.abort(semaphoreDisposedError);
+      });
+    }
+
+    for (const waiter of waiters) {
+      waiter.resolve(err(semaphoreDisposedAbortError));
+    }
+    waiters.length = 0;
+  });
+
+  const disposables = disposer.move();
 
   const withPermits =
     <T, E, D>(requestedPermits: Concurrency) =>
@@ -2499,7 +2521,7 @@ export const createSemaphore = (permits: Concurrency): Semaphore => {
         "Requested permits must not exceed semaphore capacity.",
       );
 
-      if (disposed) return err(semaphoreDisposedAbortError);
+      if (disposables.disposed) return err(semaphoreDisposedAbortError);
 
       if (waiters.length > 0 || taken + requested > permits) {
         const waiter = Promise.withResolvers<Result<void, AbortError>>();
@@ -2548,31 +2570,19 @@ export const createSemaphore = (permits: Concurrency): Semaphore => {
     withPermit: <T, E, D>(task: Task<T, E, D>): Task<T, E, D> =>
       withPermits<T, E, D>(1)(task),
 
-    snapshot: () => ({
-      permits,
-      taken,
-      waiting: NonNegativeInt.orThrow(waiters.length),
-      available: NonNegativeInt.orThrow(permits - taken),
-      isIdle: taken === 0 && waiters.length === 0,
-      disposed,
-    }),
-
-    [Symbol.dispose]: () => {
-      if (disposed) return;
-      disposed = true;
-
-      using stack = new DisposableStack();
-      for (const fiber of fibers) {
-        stack.adopt(fiber, (fiber) => {
-          fiber.abort(semaphoreDisposedError);
-        });
-      }
-
-      for (const waiter of waiters) {
-        waiter.resolve(err(semaphoreDisposedAbortError));
-      }
-      waiters.length = 0;
+    snapshot: () => {
+      assertNotDisposed(disposables);
+      return {
+        permits,
+        taken,
+        waiting: NonNegativeInt.orThrow(waiters.length),
+        available: NonNegativeInt.orThrow(permits - taken),
+        isIdle: taken === 0 && waiters.length === 0,
+        disposed: disposables.disposed,
+      };
     },
+
+    [Symbol.dispose]: () => disposables.dispose(),
   };
 };
 
@@ -2659,16 +2669,29 @@ export function createSemaphoreByKey<K, L = K>(
   permits: Concurrency,
   { lookup = identity as Lookup<K, L> }: CreateSemaphoreByKeyOptions<K, L> = {},
 ): SemaphoreByKey<K> {
+  using disposer = new DisposableStack();
   const semaphoresByKey = createLookupMap<K, Semaphore, L>({
     lookup,
   });
-  let disposed = false;
+
+  disposer.defer(() => {
+    using disposer = new DisposableStack();
+    disposer.defer(() => {
+      semaphoresByKey.clear();
+    });
+
+    for (const semaphore of semaphoresByKey.values()) {
+      disposer.use(semaphore);
+    }
+  });
+
+  const disposables = disposer.move();
 
   const withPermits =
     <T, E, D>(key: K, requestedPermits: Concurrency) =>
     (task: Task<T, E, D>): Task<T, E, D> =>
     async (run: Run<D>) => {
-      if (disposed) return err(semaphoreDisposedAbortError);
+      if (disposables.disposed) return err(semaphoreDisposedAbortError);
 
       let semaphore = semaphoresByKey.get(key);
       if (!semaphore) {
@@ -2678,6 +2701,8 @@ export function createSemaphoreByKey<K, L = K>(
 
       using _ = {
         [Symbol.dispose]: () => {
+          if (semaphoresByKey.get(key) !== semaphore) return;
+
           const snapshot = semaphore.snapshot();
           if (snapshot.isIdle) {
             semaphoresByKey.delete(key);
@@ -2695,18 +2720,12 @@ export function createSemaphoreByKey<K, L = K>(
 
     withPermits,
 
-    snapshot: (key) => semaphoresByKey.get(key)?.snapshot() ?? null,
-
-    [Symbol.dispose]: () => {
-      if (disposed) return;
-      disposed = true;
-
-      using stack = new DisposableStack();
-      for (const semaphore of semaphoresByKey.values()) {
-        stack.use(semaphore);
-      }
-      semaphoresByKey.clear();
+    snapshot: (key) => {
+      assertNotDisposed(disposables);
+      return semaphoresByKey.get(key)?.snapshot() ?? null;
     },
+
+    [Symbol.dispose]: () => disposables.dispose(),
   };
 }
 
@@ -2931,68 +2950,6 @@ export const createMutexRef = <T>(initialValue: T): MutexRef<T> => {
   };
 };
 
-/**
- * Cross-platform leader lock abstraction.
- *
- * `lock` returns a {@link Task} that waits until leadership is acquired and
- * yields a lease.
- *
- * Returns {@link AsyncDisposable} lease. Dispose it to release leadership.
- *
- * @group Concurrency primitives
- */
-export interface LeaderLock {
-  readonly lock: (name: Name) => Task<AsyncDisposable>;
-}
-
-/** @group Concurrency primitives */
-export interface LeaderLockDep {
-  readonly leaderLock: LeaderLock;
-}
-
-/**
- * Creates an in-process {@link LeaderLock}.
- *
- * Uses one {@link Mutex} per {@link Name}. Suitable for runtimes without a
- * cross-process lock manager (for example in-memory worker tests or React
- * Native).
- *
- * @group Concurrency primitives
- */
-export const createInMemoryLeaderLock = (): LeaderLock => {
-  const mutexByName = createMutexByKey<Name>();
-
-  return {
-    lock: (name) => async (run) => {
-      const leaseRun = run.create();
-      const released = createDeferred<void>();
-      const acquired = createDeferred<void>();
-
-      void leaseRun(
-        mutexByName.withLock(name, async (run) => {
-          acquired.resolve(ok());
-          await run(released.task);
-          return ok();
-        }),
-      );
-
-      const acquiredResult = await run(acquired.task);
-      if (!acquiredResult.ok) {
-        assert(
-          AbortError.is(acquiredResult.error),
-          "Leader lock acquisition deferred must not be disposed.",
-        );
-        void leaseRun[Symbol.asyncDispose]();
-        return err(acquiredResult.error);
-      }
-
-      return ok({
-        [Symbol.asyncDispose]: leaseRun[Symbol.asyncDispose],
-      });
-    },
-  };
-};
-
 /**
  * Options for {@link all}, {@link allSettled}, {@link map}, and {@link mapSettled}.
  *

package/src/Test.ts

@@ -119,10 +119,10 @@ export const testCreateDeps = (options?: {
  * // If multiple tests need the same setup, create a disposable helper.
  * // Then `await using setup` disposes everything the helper owns.
  * const setupFoo = async () => {
- *   await using stack = new AsyncDisposableStack();
- *   const run = stack.use(testCreateRun());
- *   const foo = stack.use(await run.orThrow(createFoo()));
- *   const moved = stack.move();
+ *   await using disposer = new AsyncDisposableStack();
+ *   const run = disposer.use(testCreateRun());
+ *   const foo = disposer.use(await run.orThrow(createFoo()));
+ *   const disposables = disposer.move();
  *
  *   // Return whatever the tests need: a Run with the dependency,
  *   // the dependency itself, or both.

package/src/Time.ts

@@ -177,6 +177,13 @@ export const minMillis = 0 as Millis;
 /** Maximum {@link Millis} value. */
 export const maxMillis = (maxMillisWithInfinity - 1) as Millis;
 
+/**
+ * Converts a number to {@link Millis}, rounding to the nearest millisecond and
+ * saturating overflow at {@link maxMillis}.
+ */
+export const saturateMillis = (value: number): Millis =>
+  Millis.orNull(Math.max(0, Math.round(value))) ?? maxMillis;
+
 /**
  * Converts {@link Millis} to {@link DateIso}.
  *

package/src/Type.ts

@@ -2334,6 +2334,14 @@ export const formatFiniteError =
 export const FiniteNumber = /*#__PURE__*/ finite(Number);
 export type FiniteNumber = typeof FiniteNumber.Type;
 
+/**
+ * Non-negative finite number.
+ *
+ * @group Number
+ */
+export const NonNegativeFiniteNumber = /*#__PURE__*/ nonNegative(FiniteNumber);
+export type NonNegativeFiniteNumber = typeof NonNegativeFiniteNumber.Type;
+
 /**
  * Number that is a multiple of a divisor.
  *
@@ -4651,6 +4659,7 @@ export const createFormatTypeError = <ExtraErrors extends TypeError = never>(
 
     if (extraMessage != null) return extraMessage;
 
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
     error = error as TypeErrors;
 
     switch (error.type) {

package/src/WebSocket.ts

@@ -200,7 +200,7 @@ export const createWebSocket: CreateWebSocket =
     } = {},
   ) =>
   async (run) => {
-    await using stack = new AsyncDisposableStack();
+    await using disposer = new AsyncDisposableStack();
 
     let socket: globalThis.WebSocket | null = null;
 
@@ -268,7 +268,7 @@ export const createWebSocket: CreateWebSocket =
       return closeSocket;
     });
 
-    const retryFiber = stack.use(run.daemon(retry(connect, schedule)));
+    const retryFiber = disposer.use(run.daemon(retry(connect, schedule)));
 
     // Report RetryError (schedule exhausted) via onError callback
     void retryFiber.then((result) => {
@@ -277,7 +277,7 @@ export const createWebSocket: CreateWebSocket =
       }
     });
 
-    const moved = stack.move();
+    const disposables = disposer.move();
 
     return ok<WebSocket>({
       send: (data) => {
@@ -290,14 +290,15 @@ export const createWebSocket: CreateWebSocket =
       },
 
       getReadyState: () => {
-        if (moved.disposed) return "closed";
+        if (disposables.disposed) return "closed";
         return socket ? nativeToStringState[socket.readyState] : "connecting";
       },
 
       isOpen: () =>
-        !moved.disposed && socket?.readyState === globalThis.WebSocket.OPEN,
+        !disposables.disposed &&
+        socket?.readyState === globalThis.WebSocket.OPEN,
 
-      [Symbol.asyncDispose]: () => moved.disposeAsync(),
+      [Symbol.asyncDispose]: () => disposables.disposeAsync(),
     });
   };