@evolu/common 8.0.0-next.5 → 8.0.0

package/dist/src/Task.js

@@ -1,8 +1,3 @@
-/**
- * JavaScript-native structured concurrency.
- *
- * @module
- */
 var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
     if (value !== null && value !== void 0) {
         if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
@@ -55,1268 +50,2118 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
-import { arrayFrom, emptyArray, isNonEmptyArray, mapArray, } from "./Array.js";
-import { assert, assertNotDisposed } from "./Assert.js";
-import { createConsole } from "./Console.js";
-import { createRandomBytes } from "./Crypto.js";
+/**
+ * JavaScript-native structured concurrency.
+ *
+ * @module
+ */
+import { emptyArray, isNonEmptyArray, mapArray, } from "./Array.js";
+import { assert, assertNonEmptyReadonlyArray, assertNonNullable, assertNotDisposed, } from "./Assert.js";
+import { createConsole, testCreateConsole, } from "./Console.js";
+import { createRandomBytes, testCreateRandomBytes, } from "./Crypto.js";
 import { eqArrayStrict } from "./Eq.js";
-import { identity, lazyTrue, lazyVoid } from "./Function.js";
+import { constTrue, constVoid, identity } from "./Function.js";
+import { createLeakDetector, noopLeakDetector, testCreateLeakDetector, } from "./LeakDetector.js";
 import { createLookupMap } from "./Lookup.js";
-import { decrement, increment } from "./Number.js";
-import { createRecord, emptyRecord, isFunction, isIterable, mapObject, } from "./Object.js";
-import { createRandom } from "./Random.js";
+import { decrement, increment, incrementPositiveInt } from "./Number.js";
+import { emptyRecord, mapObject, objectFromEntries, objectToEntries, } from "./Object.js";
+import { none, some } from "./Option.js";
+import { isDev } from "./Platform.js";
+import { createRandom, testCreateRandom, testCreateRandomLib, } from "./Random.js";
 import { createRef } from "./Ref.js";
-import { err, getOrThrow, ok, tryAsync } from "./Result.js";
-import { addToSet, deleteFromSet, emptySet } from "./Set.js";
-import { createTime, durationToMillis, Millis } from "./Time.js";
-import { brand, createId, Id, maxPositiveInt, NonNegativeInt, object, onePositiveInt, PositiveInt, typed, union, Unknown, UnknownResult, zeroNonNegativeInt, } from "./Type.js";
-import {} from "./Types.js";
+import { err, getOk, getOrThrow, ok, } from "./Result.js";
+import { emptySet } from "./Set.js";
+import { createTime, PositiveMillis, testCreateTime, } from "./Time.js";
+import { assertType, createId, maxPositiveInt, NonNegativeInt, object, onePositiveInt, PositiveInt, record, String, typed, Unknown, UnknownResult, } from "./Type.js";
 /**
- * Error returned when a {@link Task} is aborted via
- * {@link https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}.
- *
- * This is structured-concurrency control flow, not a domain error. It plays a
- * role similar to an interrupt: in most code, propagate it unchanged or ignore
- * it when cleanup is already handled by the runtime.
- *
- * The `reason` field is `unknown` by design — use typed errors for business
- * logic. If you need to inspect the reason, use type guards like
- * `RaceLostError.is(reason)`.
+ * Typed object explaining why a {@link Run} was aborted.
  *
- * When a piece of logic must continue once started, wrap it with
- * {@link unabortable}. That prevents ordinary mid-flight interruption, but it
- * does not erase {@link AbortError} from the type because the Task can still be
- * rejected before it starts, for example on an already-stopped {@link Run}. In
- * those cases, abort usually indicates a lifecycle bug, so use
- * `assertNotAborted` if you want to fail fast.
+ * A reason has a `type` discriminant and optional structured data, so abort
+ * causes can carry typed domain data. Well-known reasons are
+ * {@link explicitAbortReason}, {@link runDisposedAbortReason}, and
+ * {@link PanicAbortReason}.
  *
- * @group Core Types
+ * @group Core
  */
-export const AbortError = /*#__PURE__*/ typed("AbortError", {
-    reason: Unknown,
-});
+export const AbortReason = /*#__PURE__*/ object({ type: String }, 
+/*#__PURE__*/ record(String, Unknown));
 /**
- * Abort mask depth for a {@link Run} or {@link Fiber}.
+ * Typed object representing structured-concurrency abort control flow.
  *
- * - `0` — abortable (default)
- * - `>= 1` — inside {@link unabortable}, abort requests are ignored
+ * AbortError is thrown to stop Task execution when a Run observes an abort
+ * request. AbortableFiber catches AbortError and returns it as a {@link Result}
+ * error, so abort can be handled as an ordinary Task outcome.
  *
- * The mask tracks nested unabortable regions. When abort is requested, the
- * signal only propagates if `mask === 0`.
+ * The reason explains why the Run was aborted. It can be an explicit abort
+ * reason, {@link runDisposedAbortReason} for normal Run cleanup, or
+ * {@link PanicAbortReason} when a defect panicked the Run tree. The original
+ * defect is available as `panicAbortReason.defect` for diagnostics.
  *
- * - {@link unabortable} increments the mask — Task becomes protected
- * - {@link unabortableMask} provides `restore` to restore the previous mask
- * - Tasks inherit their parent's mask by default
+ * AbortError is reserved for Task abort control flow. Do not throw or reject
+ * with AbortError for domain errors; return a Result error instead.
  *
- * This enables nested resource lifecycle patterns where each level can have its
- * own abortable section while outer acquisitions remain protected.
+ * Helpers that abort their own child Tasks should catch or normalize AbortError
+ * before it escapes the helper boundary. The reason carries typed domain data.
  *
- * UI/debugging tools can use this to visually distinguish protected Tasks
- * (e.g., different icon or color) and explain why abort requests are ignored.
+ * WebKit fetch rejects with its own abort error instead of `signal.reason`.
+ * Native wrappers should treat `signal.reason` as the source of truth and
+ * normalize aborts to AbortError.
  *
- * @group Abort masking
+ * @group Core
  */
-export const AbortMask = /*#__PURE__*/ brand("AbortMask", NonNegativeInt);
+export const AbortError = /*#__PURE__*/ typed("AbortError", {
+    reason: AbortReason,
+});
 /**
- * {@link RunSnapshot} state Type.
+ * Creates an {@link AbortError} from an {@link AbortReason}.
  *
- * @group Monitoring
+ * @group Core
  */
-export const RunSnapshotState = /*#__PURE__*/ union(
-/*#__PURE__*/ typed("Running"), 
-/*#__PURE__*/ typed("Disposing"), 
-/*#__PURE__*/ typed("Settled", {
-    result: UnknownResult,
-    outcome: UnknownResult,
-}));
+export const createAbortError = (reason) => ({
+    type: "AbortError",
+    reason,
+});
 /**
- * The event-specific payload of a {@link RunEvent}.
+ * Shared abort reason used for ordinary {@link Run} cleanup.
+ *
+ * Disposal requests abort so child Tasks stop while the Run waits for them to
+ * settle. This reason distinguishes that cleanup path from explicit abort and
+ * {@link PanicAbortReason}.
  *
- * @group Monitoring
+ * @group Run
  */
-export const RunEventData = /*#__PURE__*/ union(
-/*#__PURE__*/ typed("ChildAdded", { childId: Id }), 
-/*#__PURE__*/ typed("ChildRemoved", { childId: Id }), 
-/*#__PURE__*/ typed("StateChanged", { state: RunSnapshotState }));
+export const runDisposedAbortReason = {
+    type: "RunDisposedAbortReason",
+};
+const runDisposedAbortError = createAbortError(runDisposedAbortReason);
 /**
- * Events emitted by a {@link Run} for monitoring and debugging.
- *
- * Events bubble up through parent runs, enabling centralized monitoring at the
- * root. Use with {@link Run.onEvent} to track Run lifecycle.
+ * Shared abort reason used when callers explicitly request abort without a more
+ * specific reason.
  *
- * @group Monitoring
+ * @group Run
  */
-export const RunEvent = /*#__PURE__*/ object({
-    id: Id,
-    timestamp: Millis,
-    data: RunEventData,
-});
-// TODO:
-// Partial<TracerConfigDep> & // TODO:
-// Partial<TracerDep>; // TODO:
-const runDefaultDeps = {
-    console: createConsole(),
-    randomBytes: createRandomBytes(),
-    random: createRandom(),
-    time: createTime(),
+export const explicitAbortReason = {
+    type: "ExplicitAbortReason",
 };
 /**
- * Creates root {@link Run}.
- *
- * The root Run is also the daemon Run: it stays running until disposed. Child
- * Runs created by `run(task)` are disposed by their parent once they settle.
- *
- * Call once per entry point (main thread, worker, etc.) and dispose on
- * shutdown. All Tasks run as descendants of this root Run.
- *
- * This common {@link createRun} is platform-agnostic. At application entry
- * points, prefer the platform adapter when one exists. `@evolu/web` adds
- * browser `error` and `unhandledrejection` handlers, `@evolu/nodejs` adds
- * Node.js `uncaughtException`, `unhandledRejection`, and graceful shutdown
- * handling, and `@evolu/react-native` adds React Native global error handling.
- *
- * {@link RunDefaultDeps} provides default dependencies:
- *
- * - {@link Time}
- * - {@link Console}
- * - {@link Random}
- * - {@link RandomBytes}
- *
- * ### Example
- *
- * ```ts
- * // App entry point
- * await using run = createRun();
- *
- * const result = await run(fetchData);
- * ```
- *
- * ### Example with custom dependencies
+ * Shared abort reason for tests that need a non-production abort reason.
  *
- * ```ts
- * // Define dependency interfaces
- * interface Config {
- *   readonly apiUrl: string;
- * }
+ * @group Run
+ */
+export const testAbortReason = {
+    type: "TestAbortReason",
+};
+/**
+ * Shared {@link AbortError} for tests, created from {@link testAbortReason}.
  *
- * interface ConfigDep {
- *   readonly config: Config;
- * }
+ * @group Run
+ */
+export const testAbortError = /*#__PURE__*/ createAbortError(testAbortReason);
+/**
+ * Creates a {@link PanicAbortReason} from a defect.
  *
- * // Task declares its dependencies via the D type parameter
- * const fetchUser =
- *   (id: string): Task<User, FetchError, ConfigDep> =>
- *   async (run) => {
- *     const { config } = run.deps;
- *     const response = await fetch(`${config.apiUrl}/users/${id}`);
- *     // ...
- *   };
+ * @group Core
+ */
+export const createPanicAbortReason = (defect) => ({
+    type: "PanicAbortReason",
+    defect,
+});
+/**
+ * Default {@link ReportDefect} for platform-independent {@link createRun}.
  *
- * // Composition root: create a Run with custom deps
- * type AppDeps = RunDefaultDeps & ConfigDep;
+ * Throws the reported defect from a queued microtask. This is a fallback for
+ * platforms without native global error reporting. Browser adapters use the
+ * native
+ * {@link https://developer.mozilla.org/en-US/docs/Web/API/Window/reportError | reportError}
+ * API; other platform adapters can use platform-specific reporting and preserve
+ * nested panic defects as cause or detail data.
  *
- * const appDeps: AppDeps = {
- *   ...testCreateDeps(), // or spread individual deps
- *   config: { apiUrl: "https://api.example.com" },
- * };
+ * @group Run
+ */
+export const reportDefectAfterMicrotask = (defect) => {
+    queueMicrotask(() => {
+        throw defect;
+    });
+};
+/**
+ * Creates {@link RunDefaultDeps}.
  *
- * await using run = createRun(appDeps);
+ * @group Run
+ */
+export const createRunDefaultDeps = () => {
+    const console = createConsole();
+    return {
+        console,
+        leakDetector: isDev ? createLeakDetector({ console }) : noopLeakDetector,
+        nativeFetch: globalThis.fetch.bind(globalThis),
+        randomBytes: createRandomBytes(),
+        random: createRandom(),
+        reportDefect: reportDefectAfterMicrotask,
+        time: createTime(),
+    };
+};
+/**
+ * Creates a root {@link DisposableRun}.
  *
- * // Run type is inferred from the deps argument
- * const result = await run(fetchUser("123"));
+ * @group Run
+ */
+export const createRun = (deps) => createRunInternal({
+    ...createRunDefaultDeps(),
+    ...deps,
+});
+/**
+ * Creates {@link TestReportDefect}.
  *
- * // TypeScript catches missing deps at compile time:
- * // await using run2 = createRun(); // Run<RunDefaultDeps>
- * // run2(fetchUser("123")); // Error: Property 'config' is missing
- * ```
+ * @group Testing
+ */
+export const testCreateReportDefect = () => {
+    const defects = [];
+    const nextWaiters = [];
+    let nextIndex = 0;
+    const next = () => {
+        if (nextIndex < defects.length) {
+            const defect = defects[nextIndex];
+            nextIndex += 1;
+            return Promise.resolve(defect);
+        }
+        const nextDefect = Promise.withResolvers();
+        nextWaiters.push(nextDefect.resolve);
+        return nextDefect.promise;
+    };
+    const getDefects = () => [...defects];
+    const getDefectsSnapshot = () => {
+        assert(nextWaiters.length === 0, "getDefectsSnapshot must not be called while reportDefect.next() is pending");
+        const snapshot = [...defects];
+        defects.length = 0;
+        nextIndex = 0;
+        return snapshot;
+    };
+    const clearDefects = () => {
+        assert(nextWaiters.length === 0, "clearDefects must not be called while reportDefect.next() is pending");
+        defects.length = 0;
+        nextIndex = 0;
+    };
+    return Object.assign((defect) => {
+        defects.push(defect);
+        const resolveNext = nextWaiters.shift();
+        if (!resolveNext)
+            return;
+        nextIndex += 1;
+        resolveNext(defect);
+    }, { getDefects, next, getDefectsSnapshot, clearDefects });
+};
+/**
+ * Creates {@link TestRunDefaultDeps}.
  *
- * @group Creating Run
+ * @group Testing
  */
-export const createRun = (deps) => createRunInternal({ ...runDefaultDeps, ...deps });
-const createRunInternal = (deps, parent, daemon, abortBehavior, concurrencyBehavior) => {
-    const parentMask = parent?.abortMask ?? isAbortable;
-    let abortMask;
-    switch (abortBehavior) {
-        case undefined:
-            abortMask = parentMask;
-            break;
-        case "unabortable":
-            abortMask = increment(parentMask);
-            break;
-        default:
-            assert(abortBehavior <= parentMask, "restore used outside its unabortableMask");
-            abortMask = abortBehavior;
+export const testCreateDeps = (options) => {
+    const seed = options?.seed ?? "evolu";
+    const console = testCreateConsole();
+    const leakDetector = testCreateLeakDetector({ console });
+    const random = testCreateRandom(seed);
+    const randomLib = testCreateRandomLib(seed);
+    const randomBytes = testCreateRandomBytes({ randomLib });
+    const nativeFetch = () => {
+        throw new Error("Provide a nativeFetch test double");
+    };
+    const reportDefect = testCreateReportDefect();
+    const time = testCreateTime();
+    return {
+        console,
+        leakDetector,
+        nativeFetch,
+        randomBytes,
+        random,
+        randomLib,
+        reportDefect,
+        time,
+    };
+};
+export function testCreateRun(deps) {
+    return createRunInternal({
+        ...testCreateDeps(),
+        ...deps,
+    });
+}
+const globalWithScheduler = globalThis;
+const globalWithSetImmediate = globalThis;
+const taskMetaSymbol = Symbol("evolu.Task.meta");
+const abortableMask = 0;
+const runningRunState = { type: "Running" };
+const createRunInternal = (deps, parent, rootRun, taskMeta) => {
+    const abortBehavior = taskMeta?.abortBehavior;
+    if (abortBehavior !== undefined && abortBehavior !== "unabortable") {
+        assert(parent?.restoreTokens.has(abortBehavior.restoreToken) === true, "restore is only valid inside the unabortableMask that created it");
     }
+    // Plain Tasks inherit the parent's mask. `unabortable` increments at start
+    // time because its concrete mask is relative to that parent. `restore` is
+    // validated by its token above, then uses its captured concrete mask.
+    const parentAbortMask = parent?.abortMask ?? abortableMask;
+    const abortMask = abortBehavior === undefined
+        ? parentAbortMask
+        : abortBehavior === "unabortable"
+            ? increment(parentAbortMask)
+            : abortBehavior.abortMask;
+    let state = runningRunState;
+    let exit;
+    let snapshot;
+    // Keyed by the child Run for snapshot() and removal; the value is the done
+    // promise disposal waits on.
+    const children = new Map();
+    // Invariant: requestController records every abort request immediately;
+    // signalController only exposes an abort when this Run's mask allows it.
+    // Code that must reject new work after shutdown reads requestAbortSignal.
     const requestController = new AbortController();
     const signalController = new AbortController();
-    let state = running;
-    let result;
-    let outcome;
-    let children = emptySet;
-    const requestAbort = (abortError) => {
-        if (abortMask === isAbortable)
-            signalController.abort(abortError);
-        requestController.abort(abortError);
+    let disposePromise;
+    let finalizers;
+    let finalizerAbortError;
+    const reportDefect = (reported) => {
+        try {
+            deps.reportDefect(reported);
+        }
+        catch (reporterDefect) {
+            reportDefectAfterMicrotask(new AggregateError([reported, reporterDefect], "ReportDefect failed while reporting a defect"));
+        }
     };
-    if (parent) {
-        subscribeToAbort(parent.requestSignal, () => requestAbort(parent.requestSignal.reason), { signal: requestController.signal });
-    }
     const emitEvent = (data) => {
-        if (!deps.runConfig?.eventsEnabled.get())
+        // Run events are observability-only. Handler and event-construction defects
+        // are reported, but must not panic the Run or interrupt Task settlement.
+        try {
+            if (!deps.runConfig?.eventsEnabled.get())
+                return;
+            const event = {
+                id: run.id,
+                timestamp: root.deps.time.now(),
+                data,
+            };
+            for (let node = run; node; node = node.parent) {
+                try {
+                    node.onEvent?.(event);
+                }
+                catch (error) {
+                    reportDefect(error);
+                }
+            }
+        }
+        catch (error) {
+            reportDefect(error);
+        }
+    };
+    // Reads abort reasons from the Run-owned controllers, which are only
+    // aborted with AbortError.
+    const currentAbort = () => ({
+        request: requestController.signal.reason.reason,
+        observed: signalController.signal.aborted
+            ? signalController.signal.reason.reason
+            : null,
+    });
+    const commitState = (nextState) => {
+        state = nextState;
+        emitEvent({ type: "StateChanged", state });
+    };
+    const requestAbort = (reason = explicitAbortReason) => {
+        if (requestController.signal.aborted)
             return;
-        const e = { id: self.id, timestamp: deps.time.now(), data };
-        for (let node = self; node; node = node.parent) {
-            node.onEvent?.(e);
+        const abortError = createAbortError(reason);
+        requestController.abort(abortError);
+        if (abortMask === abortableMask)
+            signalController.abort(abortError);
+        commitState({ type: "Aborted", abort: currentAbort() });
+    };
+    // The first provided exit claims the Run exit; later exits are ignored. A
+    // Run disposed without an exit stays claimable (e.g. by a panic during
+    // disposal) until children settle, then the exit defaults to ok(ok()) —
+    // root and Run.create Runs have no parent Task to supply one, and a settled
+    // Run must record an exit. A panic that claims the exit during disposal is
+    // not reflected in the already-aborted controllers, so RunStateSettled.abort
+    // can keep runDisposedAbortReason while exit records the panic.
+    const dispose = (nextExit) => {
+        exit ??= nextExit;
+        if (disposePromise)
+            return disposePromise;
+        const settle = () => {
+            exit ??= ok(ok());
+            commitState({ type: "Settled", abort: currentAbort(), exit });
+            return exit;
+        };
+        const finalizersToDispose = finalizers;
+        if (finalizersToDispose) {
+            disposePromise = Promise.all(children.values()).then(async () => {
+                try {
+                    await finalizersToDispose.disposeAsync();
+                }
+                catch (error) {
+                    finalizerAbortError = root.panic(error);
+                    exit ??= err(finalizerAbortError);
+                }
+                return settle();
+            });
+        }
+        else {
+            disposePromise = Promise.all(children.values()).then(settle);
         }
+        const abortError = exit?.ok === false ? exit.error : runDisposedAbortError;
+        const { aborted } = signalController.signal;
+        requestController.abort(abortError);
+        signalController.abort(abortError);
+        if (!aborted)
+            commitState({ type: "Aborted", abort: currentAbort() });
+        return disposePromise;
     };
-    const run = (task, taskDeps) => {
-        const childRun = createRunInternal(taskDeps === undefined
-            ? deps
-            : {
+    // Custom deps replace parent custom deps, so defaults must be picked from
+    // the merged deps by key. `satisfies RunDefaultDeps` fails to compile when
+    // a newly added required default dep is missing here; optional ones like
+    // runConfig must be added manually.
+    const createChildDeps = (taskDeps) => taskDeps === undefined
+        ? deps
+        : {
+            ...{
                 console: deps.console,
+                leakDetector: deps.leakDetector,
+                nativeFetch: deps.nativeFetch,
                 randomBytes: deps.randomBytes,
                 random: deps.random,
+                reportDefect: deps.reportDefect,
                 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) {
-            const abortError = signalController.signal.reason;
-            childRun.requestAbort(abortError);
-            task = () => err(abortError);
-        }
-        const childFiber = Object.assign(Promise.try(task, childRun)
-            .then(childRun.handleTaskFulfilled)
-            .finally(childRun.handleTaskSettled)
-            .finally(childRun[Symbol.asyncDispose])
-            .finally(() => {
-            children = deleteFromSet(children, childFiber);
-            emitEvent({ type: "ChildRemoved", childId: childRun.id });
-        }), {
-            run: childRun,
-            abort: (reason) => {
-                childRun.requestAbort(createAbortError(reason));
-            },
-            getState: () => childRun.getState(),
-            [Symbol.dispose]: () => {
-                childFiber.abort();
+                ...(deps.runConfig && { runConfig: deps.runConfig }),
             },
-        });
-        children = addToSet(children, childFiber);
-        emitEvent({ type: "ChildAdded", childId: childRun.id });
-        return childFiber;
-    };
-    let snapshot = null;
-    let disposingPromise = null;
-    const self = run;
-    {
-        const run = self;
-        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;
-        run.abortMask = abortMask;
-        run.onAbort = (callback) => {
-            if (abortMask !== isAbortable)
-                return;
-            subscribeToAbort(signalController.signal, () => callback(signalController.signal.reason.reason), { once: true, signal: requestController.signal });
-        };
-        run.getState = () => state;
-        run.getChildren = () => children;
-        run.snapshot = () => {
-            const childSnapshots = Array.from(children).map((fiber) => fiber.run.snapshot());
-            if (snapshot?.state !== state ||
-                !eqArrayStrict(snapshot.children, childSnapshots)) {
-                snapshot = {
-                    id,
-                    state,
-                    children: childSnapshots,
-                    abortMask,
-                };
-            }
-            return snapshot;
+            ...taskDeps,
         };
-        run.onEvent = undefined;
-        run.daemon = daemon ?? self;
-        run.create = (runDeps = deps) => {
-            const task = createDeferred().task;
-            return run.daemon(task, runDeps).run;
+    const run = ((task, taskDeps, { abortable = false } = {}) => {
+        assertNotDisposed({ disposed: !!disposePromise });
+        const taskMeta = task[taskMetaSymbol];
+        const taskRun = createRunInternal(createChildDeps(taskDeps), run, root, taskMeta);
+        // Disposal uses a separate promise because the Fiber starts immediately and
+        // gets its rejection handler only after the Task stack is captured.
+        const done = Promise.withResolvers();
+        children.set(taskRun, done.promise);
+        emitEvent({ type: "ChildAdded", childId: taskRun.id });
+        // Wired before the Task starts so an already-aborted parent prevents the
+        // start via startSignal.throwIfAborted below.
+        const abortFromParent = () => {
+            taskRun.requestAbort(run.requestAbortSignal.reason.reason);
         };
-        run.deps = deps;
-        run.concurrency =
-            concurrencyBehavior ?? parent?.concurrency ?? defaultConcurrency;
-        run[Symbol.asyncDispose] = () => {
-            if (disposingPromise)
-                return disposingPromise;
-            state = { type: "Disposing" };
-            emitEvent({ type: "StateChanged", state });
-            requestAbort(runStoppedAbortError);
-            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.
-                 */
-                [result, outcome] = [result ?? ok(), outcome ?? ok()];
-                state = { type: "Settled", result, outcome };
-                emitEvent({ type: "StateChanged", state });
+        if (run.requestAbortSignal.aborted)
+            abortFromParent();
+        else {
+            run.requestAbortSignal.addEventListener("abort", abortFromParent, {
+                once: true,
+                signal: taskRun.requestAbortSignal,
             });
-            return disposingPromise;
+        }
+        // The Fiber is runTask's native async-function promise. Keep runTask named:
+        // async stack traces use it as the visible Run boundary frame.
+        const runTask = async () => {
+            let exit;
+            try {
+                const startSignal = taskMeta?.abortBehavior === "unabortable"
+                    ? taskRun.requestAbortSignal
+                    : taskRun.signal;
+                const scheduler = globalWithScheduler.scheduler;
+                let result;
+                if (taskMeta?.priority && scheduler?.postTask) {
+                    result = await scheduler.postTask(() => {
+                        startSignal.throwIfAborted();
+                        // eslint-disable-next-line evolu/no-direct-task-call -- The executor invokes the Task with its child Run.
+                        return task(taskRun);
+                    }, {
+                        priority: taskMeta.priority,
+                        signal: startSignal,
+                    });
+                }
+                else {
+                    startSignal.throwIfAborted();
+                    // eslint-disable-next-line evolu/no-direct-task-call -- The executor invokes the Task with its child Run.
+                    result = await task(taskRun);
+                }
+                // Full Result validation is dev-only; production checks only the
+                // boolean `ok` discriminant. This catches common malformed returns
+                // without full validation cost.
+                assert(isDev
+                    ? UnknownResult.is(result)
+                    : typeof result
+                        ?.ok === "boolean", "Task must return Result.");
+                exit = ok(result);
+            }
+            catch (error) {
+                exit = err(AbortError.is(error) ? error : root.panic(error));
+            }
+            // Internal Child Run disposal cannot reject; finalizer defects become Err
+            // exits. Plain Task Runs settle from the Task exit; only a DisposableRun
+            // from Run.create can record an earlier exit.
+            const taskExit = await taskRun.dispose(exit);
+            // The child is removed once its Run has disposed. Parent bookkeeping
+            // tracks internal lifetime, not Fiber observers.
+            children.delete(taskRun);
+            emitEvent({ type: "ChildRemoved", childId: taskRun.id });
+            done.resolve();
+            if (taskExit.ok)
+                return taskExit.value;
+            if (abortable)
+                return err(taskExit.error);
+            // Invariant: the Run tree is every Fiber's final handler: defects are
+            // reported, aborts are control flow, and forgotten Fibers are a lint
+            // concern. Attach this late so V8 captures the defect stack before any
+            // catch observes the Fiber.
+            void fiber.catch(constVoid);
+            // eslint-disable-next-line @typescript-eslint/only-throw-error -- AbortError is Task abort control flow; aborts intentionally carry no stack.
+            throw taskExit.error;
         };
-        // Internal
-        run.ownTaskSettled = parent ? Promise.withResolvers() : null;
-        run.requestAbort = requestAbort;
-        run.requestSignal = requestController.signal;
-        run.handleTaskFulfilled = (taskOutcome) => {
-            const taskResult = self.signal.aborted
-                ? err(self.signal.reason)
-                : taskOutcome;
-            result = taskResult;
-            outcome = taskOutcome;
-            return taskResult;
+        const fiber = runTask();
+        fiber.run = taskRun;
+        if (abortable) {
+            const abortableFiber = fiber;
+            abortableFiber.abort = taskRun.requestAbort;
+            abortableFiber[Symbol.asyncDispose] = async () => {
+                abortableFiber.abort();
+                await abortableFiber;
+            };
+        }
+        return fiber;
+    });
+    const root = rootRun ?? run;
+    /* eslint-disable @typescript-eslint/no-unsafe-return -- Internal overload assignments implement public generics via TaskInternal. */
+    run.orThrow = (async (task, taskDeps) => getOrThrow(await run(task, taskDeps)));
+    run.ok = (async (task, taskDeps) => getOk((await run(task, taskDeps))));
+    /* eslint-enable @typescript-eslint/no-unsafe-return */
+    run.abortable = ((task, deps) => run(task, deps, { abortable: true }));
+    run.daemon = ((task, taskDeps) => {
+        assertNotDisposed({ disposed: !!disposePromise });
+        // Invariant: daemons detach to the root lifetime, so they must never start
+        // after this Run records abort, even if a mask hides it from run.signal.
+        run.requestAbortSignal.throwIfAborted();
+        return root.abortable(task, createChildDeps(taskDeps));
+    });
+    run.create = ((runDeps) => run.daemon(async (run) => {
+        await run.abortable(waitForAbort);
+        return ok();
+    }, runDeps).run);
+    run.id = createId(deps);
+    run.parent = parent ?? null;
+    run.deps = deps;
+    run.signal = signalController.signal;
+    run.requestAbortSignal = requestController.signal;
+    run.onAbort = (callback) => {
+        const onAbort = () => {
+            try {
+                callback(run.signal.reason);
+            }
+            catch (error) {
+                // Abort callbacks run outside a Fiber result channel.
+                root.panic(error);
+            }
         };
-        run.handleTaskSettled = () => {
-            self.ownTaskSettled?.resolve();
+        if (run.signal.aborted) {
+            onAbort();
+            return null;
+        }
+        // A user listener on run.signal calling stopImmediatePropagation could
+        // suppress this listener (see the run.signal JSDoc). Switch to
+        // addAbortCallback if/when https://github.com/whatwg/dom/pull/1425 lands
+        // (free structural fix); use a private signal exposed via AbortSignal.any
+        // only if a real-world report ever surfaces (per-Run cost).
+        run.signal.addEventListener("abort", onAbort, { once: true });
+        return {
+            [Symbol.dispose]: () => {
+                run.signal.removeEventListener("abort", onAbort);
+            },
         };
+    };
+    run.getState = () => state;
+    run.snapshot = () => {
+        const childSnapshots = Array.from(children.keys(), (childRun) => childRun.snapshot());
+        if (snapshot?.state !== state ||
+            !eqArrayStrict(snapshot.children, childSnapshots)) {
+            snapshot = {
+                id: run.id,
+                state,
+                children: childSnapshots,
+                abortMask,
+            };
+        }
+        return snapshot;
+    };
+    run.onEvent = undefined;
+    run.defer = (finalizer) => {
+        assertNotDisposed({ disposed: !!disposePromise });
+        (finalizers ??= new AsyncDisposableStack()).defer(finalizer);
+    };
+    run.abort = (reason = explicitAbortReason) => {
+        // Unlike panic, abort cannot claim the exit after disposal starts.
+        if (disposePromise)
+            return;
+        void dispose(err(createAbortError(reason)));
+    };
+    run.panic = (defect) => {
+        const abortError = createAbortError(createPanicAbortReason(defect));
+        reportDefect(abortError);
+        // Internal disposal waits for Run children and does not reject. The first
+        // disposal wins, so a later panic does not replace the root Run exit.
+        void root.dispose(err(abortError));
+        return abortError;
+    };
+    run[Symbol.dispose] = () => {
+        void dispose();
+    };
+    run[Symbol.asyncDispose] = async () => {
+        await dispose();
+        // eslint-disable-next-line @typescript-eslint/only-throw-error -- AbortError is Task abort control flow; rethrowing it avoids reporting the finalizer defect twice in Task code.
+        if (finalizerAbortError)
+            throw finalizerAbortError;
+    };
+    // Internal
+    run.abortMask = abortMask;
+    run.restoreTokens = parent?.restoreTokens ?? emptySet;
+    run.requestAbort = requestAbort;
+    run.dispose = dispose;
+    return run;
+};
+const withTaskMeta = (meta) => (task) => {
+    const taskInternal = task;
+    assert(meta.abortBehavior === undefined ||
+        taskInternal[taskMetaSymbol]?.abortBehavior === undefined, "abort behavior helpers cannot wrap the same Task");
+    // eslint-disable-next-line evolu/no-direct-task-call -- Preserve the wrapped Task's child Run.
+    const wrapped = (run) => task(run);
+    const taskMeta = taskInternal[taskMetaSymbol];
+    wrapped[taskMetaSymbol] = taskMeta ? { ...taskMeta, ...meta } : meta;
+    return wrapped;
+};
+export function all(input, fnOrOptions, options) {
+    const fn = typeof fnOrOptions === "function" ? fnOrOptions : undefined;
+    const collectionOptions = typeof fnOrOptions === "function" ? options : fnOrOptions;
+    const collectValues = collectionOptions === undefined ||
+        !("collect" in collectionOptions) ||
+        collectionOptions.collect !== false;
+    return collect("all", fn ? mapInput(input, fn) : input, collectionOptions, collectValues);
+}
+export function allSettled(input, fnOrOptions, options) {
+    const fn = typeof fnOrOptions === "function" ? fnOrOptions : undefined;
+    return collect("allSettled", fn ? mapInput(input, fn) : input, typeof fnOrOptions === "function" ? options : fnOrOptions);
+}
+const collect = (type, input, options, collectValues = true) => async (run) => {
+    let tasks;
+    let getValue;
+    if (Array.isArray(input)) {
+        if (!isNonEmptyArray(input)) {
+            return collectValues ? ok(emptyArray) : ok();
+        }
+        tasks = input;
+        getValue = identity;
+    }
+    else {
+        const entries = objectToEntries(input);
+        if (!isNonEmptyArray(entries)) {
+            return collectValues ? ok(emptyRecord) : ok();
+        }
+        tasks = mapArray(entries, ([, task]) => task);
+        getValue = (values) => objectFromEntries(entries.map(([key], index) => [key, values[index]]));
     }
-    return self;
+    const values = collectValues ? [] : undefined;
+    let firstErr;
+    await run(each(tasks, (result, index) => {
+        if (type === "allSettled") {
+            values[index] = result;
+            return "continue";
+        }
+        if (!result.ok) {
+            firstErr = result;
+            return "stop";
+        }
+        if (values)
+            values[index] = result.value;
+        return "continue";
+    }, options));
+    return firstErr ?? (values ? ok(getValue(values)) : ok());
 };
-const running = { type: "Running" };
+const mapInput = (input, fn) => Array.isArray(input)
+    ? mapArray(input, (value, index) => fn(value, index))
+    : mapObject(input, fn);
 /**
- * Abort reason indicating a {@link Run} can no longer start new Tasks.
+ * Creates a {@link Task} from a callback-based API.
+ *
+ * Use this to wrap callback-style APIs such as event listeners and Node.js
+ * callbacks. Resolve with `ok(value)` or `err(error)`, or reject with a defect,
+ * to complete the Task. Settlement is one-shot: the first `resolve` or `reject`
+ * wins, and later settlement calls are ignored, matching Promise semantics.
+ * When `reject` wins settlement, the defect panics the Run tree and is observed
+ * at Fiber boundaries as {@link AbortError} with {@link PanicAbortReason}.
+ * Rejecting AbortError is reserved for Task abort control flow: direct
+ * `run(task)` rejects with it, and `run.abortable(task)` returns it as an Err.
+ *
+ * This helper is a callback bridge. If `reject` forwards an Error created in a
+ * separate async chain, V8 cannot reconstruct the caller's zero-cost async
+ * stack through this bridge. Prefer native promise APIs and `await` when the
+ * wrapped operation already has a promise-shaped API.
+ *
+ * One-shot settlement applies only to `resolve` and `reject`. A synchronous
+ * throw from the setup function is a defect that panics the Run tree even after
+ * `resolve` was called — setup throws are bugs and must not be masked by an
+ * earlier resolution.
+ *
+ * Optionally return a synchronous cleanup callback. It runs when the Task Run
+ * signal aborts, including normal completion and explicit abort. The callback
+ * must not throw. Cleanup defects panic the root Run; if the callback Task
+ * already settled, its Fiber keeps the original Result while the root still
+ * reports the panic. Cleanup must be synchronous; returned promises are not
+ * awaited. For async cleanup, prefer {@link acquireUseRelease}, `await using`
+ * with {@link AsyncDisposableStack}, or a Task that owns the resource
+ * explicitly.
+ *
+ * If setup can throw after acquiring any resource, use a local
+ * {@link DisposableStack} before returning cleanup. Register each cleanup as
+ * soon as the resource is acquired, then move the disposer and return a cleanup
+ * callback. If setup throws before cleanup is returned, the local `using`
+ * disposal releases already-acquired resources.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { callback, createRun, ok, type Task } from "@evolu/common";
+ *
+ * const listeners = new Set<(message: string) => void>();
+ * const subscribe = (
+ *   listener: (message: string) => void,
+ * ): (() => void) => {
+ *   listeners.add(listener);
+ *   return () => listeners.delete(listener);
+ * };
+ * const nextMessage: Task<string> = callback(({ resolve }) =>
+ *   subscribe((message) => resolve(ok(message))),
+ * );
  *
- * Covers both disposing and settled Runs.
+ * await using run = createRun();
+ * const fiber = run(nextMessage);
+ * expect(listeners.size).toBe(1);
+ * for (const listener of listeners) listener("ready");
+ * expectOk(await fiber, "ready");
+ * // The callback cleanup unsubscribes after settlement.
+ * expect(listeners.size).toBe(0);
+ * ```
  *
- * @group Creating Run
+ * @group Interop
  */
-export const RunStoppedError = /*#__PURE__*/ typed("RunStoppedError");
+export const callback = (fn) => (run) => {
+    const { promise, resolve, reject } = Promise.withResolvers();
+    const cleanup = fn({ run, resolve, reject });
+    // The Task Run aborts during disposal, so this also runs callback cleanup
+    // after normal settlement. The abort listener is once-only.
+    run.onAbort((abortError) => {
+        reject(abortError);
+        cleanup?.();
+    });
+    return promise;
+};
 /**
- * Shared {@link RunStoppedError} instance used as the default
- * {@link AbortError.reason} when a Task is started on a non-running {@link Run}.
+ * Pauses execution for a specified {@link PositiveDuration}.
+ *
+ * Aborting the Task clears the scheduled timeout.
  *
- * @group Creating Run
+ * @group Timing
  */
-export const runStoppedError = {
-    type: "RunStoppedError",
-};
-const createAbortError = (reason) => ({
-    type: "AbortError",
-    reason,
-});
-const subscribeToAbort = (signal, handler, options) => {
-    if (signal.aborted)
-        handler();
-    else
-        signal.addEventListener("abort", handler, options);
-};
-const runStoppedAbortError = createAbortError(runStoppedError);
-const isAbortable = AbortMask.orThrow(0);
-const abortBehaviorSymbol = Symbol("evolu.Task.abortBehavior");
-const getAbortBehavior = (task) => task[abortBehaviorSymbol];
-const abortBehavior = (behavior) => (task) => Object.assign((run) => run(task), {
-    [abortBehaviorSymbol]: behavior,
+export const sleep = (duration) => callback(({ run: { deps }, resolve }) => {
+    const id = deps.time.setTimeout(() => resolve(ok()), duration);
+    return () => deps.time.clearTimeout(id);
 });
 /**
- * Makes a {@link Task} unabortable.
+ * Typed error returned by {@link timeout} when a Task exceeds its duration.
  *
- * Once started, an unabortable Task always completes. Abort requests are masked
- * while it runs, and `signal.aborted` remains `false` inside the Task.
+ * @group Timing
+ */
+export const TimeoutError = 
+/*#__PURE__*/ typed("TimeoutError");
+/**
+ * The {@link TimeoutError} instance returned by {@link timeout}.
  *
- * `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”.
+ * @group Timing
+ */
+export const timeoutError = { type: "TimeoutError" };
+/**
+ * Limits how long a {@link Task} may run.
  *
- * 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.
+ * Returns the Task {@link Result} when it settles within the duration.
+ * Otherwise, the Task is aborted and {@link TimeoutError} is returned. A Task
+ * that doesn't observe abort delays the TimeoutError until it settles; when
+ * that wait is unacceptable, wrap the Task with {@link daemon}:
+ * `timeout(daemon(task), duration)`.
  *
  * ### Example
  *
  * ```ts
+ * import {
+ *   createRun,
+ *   timeout,
+ *   timeoutError,
+ *   waitForAbort,
+ *   type Result,
+ *   type TimeoutError,
+ * } from "@evolu/common";
+ *
  * await using run = createRun();
  *
- * const events: Array<string> = [];
- * const canComplete = Promise.withResolvers<void>();
- * let signalAbortedInAnalytics = true;
- *
- * // Simulate async analytics API (abortable by default)
- * const sendToAnalytics =
- *   (event: number): Task<void, never> =>
- *   async ({ signal }) => {
- *     await canComplete.promise;
- *     signalAbortedInAnalytics = signal.aborted;
- *     events.push(`sent ${event}`);
- *     return ok();
- *   };
+ * const result = await run(timeout(waitForAbort, "1ms"));
+ * expectTypeOf(result).toEqualTypeOf<Result<never, TimeoutError>>();
+ * expectErr(result, timeoutError);
+ * ```
  *
- * // Important events must be sent even if the user navigates away
- * const trackImportantEvent = (event: number) =>
- *   unabortable(sendToAnalytics(event));
+ * @group Timing
+ */
+export const timeout = (task, duration) => race([
+    task,
+    async (run) => {
+        await run.ok(sleep(duration));
+        return err(timeoutError);
+    },
+]);
+/**
+ * Retries a Task according to a {@link Schedule}.
  *
- * // User clicks, we start tracking (Task runs until first await)
- * const fiber = run(trackImportantEvent(123));
+ * Use `retry` for failure recovery: it repeats after {@link Err} and wraps the
+ * final domain error. Use {@link repeat} for success-driven loops: it repeats
+ * after {@link Ok} and returns the Task's natural Result.
  *
- * // User navigates away (abort requested while task is running)
- * fiber.abort();
- * canComplete.resolve();
+ * {@link AbortError} passes through unchanged when returned as a Result error,
+ * such as from {@link daemon}. Abort from `run(task)` remains Fiber control
+ * flow. Other errors are domain errors: retrying continues while the schedule
+ * yields another delay and {@link RetryOptions.shouldRetry} returns `true`. When
+ * retrying stops, `retry` returns {@link RetryError} with the final domain error
+ * as `lastError`.
  *
- * const result = await fiber;
+ * AbortError recognition is structural. Domain errors, especially values parsed
+ * from untrusted input, must not use the reserved AbortError shape.
  *
- * expect(signalAbortedInAnalytics).toBe(false);
- * // Analytics was sent despite abort
- * expect(events).toEqual(["sent 123"]);
- * expect(result).toEqual(ok());
- * ```
+ * ### Example
  *
- * @group Abort masking
- */
-// TODO: Clear AbortError from unabortable task results.
-export const unabortable = /*#__PURE__*/ abortBehavior("unabortable");
-/**
- * Like {@link unabortable}, but provides `restore` to restore abortability for
- * specific tasks.
+ * ```ts
+ * import {
+ *   createRun,
+ *   err,
+ *   recurs,
+ *   retry,
+ *   type Result,
+ *   type RetryTaskError,
+ *   type Task,
+ * } from "@evolu/common";
  *
- * Tasks inherit abort masking from their parent. This means:
+ * await using run = createRun();
  *
- * - Tasks run inside `unabortableMask` are unabortable by default
- * - Tasks wrapped with `restore()` restore the previous abortability
+ * interface FetchDataError {
+ *   readonly type: "FetchDataError";
+ * }
  *
- * @group Abort masking
- */
-export const unabortableMask = (fn) => unabortable((run) => fn(abortBehavior(AbortMask.orThrow(decrement(run.abortMask))))(run));
-const defaultConcurrency = 1;
-const concurrencyBehaviorSymbol = Symbol("evolu.Task.concurrencyBehavior");
-const getConcurrencyBehavior = (task) => task[concurrencyBehaviorSymbol];
-export function concurrently(concurrencyOrTask, taskOrFallback) {
-    const isTask = isFunction(concurrencyOrTask);
-    const task = isTask ? concurrencyOrTask : taskOrFallback;
-    return Object.assign((run) => run(task), {
-        [concurrencyBehaviorSymbol]: isTask ? maxPositiveInt : concurrencyOrTask,
-    });
-}
-/**
- * Yields execution to allow other work to proceed.
+ * const fetchData: Task<string, FetchDataError> = () =>
+ *   err({ type: "FetchDataError" });
  *
- * Long-running JavaScript blocks the main thread. In browsers, this makes the
- * UI unresponsive (user interactions, animations). In Node.js, it prevents I/O
- * callbacks, timers, and other requests from being handled. Inserting yield
- * points lets the runtime process high-priority work between chunks of code.
+ * const fetchWithRetry = retry(fetchData, recurs(2));
  *
- * Uses `scheduler.yield()` in browsers for optimal main thread scheduling,
- * falls back to `setImmediate` in Node.js, or `setTimeout` elsewhere.
+ * const result = await run(fetchWithRetry);
+ * expectTypeOf(result).toEqualTypeOf<
+ *   Result<string, RetryTaskError<FetchDataError>>
+ * >();
+ * expectErr(result, {
+ *   type: "RetryError",
+ *   attempts: 3,
+ *   lastError: { type: "FetchDataError" },
+ * });
+ * ```
  *
  * ### Example
  *
  * ```ts
- * const processLargeArray: Task<void, never> = async (run) => {
- *   const { time } = run.deps;
- *   let lastYield = time.now();
- *
- *   for (const item of largeArray) {
- *     processItem(item);
- *
- *     // Yield periodically to keep UI responsive
- *     if (time.now() - lastYield > msLongTask) {
- *       const r = await run(yieldNow);
- *       if (!r.ok) return r;
- *       lastYield = time.now();
- *     }
- *   }
- *
- *   return ok();
- * };
- * ```
+ * import { createRun, err, recurs, retry, type Task } from "@evolu/common";
  *
- * Recursive tasks also benefit from periodic yields — without them, deep
- * recursion overflows the call stack:
+ * interface FetchDataError {
+ *   readonly type: "RecoverableError" | "FatalError";
+ * }
  *
- * ```ts
- * const processRecursive =
- *   (count: number, index: number, sum: number): Task<number> =>
- *   async (run) => {
- *     if (index >= count) return ok(sum);
+ * const fetchData: Task<string, FetchDataError> = () =>
+ *   err({ type: "FatalError" });
  *
- *     // Yield periodically to break synchronous call chains.
- *     if (index > 0 && index % 1000 === 0) {
- *       const y = await run(yieldNow);
- *       if (!y.ok) return y;
- *     }
+ * const fetchWithRetry = retry(fetchData, recurs(5), {
+ *   shouldRetry: (error) => error.type !== "FatalError",
+ * });
  *
- *     // Direct tail-call: no fiber overhead, stack-safe thanks to yieldNow.
- *     return await processRecursive(count, index + 1, sum + index)(run);
- *   };
+ * await using run = createRun();
+ * expectErr(await run(fetchWithRetry), {
+ *   type: "RetryError",
+ *   attempts: 1,
+ *   lastError: { type: "FatalError" },
+ * });
  * ```
  *
- * @group Composition
- * @see https://developer.mozilla.org/en-US/docs/Web/API/Scheduler/yield
- * @see https://web.dev/articles/optimize-long-tasks
+ * @group Resilience
  */
-export const yieldNow = () => tryAsync(() => yieldImpl(), // TODO: yieldImpl(run.signal)
-(reason) => createAbortError(reason));
-const scheduler = globalThis.scheduler;
-const yieldImpl = typeof scheduler?.yield === "function"
-    ? () => scheduler.yield()
-    : typeof setImmediate !== "undefined"
-        ? () => new Promise((resolve) => setImmediate(resolve))
-        : () => new Promise((r) => setTimeout(r, 0)); // Safari
+export const retry = (task, schedule, { shouldRetry = constTrue, onRetry, } = {}) => async (run) => {
+    const step = schedule(run.deps);
+    let attempt = onePositiveInt;
+    const createRetryError = (lastError) => ({
+        type: "RetryError",
+        lastError,
+        attempts: attempt,
+    });
+    for (;;) {
+        const result = await run(task);
+        if (result.ok)
+            return result;
+        if (AbortError.is(result.error))
+            return result;
+        const error = result.error;
+        if (!shouldRetry(error))
+            return err(createRetryError(error));
+        const next = step(error);
+        if (!next.ok)
+            return err(createRetryError(error));
+        const [output, delay] = next.value;
+        onRetry?.({ error, attempt, output, delay });
+        attempt = incrementPositiveInt(attempt);
+        if (delay > 0)
+            await run.ok(sleep(PositiveMillis.orThrow(delay)));
+    }
+};
 /**
- * Creates a {@link Task} from a callback-based API.
+ * Repeats a Task according to a {@link Schedule}.
  *
- * Use this to wrap callback-style APIs (event listeners, Node.js callbacks,
- * etc.) into Tasks with proper abort handling.
+ * Runs the Task once, then repeats while the Task returns {@link Ok}, the
+ * schedule yields another delay, and {@link RepeatOptions.shouldRepeat} returns
+ * `true`. When repeating stops, `repeat` returns the last successful Result. If
+ * the Task returns {@link Err}, including {@link Done} from a {@link NextTask},
+ * `repeat` returns that error without scheduling another attempt.
  *
- * Optionally return a teardown function that runs on abort.
+ * Use `repeat` for success-driven loops such as polling or consuming a
+ * NextTask: it repeats after Ok and returns the Task's natural Result. Use
+ * {@link retry} for failure recovery: it repeats after Err and wraps the final
+ * domain error in {@link RetryError}.
  *
- * This helper can also wrap promise APIs that do not observe `AbortSignal`.
- * Start the promise work inside the callback, and aborting the Task stops
- * waiting for it immediately.
+ * With `take(n)`, the Task runs n+1 times: the initial attempt plus n repeats.
  *
  * ### Example
  *
  * ```ts
- * // The sleep helper is implemented using callback:
- * const sleep = (duration: Duration): Task<void> =>
- *   callback(({ ok, deps: { time } }) => {
- *     const id = time.setTimeout(ok, durationToMillis(duration));
- *     return () => time.clearTimeout(id);
- *   });
+ * import { createRun, ok, recurs, repeat, type Task } from "@evolu/common";
  *
- * // Wrap an event listener — use signal directly
- * const waitForClick = (element: HTMLElement): Task<MouseEvent> =>
- *   callback(({ ok, signal }) => {
- *     element.addEventListener("click", ok, { once: true, signal });
- *   });
+ * let attempts = 0;
+ * const checkStatus: Task<string> = () => {
+ *   attempts += 1;
+ *   return ok("pending");
+ * };
  *
- * // Wrap Node.js callback API
- * const readFile = (path: string): Task<string, NodeJS.ErrnoException> =>
- *   callback(({ ok, err }) => {
- *     fs.readFile(path, "utf8", (error, data) => {
- *       if (error) err(error);
- *       else ok(data);
- *     });
- *   });
+ * const poll = repeat(checkStatus, recurs(3));
  *
- * // Wrap a non-cooperating promise API. Aborting the Task stops waiting even
- * // if promiseApi itself ignores AbortSignal.
- * const fromPromiseApi = (): Task<string> =>
- *   callback(({ ok, err }) => {
- *     void promiseApi().then(ok, err);
- *   });
+ * await using run = createRun();
+ * expectOk(await run(poll), "pending");
+ * expect(attempts).toBe(4);
  * ```
  *
- * @group Composition
- */
-export const callback = (callback) => (run) => new Promise((resolve) => {
-    const teardown = callback({
-        ok: (value) => resolve(ok(value)),
-        err: (error) => resolve(err(error)),
-        signal: run.signal,
-        deps: run.deps,
-    });
-    run.onAbort((reason) => {
-        if (teardown)
-            teardown();
-        resolve(err(createAbortError(reason)));
-    });
-});
-/**
- * Pauses execution for a specified duration.
- *
  * ### Example
  *
  * ```ts
- * const task: Task<void> = async (run) => {
- *   console.log("Starting...");
- *   await run(sleep("1s"));
- *   console.log("Done after 1 second");
- *   return ok();
- * };
- * ```
+ * import {
+ *   createRun,
+ *   done,
+ *   err,
+ *   ok,
+ *   repeat,
+ *   spaced,
+ *   type NextTask,
+ * } from "@evolu/common";
  *
- * @group Composition
- */
-export const sleep = (duration) => callback(({ ok, deps: { time } }) => {
-    const id = time.setTimeout(ok, durationToMillis(duration));
-    return () => time.clearTimeout(id);
-});
-/**
- * Returns a {@link Task} that completes first.
+ * await using run = createRun();
  *
- * Like
- * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/race | Promise.race},
- * the first Task to complete (whether success or failure) wins. All other Tasks
- * are aborted. Use {@link any} if you need the first Task to succeed instead.
+ * interface Item {
+ *   readonly id: string;
+ * }
  *
- * Requires a non-empty array — racing zero Tasks has no meaningful result
- * (there's no "first to complete" without participants). This is enforced at
- * compile time for non-empty tuple types. For other arrays, guard with
- * {@link isNonEmptyArray}:
+ * const queue: Array<Item> = [{ id: "item-1" }];
  *
- * ```ts
- * if (isNonEmptyArray(tasks)) {
- *   await run(race(tasks));
- * }
+ * const processQueue: NextTask<Item> = () => {
+ *   const item = queue.shift();
+ *   return item ? ok(item) : err(done());
+ * };
+ *
+ * const result = await run(repeat(processQueue, spaced("1ms")));
+ * expectErr(result, done());
+ * expect(queue).toEqual([]);
  * ```
  *
+ * @group Repetition
+ */
+export const repeat = (task, schedule, { shouldRepeat = constTrue, onRepeat } = {}) => async (run) => {
+    const step = schedule(run.deps);
+    let attempt = onePositiveInt;
+    for (;;) {
+        const result = await run(task);
+        if (!result.ok)
+            return result;
+        if (!shouldRepeat(result.value))
+            return result;
+        const next = step(result.value);
+        if (!next.ok)
+            return result;
+        const [output, delay] = next.value;
+        onRepeat?.({ value: result.value, attempt, output, delay });
+        attempt = incrementPositiveInt(attempt);
+        if (delay > 0)
+            await run.ok(sleep(PositiveMillis.orThrow(delay)));
+    }
+};
+/**
+ * Runs Tasks until one returns {@link Ok} or all return {@link Err}.
+ *
+ * Use {@link race} to return the first settled Result instead, whether Ok or
+ * {@link Err}.
+ *
+ * Returns the first {@link Ok} Result. Losing Tasks are aborted. If no Task
+ * returns Ok, returns the last Err by input order, regardless of completion
+ * order. Other Err results are discarded; use {@link allSettled} when you need
+ * every error.
+ *
+ * Sequential by default; pass a `concurrency` option to run more than one Task
+ * at a time.
+ *
+ * Similar to
+ * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/any | Promise.any},
+ * but races Tasks, returns Result values, and aborts losers.
+ *
  * ### Example
  *
  * ```ts
- * const fast: Task<string> = () => ok("fast");
- * const slow: Task<string> = async (run) => {
- *   await run(sleep("10ms"));
- *   return ok("slow");
+ * import {
+ *   any,
+ *   createRun,
+ *   err,
+ *   ok,
+ *   type Result,
+ *   type Task,
+ * } from "@evolu/common";
+ *
+ * const unavailable: Task<string, "Unavailable"> = () =>
+ *   err("Unavailable");
+ * let fallbackStarted = false;
+ * const fallback: Task<string> = () => {
+ *   fallbackStarted = true;
+ *   return ok("fallback");
  * };
  *
- * // First wins, others are aborted.
- * const result = await run(race([fast, slow])); // ok("fast")
- * ```
+ * await using run = createRun();
+ * const result = await run(any([unavailable, fallback]));
  *
- * Always runs with unlimited concurrency — a sequential race makes no sense
- * since the first Task would always "win".
+ * expectTypeOf(result).toEqualTypeOf<Result<string, "Unavailable">>();
+ * expectOk(result, "fallback");
+ * expect(fallbackStarted).toBe(true);
+ * ```
  *
- * @group Composition
+ * @group Racing
  */
-export const race = (tasks, { abortReason = raceLostError, } = {}) => concurrently(pool(tasks, { stopOn: "first", collect: false, abortReason }));
+export const any = (tasks, options) => async (run) => {
+    let firstOk;
+    let lastErr;
+    let lastErrIndex = -1;
+    await run(each(tasks, (result, index) => {
+        if (result.ok) {
+            firstOk = result;
+            return "stop";
+        }
+        if (index > lastErrIndex) {
+            lastErrIndex = index;
+            lastErr = result;
+        }
+        return "continue";
+    }, options));
+    if (firstOk)
+        return firstOk;
+    assertNonNullable(lastErr);
+    return lastErr;
+};
 /**
- * Abort reason for tasks that lose a {@link race}.
+ * Runs Tasks until the first Task settles.
  *
- * @group Composition
- */
-export const RaceLostError = /*#__PURE__*/ typed("RaceLostError");
-/**
- * {@link RaceLostError} used as abort reason in {@link race}.
+ * Returns the first Task {@link Result} to settle, whether {@link Ok} or
+ * {@link Err}.
  *
- * @group Composition
- */
-export const raceLostError = { type: "RaceLostError" };
-/**
- * Wraps a {@link Task} with a time limit.
+ * Use {@link any} to wait for the first Ok instead.
+ *
+ * Losing Tasks are aborted.
  *
- * Returns {@link TimeoutError} if the Task doesn't complete within the specified
- * duration. The original Task is aborted when the timeout fires.
+ * Tasks always run concurrently because racing sequentially would be
+ * meaningless.
+ *
+ * Similar to
+ * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/race | Promise.race},
+ * but races Tasks, returns Result values, and aborts losers.
+ *
+ * Requires a non-empty array: zero Tasks have no meaningful first settled
+ * Result. This is enforced at compile time for non-empty tuple types. For
+ * arrays whose emptiness is only known at runtime, guard with
+ * {@link isNonEmptyArray}:
  *
  * ### Example
  *
  * ```ts
- * const fetchWithTimeout = timeout(fetchData, "5s");
+ * import {
+ *   createRun,
+ *   isNonEmptyArray,
+ *   ok,
+ *   race,
+ *   type Task,
+ * } from "@evolu/common";
  *
- * const result = await run(fetchWithTimeout);
- * if (!result.ok && result.error.type === "TimeoutError") {
- *   console.log("Request timed out");
+ * const tasks: ReadonlyArray<Task<string>> = [() => ok("first")];
+ * await using run = createRun();
+ * if (isNonEmptyArray(tasks)) {
+ *   const result = await run(race(tasks));
+ *   expectOk(result, "first");
  * }
  * ```
  *
- * @group Composition
- */
-export const timeout = (task, duration, { abortReason = timeoutError, } = {}) => race([
-    task,
-    async (run) => {
-        await run(sleep(duration));
-        return err(timeoutError);
-    },
-], { abortReason });
-/**
- * Typed error returned by {@link timeout} when a task exceeds its time limit.
+ * ### Example
  *
- * @group Composition
- */
-export const TimeoutError = /*#__PURE__*/ typed("TimeoutError");
-/**
- * {@link TimeoutError} used as abort reason in {@link timeout}.
+ * ```ts
+ * import {
+ *   createRun,
+ *   ok,
+ *   race,
+ *   sleep,
+ *   type Result,
+ *   type Task,
+ * } from "@evolu/common";
+ *
+ * await using run = createRun();
+ *
+ * const fast: Task<string> = () => ok("fast");
+ * let slowCompleted = false;
+ * const slow: Task<string> = async (run) => {
+ *   await run.ok(sleep("10ms"));
+ *   slowCompleted = true;
+ *   return ok("slow");
+ * };
  *
- * @group Composition
+ * // Input order does not matter: the first settled Result wins, and the
+ * // still-running loser is aborted.
+ * const result = await run(race([slow, fast]));
+ * expectTypeOf(result).toEqualTypeOf<Result<string>>();
+ * expectOk(result, "fast");
+ * expect(slowCompleted).toBe(false);
+ * ```
+ *
+ * @group Racing
  */
-export const timeoutError = { type: "TimeoutError" };
+export const race = (tasks) => async (run) => {
+    assertNonEmptyReadonlyArray(tasks);
+    let firstResult;
+    await run(each(tasks, (result) => {
+        firstResult = result;
+        return "stop";
+    }, { concurrency: tasks.length }));
+    assertNonNullable(firstResult);
+    return firstResult;
+};
 /**
- * Wraps a {@link Task} with retry logic.
+ * Runs Tasks until `count` Tasks return {@link Ok} or all Tasks settle.
  *
- * Retries the Task according to the {@link Schedule}'s rules. Use
- * {@link RetryOptions.retryable} to filter which errors should trigger retries.
+ * Returns {@link Ok} with Ok values in settlement order, not input order.
+ * {@link Err} Results are ignored. When `count` Ok values have settled,
+ * remaining Tasks are aborted. If fewer than `count` Tasks return Ok, returns
+ * the Ok values that did settle.
  *
- * All non-abort errors are wrapped in {@link RetryError}:
+ * Sequential by default; pass a `concurrency` option to run more than one Task
+ * at a time. The count uses {@link Int1To100OrPositiveInt}: pass `1` to `100` as
+ * a literal, or a validated {@link PositiveInt} for larger values.
  *
- * - Task succeeds → `ok(value)`
- * - Task returns {@link AbortError} → `err(AbortError)` — passed through, no
- *   retry, no wrapping
- * - Task returns any other error → retry until schedule exhausted or `retryable`
- *   returns false → `err(RetryError)` with `cause` = the last error
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   createRun,
+ *   err,
+ *   firstN,
+ *   ok,
+ *   sleep,
+ *   type Task,
+ * } from "@evolu/common";
  *
- * The `RetryError` is informative: "I tried N times, here's why I finally gave
- * up" — and `cause` contains the actual underlying error.
+ * let slowCompleted = false;
+ * const slow: Task<string, "Failed"> = async (run) => {
+ *   await run.ok(sleep("10ms"));
+ *   slowCompleted = true;
+ *   return ok("slow");
+ * };
+ * const tasks = [
+ *   slow,
+ *   () => err("Failed" as const),
+ *   () => ok("fast-1"),
+ *   () => ok("fast-2"),
+ * ] as const;
+ * await using run = createRun();
+ *
+ * // Errs do not count. After two Ok values settle, the slow Task is aborted.
+ * const result = await run(firstN(tasks, 2, { concurrency: 4 }));
+ * expectOk(result, ["fast-1", "fast-2"]);
+ * expect(slowCompleted).toBe(false);
+ * ```
+ *
+ * @group Racing
+ */
+export const firstN = (tasks, count, options) => async (run) => {
+    assertType(PositiveInt, count);
+    const values = [];
+    await run(each(tasks, (result) => {
+        if (result.ok)
+            values.push(result.value);
+        return values.length < count ? "continue" : "stop";
+    }, options));
+    return ok(values);
+};
+/**
+ * Runs Tasks until `count` Tasks settle or all Tasks settle.
+ *
+ * Returns {@link Ok} with Task {@link Result}s in settlement order, not input
+ * order. When `count` Results have settled, remaining Tasks are aborted. If
+ * fewer than `count` Tasks settle, returns the Results that did settle.
+ *
+ * Sequential by default; pass a `concurrency` option to run more than one Task
+ * at a time. The count uses {@link Int1To100OrPositiveInt}: pass `1` to `100` as
+ * a literal, or a validated {@link PositiveInt} for larger values.
  *
  * ### Example
  *
  * ```ts
  * import {
- *   exponential,
- *   jitter,
- *   maxDelay,
- *   retry,
- *   take,
+ *   createRun,
+ *   err,
+ *   firstNSettled,
+ *   ok,
+ *   sleep,
+ *   type Task,
  * } from "@evolu/common";
  *
- * const fetchWithRetry = retry(
- *   fetchData,
- *   // A jittered, capped, limited exponential backoff.
- *   jitter(1)(maxDelay("20s")(take(2)(exponential("100ms")))),
- * );
+ * let slowCompleted = false;
+ * const slow: Task<string, "Failed"> = async (run) => {
+ *   await run.ok(sleep("10ms"));
+ *   slowCompleted = true;
+ *   return ok("slow");
+ * };
+ * const tasks = [
+ *   slow,
+ *   () => err("Failed" as const),
+ *   () => ok("fast"),
+ * ] as const;
+ * await using run = createRun();
  *
- * const result = await run(fetchWithRetry);
- * if (!result.ok) {
- *   if (AbortError.is(result.error)) {
- *     // Was aborted externally
- *   } else {
- *     // RetryError — failed after retrying
- *     console.log(`Failed after ${result.error.attempts} attempts`);
- *     console.log(`Last error:`, result.error.cause);
- *   }
- * }
+ * // Err and Ok both count, and Results use settlement order.
+ * const result = await run(firstNSettled(tasks, 2, { concurrency: 3 }));
+ * expectOk(result, [
+ *   { ok: false, error: "Failed" },
+ *   { ok: true, value: "fast" },
+ * ]);
+ * expect(slowCompleted).toBe(false);
  * ```
  *
- * The schedule receives the error as input, enabling error-aware strategies
- * like stopping on fatal errors:
+ * @group Racing
+ */
+export const firstNSettled = (tasks, count, options) => async (run) => {
+    assertType(PositiveInt, count);
+    const results = [];
+    await run(each(tasks, (result) => {
+        results.push(result);
+        return results.length < count ? "continue" : "stop";
+    }, options));
+    return ok(results);
+};
+/**
+ * Runs Tasks under a concurrency limit and calls `onResult` for each Task
+ * {@link Result} as it settles.
+ *
+ * `onResult` receives the Result and the original input index; call order is
+ * settlement order, not input order. Returning `continue` lets queued Tasks
+ * start when capacity is available. Returning `stop` prevents queued Tasks from
+ * starting and aborts already-running Tasks through structured Run disposal —
+ * `each` still waits for them to settle before returning.
+ *
+ * `each` is the scheduling primitive under the collection helpers. Each one is
+ * a small `onResult` policy:
+ *
+ * | Helper                | Policy                                |
+ * | --------------------- | ------------------------------------- |
+ * | {@link all}           | Collect values, stop on the first Err |
+ * | {@link allSettled}    | Collect every Result, never stop      |
+ * | {@link any}           | Stop on the first Ok                  |
+ * | {@link race}          | Stop on the first settled Result      |
+ * | {@link firstN}        | Stop after n Ok values                |
+ * | {@link firstNSettled} | Stop after n Results                  |
+ *
+ * Use `each` directly to build a collection policy the helpers don't cover. For
+ * example, keep the first successful value together with its original input
+ * index:
+ *
+ * ### Example
  *
  * ```ts
- * import { whileScheduleInput } from "@evolu/common";
+ * import {
+ *   createRun,
+ *   each,
+ *   err,
+ *   ok,
+ *   sleep,
+ *   type Task,
+ * } from "@evolu/common";
  *
- * // Don't retry fatal errors
- * const smartRetry = retry(
- *   fetchData,
- *   whileScheduleInput((e: FetchError) => e.type !== "FatalError")(
- *     take(5)(spaced("1s")),
+ * let slowCompleted = false;
+ * const slow: Task<string> = async (run) => {
+ *   await run.ok(sleep("10ms"));
+ *   slowCompleted = true;
+ *   return ok("slow");
+ * };
+ * const tasks = [
+ *   slow,
+ *   () => err("Unavailable" as const),
+ *   () => ok("fast"),
+ * ] as const;
+ * let first: readonly [string, number] | undefined;
+ * await using run = createRun();
+ * const result = await run(
+ *   each(
+ *     tasks,
+ *     (result, index) => {
+ *       if (!result.ok) return "continue";
+ *       first = [result.value, index];
+ *       return "stop";
+ *     },
+ *     { concurrency: 2 },
  *   ),
  * );
+ *
+ * expectOk(result, undefined);
+ * expect(first).toEqual(["fast", 2]);
+ * expect(slowCompleted).toBe(false);
  * ```
  *
- * @group Composition
- * @see {@link RetryOptions}
+ * `onResult` is a synchronous scheduling decision, not a place to do work. It
+ * runs in the scheduler's own continuation, bracketed by abort checks, and its
+ * return value gates whether queued Tasks may start. For async work per result,
+ * put it inside the Task itself — the Task is the async slot — or start a
+ * supervised side effect with `void run(task)` from inside the callback and
+ * keep the decision synchronous. Like {@link RetryOptions.shouldRetry} and
+ * {@link RetryOptions.onRetry}, `onResult` must not throw: a thrown exception is
+ * a defect that panics the Run tree.
+ *
+ * Sequential by default; pass a `concurrency` option to run more than one Task
+ * at a time. Defects from child Tasks keep caller-linked async stack traces;
+ * building on `each` preserves diagnostics that a hand-rolled scheduling loop
+ * typically loses.
+ *
+ * @group Concurrency
  */
-export const retry = (task, schedule, { retryable = lazyTrue, onRetry } = {}) => async (run) => {
-    const step = schedule(run.deps);
-    let attempt = onePositiveInt;
-    let error;
-    for (;;) {
-        if (error !== undefined) {
-            const scheduleResult = step(error);
-            if (!scheduleResult.ok) {
-                return err({
-                    type: "RetryError",
-                    cause: error,
-                    attempts: PositiveInt.orThrow(decrement(attempt)),
-                });
+export const each = (tasks, onResult, options = {}) => async (run) => {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        // Guard against hanging on an empty array.
+        assertNonEmptyReadonlyArray(tasks);
+        const parked = new Promise(constVoid);
+        const wake = Promise.withResolvers();
+        const _ = __addDisposableResource(env_1, run.onAbort(wake.reject), false);
+        let stopped = false;
+        let nextIndex = 0;
+        const workerCount = Math.min(options.concurrency ?? onePositiveInt, tasks.length);
+        let active = workerCount;
+        // This topology is measured by StackTrace.test.ts ("pool parked" and
+        // "pool parked wake reject"). Defects and stacks must travel await/
+        // combinator edges, not resolver/then bridges; V8 drops parent frames when
+        // a started worker is re-raced, JSC drops them through nested combinators.
+        // Workers are direct race arms and never resolve — non-panic child
+        // AbortErrors reject a worker arm; panics and caller abort reject the wake
+        // via run.onAbort; drain and stop resolve it. `parked` must stay per-call:
+        // a shared never-settling promise would retain worker reactions forever.
+        const eachWorker = async () => {
+            try {
+                while (!stopped && nextIndex < tasks.length) {
+                    const index = nextIndex;
+                    nextIndex += 1;
+                    const result = await run(tasks[index]);
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- stopped can flip across the await via sibling workers
+                    if (stopped)
+                        break;
+                    run.signal.throwIfAborted();
+                    const decision = onResult(result, index);
+                    run.signal.throwIfAborted();
+                    if (decision === "stop") {
+                        stopped = true;
+                        wake.resolve();
+                    }
+                }
             }
-            const [output, delay] = scheduleResult.value;
-            onRetry?.({
-                error,
-                attempt: PositiveInt.orThrow(decrement(attempt)),
-                output,
-                delay,
-            });
-            if (delay > 0) {
-                const sleepResult = await run(sleep(delay));
-                if (!sleepResult.ok)
-                    return sleepResult;
+            catch (error) {
+                stopped = true;
+                throw error;
             }
-        }
-        const result = await run(task);
-        if (result.ok)
-            return result;
-        if (AbortError.is(result.error))
-            return err(result.error);
-        error = result.error;
-        if (!retryable(error)) {
-            return err({
-                type: "RetryError",
-                cause: error,
-                attempts: attempt,
-            });
-        }
-        attempt = PositiveInt.orThrow(increment(attempt));
+            active -= 1;
+            if (active === 0)
+                wake.resolve();
+            return await parked;
+        };
+        await Promise.race([
+            ...Array.from({ length: workerCount }, eachWorker),
+            wake.promise,
+        ]);
+        return ok();
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        __disposeResources(env_1);
     }
 };
 /**
- * Repeats a {@link Task} according to a {@link Schedule}.
+ * Assigns static scheduler priority to a {@link Task}.
+ *
+ * {@link Run} uses the priority with native `scheduler.postTask` when available.
+ * Platforms without the Scheduler API run the Task normally. Use a Scheduler
+ * API polyfill such as
+ * {@link https://github.com/GoogleChromeLabs/scheduler-polyfill | scheduler-polyfill}
+ * for hosts like Safari and React Native when priority-aware scheduling is
+ * needed.
  *
- * Runs the Task, then checks the schedule to determine if it should repeat. The
- * schedule controls how many repetitions occur and the delay between them.
- * Continues until the schedule returns `Err(Done<void>)` or the Task fails.
+ * `scheduler.postTask` must reject queued aborts with `AbortSignal.reason`.
+ * Other host-specific abort objects are treated as defects.
  *
- * With `take(n)`, the task runs n+1 times (initial run plus n repetitions).
+ * ### Example
+ *
+ * ```ts
+ * import { createRun, ok, prioritized, type Task } from "@evolu/common";
+ *
+ * const rebuildSearchIndex: Task<string> = () => ok("indexed");
+ * const backgroundIndexing = prioritized("background", rebuildSearchIndex);
  *
- * Also works with {@link NextTask} — when the Task returns `Err(Done<D>)`,
- * repeat stops and propagates the done signal.
+ * await using run = createRun();
+ * expectOk(await run(backgroundIndexing), "indexed");
+ * ```
+ *
+ * @group Scheduling
+ */
+export const prioritized = (priority, task) => withTaskMeta({ priority })(task);
+/**
+ * Yields execution to the host scheduler.
+ *
+ * Uses native `scheduler.yield()` when available, `setImmediate` when
+ * available, and `setTimeout` elsewhere. Because this is a Task, `await
+ * run(yieldNow)` is an explicit abortable checkpoint and is visible in Run
+ * monitoring.
+ *
+ * For example, call it periodically in a long-running synchronous loop to let
+ * the host process rendering, input, and other scheduled work.
  *
  * ### Example
  *
  * ```ts
- * import { fixed, take } from "@evolu/common/schedule";
- * import { repeat } from "@evolu/common";
+ * import { createRun, ok, yieldNow, type Task } from "@evolu/common";
  *
- * // Heartbeat every 30 seconds (runs forever until aborted)
- * const heartbeat = repeat(sendHeartbeat, fixed("30s"));
+ * const sumTo =
+ *   (count: number): Task<number> =>
+ *   async (run) => {
+ *     let sum = 0;
  *
- * // Poll 4 times total (initial + 3 repetitions), 1 second apart
- * const poll = repeat(checkStatus, take(3)(fixed("1s")));
+ *     for (let index = 0; index < count; index++) {
+ *       if (index > 0 && index % 1000 === 0) await run.ok(yieldNow);
+ *       sum += index;
+ *     }
  *
- * // Process queue items until empty (NextTask pattern)
- * const processQueue: NextTask<Item, ProcessError, void> = async (run) => {
- *   const item = queue.dequeue();
- *   if (!item) return err(done()); // Queue empty, stop
- *   await process(item);
- *   return ok(item);
- * };
+ *     return ok(sum);
+ *   };
  *
- * const result = await run(repeat(processQueue, fixed("100ms")));
- * if (!result.ok && result.error.type === "Done") {
- *   console.log("Queue exhausted");
- * }
+ * await using run = createRun();
+ * expectOk(await run(sumTo(1001)), 500500);
  * ```
  *
- * @group Composition
+ * @group Scheduling
  */
-export const repeat = (task, schedule, { repeatable = lazyTrue, onRepeat } = {}) => async (run) => {
-    const step = schedule(run.deps);
-    let lastResult;
-    let attempt = onePositiveInt;
-    for (;;) {
-        const result = await run(task);
-        if (!result.ok)
-            return result;
-        lastResult = result;
-        if (!repeatable(result.value))
-            return lastResult;
-        const next = step(result.value);
-        if (!next.ok)
-            break;
-        const [output, delay] = next.value;
-        onRepeat?.({
-            value: result.value,
-            attempt,
-            output,
-            delay,
+export const yieldNow = async (run) => {
+    const scheduler = globalWithScheduler.scheduler;
+    if (scheduler?.yield) {
+        await scheduler.yield();
+    }
+    else {
+        // Intentionally bypasses deps.time: yielding is a host-scheduler concern,
+        // not logical time, and fake time would block awaiting code in tests. The
+        // timer is not cleared on abort; throwIfAborted below observes abort after
+        // the tick, delaying settlement by at most one timer tick.
+        await new Promise((resolve) => {
+            const immediate = globalWithSetImmediate.setImmediate;
+            if (immediate)
+                immediate(resolve);
+            else
+                setTimeout(resolve, 0);
         });
-        attempt = PositiveInt.orThrow(increment(attempt));
-        if (delay > 0) {
-            const sleepResult = await run(sleep(delay));
-            if (!sleepResult.ok)
-                return sleepResult;
-        }
     }
-    return lastResult;
+    run.signal.throwIfAborted();
+    return ok();
 };
+// Abortability
 /**
- * Creates a {@link Deferred}.
+ * Waits until the current {@link Run} aborts, then rejects with its
+ * {@link AbortError}.
  *
- * @group Concurrency primitives
- */
-export const createDeferred = () => {
-    let resolved = null;
-    const resolvers = new Set();
-    const resolve = (result) => {
-        if (resolved !== null)
-            return false;
-        resolved = result;
-        for (const resolver of resolvers)
-            resolver(result);
-        resolvers.clear();
-        return true;
-    };
-    return {
-        task: (run) => {
-            if (resolved !== null)
-                return resolved;
-            return new Promise((resolvePromise) => {
-                const resolve = (result) => {
-                    resolvers.delete(resolve);
-                    resolvePromise(result);
-                };
-                resolvers.add(resolve);
-                run.onAbort((reason) => {
-                    resolve(err(createAbortError(reason)));
-                });
-            });
-        },
-        resolve,
-        [Symbol.dispose]: () => {
-            resolve(err(deferredDisposedError));
-        },
-    };
-};
-/**
- * Abort reason used when a {@link Deferred} is disposed.
+ * Use it to keep long-running services and Run-owned resources alive until
+ * their owning Run shuts down.
  *
- * @group Concurrency primitives
- */
-export const DeferredDisposedError = /*#__PURE__*/ typed("DeferredDisposedError");
-/**
- * {@link DeferredDisposedError} used as abort reason in {@link createDeferred}.
+ * ### Example
  *
- * @group Concurrency primitives
+ * ```ts
+ * import {
+ *   AbortError,
+ *   createRun,
+ *   ok,
+ *   waitForAbort,
+ *   type Task,
+ * } from "@evolu/common";
+ *
+ * interface ServerDep {
+ *   readonly port: number;
+ * }
+ * interface Server extends AsyncDisposable {}
+ *
+ * const serverStarted = Promise.withResolvers<void>();
+ * let serverStopped = false;
+ * const startServer: Task<Server, never, ServerDep> = ({ deps }) => {
+ *   expect(deps.port).toBe(3000);
+ *   serverStarted.resolve();
+ *   return ok({
+ *     [Symbol.asyncDispose]: async () => {
+ *       serverStopped = true;
+ *     },
+ *   });
+ * };
+ *
+ * const serve = (): Task<never, never, ServerDep> => async (run) => {
+ *   await using server = await run.ok(startServer);
+ *   return await run(waitForAbort);
+ * };
+ *
+ * expectTypeOf(serve).returns.toEqualTypeOf<
+ *   Task<never, never, ServerDep>
+ * >();
+ *
+ * await using run = createRun();
+ * const fiber = run.abortable(serve(), { port: 3000 });
+ * await serverStarted.promise;
+ * fiber.abort();
+ *
+ * const result = await fiber;
+ * assert(!result.ok);
+ * expect(AbortError.is(result.error)).toBe(true);
+ * expect(serverStopped).toBe(true);
+ * ```
+ *
+ * @group Abortability
  */
-export const deferredDisposedError = {
-    type: "DeferredDisposedError",
+export const waitForAbort = async (run) => {
+    const env_2 = { stack: [], error: void 0, hasError: false };
+    try {
+        const aborted = Promise.withResolvers();
+        const _ = __addDisposableResource(env_2, run.onAbort(aborted.reject), false);
+        return await aborted.promise;
+    }
+    catch (e_2) {
+        env_2.error = e_2;
+        env_2.hasError = true;
+    }
+    finally {
+        __disposeResources(env_2);
+    }
 };
 /**
- * Creates a {@link Gate} that starts closed.
- *
- * Useful for "stop/go" logic where multiple Tasks need to wait for a state
- * change.
+ * Starts a {@link Task} with {@link Run.daemon} and waits until it settles or the
+ * current Run aborts.
+ *
+ * When the current Run aborts, this helper requests abort for the daemon Task
+ * and returns {@link AbortError} without waiting for that daemon Task to observe
+ * abort, clean up, or settle. This makes the wait abortable, not the underlying
+ * execution. The daemon Task continues under root Run ownership until it
+ * settles, observes abort, or the root Run is disposed.
+ *
+ * This is not a replacement for direct {@link AbortSignal} support in operations
+ * that can observe abort, such as {@link fetch}, timers that accept a signal, or
+ * callback APIs that accept a signal. Use it as an escape hatch for Tasks that
+ * ignore abort when an abort request must stop waiting immediately.
+ *
+ * Do not wrap a Task that keeps using a resource the caller may release after
+ * this wrapper returns, unless the Task reliably observes abort before using
+ * that resource. The daemon Task can continue after the caller stops waiting.
+ * Later domain `Err` results from the daemon Task are discarded after the
+ * caller stops waiting. Defects from the daemon Task remain visible to the root
+ * Run: if it later throws or rejects, the root Run still panics and reports the
+ * defect.
+ *
+ * Compose with {@link race} or {@link timeout} when the losing Task must not
+ * delay the winner. Those helpers normally abort losing Tasks and wait for them
+ * to settle, keeping cleanup and late defects inside the caller's lifetime. A
+ * Task that ignores abort can keep them waiting.
+ *
+ * `run.abortable(task)` returns an owned child Fiber and requests abort through
+ * that Fiber; `daemon(task)` starts a daemon child and stops waiting when the
+ * current Run aborts. {@link unabortable} masks abort for a Task that must
+ * finish once started; daemon lets a Task outlive the caller.
+ *
+ * Because the Task starts with {@link Run.daemon}, a recorded abort request
+ * returns AbortError before the Task starts — including a request masked by
+ * {@link unabortable}, even though `run.signal` stays un-aborted inside the
+ * mask. Inside a masked body, wrapping a Task with `daemon` opts the wait back
+ * into abort observation; omit the wrapper when the mask should keep the Task
+ * running.
  *
  * ### Example
  *
  * ```ts
- * const networkGate = createGate();
+ * import {
+ *   createRun,
+ *   daemon,
+ *   ok,
+ *   timeout,
+ *   type Task,
+ * } from "@evolu/common";
  *
- * // Pause processing when offline
- * const onOffline = () => networkGate.close();
+ * let finished = false;
+ * let finishTask = (): void => {};
+ * const taskNotUsingAbort: Task<string> = () =>
+ *   new Promise((resolve) => {
+ *     finishTask = () => {
+ *       finished = true;
+ *       resolve(ok("done"));
+ *     };
+ *   });
  *
- * // Resume processing when online
- * const onOnline = () => networkGate.open();
+ * {
+ *   await using run = createRun();
+ *   const result = await run(timeout(daemon(taskNotUsingAbort), "1ms"));
+ *   assert(!result.ok);
+ *   expect(result.error.type).toBe("TimeoutError");
+ *   expect(finished).toBe(false);
+ *   finishTask();
+ * }
+ * expect(finished).toBe(true);
+ * ```
  *
- * const syncLoop = async (run) => {
- *   while (true) {
- *     // Blocks here whenever the gate is closed
- *     await run(networkGate.wait);
- *     await run(uploadNextItem);
- *   }
+ * Promise-producing operations should start inside the Task, not before it.
+ *
+ * ```ts
+ * import { createRun, ok, type Result, type Task } from "@evolu/common";
+ *
+ * type ResultValue = string;
+ * interface MyError {
+ *   readonly type: "MyError";
+ * }
+ * const createPromiseReturningResult = (): Promise<
+ *   Result<ResultValue, MyError>
+ * > => Promise.resolve(ok("value"));
+ *
+ * const task: Task<ResultValue, MyError> = () =>
+ *   createPromiseReturningResult();
+ *
+ * await using run = createRun();
+ * expectOk(await run(task), "value");
+ * ```
+ *
+ * Do not reuse an already-running Promise. It started outside the Task, so the
+ * Run cannot own its lifetime or request abort before it begins.
+ *
+ * ```ts
+ * import { ok, type Result, type Task } from "@evolu/common";
+ *
+ * type ResultValue = string;
+ * interface MyError {
+ *   readonly type: "MyError";
+ * }
+ * let promiseStarted = false;
+ * const createPromiseReturningResult = (): Promise<
+ *   Result<ResultValue, MyError>
+ * > => {
+ *   promiseStarted = true;
+ *   return Promise.resolve(ok("value"));
  * };
+ *
+ * // Wrong: the Promise starts now, before a Run starts the Task.
+ * const promise = createPromiseReturningResult();
+ * const task: Task<ResultValue, MyError> = () => promise;
+ *
+ * expect(promiseStarted).toBe(true);
+ * expectTypeOf(task).toEqualTypeOf<Task<ResultValue, MyError>>();
  * ```
  *
- * @group Concurrency primitives
+ * @group Lifetime
  */
-export const createGate = () => {
-    const env_1 = { stack: [], error: void 0, hasError: false };
+export const daemon = (task) => async (run) => {
+    const env_3 = { 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(),
-        };
+        let fiber;
+        try {
+            fiber = run.daemon(task);
+        }
+        catch (error) {
+            if (AbortError.is(error))
+                return err(error);
+            throw error;
+        }
+        const aborted = Promise.withResolvers();
+        const _ = __addDisposableResource(env_3, run.onAbort((abortError) => {
+            fiber.abort(abortError.reason);
+            aborted.resolve(err(abortError));
+        }), false);
+        return await Promise.race([fiber, aborted.promise]);
     }
-    catch (e_1) {
-        env_1.error = e_1;
-        env_1.hasError = true;
+    catch (e_3) {
+        env_3.error = e_3;
+        env_3.hasError = true;
     }
     finally {
-        __disposeResources(env_1);
+        __disposeResources(env_3);
     }
 };
 /**
- * Creates a {@link Semaphore} that limits concurrent {@link Task}s.
+ * Makes a {@link Task} unabortable after it starts.
+ *
+ * Abort requests are masked while the Task runs, so `run.signal.aborted`
+ * remains false inside the Task. This does not force the Task to start after an
+ * abort request has already reached its Run; unabortable means the Task is not
+ * interrupted once it has started. Disposing the enclosing Run still waits for
+ * the Task to settle.
+ *
+ * Apply at most one abort behavior helper to a Task: do not wrap the same Task
+ * with both unabortable and restore, or apply either helper more than once.
  *
  * ### Example
  *
  * ```ts
+ * import { createRun, ok, unabortable, type Task } from "@evolu/common";
+ *
+ * const commitStarted = Promise.withResolvers<void>();
+ * const finishCommit = Promise.withResolvers<void>();
+ * const commit: Task<string> = unabortable(async ({ signal }) => {
+ *   commitStarted.resolve();
+ *   await finishCommit.promise;
+ *   expect(signal.aborted).toBe(false);
+ *   return ok("committed");
+ * });
+ *
  * await using run = createRun();
+ * const fiber = run.abortable(commit);
+ * await commitStarted.promise;
+ * fiber.abort();
+ * finishCommit.resolve();
  *
- * const semaphore = createSemaphore(PositiveInt.orThrow(2));
+ * expectOk(await fiber, "committed");
+ * ```
  *
- * const fetchUser =
- *   (id: string): Task<string> =>
+ * @group Abortability
+ */
+export const unabortable = /*#__PURE__*/ withTaskMeta({
+    abortBehavior: "unabortable",
+});
+/**
+ * Like {@link unabortable}, but provides `restore` for child Tasks that should
+ * run with the previous abort mask.
+ *
+ * Use this for acquire/use/release flows where acquire and release must finish
+ * once started, while use should remain abortable. Child Tasks inherit the mask
+ * unless they are wrapped with `restore()` before scheduling.
+ *
+ * An abort request before the mask Task starts prevents entering the mask. Once
+ * the body starts, plain child Tasks inherit the mask, so acquire and release
+ * can run after abort. Put release operations directly in the original mask's
+ * `finally`; do not wrap release in a nested `unabortableMask`, which is a new
+ * critical-section entry and may not start after abort.
+ *
+ * {@link AsyncDisposableStack} is often enough for ordinary acquire/release. Use
+ * it inside `unabortableMask` when masked acquire/release spans multiple or
+ * conditional resources.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   AbortError,
+ *   createRun,
+ *   ok,
+ *   unabortableMask,
+ *   waitForAbort,
+ *   type Task,
+ * } from "@evolu/common";
+ *
+ * await using run = createRun();
+ *
+ * interface Resource {
+ *   readonly id: string;
+ * }
+ *
+ * const acquire: Task<Resource> = () => ok({ id: "resource-1" });
+ * const operationStarted = Promise.withResolvers<void>();
+ * const operate =
+ *   (resource: Resource): Task<never> =>
  *   async (run) => {
- *     const { console } = run.deps;
- *     console.log("[demo]", "start", id);
- *     const slept = await run(sleep("10ms"));
- *     if (!slept.ok) return slept;
- *     console.log("[demo]", "end", id);
- *     return ok(`user:${id}`);
+ *     expect(resource.id).toBe("resource-1");
+ *     operationStarted.resolve();
+ *     return await run(waitForAbort);
+ *   };
+ * let released = false;
+ * const release =
+ *   (_resource: Resource): Task<void> =>
+ *   ({ signal }) => {
+ *     // Release inherits the mask even after abort was requested.
+ *     expect(signal.aborted).toBe(false);
+ *     released = true;
+ *     return ok();
  *   };
  *
- * const fetchWithPermit = (id: string) =>
- *   semaphore.withPermit(fetchUser(id));
+ * const fiber = run.abortable(
+ *   unabortableMask((restore) => async (run) => {
+ *     // Acquire with abort masked.
+ *     const resource = await run.ok(acquire);
+ *
+ *     try {
+ *       // Use with the previous abort mask restored.
+ *       return await run(restore(operate(resource)));
+ *     } finally {
+ *       // Release with abort masked.
+ *       await run.ok(release(resource));
+ *     }
+ *   }),
+ * );
  *
- * await Promise.all([
- *   run(fetchWithPermit("1")),
- *   run(fetchWithPermit("2")),
- *   run(fetchWithPermit("3")),
- * ]);
+ * await operationStarted.promise;
+ * fiber.abort();
+ * const result = await fiber;
+ * assert(!result.ok);
+ * expect(AbortError.is(result.error)).toBe(true);
+ * expect(released).toBe(true);
+ * ```
+ *
+ * @group Abortability
+ */
+export const unabortableMask = (fn) => unabortable((run) => {
+    const runInternal = run;
+    // Only verifies the Run is masked. A direct call inside an already masked
+    // Run passes undetected; direct calls bypass Run semantics by design.
+    assert(runInternal.abortMask > abortableMask, "unabortableMask requires a masked Run; use run(task), not a direct call");
+    const restoreToken = Symbol();
+    // The token is local to this Task Run; descendant Runs inherit the token
+    // set so helpers can receive restore while the mask Task is alive.
+    // Each set is bounded by its Run lifetime and is intentionally not pruned.
+    runInternal.restoreTokens = new Set(runInternal.restoreTokens).add(restoreToken);
+    return run(fn(withTaskMeta({
+        abortBehavior: {
+            abortMask: decrement(runInternal.abortMask),
+            restoreToken,
+        },
+    })));
+});
+/**
+ * Runs acquire, use, and release as one bracketed {@link Task}.
+ *
+ * Acquire and release are masked once the helper starts, while use runs with
+ * the previous abort mask restored. If acquire returns an error, release is not
+ * run. Release must not return recoverable errors; handle expected cleanup
+ * failures inside the release Task.
  *
- * // [demo] start 1
- * // [demo] start 2
- * // [demo] end 1
- * // [demo] start 3
- * // [demo] end 2
- * // [demo] end 3
+ * Use this when a resource, lease, lock, or session must always be released
+ * after it is acquired, even when use fails or is aborted.
+ *
+ * Prefer native `using`, `await using`, or {@link AsyncDisposableStack} for
+ * owned values that implement {@link Disposable} or {@link AsyncDisposable}. Use
+ * `acquireUseRelease` when acquisition must be balanced with a separate release
+ * operation, such as unlocking, returning a pooled value, releasing a lease, or
+ * logging out of a session.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   acquireUseRelease,
+ *   createRun,
+ *   err,
+ *   ok,
+ *   type Task,
+ * } from "@evolu/common";
+ *
+ * interface Connection {
+ *   readonly user: string;
+ *   readonly isAvailable: boolean;
+ * }
+ *
+ * const openConnection: Task<Connection> = () =>
+ *   ok({ user: "Ada", isAvailable: false });
+ * const loadUser =
+ *   (connection: Connection): Task<string, "Unavailable"> =>
+ *   () =>
+ *     connection.isAvailable ? ok(connection.user) : err("Unavailable");
+ * let connectionClosed = false;
+ * const closeConnection =
+ *   (_connection: Connection): Task<void> =>
+ *   () => {
+ *     connectionClosed = true;
+ *     return ok();
+ *   };
+ *
+ * const queryUser = acquireUseRelease(
+ *   openConnection,
+ *   loadUser,
+ *   (connection) => closeConnection(connection),
+ * );
+ *
+ * await using run = createRun();
+ * expectErr(await run(queryUser), "Unavailable");
+ * // Release still runs when use returns a domain error.
+ * expect(connectionClosed).toBe(true);
  * ```
  *
- * @group Concurrency primitives
+ * @group Abortability
  */
-export const createSemaphore = (permits) => {
-    const env_2 = { stack: [], error: void 0, hasError: false };
+export const acquireUseRelease = (acquire, use, release) => unabortableMask((restore) => async (run) => {
+    const resourceResult = await run(acquire);
+    if (!resourceResult.ok)
+        return resourceResult;
     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 {
-                const disposer = __addDisposableResource(env_3, new DisposableStack(), false);
-                for (const fiber of fibers) {
-                    disposer.adopt(fiber, (fiber) => {
-                        fiber.abort(semaphoreDisposedError);
-                    });
-                }
-                for (const waiter of waiters) {
-                    waiter.resolve(err(semaphoreDisposedAbortError));
-                }
-                waiters.length = 0;
-            }
-            catch (e_3) {
-                env_3.error = e_3;
-                env_3.hasError = true;
-            }
-            finally {
-                __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;
+        // eslint-disable-next-line react-hooks/rules-of-hooks -- `use` is an acquireUseRelease callback, not a React Hook.
+        return await run(restore(use(resourceResult.value)));
     }
     finally {
-        __disposeResources(env_2);
+        await run.ok(release(resourceResult.value));
     }
-};
+});
 /**
- * Abort reason used when a {@link Semaphore} is disposed.
+ * Creates a {@link Deferred}.
  *
  * @group Concurrency primitives
  */
-export const SemaphoreDisposedError = /*#__PURE__*/ typed("SemaphoreDisposedError");
+export const createDeferred = () => {
+    let resolvedResult;
+    const waiters = new Set();
+    return {
+        task: callback(({ resolve }) => {
+            if (resolvedResult) {
+                resolve(resolvedResult);
+                return;
+            }
+            waiters.add(resolve);
+            return () => {
+                waiters.delete(resolve);
+            };
+        }),
+        resolve: (result) => {
+            if (resolvedResult)
+                return false;
+            resolvedResult = result;
+            for (const wait of waiters)
+                wait(result);
+            waiters.clear();
+            return true;
+        },
+    };
+};
 /**
- * {@link SemaphoreDisposedError} used as abort reason in {@link createSemaphore}.
+ * Creates a {@link Gate}.
  *
  * @group Concurrency primitives
  */
-export const semaphoreDisposedError = {
-    type: "SemaphoreDisposedError",
+export const createGate = ({ isOpen = false, } = {}) => {
+    let deferred = createDeferred();
+    if (isOpen)
+        deferred.resolve(ok());
+    return {
+        // Direct same-Run delegation is intentional so wait observes the current deferred.
+        // eslint-disable-next-line evolu/no-direct-task-call
+        wait: (run) => deferred.task(run),
+        open: () => {
+            if (isOpen)
+                return false;
+            isOpen = true;
+            deferred.resolve(ok());
+            return true;
+        },
+        close: () => {
+            if (!isOpen)
+                return false;
+            isOpen = false;
+            deferred = createDeferred();
+            return true;
+        },
+        release: () => {
+            if (isOpen)
+                return false;
+            deferred.resolve(ok());
+            deferred = createDeferred();
+            return true;
+        },
+        isOpen: () => isOpen,
+    };
 };
-const semaphoreDisposedAbortError = createAbortError(semaphoreDisposedError);
-export function createSemaphoreByKey(permits, { lookup = identity } = {}) {
-    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 {
-                const disposer = __addDisposableResource(env_6, new DisposableStack(), false);
-                disposer.defer(() => {
-                    semaphoresByKey.clear();
-                });
-                for (const semaphore of semaphoresByKey.values()) {
-                    disposer.use(semaphore);
-                }
-            }
-            catch (e_6) {
-                env_6.error = e_6;
-                env_6.hasError = true;
-            }
-            finally {
-                __disposeResources(env_6);
+/**
+ * Creates a {@link Semaphore}.
+ *
+ * @group Concurrency primitives
+ */
+export const createSemaphore = (initialPermits, { policy = "fifo", } = {}) => {
+    const isGreedy = policy === "greedy";
+    let permits = PositiveInt.orThrow(initialPermits);
+    let taken = NonNegativeInt.orThrow(0);
+    const waiters = new Set();
+    const hasFreePermits = (requested) => taken + requested <= permits;
+    const canTake = (requested) => hasFreePermits(requested) && (isGreedy || waiters.size === 0);
+    const grant = (requested, leakDetector) => {
+        taken = NonNegativeInt.orThrow(taken + requested);
+        let released = false;
+        const handle = {};
+        const release = () => {
+            if (released)
+                return false;
+            released = true;
+            leakDetector.untrack(handle);
+            taken = NonNegativeInt.orThrow(taken - requested);
+            releaseWaiters();
+            return true;
+        };
+        const permit = {
+            permits: requested,
+            release,
+            [Symbol.dispose]: release,
+        };
+        leakDetector.track(permit, { name: "SemaphorePermit", isLeaked: () => !released }, handle);
+        return permit;
+    };
+    const releaseWaiters = () => {
+        for (const waiter of waiters) {
+            if (!hasFreePermits(waiter.permits)) {
+                if (!isGreedy)
+                    break;
+                continue;
             }
-        });
-        const disposables = disposer.move();
-        const withPermits = (key, requestedPermits) => (task) => async (run) => {
-            const env_7 = { stack: [], error: void 0, hasError: false };
+            waiters.delete(waiter);
+            waiter.resolve(ok(grant(waiter.permits, waiter.leakDetector)));
+        }
+    };
+    const take = (requestedPermits) => callback(({ run: { deps }, resolve }) => {
+        const requested = PositiveInt.orThrow(requestedPermits);
+        if (canTake(requested)) {
+            resolve(ok(grant(requested, deps.leakDetector)));
+            return;
+        }
+        const waiter = {
+            permits: requested,
+            leakDetector: deps.leakDetector,
+            resolve,
+        };
+        waiters.add(waiter);
+        return () => {
+            if (waiters.delete(waiter))
+                releaseWaiters();
+        };
+    });
+    const withPermits = (requestedPermits) => (task) => async (run) => {
+        const env_4 = { stack: [], error: void 0, hasError: false };
+        try {
+            const _permit = __addDisposableResource(env_4, await run.ok(take(requestedPermits)), false);
+            return await run(task);
+        }
+        catch (e_4) {
+            env_4.error = e_4;
+            env_4.hasError = true;
+        }
+        finally {
+            __disposeResources(env_4);
+        }
+    };
+    const isIdle = () => taken === 0 && waiters.size === 0;
+    return {
+        withPermit: (task) => withPermits(1)(task),
+        withPermits,
+        withPermitsIfAvailable: (requestedPermits) => (task) => async (run) => {
+            const env_5 = { 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));
+                const requested = PositiveInt.orThrow(requestedPermits);
+                if (!canTake(requested))
+                    return ok(none);
+                const _permit = __addDisposableResource(env_5, grant(requested, run.deps.leakDetector), false);
+                const result = await run(task);
+                if (!result.ok)
+                    return result;
+                return ok(some(result.value));
             }
-            catch (e_7) {
-                env_7.error = e_7;
-                env_7.hasError = true;
+            catch (e_5) {
+                env_5.error = e_5;
+                env_5.hasError = true;
             }
             finally {
-                __disposeResources(env_7);
+                __disposeResources(env_5);
             }
-        };
-        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);
-    }
-}
+        },
+        take,
+        resize: (newPermits) => {
+            permits = PositiveInt.orThrow(newPermits);
+            releaseWaiters();
+        },
+        snapshot: () => ({
+            policy,
+            permits,
+            taken,
+            waiters: Array.from(waiters, ({ permits }) => ({ permits })),
+            available: NonNegativeInt.orThrow(!isGreedy && waiters.size > 0 ? 0 : Math.max(0, permits - taken)),
+            isIdle: isIdle(),
+        }),
+        isIdle,
+    };
+};
 /**
  * Creates a {@link Mutex}.
  *
  * @group Concurrency primitives
  */
 export const createMutex = () => {
-    const semaphore = createSemaphore(onePositiveInt);
+    const semaphore = createSemaphore(1);
     return {
         withLock: semaphore.withPermit,
         snapshot: semaphore.snapshot,
-        [Symbol.dispose]: semaphore[Symbol.dispose],
     };
 };
+export function createSemaphoreByKey(initialPermits, { lookup = identity } = {}) {
+    const semaphoresByKey = createLookupMap({ lookup });
+    const getSemaphore = (key) => semaphoresByKey.getOrInsertComputed(key, () => createSemaphore(initialPermits));
+    const withPermits = (key, requestedPermits) => (task) => async (run) => {
+        const semaphore = getSemaphore(key);
+        try {
+            const env_6 = { stack: [], error: void 0, hasError: false };
+            try {
+                const _permit = __addDisposableResource(env_6, await run.ok(semaphore.take(requestedPermits)), false);
+                return await run(task);
+            }
+            catch (e_6) {
+                env_6.error = e_6;
+                env_6.hasError = true;
+            }
+            finally {
+                __disposeResources(env_6);
+            }
+        }
+        finally {
+            if (semaphore.isIdle())
+                semaphoresByKey.delete(key);
+        }
+    };
+    return {
+        withPermit: (key, task) => withPermits(key, 1)(task),
+        withPermits,
+        isIdle: (key) => semaphoresByKey.get(key)?.isIdle() ?? true,
+        snapshot: (key) => semaphoresByKey.get(key)?.snapshot() ?? null,
+    };
+}
 export function createMutexByKey({ lookup = identity, } = {}) {
-    const semaphoreByKey = createSemaphoreByKey(onePositiveInt, {
-        lookup,
-    });
+    const semaphoreByKey = createSemaphoreByKey(1, { lookup });
     return {
         withLock: (key, task) => semaphoreByKey.withPermit(key, task),
+        isIdle: semaphoreByKey.isIdle,
         snapshot: semaphoreByKey.snapshot,
-        [Symbol.dispose]: semaphoreByKey[Symbol.dispose],
     };
 }
 /**
- * Creates a {@link MutexRef} with the given initial immutable value.
+ * Creates a {@link MutexRef}.
  *
  * @group Concurrency primitives
  */
@@ -1347,288 +2192,40 @@ export const createMutexRef = (initialValue) => {
             return ok(previousValue);
         }),
         updateAndGet: (updater) => mutex.withLock(async (run) => {
-            const currentValue = ref.get();
-            const nextValue = await run(updater(currentValue));
+            const nextValue = await run(updater(ref.get()));
             if (!nextValue.ok)
                 return nextValue;
             ref.set(nextValue.value);
             return ok(nextValue.value);
         }),
         modify: (modifier) => mutex.withLock(async (run) => {
-            const nextValue = await run(modifier(ref.get()));
-            if (!nextValue.ok)
-                return nextValue;
-            const [result, updatedValue] = nextValue.value;
-            ref.set(updatedValue);
-            return ok(result);
+            const result = await run(modifier(ref.get()));
+            if (!result.ok)
+                return result;
+            const [value, nextValue] = result.value;
+            ref.set(nextValue);
+            return ok(value);
         }),
-        [Symbol.dispose]: mutex[Symbol.dispose],
+        snapshot: mutex.snapshot,
     };
 };
-export function all(input, options) {
-    return collect("all", input, options);
-}
-/**
- * Abort reason used by {@link all} when aborting remaining tasks.
- *
- * Used when a Task fails and other Tasks need to be aborted.
- *
- * @group Composition
- */
-export const AllAbortError = /*#__PURE__*/ typed("AllAbortError");
-/**
- * {@link AllAbortError} used as abort reason in {@link all}.
- *
- * @group Composition
- */
-export const allAbortError = { type: "AllAbortError" };
-export function allSettled(input, options) {
-    return collect("allSettled", input, options);
-}
-/**
- * Abort reason used by {@link allSettled} when aborted externally.
- *
- * @group Composition
- */
-export const AllSettledAbortError = /*#__PURE__*/ typed("AllSettledAbortError");
-/**
- * {@link AllSettledAbortError} used as abort reason in {@link allSettled}.
- *
- * @group Composition
- */
-export const allSettledAbortError = {
-    type: "AllSettledAbortError",
-};
-export function map(items, fn, { abortReason = mapAbortError, ...options } = {}) {
-    const mapped = mapInput(items, fn);
-    return all(mapped, {
-        ...options,
-        abortReason,
-    });
-}
-/**
- * Abort reason used by {@link map} when aborting remaining tasks.
- *
- * @group Composition
- */
-export const MapAbortError = /*#__PURE__*/ typed("MapAbortError");
-/**
- * {@link MapAbortError} used as abort reason in {@link map}.
- *
- * @group Composition
- */
-export const mapAbortError = {
-    type: "MapAbortError",
-};
-export function mapSettled(items, task, options) {
-    const mapped = mapInput(items, task);
-    return allSettled(mapped, options);
-}
-export function any(tasks, options) {
-    const { allFailed = "input" } = options ?? {};
-    return pool(tasks, {
-        stopOn: "success",
-        collect: false,
-        abortReason: anyAbortError,
-        allFailed,
-    });
-}
-/**
- * Abort reason used by {@link any} when aborting remaining tasks.
- *
- * @group Composition
- */
-export const AnyAbortError = /*#__PURE__*/ typed("AnyAbortError");
-/**
- * {@link AnyAbortError} used as abort reason in {@link any}.
- *
- * @group Composition
- */
-export const anyAbortError = { type: "AnyAbortError" };
-/** Shared implementation for {@link all} and {@link allSettled}. */
-const collect = (type, input, { collect = true, abortReason = type === "all" ? allAbortError : allSettledAbortError, } = {}) => {
-    const stopOn = type === "all" ? "error" : null;
-    if (isIterable(input)) {
-        const tasks = input;
-        const array = arrayFrom(tasks);
-        if (!isNonEmptyArray(array))
-            return () => ok(collect ? emptyArray : undefined);
-        return pool(array, {
-            stopOn,
-            collect,
-            abortReason,
-        });
-    }
-    const keys = [];
-    const taskArray = [];
-    for (const key in input) {
-        keys.push(key);
-        taskArray.push(input[key]);
-    }
-    if (keys.length === 0)
-        return () => ok(collect ? emptyRecord : undefined);
-    return async (run) => {
-        const result = await run(pool(taskArray, { stopOn, collect, abortReason }));
-        if (!result.ok)
-            return result;
-        if (!collect)
-            return ok();
-        const record = createRecord();
-        for (let i = 0; i < keys.length; i++) {
-            record[keys[i]] = result.value[i];
-        }
-        return ok(record);
-    };
-};
-const mapInput = (input, fn) => isIterable(input) ? mapArray(arrayFrom(input), fn) : mapObject(input, fn);
-function pool(tasksIterable, { stopOn = null, collect, abortReason, allFailed, }) {
-    const tasks = arrayFrom(tasksIterable);
-    const { length } = tasks;
-    if (length === 0)
-        return () => ok(emptyArray);
-    return async (run) => {
-        const env_8 = { stack: [], error: void 0, hasError: false };
-        try {
-            const results = collect ? new Array(length) : null;
-            const aborted = Promise.withResolvers();
-            const stopSignal = stopOn ? Promise.withResolvers() : null;
-            let index = 0;
-            let stopped = null;
-            let lastResult = null;
-            let lastIndexResult = null;
-            const worker = async (run) => {
-                while (index < length && (stopOn ? !stopped : true)) {
-                    const i = index++;
-                    const result = (await run(tasks[i]));
-                    lastResult = result;
-                    if (i === length - 1)
-                        lastIndexResult = result;
-                    if (!stopOn) {
-                        if (results)
-                            results[i] = result;
-                        continue;
-                    }
-                    const stop = stopOn === "first" ||
-                        (stopOn === "error" && !result.ok) ||
-                        (stopOn === "success" && result.ok);
-                    if (!stop) {
-                        if (results)
-                            results[i] = result.value;
-                        continue;
-                    }
-                    if (!stopped) {
-                        stopped = result;
-                        abortWorkers(!result.ok && AbortError.is(result.error)
-                            ? result.error.reason
-                            : abortReason);
-                        stopSignal?.resolve();
-                    }
-                    break;
-                }
-                return ok();
-            };
-            let workersAborted = false;
-            const abortWorkers = (reason) => {
-                if (workersAborted)
-                    return;
-                workersAborted = true;
-                for (const worker of workers)
-                    worker.abort(reason);
-            };
-            const workerCount = Math.min(run.concurrency, length);
-            const workers = arrayFrom(workerCount, () => run.daemon(worker, run.deps));
-            const _ = __addDisposableResource(env_8, new DisposableStack(), false);
-            _.defer(() => {
-                abortWorkers(abortReason);
-            });
-            run.onAbort((reason) => {
-                abortWorkers(reason);
-                aborted.resolve();
-            });
-            const waitFor = [Promise.all(workers), aborted.promise];
-            if (stopSignal)
-                waitFor.push(stopSignal.promise);
-            await Promise.race(waitFor);
-            if (run.signal.aborted) {
-                return err(run.signal.reason);
-            }
-            if (!stopOn)
-                return results ? ok(results) : ok();
-            if (stopped)
-                return stopped;
-            if (results)
-                return ok(results);
-            // For all/allSettled/map/mapSettled with collect: false (no allFailed handler)
-            if (!allFailed)
-                return ok();
-            return allFailed === "completion" ? lastResult : lastIndexResult;
-        }
-        catch (e_8) {
-            env_8.error = e_8;
-            env_8.hasError = true;
-        }
-        finally {
-            __disposeResources(env_8);
-        }
-    };
-}
-/**
- * Error returned when a {@link fetch} {@link Task} fails.
- *
- * @group Composition
- */
-export const FetchError = /*#__PURE__*/ typed("FetchError", { error: Unknown });
-/**
- * Creates a {@link Task} that wraps the native
- * {@link https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API | Fetch API}.
- *
- * Handles cross-browser abort behavior — WebKit throws a `DOMException` with
- * message "Fetch is aborted" instead of propagating `signal.reason`. This
- * helper normalizes the behavior to always return {@link AbortError}.
- *
- * ### Example
- *
- * ```ts
- * await using run = createRun();
- *
- * const result = await run(fetch("https://api.example.com/users"));
- *
- * if (!result.ok) {
- *   // Handle FetchError or AbortError
- * }
- *
- * // Compose with timeout and retry
- * const fetchWithRetry = (url: string) =>
- *   retry(timeout(fetch(url), "10s"), retryStrategyAws);
- * ```
- *
- * @group Composition
- */
-export const fetch = (input, init) => ({ signal }) => tryAsync(() => globalThis.fetch(input, { ...init, signal }), (error) => {
-    if (AbortError.is(error))
-        return error;
-    // WebKit throws DOMException with message "Fetch is aborted" instead of
-    // propagating signal.reason. Detect this and create AbortError.
-    if (signal.aborted &&
-        error instanceof Error &&
-        error.message === "Fetch is aborted") {
-        return createAbortError(signal.reason);
-    }
-    return { type: "FetchError", error };
-});
-// TODO: Prioritized Task Scheduling API integration
-// https://developer.mozilla.org/en-US/docs/Web/API/Prioritized_Task_Scheduling_API
-//
-// - `run(task, { priority })` - Fiber-level priority via TaskController
-//   (extends AbortController), so the fiber's signal gets priority and all
-//   nested work inherits it.
-// - `fiber.setPriority(priority)` - Dynamic priority changes mid-flight via
-//   TaskController.setPriority().
-//
-// Note: scheduler.yield() inherits priority from enclosing postTask, so
-// yieldNow doesn't need a priority argument — just run the fiber at priority.
-//
-// Safari doesn't support it yet, Node.js probably never will (use setImmediate).
-// For Safari, scheduler-polyfill can be used.
-// https://www.npmjs.com/package/scheduler-polyfill
-// TODO: Do we really need specialized aborts?
+// TODO: Add Run observability after Task migration.
+// - Structured logging with levels, inherited log annotations, JSON output,
+//   filtering, and pluggable log sinks.
+// - Tracing spans with names, timing, parent-child relationships, attributes,
+//   error status, and helpers for annotating the current or child spans.
+// - Metrics for counters, gauges, histograms, and operation durations.
+// - Resource metadata for service name, service version, deployment
+//   environment, and user-provided attributes.
+// - Exporters for production telemetry backends, including OTLP-compatible
+//   logs, traces, and metrics.
+// - Transferable snapshots for local and worker monitoring. Current snapshots
+//   can contain arbitrary Result values and Error objects, so serialization must
+//   replace non-transferable values with safe diagnostics.
+// - Incremental snapshot invalidation so polling unchanged large Run trees
+//   avoids recursive traversal and child-array allocation.
+// - Run labels and structured annotations for rendering useful snapshot trees
+//   instead of anonymous ids.
+// - Snapshot and trace views should preserve ownership boundaries, so reusable
+//   resources and long-lived operations appear as labeled subtrees instead of
+//   unrelated child operations.