@youngspe/async-scope 0.1.0-dev.0 → 0.1.0-dev.1

package/dist/cancel.d.ts

@@ -10,7 +10,7 @@ export interface Cancellable {
     [Symbols.cancellableAdded]?(key: CancellableParent, sub: Subscription): boolean | void;
     [Symbols.cancellableRemoved]?(key: CancellableParent): void;
 }
-export type CancellableLike = Cancellable | Falsy | Disposable | AsyncDisposable | readonly CancellableLike[];
+export type CancellableLike<Extra = never> = Cancellable | Falsy | Disposable | AsyncDisposable | readonly CancellableLike<Extra>[] | Extra;
 export type CancellationListener = (reason: Error) => Awaitable<void>;
 export declare function cancelObject(target: CancellableOrDisposable, reason: Error): Promise<void>;
 export declare function cancel(target: CancellableLike, reason?: Error): Promise<void>;

package/dist/cancel.js

@@ -1,7 +1,6 @@
 import { CancellationError } from './error.js';
 import { Subscription } from './events/sub.js';
-import { whenAllSettled } from './join.js';
-import { isArray } from './utils.js';
+import { isArray, whenAllSettled } from '@youngspe/common-async-utils';
 export async function cancelObject(target, reason) {
     if (typeof target.cancel === 'function') {
         await target.cancel(reason);

package/dist/commonResources.d.ts

@@ -0,0 +1,3 @@
+import { ResourceKey } from "./scopedResource.ts";
+export declare const clock: ResourceKey<unknown, unknown>;
+//# sourceMappingURL=commonResources.d.ts.map

package/dist/commonResources.js

@@ -0,0 +1,3 @@
+import { ResourceKey } from "./scopedResource.js";
+export const clock = ResourceKey.create("clock");
+//# sourceMappingURL=commonResources.js.map

package/dist/error.d.ts

@@ -22,7 +22,7 @@ type ToError<T> = Error extends T ? Error : T extends Error ? T : Error;
  * - Any other value, a {@link CancellationError} with the {@link CancellationError.value|value} property
  *   set to `value`.
  */
-export declare function toError<T>(value: T): ToError<T>;
+export declare function toErrorForCancellation<T>(value: T): ToError<T>;
 /**
  * Combines an iterator of errors into a single value.
  *
@@ -33,5 +33,6 @@ export declare function toError<T>(value: T): ToError<T>;
  * - otherwise, an {@link AggregateError} of the items in `errors`, after removing `undefined` values and duplicates.
  */
 export declare function combineErrors(errors: Iterable<unknown>): unknown;
+export declare function unwrapCancellationError(error: unknown): CancellationError | undefined;
 export {};
 //# sourceMappingURL=error.d.ts.map

package/dist/error.js

@@ -1,4 +1,4 @@
-import { isArray, isIterable } from './utils.js';
+import { isArray, isIterable } from '@youngspe/common-async-utils';
 /**
  * Represents an operation that has been cancelled but not necessarily due to a failure.
  */
@@ -13,11 +13,22 @@ export class CancellationError extends Error {
     /** An arbitrary value attached to the error */
     value;
 }
-export function toError(value) {
+export function toErrorForCancellation(value) {
     const errors = new Set();
+    let isCancellation = true;
     const inner = (value) => {
-        if (value instanceof Error)
+        if (value instanceof Error) {
+            if (value.name === 'AbortError') {
+                if (value.cause !== undefined)
+                    return inner(value.cause);
+                return new CancellationError(undefined, { cause: value });
+            }
+            const cancellationError = unwrapCancellationError(value);
+            if (cancellationError)
+                return cancellationError;
+            isCancellation = false;
             return value;
+        }
         if (value === undefined)
             return;
         if (typeof value === 'string')
@@ -47,7 +58,9 @@ export function toError(value) {
     if (error)
         return error;
     if (errors.size > 1)
-        return new AggregateError(errors);
+        return isCancellation ?
+            new CancellationError(undefined, { cause: new AggregateError(errors) })
+            : new AggregateError(errors);
     [error] = errors;
     return error ?? new CancellationError();
 }
@@ -71,4 +84,13 @@ export function combineErrors(errors) {
     }
     return new AggregateError(errorSet);
 }
+export function unwrapCancellationError(error) {
+    while (true) {
+        if (error instanceof CancellationError)
+            return error;
+        if (!(error instanceof Error))
+            return undefined;
+        error = error.cause;
+    }
+}
 //# sourceMappingURL=error.js.map

package/dist/events/cancel.d.ts

@@ -3,11 +3,12 @@ import { Token, type TokenController } from '../token.ts';
 import type { Awaitable } from '../types.ts';
 import { GenericEventEmitter } from './generic.ts';
 import { type Subscription } from './sub.ts';
+import type { AddCancellableOptions } from '../token/base.ts';
 export declare class CancelEvent extends Token {
     #private;
     constructor(inner: GenericEventEmitter<Error, Awaitable<void>>);
     get error(): Error | undefined;
-    protected addOne(listener: CancellableOrDisposable): Subscription | undefined;
+    protected addOne(listener: CancellableOrDisposable, { paused, passive }?: AddCancellableOptions): Subscription | undefined;
     static createController(this: void, params?: Token.CreateParams): TokenController;
 }
 //# sourceMappingURL=cancel.d.ts.map

package/dist/events/cancel.js

@@ -1,7 +1,7 @@
+import { joinPromises } from '@youngspe/common-async-utils';
 import { cancelObject } from '../cancel.js';
-import { combineErrors, toError } from '../error.js';
+import { CancellationError, combineErrors, toErrorForCancellation, unwrapCancellationError, } from '../error.js';
 import * as Symbols from '../symbols.js';
-import { joinPromises } from '../join.js';
 import { Token } from '../token.js';
 import { GenericEventEmitter } from './generic.js';
 import {} from './sub.js';
@@ -16,13 +16,15 @@ export class CancelEvent extends Token {
     get error() {
         return this.#error;
     }
-    addOne(listener) {
+    addOne(listener, { paused, passive } = {}) {
         if (this.#error)
             return undefined;
         const sub = this.#inner.add(e => cancelObject(listener, e), {
             once: true,
             onRemove: listener[Symbols.cancellableRemoved]
                 && (() => void listener[Symbols.cancellableRemoved]?.(this.#key)),
+            paused,
+            passive,
         });
         if (sub.isActive) {
             listener[Symbols.cancellableAdded]?.(this.#key, sub);
@@ -34,35 +36,60 @@ export class CancelEvent extends Token {
         #parentSubs = new Map();
         #promise;
         #callbacks;
-        constructor(inner, callbacks) {
+        #filter;
+        #sealed;
+        constructor(inner, callbacks, sealed, filter) {
             this.#inner = inner;
             this.#callbacks = callbacks;
             this.token = new CancelEvent(inner.emitter);
+            this.#sealed = sealed;
+            this.#filter = filter;
         }
         token;
-        cancel = (reason) => (this.#promise ??= (async error => {
-            this.token.#error = error;
-            const callbacks = this.#callbacks;
-            const { onBeforeCancel, onAfterCancel } = callbacks;
-            callbacks.onBeforeCancel = callbacks.onAfterCancel = callbacks.onDefuse = undefined;
-            const errors = new Set();
-            try {
-                await onBeforeCancel?.(error);
+        cancel = (reason) => {
+            let error = toErrorForCancellation(reason);
+            const filter = this.#filter;
+            if (filter) {
+                const result = filter(error);
+                if (!result)
+                    return Promise.resolve();
+                this.#filter = undefined;
+                if (result === 'defuse') {
+                    this.defuse();
+                    return Promise.resolve();
+                }
+                else if (result instanceof Error) {
+                    error = result;
+                }
             }
-            catch (e) {
-                errors.add(e);
-            }
-            await joinPromises(this.#inner.getListeners().listeners(), l => l(error), undefined, e => errors.add(e));
-            try {
-                await onAfterCancel?.(error);
-            }
-            catch (e) {
-                errors.add(e);
-            }
-            if (errors.size)
-                throw combineErrors(errors);
-        })(toError(reason)));
-        defuse = () => this.#inner.dispose();
+            return (this.#promise ??= (async () => {
+                this.token.#error = error;
+                const callbacks = this.#callbacks;
+                const { onBeforeCancel, onAfterCancel } = callbacks;
+                callbacks.onBeforeCancel = callbacks.onAfterCancel = callbacks.onDefuse = undefined;
+                const errors = new Set();
+                try {
+                    await onBeforeCancel?.(error);
+                }
+                catch (e) {
+                    errors.add(e);
+                }
+                await joinPromises(this.#inner.getListeners().listeners(), l => l(error), undefined, e => void errors.add(e));
+                try {
+                    await onAfterCancel?.(error);
+                }
+                catch (e) {
+                    errors.add(e);
+                }
+                if (errors.size)
+                    throw toErrorForCancellation(errors);
+            })());
+        };
+        defuse = () => {
+            this.#filter = undefined;
+            this.#promise ??= Promise.resolve();
+            this.#inner.dispose();
+        };
         [Symbols.cancellableAdded] = (key, sub) => {
             if (this.token.isDefused || this.token.isCancelled || this.#parentSubs.has(key))
                 return false;
@@ -70,13 +97,16 @@ export class CancelEvent extends Token {
             return true;
         };
         [Symbols.cancellableRemoved] = (key) => {
-            this.#parentSubs.delete(key);
+            const removed = this.#parentSubs.delete(key);
+            if (removed && this.#sealed && this.#parentSubs.size === 0) {
+                this.defuse();
+            }
         };
         [Symbol.asyncDispose] = this.cancel;
-        static createInner({ onAfterCancel, onBeforeCancel, onDefuse, init, dispose, }) {
+        static createInner({ onAfterCancel, onBeforeCancel, onDefuse, init, dispose, sealed = false, filter, }) {
             const callbacks = { onBeforeCancel, onAfterCancel, onDefuse };
             return GenericEventEmitter.createController({
-                context: ctrl => new CancelEvent.#Controller(ctrl, callbacks),
+                context: ctrl => new CancelEvent.#Controller(ctrl, callbacks, sealed, filter),
                 init: ({ context }) => {
                     const parents = context.#parentSubs;
                     const _init = init?.(context);

package/dist/events/generic.d.ts

@@ -1,9 +1,9 @@
+import type { CancellableOptions } from '../cancel.ts';
 import type { OptionalUndefinedProps } from '../types.ts';
 import { type SubscriptionLifecycle, Subscription } from './sub.ts';
 export interface EventListenerKey {
 }
 export type MaybePromise<T, Async extends boolean> = T | (Async extends true ? Promise<T> : never);
-export type Awaitable<T> = T | Promise<T> | PromiseLike<T>;
 export interface ListenerSet<T, Ret> extends Disposable {
     get isEmpty(): boolean;
     listeners(): Generator<(value: T) => Ret, void, void>;
@@ -12,11 +12,15 @@ export interface ListenerSet<T, Ret> extends Disposable {
     callReversed(value: T): Generator<Ret, void, void>;
     popFront(): ((value: T) => Ret) | undefined;
     popBack(): ((value: T) => Ret) | undefined;
+    release(): void;
+    dispose(): void;
 }
-export interface GenericEventController<T, Ret = void, Async extends boolean = false, Context = void> extends Disposable {
-    readonly emitter: GenericEventEmitter<T, Ret>;
+export interface EventControllerLike<in T, out Ret = void, Async extends boolean = false> {
     readonly getListeners: (this: void) => MaybePromise<ListenerSet<T, Ret>, Async>;
     readonly dispose: (this: void) => void;
+}
+export interface GenericEventController<T, Ret = void, Async extends boolean = false, Context = void> extends Disposable, EventControllerLike<T, Ret, Async> {
+    readonly emitter: GenericEventEmitter<T, Ret>;
     get context(): Context;
 }
 export type GenericEventEmitterParams<T, Ret, Async extends boolean = false, Context = void> = OptionalUndefinedProps<GenericEventEmitterParams.Base<T, Ret, Async, Context>>;
@@ -31,21 +35,21 @@ type GenericEventLifecycle<T, Ret, Async extends boolean, Context> = Subscriptio
 ], [
     controller: GenericEventController<T, Ret, Async, Context>
 ]>;
-export interface AddListenerOptions {
-    signal?: AbortSignal | undefined;
+export interface AddListenerOptions extends CancellableOptions {
     once?: boolean | undefined;
     key?: EventListenerKey | undefined;
     onRemove?: (() => void) | undefined;
+    paused?: boolean | undefined;
+    /** If `true`, this listener will not keep the event source from pausing. */
+    passive?: boolean | undefined;
 }
-export declare class GenericEventEmitter<T, Ret = void> {
-    #private;
-    private constructor();
-    get isDisposed(): boolean;
-    add(listener: (this: void, value: T) => Ret, options?: AddListenerOptions): Subscription;
-    has(key: EventListenerKey | undefined | null): boolean;
-    remove(key: EventListenerKey | undefined | null): boolean;
-    static createController<T, Ret = void, Async extends boolean = false, Context = void>(this: void, params: GenericEventEmitterParams<T, Ret, Async, Context>): GenericEventController<T, Ret, Async, Context>;
-    static create<T, Ret = void, Async extends boolean = false>(this: void, params: GenericEventEmitterParams<T, Ret, Async>): GenericEventEmitter<T, Ret>;
+export declare abstract class GenericEventEmitter<out T, in Ret = void> {
+    abstract get isDisposed(): boolean;
+    abstract add(listener: (this: void, value: T) => Ret, options?: AddListenerOptions): Subscription;
+    abstract has(key: EventListenerKey | undefined | null): boolean;
+    abstract remove(key: EventListenerKey | undefined | null): boolean;
+    static createController<T, Ret = void, Async extends boolean = false, Context = undefined>(this: void, params: GenericEventEmitterParams<T, Ret, Async, Context>): GenericEventController<T, Ret, Async, Context>;
+    static create<T, Ret = void, Async extends boolean = false, Context = undefined>(this: void, params: GenericEventEmitterParams<T, Ret, Async, Context>): GenericEventEmitter<T, Ret>;
 }
 export {};
 //# sourceMappingURL=generic.d.ts.map

package/dist/events/generic.js

@@ -1,3 +1,4 @@
+import { Token } from '../token.js';
 import { SubscriptionLifecycleManager, Subscription } from './sub.js';
 function wrapListener(listener) {
     let _listener = listener;
@@ -123,8 +124,8 @@ class GenericEventEmitterState {
             return 'disposed';
         if (this.handlers.has(handler.key))
             return;
-        const { paused } = handler;
-        if (!paused && this.#activeCount++ === 0) {
+        const { paused, passive } = handler;
+        if (!passive && !paused && this.#activeCount++ === 0) {
             const args = this.#getLifecycleArgs();
             if (!args)
                 return;
@@ -140,9 +141,9 @@ class GenericEventEmitterState {
         if (!handler)
             return false;
         this.handlers.delete(key);
-        const { paused } = handler;
+        const { paused, passive } = handler;
         handler.dispose?.();
-        if (!paused && --this.#activeCount === 0) {
+        if (!passive && !paused && --this.#activeCount === 0) {
             this.#lifecycle.pause();
         }
         return true;
@@ -151,9 +152,9 @@ class GenericEventEmitterState {
         const handler = this.handlers?.get(key);
         if (!handler)
             return;
-        const { paused } = handler;
+        const { paused, passive } = handler;
         handler.paused = false;
-        if (paused && this.#activeCount++ === 0) {
+        if (!passive && paused && this.#activeCount++ === 0) {
             const args = this.#getLifecycleArgs();
             if (!args)
                 return;
@@ -164,9 +165,9 @@ class GenericEventEmitterState {
         const handler = this.handlers?.get(key);
         if (!handler)
             return;
-        const { paused } = handler;
+        const { paused, passive } = handler;
         handler.paused = true;
-        if (!paused && --this.#activeCount === 0) {
+        if (!passive && !paused && --this.#activeCount === 0) {
             this.#lifecycle.pause();
         }
     }
@@ -186,16 +187,26 @@ class GenericEventEmitterState {
     }
 }
 export class GenericEventEmitter {
+    static createController(params) {
+        return DefaultGenericEventEmitter._createController(params);
+    }
+    static create(params) {
+        return DefaultGenericEventEmitter._create(params);
+    }
+}
+class DefaultGenericEventEmitter extends GenericEventEmitter {
     #state;
     constructor(state) {
+        super();
         this.#state = state;
     }
     get isDisposed() {
         return !this.#state?.deref()?.handlers;
     }
     add(listener, options) {
-        const { signal, onRemove, once = false } = options ?? {};
-        if (signal?.aborted)
+        const { onRemove, once = false, paused = false, passive = false } = options ?? {};
+        const token = Token.from(options);
+        if (token?.isCancelled)
             return Subscription.noop;
         let _state = this.#state;
         const state = _state?.deref();
@@ -205,11 +216,11 @@ export class GenericEventEmitter {
             state.removeHandler(options.key);
         }
         const key = options?.key ?? {};
-        const handler = { key, listener, once, paused: false };
+        const handler = { key, listener, once, paused, passive };
         const sub = Subscription.fromLifecycle({
             init: () => ({
-                resume: first => {
-                    if (!first) {
+                resume: initializing => {
+                    if (!initializing) {
                         _state?.deref()?.resumeHandler(key);
                     }
                     return { pause: () => _state?.deref()?.pauseHandler(key) };
@@ -221,24 +232,23 @@ export class GenericEventEmitter {
                 s?.deref()?.removeHandler(key);
             },
             isActive: () => !!_state?.deref()?.handlers?.has(key),
+            paused,
         });
-        let removeSignal = undefined;
-        if (signal) {
-            const onAbort = () => sub.dispose();
-            signal.addEventListener('abort', onAbort, { once: true });
-            removeSignal = () => signal.removeEventListener('abort', onAbort);
+        let tokenSub = token?.isDefused === false ? token.add(sub) : undefined;
+        if (!tokenSub?.isActive) {
+            tokenSub = undefined;
         }
         handler.dispose =
-            onRemove && removeSignal ?
+            onRemove && tokenSub ?
                 () => {
                     try {
-                        removeSignal();
+                        tokenSub.dispose();
                     }
                     finally {
                         onRemove();
                     }
                 }
-                : onRemove || removeSignal;
+                : onRemove || tokenSub?.dispose.bind(tokenSub);
         state.addHandler(handler);
         return sub;
     }
@@ -262,7 +272,7 @@ export class GenericEventEmitter {
             this.#isAsync = isAsync ?? false;
             this.#state = new GenericEventEmitterState(lifecycle);
             this.#state.controller = new WeakRef(this);
-            this.emitter = new GenericEventEmitter(new WeakRef(this.#state));
+            this.emitter = new DefaultGenericEventEmitter(new WeakRef(this.#state));
             this.#getContext = context;
             controllerFinalizationRegistry.register(this, this.#state, this.#state);
         }
@@ -306,11 +316,11 @@ export class GenericEventEmitter {
             return this.#context;
         }
     };
-    static createController(params) {
-        return new GenericEventEmitter.#Controller(params);
+    static _createController(params) {
+        return new DefaultGenericEventEmitter.#Controller(params);
     }
-    static create(params) {
-        return GenericEventEmitter.createController(params).emitter;
+    static _create(params) {
+        return DefaultGenericEventEmitter.createController(params).emitter;
     }
 }
 //# sourceMappingURL=generic.js.map

package/dist/events/sub.d.ts

@@ -55,9 +55,10 @@ export declare abstract class Subscription {
         resume(): void;
         [Symbol.dispose](): void;
     }>;
-    static fromLifecycle(this: void, lifecycle: (SubscriptionLifecycle<[], [first: boolean]> & {
+    static fromLifecycle(this: void, lifecycle: (SubscriptionLifecycle<[], [initializing: boolean]> & {
         isActive?: ((this: void) => boolean) | undefined;
-    }) | (() => SubscriptionLifecycle.Initialized<[first: boolean]>) | undefined): Subscription;
+        paused?: boolean | undefined;
+    }) | (() => SubscriptionLifecycle.Initialized<[initializing: boolean]>) | undefined): Subscription;
     static collect(this: void, subscriptions: Iterable<Subscription | Falsy>): Subscription;
 }
 export {};

package/dist/events/sub.js

@@ -141,14 +141,18 @@ class LifecycleSubscription extends Subscription {
     #isActive;
     constructor(lifecycle) {
         super();
+        let paused = false;
         if (typeof lifecycle !== 'function') {
             this.#isActive = lifecycle?.isActive;
+            paused = lifecycle?.paused ?? false;
         }
         this.#lifecycle =
             lifecycle
                 && new SubscriptionLifecycleManager(typeof lifecycle === 'function' ? { init: lifecycle } : lifecycle);
         this.#initialized = this.#lifecycle?.init();
-        this.#initialized?.resume(true);
+        if (!paused) {
+            this.#initialized?.resume(true);
+        }
     }
     resume() {
         this.#initialized?.resume(false);

package/dist/events/utils.d.ts

@@ -0,0 +1,19 @@
+import type { CancellableOptions } from '../cancel.ts';
+import { GenericEventEmitter, type AddListenerOptions } from '../events.ts';
+import { type ScopeContext } from '../scope.ts';
+import type { Awaitable, OptionalUndefinedParams, UndefinedIfDefault } from '../types.ts';
+type OnNextEventListenerReturn<U, Ret> = UndefinedIfDefault<OptionalUndefinedParams<[Awaitable<U>, Ret]>, [
+]>;
+type OnNextEventListenerReturnAsync<U, Ret> = PromiseLike<UndefinedIfDefault<OptionalUndefinedParams<[Awaitable<U>, Awaitable<Ret>]>>>;
+interface NextEventOptions<UCancel> extends CancellableOptions, Pick<AddListenerOptions, 'passive'> {
+    onDispose?: (() => Awaitable<UCancel>) | undefined;
+}
+export declare function onNextEvent<T, Ret, U, UCancel = never>(emitter: GenericEventEmitter<T, Promise<Ret>>, listener: (this: void, cx: ScopeContext<{
+    value: T;
+}>) => OnNextEventListenerReturnAsync<U, Ret>, options?: NextEventOptions<UCancel>): Promise<U | UCancel>;
+export declare function onNextEvent<T, Ret, U, UCancel = never>(emitter: GenericEventEmitter<T, Ret>, listener: (this: void, cx: ScopeContext<{
+    value: T;
+}>) => OnNextEventListenerReturn<U, Ret>, options?: NextEventOptions<UCancel>): Promise<U | UCancel>;
+export declare function nextEvent<T, UCancel = never>(emitter: GenericEventEmitter<T, undefined>, options?: NextEventOptions<UCancel>): Promise<T | UCancel>;
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/dist/events/utils.js

@@ -0,0 +1,56 @@
+import { isPromiseLike } from '@youngspe/common-async-utils';
+import { GenericEventEmitter } from '../events.js';
+import { Scope } from '../scope.js';
+import { Token } from '../token.js';
+export async function onNextEvent(emitter, listener, options) {
+    const scope = Scope.from(options);
+    scope.throwIfClosed();
+    let onDispose = options?.onDispose;
+    using _sub = onDispose
+        && scope.token.add(() => {
+            onDispose = undefined;
+        });
+    return await scope.resolveOrCancel(new Promise((resolve, reject) => {
+        emitter.add(value => {
+            try {
+                _sub?.dispose();
+                onDispose = undefined;
+                const result = listener(scope.withContextValues({ value }).getContext());
+                if (isPromiseLike(result))
+                    return Promise.resolve(result.then(args => {
+                        resolve(args?.[0]);
+                        return args?.[1];
+                    })).catch(error => {
+                        reject(error);
+                        throw error;
+                    });
+                resolve(result?.[0]);
+                return result?.[1];
+            }
+            catch (error) {
+                reject(error);
+                throw error;
+            }
+        }, {
+            once: true,
+            scope,
+            passive: options?.passive,
+            onRemove: (_sub || onDispose)
+                && (() => {
+                    _sub?.dispose();
+                    if (onDispose) {
+                        try {
+                            resolve(onDispose());
+                        }
+                        catch (error) {
+                            reject(error);
+                        }
+                    }
+                }),
+        });
+    }));
+}
+export function nextEvent(emitter, options) {
+    return onNextEvent(emitter, ({ value }) => [value], options);
+}
+//# sourceMappingURL=utils.js.map

package/dist/events.d.ts

@@ -1,3 +1,4 @@
-export { GenericEventEmitter, type GenericEventEmitterParams, type GenericEventController, type AddListenerOptions, type EventListenerKey, type ListenerSet, type MaybePromise, } from './events/generic.ts';
+export { GenericEventEmitter, type EventControllerLike, type GenericEventEmitterParams, type GenericEventController, type AddListenerOptions, type EventListenerKey, type ListenerSet, type MaybePromise, } from './events/generic.ts';
 export { Subscription, type SubscriptionLifecycle, SubscriptionLifecycleManager } from './events/sub.ts';
+export { onNextEvent } from './events/utils.ts';
 //# sourceMappingURL=events.d.ts.map

package/dist/events.js

@@ -1,3 +1,4 @@
 export { GenericEventEmitter, } from './events/generic.js';
 export { Subscription, SubscriptionLifecycleManager } from './events/sub.js';
+export { onNextEvent } from './events/utils.js';
 //# sourceMappingURL=events.js.map

package/dist/index.d.ts

@@ -1,7 +1,10 @@
-export { Token, type TokenController } from './token.ts';
+export { Token, type TokenController, type AddCancellableOptions, type ErrorFilter } from './token.ts';
 export { Scope, type CommonScopeOptions, type ScopeContext, type ScopeRunOptions, type ToScope, } from './scope.ts';
 export { cancel, type Cancellable, type CancellableLike, type CancellableOptions, type CancellableParent, type CancellationListener, } from './cancel.ts';
+export { CancellationError, toErrorForCancellation, unwrapCancellationError } from './error.ts';
 export * as Symbols from './symbols.ts';
 export * from './events.ts';
 export { ResourceError, ResourceKey, type ResourceReadKey, type ResourceWriteKey, ScopedResources, } from './scopedResource.ts';
+export { Lock, type Guard, type SharedGuard } from './lock.ts';
+export { delay, type Clock, GlobalClock, type TimerOptions } from './timers.ts';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,7 +1,10 @@
 export { Token } from './token.js';
 export { Scope, } from './scope.js';
 export { cancel, } from './cancel.js';
+export { CancellationError, toErrorForCancellation, unwrapCancellationError } from './error.js';
 export * as Symbols from './symbols.js';
 export * from './events.js';
 export { ResourceError, ResourceKey, ScopedResources, } from './scopedResource.js';
+export { Lock } from './lock.js';
+export { delay, GlobalClock } from './timers.js';
 //# sourceMappingURL=index.js.map

package/dist/lock.d.ts

@@ -0,0 +1,18 @@
+import type { CancellableOptions } from './cancel.ts';
+import type { OptionalUndefinedParams } from './types.ts';
+export interface SharedGuard<out T> extends Disposable {
+    get value(): T;
+    release(): void;
+}
+export interface Guard<in out T> extends SharedGuard<T> {
+    set value(value: T);
+}
+export declare class Lock<T = void> {
+    #private;
+    constructor(...[value]: OptionalUndefinedParams<[value: T]>);
+    acquireShared(options?: CancellableOptions): Promise<SharedGuard<T>>;
+    acquire(options?: CancellableOptions): Promise<Guard<T>>;
+    tryAcquireShared(options?: CancellableOptions): SharedGuard<T> | undefined;
+    tryAcquire(options?: CancellableOptions): Guard<T> | undefined;
+}
+//# sourceMappingURL=lock.d.ts.map