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

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";
@@ -154,7 +154,7 @@ export const RunEvent = /*#__PURE__*/ object({
 // TODO:
 // Partial<TracerConfigDep> & // TODO:
 // Partial<TracerDep>; // TODO:
-const runDeps = {
+const runDefaultDeps = {
     console: createConsole(),
     randomBytes: createRandomBytes(),
     random: createRandom(),
@@ -175,7 +175,7 @@ const runDeps = {
  * Node.js `uncaughtException`, `unhandledRejection`, and graceful shutdown
  * handling, and `@evolu/react-native` adds React Native global error handling.
  *
- * {@link RunDeps} provides default dependencies:
+ * {@link RunDefaultDeps} provides default dependencies:
  *
  * - {@link Time}
  * - {@link Console}
@@ -213,7 +213,7 @@ const runDeps = {
  *   };
  *
  * // Composition root: create a Run with custom deps
- * type AppDeps = RunDeps & ConfigDep;
+ * type AppDeps = RunDefaultDeps & ConfigDep;
  *
  * const appDeps: AppDeps = {
  *   ...testCreateDeps(), // or spread individual deps
@@ -226,17 +226,14 @@ const runDeps = {
  * const result = await run(fetchUser("123"));
  *
  * // TypeScript catches missing deps at compile time:
- * // await using run2 = createRun(); // Run<RunDeps>
+ * // await using run2 = createRun(); // Run<RunDefaultDeps>
  * // run2(fetchUser("123")); // Error: Property 'config' is missing
  * ```
  *
  * @group Creating Run
  */
-export const createRun = (deps) => {
-    const mergedDeps = { ...runDeps, ...deps };
-    return createRunInternal(createRef(mergedDeps))();
-};
-const createRunInternal = (depsRef) => (parent, daemon, abortBehavior, concurrencyBehavior) => {
+export const createRun = (deps) => createRunInternal({ ...runDefaultDeps, ...deps });
+const createRunInternal = (deps, parent, daemon, abortBehavior, concurrencyBehavior) => {
     const parentMask = parent?.abortMask ?? isAbortable;
     let abortMask;
     switch (abortBehavior) {
@@ -256,8 +253,7 @@ const createRunInternal = (depsRef) => (parent, daemon, abortBehavior, concurren
     let result;
     let outcome;
     let children = emptySet;
-    const requestAbort = (reason) => {
-        const abortError = reason;
+    const requestAbort = (abortError) => {
         if (abortMask === isAbortable)
             signalController.abort(abortError);
         requestController.abort(abortError);
@@ -266,7 +262,6 @@ const createRunInternal = (depsRef) => (parent, daemon, abortBehavior, concurren
         subscribeToAbort(parent.requestSignal, () => requestAbort(parent.requestSignal.reason), { signal: requestController.signal });
     }
     const emitEvent = (data) => {
-        const deps = depsRef.get();
         if (!deps.runConfig?.eventsEnabled.get())
             return;
         const e = { id: self.id, timestamp: deps.time.now(), data };
@@ -274,16 +269,28 @@ const createRunInternal = (depsRef) => (parent, daemon, abortBehavior, concurren
             node.onEvent?.(e);
         }
     };
-    const run = (task) => {
-        const childRun = createRunInternal(depsRef)(self, daemon ?? self, getAbortBehavior(task), getConcurrencyBehavior(task));
+    const run = (task, taskDeps) => {
+        const childRun = createRunInternal(taskDeps === undefined
+            ? deps
+            : {
+                console: deps.console,
+                randomBytes: deps.randomBytes,
+                random: deps.random,
+                time: deps.time,
+                ...(deps.runConfig && {
+                    runConfig: deps.runConfig,
+                }),
+                ...taskDeps,
+            }, self, daemon ?? self, getAbortBehavior(task), getConcurrencyBehavior(task));
         if (state !== running) {
             childRun.requestAbort(runStoppedAbortError);
             task = () => err(runStoppedAbortError);
         }
         else if (signalController.signal.aborted &&
             childRun.abortMask === isAbortable) {
-            childRun.requestAbort(signalController.signal.reason);
-            task = () => err(signalController.signal.reason);
+            const abortError = signalController.signal.reason;
+            childRun.requestAbort(abortError);
+            task = () => err(abortError);
         }
         const childFiber = Object.assign(Promise.try(task, childRun)
             .then(childRun.handleTaskFulfilled)
@@ -306,13 +313,17 @@ const createRunInternal = (depsRef) => (parent, daemon, abortBehavior, concurren
         emitEvent({ type: "ChildAdded", childId: childRun.id });
         return childFiber;
     };
+    let snapshot = null;
+    let disposingPromise = null;
     const self = run;
     {
         const run = self;
-        const id = createId(depsRef.get());
-        let snapshot = null;
-        let disposingPromise = null;
-        run.orThrow = async (task) => getOrThrow(await self(task));
+        const id = createId(deps);
+        async function orThrow(task, taskDeps) {
+            const result = taskDeps === undefined ? await self(task) : await self(task, taskDeps);
+            return getOrThrow(result);
+        }
+        run.orThrow = orThrow;
         run.id = id;
         run.parent = parent ?? null;
         run.signal = signalController.signal;
@@ -330,45 +341,38 @@ const createRunInternal = (depsRef) => (parent, daemon, abortBehavior, concurren
                 !eqArrayStrict(snapshot.children, childSnapshots)) {
                 snapshot = {
                     id,
-                    state: state,
+                    state,
                     children: childSnapshots,
                     abortMask,
                 };
             }
             return snapshot;
         };
+        run.onEvent = undefined;
         run.daemon = daemon ?? self;
-        run.create = () => run.daemon(createDeferred().task).run;
-        Object.defineProperty(run, "deps", { get: depsRef.get });
+        run.create = (runDeps = deps) => {
+            const task = createDeferred().task;
+            return run.daemon(task, runDeps).run;
+        };
+        run.deps = deps;
         run.concurrency =
             concurrencyBehavior ?? parent?.concurrency ?? defaultConcurrency;
-        run.addDeps = (newDeps) => {
-            depsRef.modify((currentDeps) => {
-                const duplicate = Object.keys(newDeps).find((k) => k in currentDeps);
-                assert(!duplicate, `Dependency '${duplicate}' already added. ` +
-                    `This assert ensures dependencies are created once. ` +
-                    `Automatic deduplication would mask bugs.`);
-                return [undefined, { ...currentDeps, ...newDeps }];
-            });
-            return self;
-        };
         run[Symbol.asyncDispose] = () => {
             if (disposingPromise)
                 return disposingPromise;
             state = { type: "Disposing" };
             emitEvent({ type: "StateChanged", state });
             requestAbort(runStoppedAbortError);
-            disposingPromise = Promise.allSettled((run.ownTaskSettled
-                ? [run.ownTaskSettled.promise, ...children]
+            disposingPromise = Promise.allSettled((self.ownTaskSettled
+                ? [self.ownTaskSettled.promise, ...children]
                 : children))
                 .then(lazyVoid)
                 .finally(() => {
                 /**
-                 * Root and daemon Runs have no own Task, so
-                 * `run.handleTaskFulfilled` never populates their terminal values.
-                 * In that case disposal publishes `ok()` for both `result` and
-                 * `outcome`. Task-backed Runs normally reach this point with both
-                 * values already set.
+                 * Root and daemon Runs have no own Task, so `run.handleTaskFulfilled`
+                 * never populates their terminal values. In that case disposal
+                 * publishes `ok()` for both `result` and `outcome`. Task-backed Runs
+                 * normally reach this point with both values already set.
                  */
                 [result, outcome] = [result ?? ok(), outcome ?? ok()];
                 state = { type: "Settled", result, outcome };
@@ -381,15 +385,15 @@ const createRunInternal = (depsRef) => (parent, daemon, abortBehavior, concurren
         run.requestAbort = requestAbort;
         run.requestSignal = requestController.signal;
         run.handleTaskFulfilled = (taskOutcome) => {
-            const taskResult = run.signal.aborted
-                ? err(run.signal.reason)
+            const taskResult = self.signal.aborted
+                ? err(self.signal.reason)
                 : taskOutcome;
             result = taskResult;
             outcome = taskOutcome;
             return taskResult;
         };
         run.handleTaskSettled = () => {
-            run.ownTaskSettled?.resolve();
+            self.ownTaskSettled?.resolve();
         };
     }
     return self;
@@ -432,16 +436,19 @@ const abortBehavior = (behavior) => (task) => Object.assign((run) => run(task),
 /**
  * Makes a {@link Task} unabortable.
  *
- * Once started, an unabortable Task always completes — abort requests are
- * ignored and `signal.aborted` remains `false`.
+ * Once started, an unabortable Task always completes. Abort requests are masked
+ * while it runs, and `signal.aborted` remains `false` inside the Task.
  *
- * If the parent {@link Run} is already disposing or settled, `run(task)`
+ * `unabortable` controls abort signal propagation; it does not force work to
+ * start. If the parent {@link Run} is already disposing or settled, `run(task)`
  * short-circuits before task execution and returns `err(AbortError)` with
  * {@link runStoppedError} as reason. So `unabortable` means “do not interrupt
  * this Task once it has started”, not “remove AbortError from its type”.
  *
- * When that pre-start abort would be a programmer error, assert it explicitly
- * with `assertNotAborted` after awaiting the result.
+ * Most callers should still propagate or ignore {@link AbortError} according to
+ * ordinary structured-concurrency ownership. When abort would violate a
+ * lifecycle invariant, await the unabortable Task and use
+ * {@link assertNotAborted} to fail fast if it could not even start.
  *
  * ### Example
  *
@@ -804,7 +811,7 @@ export const timeoutError = { type: "TimeoutError" };
  * @group Composition
  * @see {@link RetryOptions}
  */
-export const retry = (task, schedule, { retryable = lazyTrue, onRetry, } = {}) => async (run) => {
+export const retry = (task, schedule, { retryable = lazyTrue, onRetry } = {}) => async (run) => {
     const step = schedule(run.deps);
     let attempt = onePositiveInt;
     let error;
@@ -887,7 +894,7 @@ export const retry = (task, schedule, { retryable = lazyTrue, onRetry, } = {}) =
  *
  * @group Composition
  */
-export const repeat = (task, schedule, { repeatable = lazyTrue, onRepeat, } = {}) => async (run) => {
+export const repeat = (task, schedule, { repeatable = lazyTrue, onRepeat } = {}) => async (run) => {
     const step = schedule(run.deps);
     let lastResult;
     let attempt = onePositiveInt;
@@ -998,37 +1005,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 +1092,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 +1112,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 +1217,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 +1365,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);
 }
@@ -1433,7 +1449,8 @@ export const anyAbortError = { type: "AnyAbortError" };
 const collect = (type, input, { collect = true, abortReason = type === "all" ? allAbortError : allSettledAbortError, } = {}) => {
     const stopOn = type === "all" ? "error" : null;
     if (isIterable(input)) {
-        const array = arrayFrom(input);
+        const tasks = input;
+        const array = arrayFrom(tasks);
         if (!isNonEmptyArray(array))
             return () => ok(collect ? emptyArray : undefined);
         return pool(array, {
@@ -1470,7 +1487,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();
@@ -1519,8 +1536,8 @@ function pool(tasksIterable, { stopOn = null, collect, abortReason, allFailed, }
                     worker.abort(reason);
             };
             const workerCount = Math.min(run.concurrency, length);
-            const workers = arrayFrom(workerCount, () => run.daemon(worker));
-            const _ = __addDisposableResource(env_5, new DisposableStack(), false);
+            const workers = arrayFrom(workerCount, () => run.daemon(worker, run.deps));
+            const _ = __addDisposableResource(env_8, new DisposableStack(), false);
             _.defer(() => {
                 abortWorkers(abortReason);
             });
@@ -1546,12 +1563,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);
         }
     };
 }