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

package/dist/src/Task.js

@@ -56,7 +56,7 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
 import { arrayFrom, emptyArray, isNonEmptyArray, mapArray, } from "./Array.js";
-import { assert } from "./Assert.js";
+import { assert, assertNotDisposed } from "./Assert.js";
 import { createConsole } from "./Console.js";
 import { createRandomBytes } from "./Crypto.js";
 import { eqArrayStrict } from "./Eq.js";
@@ -998,37 +998,51 @@ export const deferredDisposedError = {
  * @group Concurrency primitives
  */
 export const createGate = () => {
-    let isOpen = false;
-    let disposed = false;
-    let deferred = createDeferred();
-    return {
-        wait: (run) => {
-            if (disposed)
-                return err(deferredDisposedError);
-            if (isOpen)
-                return ok();
-            return run(deferred.task);
-        },
-        open: () => {
-            if (disposed || isOpen)
-                return;
-            isOpen = true;
-            deferred.resolve(ok());
-        },
-        close: () => {
-            if (disposed || !isOpen)
-                return;
-            isOpen = false;
-            deferred = createDeferred();
-        },
-        isOpen: () => isOpen,
-        [Symbol.dispose]: () => {
-            if (disposed)
-                return;
-            disposed = true;
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const disposer = __addDisposableResource(env_1, new DisposableStack(), false);
+        let isOpen = false;
+        let deferred = createDeferred();
+        disposer.defer(() => {
             deferred[Symbol.dispose]();
-        },
-    };
+        });
+        const disposables = disposer.move();
+        return {
+            wait: (run) => {
+                if (disposables.disposed)
+                    return err(deferredDisposedError);
+                if (isOpen)
+                    return ok();
+                return run(deferred.task);
+            },
+            open: () => {
+                assertNotDisposed(disposables);
+                if (isOpen)
+                    return;
+                isOpen = true;
+                deferred.resolve(ok());
+            },
+            close: () => {
+                assertNotDisposed(disposables);
+                if (!isOpen)
+                    return;
+                isOpen = false;
+                deferred = createDeferred();
+            },
+            isOpen: () => {
+                assertNotDisposed(disposables);
+                return isOpen;
+            },
+            [Symbol.dispose]: () => disposables.dispose(),
+        };
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        __disposeResources(env_1);
+    }
 };
 /**
  * Creates a {@link Semaphore} that limits concurrent {@link Task}s.
@@ -1071,85 +1085,18 @@ export const createGate = () => {
  * @group Concurrency primitives
  */
 export const createSemaphore = (permits) => {
-    const fibers = new Set();
-    const waiters = [];
-    let taken = zeroNonNegativeInt;
-    let disposed = false;
-    const withPermits = (requestedPermits) => (task) => async (run) => {
-        const env_1 = { stack: [], error: void 0, hasError: false };
-        try {
-            const requested = PositiveInt.orThrow(requestedPermits);
-            assert(requested <= permits, "Requested permits must not exceed semaphore capacity.");
-            if (disposed)
-                return err(semaphoreDisposedAbortError);
-            if (waiters.length > 0 || taken + requested > permits) {
-                const waiter = Promise.withResolvers();
-                const waiting = {
-                    permits: requested,
-                    resolve: waiter.resolve,
-                };
-                waiters.push(waiting);
-                run.onAbort((reason) => {
-                    const i = waiters.indexOf(waiting);
-                    if (i >= 0)
-                        waiters.splice(i, 1);
-                    waiter.resolve(err(createAbortError(reason)));
-                });
-                const permit = await waiter.promise;
-                if (!permit.ok)
-                    return permit;
-            }
-            else {
-                taken = NonNegativeInt.orThrow(taken + requested);
-            }
-            let fiber = null;
-            const _ = __addDisposableResource(env_1, {
-                [Symbol.dispose]: () => {
-                    if (fiber)
-                        fibers.delete(fiber);
-                    taken = NonNegativeInt.orThrow(taken - requested);
-                    while (waiters.length > 0) {
-                        const waiter = waiters[0];
-                        if (taken + waiter.permits > permits)
-                            break;
-                        waiters.shift();
-                        taken = NonNegativeInt.orThrow(taken + waiter.permits);
-                        waiter.resolve(ok());
-                    }
-                },
-            }, false);
-            fiber = run(task);
-            fibers.add(fiber);
-            return await fiber;
-        }
-        catch (e_1) {
-            env_1.error = e_1;
-            env_1.hasError = true;
-        }
-        finally {
-            __disposeResources(env_1);
-        }
-    };
-    return {
-        withPermits,
-        withPermit: (task) => withPermits(1)(task),
-        snapshot: () => ({
-            permits,
-            taken,
-            waiting: NonNegativeInt.orThrow(waiters.length),
-            available: NonNegativeInt.orThrow(permits - taken),
-            isIdle: taken === 0 && waiters.length === 0,
-            disposed,
-        }),
-        [Symbol.dispose]: () => {
-            const env_2 = { stack: [], error: void 0, hasError: false };
+    const env_2 = { stack: [], error: void 0, hasError: false };
+    try {
+        const disposer = __addDisposableResource(env_2, new DisposableStack(), false);
+        const fibers = new Set();
+        const waiters = [];
+        let taken = zeroNonNegativeInt;
+        disposer.defer(() => {
+            const env_3 = { stack: [], error: void 0, hasError: false };
             try {
-                if (disposed)
-                    return;
-                disposed = true;
-                const stack = __addDisposableResource(env_2, new DisposableStack(), false);
+                const disposer = __addDisposableResource(env_3, new DisposableStack(), false);
                 for (const fiber of fibers) {
-                    stack.adopt(fiber, (fiber) => {
+                    disposer.adopt(fiber, (fiber) => {
                         fiber.abort(semaphoreDisposedError);
                     });
                 }
@@ -1158,15 +1105,94 @@ export const createSemaphore = (permits) => {
                 }
                 waiters.length = 0;
             }
-            catch (e_2) {
-                env_2.error = e_2;
-                env_2.hasError = true;
+            catch (e_3) {
+                env_3.error = e_3;
+                env_3.hasError = true;
             }
             finally {
-                __disposeResources(env_2);
+                __disposeResources(env_3);
             }
-        },
-    };
+        });
+        const disposables = disposer.move();
+        const withPermits = (requestedPermits) => (task) => async (run) => {
+            const env_4 = { stack: [], error: void 0, hasError: false };
+            try {
+                const requested = PositiveInt.orThrow(requestedPermits);
+                assert(requested <= permits, "Requested permits must not exceed semaphore capacity.");
+                if (disposables.disposed)
+                    return err(semaphoreDisposedAbortError);
+                if (waiters.length > 0 || taken + requested > permits) {
+                    const waiter = Promise.withResolvers();
+                    const waiting = {
+                        permits: requested,
+                        resolve: waiter.resolve,
+                    };
+                    waiters.push(waiting);
+                    run.onAbort((reason) => {
+                        const i = waiters.indexOf(waiting);
+                        if (i >= 0)
+                            waiters.splice(i, 1);
+                        waiter.resolve(err(createAbortError(reason)));
+                    });
+                    const permit = await waiter.promise;
+                    if (!permit.ok)
+                        return permit;
+                }
+                else {
+                    taken = NonNegativeInt.orThrow(taken + requested);
+                }
+                let fiber = null;
+                const _ = __addDisposableResource(env_4, {
+                    [Symbol.dispose]: () => {
+                        if (fiber)
+                            fibers.delete(fiber);
+                        taken = NonNegativeInt.orThrow(taken - requested);
+                        while (waiters.length > 0) {
+                            const waiter = waiters[0];
+                            if (taken + waiter.permits > permits)
+                                break;
+                            waiters.shift();
+                            taken = NonNegativeInt.orThrow(taken + waiter.permits);
+                            waiter.resolve(ok());
+                        }
+                    },
+                }, false);
+                fiber = run(task);
+                fibers.add(fiber);
+                return await fiber;
+            }
+            catch (e_4) {
+                env_4.error = e_4;
+                env_4.hasError = true;
+            }
+            finally {
+                __disposeResources(env_4);
+            }
+        };
+        return {
+            withPermits,
+            withPermit: (task) => withPermits(1)(task),
+            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(),
+        };
+    }
+    catch (e_2) {
+        env_2.error = e_2;
+        env_2.hasError = true;
+    }
+    finally {
+        __disposeResources(env_2);
+    }
 };
 /**
  * Abort reason used when a {@link Semaphore} is disposed.
@@ -1184,64 +1210,80 @@ export const semaphoreDisposedError = {
 };
 const semaphoreDisposedAbortError = createAbortError(semaphoreDisposedError);
 export function createSemaphoreByKey(permits, { lookup = identity } = {}) {
-    const semaphoresByKey = createLookupMap({
-        lookup,
-    });
-    let disposed = false;
-    const withPermits = (key, requestedPermits) => (task) => async (run) => {
-        const env_3 = { stack: [], error: void 0, hasError: false };
-        try {
-            if (disposed)
-                return err(semaphoreDisposedAbortError);
-            let semaphore = semaphoresByKey.get(key);
-            if (!semaphore) {
-                semaphore = createSemaphore(permits);
-                semaphoresByKey.set(key, semaphore);
-            }
-            const _ = __addDisposableResource(env_3, {
-                [Symbol.dispose]: () => {
-                    const snapshot = semaphore.snapshot();
-                    if (snapshot.isIdle) {
-                        semaphoresByKey.delete(key);
-                        semaphore[Symbol.dispose]();
-                    }
-                },
-            }, false);
-            return await run(semaphore.withPermits(requestedPermits)(task));
-        }
-        catch (e_3) {
-            env_3.error = e_3;
-            env_3.hasError = true;
-        }
-        finally {
-            __disposeResources(env_3);
-        }
-    };
-    return {
-        withPermit: (key, task) => withPermits(key, 1)(task),
-        withPermits,
-        snapshot: (key) => semaphoresByKey.get(key)?.snapshot() ?? null,
-        [Symbol.dispose]: () => {
-            const env_4 = { stack: [], error: void 0, hasError: false };
+    const env_5 = { stack: [], error: void 0, hasError: false };
+    try {
+        const disposer = __addDisposableResource(env_5, new DisposableStack(), false);
+        const semaphoresByKey = createLookupMap({
+            lookup,
+        });
+        disposer.defer(() => {
+            const env_6 = { stack: [], error: void 0, hasError: false };
             try {
-                if (disposed)
-                    return;
-                disposed = true;
-                const stack = __addDisposableResource(env_4, new DisposableStack(), false);
+                const disposer = __addDisposableResource(env_6, new DisposableStack(), false);
+                disposer.defer(() => {
+                    semaphoresByKey.clear();
+                });
                 for (const semaphore of semaphoresByKey.values()) {
-                    stack.use(semaphore);
+                    disposer.use(semaphore);
                 }
-                semaphoresByKey.clear();
             }
-            catch (e_4) {
-                env_4.error = e_4;
-                env_4.hasError = true;
+            catch (e_6) {
+                env_6.error = e_6;
+                env_6.hasError = true;
             }
             finally {
-                __disposeResources(env_4);
+                __disposeResources(env_6);
             }
-        },
-    };
+        });
+        const disposables = disposer.move();
+        const withPermits = (key, requestedPermits) => (task) => async (run) => {
+            const env_7 = { stack: [], error: void 0, hasError: false };
+            try {
+                if (disposables.disposed)
+                    return err(semaphoreDisposedAbortError);
+                let semaphore = semaphoresByKey.get(key);
+                if (!semaphore) {
+                    semaphore = createSemaphore(permits);
+                    semaphoresByKey.set(key, semaphore);
+                }
+                const _ = __addDisposableResource(env_7, {
+                    [Symbol.dispose]: () => {
+                        if (semaphoresByKey.get(key) !== semaphore)
+                            return;
+                        const snapshot = semaphore.snapshot();
+                        if (snapshot.isIdle) {
+                            semaphoresByKey.delete(key);
+                            semaphore[Symbol.dispose]();
+                        }
+                    },
+                }, false);
+                return await run(semaphore.withPermits(requestedPermits)(task));
+            }
+            catch (e_7) {
+                env_7.error = e_7;
+                env_7.hasError = true;
+            }
+            finally {
+                __disposeResources(env_7);
+            }
+        };
+        return {
+            withPermit: (key, task) => withPermits(key, 1)(task),
+            withPermits,
+            snapshot: (key) => {
+                assertNotDisposed(disposables);
+                return semaphoresByKey.get(key)?.snapshot() ?? null;
+            },
+            [Symbol.dispose]: () => disposables.dispose(),
+        };
+    }
+    catch (e_5) {
+        env_5.error = e_5;
+        env_5.hasError = true;
+    }
+    finally {
+        __disposeResources(env_5);
+    }
 }
 /**
  * Creates a {@link Mutex}.
@@ -1316,39 +1358,6 @@ export const createMutexRef = (initialValue) => {
         [Symbol.dispose]: mutex[Symbol.dispose],
     };
 };
-/**
- * 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 = () => {
-    const mutexByName = createMutexByKey();
-    return {
-        lock: (name) => async (run) => {
-            const leaseRun = run.create();
-            const released = createDeferred();
-            const acquired = createDeferred();
-            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],
-            });
-        },
-    };
-};
 export function all(input, options) {
     return collect("all", input, options);
 }
@@ -1470,7 +1479,7 @@ function pool(tasksIterable, { stopOn = null, collect, abortReason, allFailed, }
     if (length === 0)
         return () => ok(emptyArray);
     return async (run) => {
-        const env_5 = { stack: [], error: void 0, hasError: false };
+        const env_8 = { stack: [], error: void 0, hasError: false };
         try {
             const results = collect ? new Array(length) : null;
             const aborted = Promise.withResolvers();
@@ -1520,7 +1529,7 @@ function pool(tasksIterable, { stopOn = null, collect, abortReason, allFailed, }
             };
             const workerCount = Math.min(run.concurrency, length);
             const workers = arrayFrom(workerCount, () => run.daemon(worker));
-            const _ = __addDisposableResource(env_5, new DisposableStack(), false);
+            const _ = __addDisposableResource(env_8, new DisposableStack(), false);
             _.defer(() => {
                 abortWorkers(abortReason);
             });
@@ -1546,12 +1555,12 @@ function pool(tasksIterable, { stopOn = null, collect, abortReason, allFailed, }
                 return ok();
             return allFailed === "completion" ? lastResult : lastIndexResult;
         }
-        catch (e_5) {
-            env_5.error = e_5;
-            env_5.hasError = true;
+        catch (e_8) {
+            env_8.error = e_8;
+            env_8.hasError = true;
         }
         finally {
-            __disposeResources(env_5);
+            __disposeResources(env_8);
         }
     };
 }

package/dist/src/Test.d.ts

@@ -84,10 +84,10 @@ export declare 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/dist/src/Time.d.ts

@@ -79,6 +79,11 @@ export type Millis = typeof Millis.Type;
 export declare const minMillis: Millis;
 /** Maximum {@link Millis} value. */
 export declare const maxMillis: Millis;
+/**
+ * Converts a number to {@link Millis}, rounding to the nearest millisecond and
+ * saturating overflow at {@link maxMillis}.
+ */
+export declare const saturateMillis: (value: number) => Millis;
 /**
  * Converts {@link Millis} to {@link DateIso}.
  *

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

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

package/dist/src/Time.js

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

package/dist/src/Type.d.ts

@@ -1509,6 +1509,13 @@ export declare const formatFiniteError: TypeErrorFormatter<FiniteError>;
  */
 export declare const FiniteNumber: BrandType<Type<"Number", number, number, NumberError, number, NumberError>, "Finite", FiniteError, NumberError>;
 export type FiniteNumber = typeof FiniteNumber.Type;
+/**
+ * Non-negative finite number.
+ *
+ * @group Number
+ */
+export declare const NonNegativeFiniteNumber: BrandType<Type<"Brand", number & Brand<"Finite">, number, FiniteError, number, NumberError>, "NonNegative", NonNegativeError, FiniteError | NumberError>;
+export type NonNegativeFiniteNumber = typeof NonNegativeFiniteNumber.Type;
 /**
  * Number that is a multiple of a divisor.
  *