@dxos/async 0.10.0 → 0.11.1

package/dist/lib/index.mjs

@@ -0,0 +1,1327 @@
+import { a as sleepWithContext, c as observableError, i as sleep, l as toError, n as asyncReturn, o as unrefTimeout, r as asyncTimeout, s as TimeoutError, t as Event } from "./chunk-events.mjs";
+import { ComplexMap, createSetDispatch } from "@dxos/util";
+import { Context, ContextDisposedError, LifecycleState, Resource, cancelWithContext } from "@dxos/context";
+import { StackTrace, warnAfterTimeout } from "@dxos/debug";
+import Observable from "zen-observable";
+import PushStream from "zen-push";
+import { invariant } from "@dxos/invariant";
+import { log } from "@dxos/log";
+//#region src/callback.ts
+/**
+* Helper to convert a callback based API into a promise based API.
+*/
+var promiseFromCallback = (run) => new Promise((resolve, reject) => {
+	run((error, value) => {
+		if (error) reject(error);
+		else resolve(value);
+	});
+});
+//#endregion
+//#region src/chain.ts
+/**
+* Async reducer iteratively applies functions to the given array of elements.
+*/
+var chain = (chain) => async (elements) => {
+	let result = await elements;
+	for (const part of chain) result = await Promise.all(result.map(async (element) => await part(element)));
+	return result;
+};
+//#endregion
+//#region src/cleanup.ts
+/**
+* Combine multiple cleanup functions into a single cleanup function.
+* Can be used in effect hooks in conjunction with `addEventListener`.
+*/
+var combine = (...cleanupFns) => {
+	return () => {
+		cleanupFns.flat().filter((f) => typeof f === "function").forEach((cleanupFn) => cleanupFn());
+	};
+};
+var timeout = (cb, ms = 0) => {
+	const t = setTimeout(cb, ms);
+	return () => clearTimeout(t);
+};
+var interval = (cb, ms) => {
+	const t = setInterval(cb, ms);
+	return () => clearInterval(t);
+};
+/**
+* Add the event listener and return a cleanup function.
+* Can be used in effect hooks in conjunction with `combine`.
+*/
+var addEventListener = (target, type, listener, options) => {
+	target.addEventListener(type, listener, options);
+	return () => target.removeEventListener(type, listener, options);
+};
+var SubscriptionList = class {
+	_cleanups = [];
+	add(...cb) {
+		this._cleanups.push(...cb);
+		return this;
+	}
+	clear() {
+		this._cleanups.forEach((cb) => cb());
+		this._cleanups.length = 0;
+	}
+};
+var SubscriptionSet = class {
+	_cleanupMap;
+	constructor(keyProjection) {
+		this._cleanupMap = new ComplexMap(keyProjection);
+	}
+	set(key, cb) {
+		this._cleanupMap.set(key, cb);
+		return this;
+	}
+	clear() {
+		this._cleanupMap.forEach((cb) => cb());
+		this._cleanupMap.clear();
+	}
+};
+//#endregion
+//#region src/debounce.ts
+/**
+* Delay callback execution by a specified time.
+* Unlike debounce, subsequent calls during the delay period are ignored.
+*
+* @param cb Callback to invoke.
+* @param delay Time to wait before invoking the callback.
+* @returns A new function that schedules the callback once and ignores subsequent calls until executed.
+*/
+var delay = (cb, delay = 100) => {
+	let pending = false;
+	return ((...args) => {
+		if (pending) return;
+		pending = true;
+		setTimeout(() => {
+			try {
+				cb(...args);
+			} finally {
+				pending = false;
+			}
+		}, delay);
+	});
+};
+/**
+* Debounce callback: delays execution until calls stop.
+* Each new call resets the timer, so the callback fires only after the delay elapses with no further calls (trailing-edge).
+* Use when you want to react to the end of a burst of events (e.g. user stops typing).
+*
+* @param cb Callback to invoke.
+* @param delay Idle time (ms) to wait after the last call before invoking.
+* @returns Wrapped function that postpones invocation until activity ceases.
+*/
+var debounce = (cb, delay = 100) => {
+	let t;
+	return ((...args) => {
+		clearTimeout(t);
+		t = setTimeout(() => cb(...args), delay);
+	});
+};
+/**
+* Throttle callback: limits execution to at most once per interval.
+* The callback fires immediately on the first call;
+* subsequent calls within the same interval are dropped (leading-edge).
+* Use when you need regular updates at a bounded rate (e.g. scroll or resize handlers).
+*
+* @param cb Callback to invoke.
+* @param delay Minimum interval (ms) between successive invocations.
+* @returns Wrapped function that rate-limits invocations.
+*/
+var throttle = (cb, delay = 100) => {
+	let lastCall = 0;
+	return ((...args) => {
+		const now = Date.now();
+		if (now - lastCall >= delay) {
+			cb(...args);
+			lastCall = now;
+		}
+	});
+};
+/**
+* Debounce and throttle callback.
+* Executes immediately on the first call (throttle), prevents calls during the throttle window,
+* and ensures a final call happens after activity stops (debounce).
+*
+* @param cb Callback to invoke.
+* @param delay Time window for both throttle and debounce.
+* @returns A new function that combines throttle and debounce behavior.
+*/
+var debounceAndThrottle = (cb, delay = 100) => {
+	let timeout;
+	let lastCall = 0;
+	return ((...args) => {
+		const now = Date.now();
+		const delta = now - lastCall;
+		clearTimeout(timeout);
+		if (delta >= delay) {
+			cb(...args);
+			lastCall = now;
+		} else timeout = setTimeout(() => {
+			cb(...args);
+			lastCall = Date.now();
+		}, delay - delta);
+	});
+};
+//#endregion
+//#region src/event-emitter.ts
+/**
+* Adds the listener and returns a function to remove it.
+* Promotes removing listeners when cleaning up objects (to prevent leaks).
+*/
+var onEvent = (eventEmitter, eventName, callback) => {
+	eventEmitter.on(eventName, callback);
+	return () => eventEmitter.off(eventName, callback);
+};
+/**
+* @deprecated
+*/
+var addListener = (eventEmitter, eventName, callback) => {
+	const off = onEvent(eventEmitter, eventName, callback);
+	return { remove: () => off() };
+};
+/**
+* Waits for an event with an optional test condition.
+*/
+var waitForEvent = (eventEmitter, eventName, test, timeout, error) => {
+	let off;
+	const promise = new Promise((resolve) => {
+		off = onEvent(eventEmitter, eventName, (...args) => {
+			if (!test || test(...args)) resolve(...args);
+		});
+	});
+	return timeout ? asyncTimeout(promise, timeout, error ?? /* @__PURE__ */ new Error()).finally(off) : promise.finally(off);
+};
+//#endregion
+//#region src/mutex.ts
+/**
+* A locking mechanism to ensure that a given section of the code is executed by only one single "thread" at a time.
+*
+* Functions are chained in a structure similar to a linked list.
+* `_lastPromise` always contains the function that will finish executing last.
+*
+* Initially it is set to `Promise.resolve()` -- a promise that resolves immediately.
+* Enqueuing is done by attaching provided function to the `_lastPromise` via a `.then()` call
+* then updating the `_lastPromise` variable.
+*
+* It is important that enqueuing is done atomically:
+* there are no `await`s in `executeSynchronized` and it's not async while still returning a promise.
+*
+* Java docs reference on synchronized sections:
+* https://docs.oracle.com/javase/tutorial/essential/concurrency/locksync.html
+*/
+var Mutex = class {
+	_queue = Promise.resolve();
+	_queueLength = 0;
+	_tag = null;
+	get tag() {
+		return this._tag;
+	}
+	isLocked() {
+		return this._queueLength > 0;
+	}
+	/**
+	* Acquires the lock.
+	* Caller is responsible for releasing the lock using the returned callback.
+	* NOTE: Using `executeSynchronized` is preferred over using `acquire` directly.
+	* @returns Release callback
+	*/
+	async acquire(tag) {
+		const prev = this._queue;
+		let guard;
+		this._queueLength++;
+		this._queue = new Promise((resolve) => {
+			guard = new MutexGuard(() => {
+				this._queueLength--;
+				this._tag = null;
+				resolve();
+			});
+		});
+		await prev;
+		if (tag !== void 0) this._tag = tag;
+		return guard;
+	}
+	/**
+	* Waits for all previous executions to complete and then executes a given function.
+	* Only a single function can be executed at a time.
+	* Function are executed in the same order as `executeSynchronized` is called.
+	* WARNING: Calling `executeSynchronized` inside of `executeSynchronized` on the same lock instance is a deadlock.
+	*/
+	async executeSynchronized(fun) {
+		const guard = await this.acquire();
+		try {
+			return await fun();
+		} finally {
+			guard.release();
+		}
+	}
+};
+var MutexGuard = class {
+	_release;
+	constructor(_release) {
+		this._release = _release;
+	}
+	/**
+	* Releases the lock.
+	*/
+	release() {
+		this._release();
+	}
+	[Symbol.dispose]() {
+		this.release();
+	}
+};
+var classMutexSymbol = Symbol("class-mutex");
+var enableWarning = globalThis.mochaExecutor;
+/**
+* Same as `synchronized` in Java.
+* Uses a lock global to the current class instance.
+* This way every synchronized method on the same instance will share a single lock.
+*/
+var synchronized = (target, propertyName, descriptor) => {
+	const method = descriptor.value;
+	descriptor.value = async function synchronizedMethod(...args) {
+		const mutex = this[classMutexSymbol] ??= new Mutex();
+		const tag = `${target.constructor.name}.${propertyName}`;
+		let guard;
+		if (!enableWarning) guard = await mutex.acquire(tag);
+		else guard = await warnAfterTimeout(1e4, `lock on ${tag} (taken by ${mutex.tag})`, () => mutex.acquire(tag));
+		try {
+			return await method.apply(this, args);
+		} finally {
+			guard.release();
+		}
+	};
+	Object.defineProperty(descriptor.value, "name", { value: propertyName + "$synchronized" });
+};
+//#endregion
+//#region src/trigger.ts
+var __dxlog_file$4 = "/__w/dxos/dxos/packages/common/async/src/trigger.ts";
+/**
+* Returns a tuple containing a Promise that will be resolved when the resolver function is called.
+* @deprecated Use `Trigger` instead.
+*/
+var trigger = (timeout) => {
+	let callback;
+	const promise = new Promise((resolve, reject) => {
+		if (timeout) setTimeout(() => reject(/* @__PURE__ */ new Error(`Timed out after ${timeout.toLocaleString()}ms`)), timeout);
+		callback = resolve;
+	});
+	const provider = () => promise;
+	const resolver = (value) => callback(value);
+	return [provider, resolver];
+};
+var TriggerState = /* @__PURE__ */ function(TriggerState) {
+	TriggerState["WAITING"] = "WAITING";
+	TriggerState["RESOLVED"] = "RESOLVED";
+	TriggerState["REJECTED"] = "REJECTED";
+	return TriggerState;
+}({});
+/**
+* Enables blocked listeners to be awakened with optional timeouts.
+*
+* Has two states:
+* - WAITING: promise is in pending state and will be resolved once `wake()` is called.
+* - RESOLVED: promise is already resolved, and all calls to `wait()` resolve immediately.
+* - REJECTED: promise is rejected, and all calls to `wait()` return rejected promise.
+*
+* Trigger starts in WAITING state initially.
+* Use `reset()` to switch resolved trigger back to WAITING state.
+*/
+var Trigger = class {
+	_options;
+	_promise;
+	_resolve;
+	_reject;
+	_state = "WAITING";
+	constructor(_options = { autoReset: false }) {
+		this._options = _options;
+		this.reset();
+	}
+	get state() {
+		return this._state;
+	}
+	/**
+	* Wait until wake is called, with optional timeout.
+	*/
+	async wait({ timeout } = {}) {
+		if (timeout) return asyncTimeout(this._promise, timeout, new TimeoutError(timeout));
+		else return this._promise;
+	}
+	/**
+	* Wake blocked callers (if any).
+	* NOOP if the trigger is already resolved.
+	*/
+	wake(value) {
+		if (this._state !== "WAITING") return this;
+		this._state = "RESOLVED";
+		this._resolve(value);
+		if (this._options.autoReset) return this.reset();
+		return this;
+	}
+	/**
+	* Reset promise (new waiters will wait).
+	*/
+	reset() {
+		this._state = "WAITING";
+		this._promise = new Promise((resolve, reject) => {
+			this._resolve = resolve;
+			this._reject = reject;
+		});
+		this._promise.catch(() => {});
+		return this;
+	}
+	/**
+	* Throw error to blocked callers (if any).
+	* NOOP if the trigger is already resolved.
+	*/
+	throw(error) {
+		if (this._state !== "WAITING") return this;
+		this._state = "REJECTED";
+		this._reject(error);
+		if (this._options.autoReset) return this.reset();
+		return this;
+	}
+};
+/**
+* Returns a callback and a promise that's resolved when the callback is called n times.
+* @deprecated Use `Trigger` instead.
+*/
+var latch = ({ count = 1, timeout } = {}) => {
+	invariant(count >= 0, void 0, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$4,
+		L: 139,
+		S: void 0,
+		A: ["count >= 0", ""]
+	});
+	let t;
+	let doResolve;
+	let doReject;
+	const promise = new Promise((resolve, reject) => {
+		doResolve = (value) => {
+			clearTimeout(t);
+			resolve(value);
+		};
+		doReject = (err) => {
+			clearTimeout(t);
+			reject(err);
+		};
+	});
+	if (count === 0) setTimeout(() => {
+		doResolve(0);
+	});
+	else if (timeout) t = setTimeout(() => {
+		doReject(/* @__PURE__ */ new Error(`Timed out after ${timeout.toLocaleString()}ms`));
+	}, timeout);
+	let i = 0;
+	return [
+		async () => await promise,
+		() => {
+			if (++i === count) doResolve(i);
+			return i;
+		},
+		(err) => doReject(err)
+	];
+};
+//#endregion
+//#region src/observable.ts
+/**
+* Observable which supports multiple subscribers and stores the current value.
+*
+* The current value is emitted to new subscribers on subscription.
+*/
+var MulticastObservable = class MulticastObservable extends Observable {
+	_value;
+	_observers = /* @__PURE__ */ new Set();
+	_observable;
+	_completed = new Trigger();
+	constructor(subscriber, _value) {
+		super((observer) => this._subscribe(observer));
+		this._value = _value;
+		this._observable = typeof subscriber === "function" ? new Observable(subscriber) : subscriber;
+		this._observable.subscribe(this._handlers);
+	}
+	static from(value, initialValue) {
+		if ("emit" in value) return new MulticastObservable((observer) => {
+			value.on((data) => {
+				observer.next(data);
+			});
+		}, initialValue);
+		const observable = Observable.from(value);
+		return new MulticastObservable(observable, initialValue);
+	}
+	static of(...items) {
+		return new MulticastObservable(Observable.of(...items.slice(1)), items[0]);
+	}
+	/**
+	* @returns Stable reference to an observable that always returns `undefined`.
+	*/
+	static empty() {
+		return EMPTY_OBSERVABLE;
+	}
+	/**
+	* Get the current value of the observable.
+	*/
+	get() {
+		if (this._value === void 0) throw new Error("MulticastObservable is not initialized.");
+		return this._value;
+	}
+	/**
+	* Wait for the observable to complete.
+	*
+	* @returns Promise that resolves to the value of the observable at the time of completion.
+	*/
+	async wait({ timeout } = {}) {
+		await this._completed.wait({ timeout });
+		return this.get();
+	}
+	forEach(callback) {
+		return this._observable.forEach(callback);
+	}
+	map(callback) {
+		return new MulticastObservable(this._observable.map(callback), this._value && callback(this._value));
+	}
+	filter(callback) {
+		return new MulticastObservable(this._observable.filter(callback), this._value && callback(this._value) ? this._value : void 0);
+	}
+	reduce(callback, initialValue) {
+		return new MulticastObservable(initialValue ? this._observable.reduce(callback, initialValue) : this._observable.reduce(callback), initialValue ?? this._value);
+	}
+	flatMap(callback) {
+		return new MulticastObservable(this._observable.flatMap(callback), this._value && callback(this._value).get());
+	}
+	concat(...observables) {
+		return new MulticastObservable(this._observable.concat(...observables), this._value);
+	}
+	/**
+	* Concatenates multicast observables without losing the current value.
+	* @param reducer reduces the values of any multicast observables being concatenated into a single value
+	* @param observables observables to concatenate
+	* @returns concatenated observable
+	*/
+	losslessConcat(reducer, ...observables) {
+		const multicast = observables.filter((observable) => observable instanceof MulticastObservable);
+		const value = reducer(this._value, multicast.map((observable) => observable.get()));
+		return new MulticastObservable(this._observable.concat(...observables), value);
+	}
+	_subscribe(observer) {
+		if (!this._observers.has(observer)) this._observers.add(observer);
+		if (this._value !== void 0) observer.next?.(this._value);
+		return () => {
+			this._observers.delete(observer);
+		};
+	}
+	_handlers = {
+		next: (value) => {
+			this._value = value;
+			this._observers.forEach((observer) => observer.next?.(value));
+		},
+		error: (err) => {
+			this._observers.forEach((observer) => observer.error?.(err));
+		},
+		complete: () => {
+			this._completed.wake();
+			this._observers.forEach((observer) => observer.complete?.());
+		}
+	};
+};
+var EMPTY_OBSERVABLE = MulticastObservable.of(null);
+//#endregion
+//#region src/observable-value.ts
+/**
+* Provider that manages a set of subscriptions.
+* @deprecated
+*/
+var ObservableProvider = class {
+	_handlers = /* @__PURE__ */ new Set();
+	_proxy = createSetDispatch({ handlers: this._handlers });
+	_value;
+	/**
+	* Proxy used to dispatch callbacks to each subscription.
+	*/
+	get callback() {
+		return this._proxy;
+	}
+	get value() {
+		return this._value;
+	}
+	setValue(value) {
+		this._value = value;
+	}
+	subscribe(handler) {
+		this._handlers.add(handler);
+		return () => {
+			this._handlers.delete(handler);
+		};
+	}
+};
+/**
+* Implements subscriptions with ability to be cancelled.
+* @deprecated
+*/
+var CancellableObservableProvider = class extends ObservableProvider {
+	_handleCancel;
+	_cancelled = false;
+	constructor(_handleCancel) {
+		super();
+		this._handleCancel = _handleCancel;
+	}
+	get cancelled() {
+		return this._cancelled;
+	}
+	async cancel() {
+		if (this._cancelled) return;
+		this._cancelled = true;
+		await this._handleCancel?.();
+		this.callback.onCancelled?.();
+	}
+};
+//#endregion
+//#region src/track-leaks.ts
+var __dxlog_file$3 = "/__w/dxos/dxos/packages/common/async/src/track-leaks.ts";
+var enabled = typeof process !== "undefined" && !!process.env.DX_TRACK_LEAKS;
+var openResources = /* @__PURE__ */ new Set();
+var handleSymbol = Symbol("checkLeaksHandle");
+var trackResource = (resourceProvider) => {
+	if (!enabled) return () => {};
+	const resource = resourceProvider();
+	openResources.add(resource);
+	return () => {
+		openResources.delete(resource);
+	};
+};
+/**
+* Makes sure that the resource is at the end of the test.
+*
+* Example:
+*
+* ```typescript
+* @trackLeaks('open', 'close')
+* class Resource {}
+* ```
+*/
+var trackLeaks = (open, close) => (target) => {
+	if (!enabled) return;
+	const openMethod = target.prototype[open];
+	const closeMethod = target.prototype[close];
+	if (!openMethod || !closeMethod) throw new Error(`Cannot find ${open} or ${close} method in ${target.name}`);
+	target.prototype[open] = async function(...args) {
+		this[handleSymbol] = trackResource(() => ({
+			name: target.name,
+			openStack: new StackTrace()
+		}));
+		return openMethod.apply(this, args);
+	};
+	Object.defineProperty(target.prototype[open], "name", { value: open + "$checkLeaks" });
+	target.prototype[close] = async function(...args) {
+		this[handleSymbol]?.();
+		return closeMethod.apply(this, args);
+	};
+	Object.defineProperty(target.prototype[close], "name", { value: close + "$checkLeaks" });
+};
+var dumpLeaks = () => {
+	if (!enabled) return;
+	log.info(`Leaked resources ${openResources.size}:`, void 0, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$3,
+		L: 82,
+		S: void 0
+	});
+	for (const resource of openResources) {
+		log.info(`- ${resource.name} at`, void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$3,
+			L: 84,
+			S: void 0
+		});
+		log.info(resource.openStack.getStack(1), void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$3,
+			L: 85,
+			S: void 0
+		});
+		log.info("\n", void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$3,
+			L: 86,
+			S: void 0
+		});
+	}
+};
+if (enabled) global.dxDumpLeaks = dumpLeaks;
+//#endregion
+//#region src/task-scheduling.ts
+var __dxlog_file$2 = "/__w/dxos/dxos/packages/common/async/src/task-scheduling.ts";
+/**
+* A task that can be scheduled to run in the next event loop iteration.
+* Could be triggered multiple times, but only runs once.
+* If a new task is triggered while a previous one is running, the next run would occur immediately after the current run has finished.
+*/
+var DeferredTask = class {
+	_ctx;
+	_callback;
+	_scheduled = false;
+	_currentTask = null;
+	_nextTask = new Trigger();
+	constructor(_ctx, _callback) {
+		this._ctx = _ctx;
+		this._callback = _callback;
+	}
+	get scheduled() {
+		return this._scheduled;
+	}
+	/**
+	* Schedule the task to run asynchronously.
+	*/
+	schedule() {
+		if (this._scheduled) return;
+		scheduleTask(this._ctx, async () => {
+			await this._currentTask;
+			this._scheduled = false;
+			const completionTrigger = this._nextTask;
+			this._nextTask = new Trigger();
+			this._currentTask = runInContextAsync(this._ctx, () => this._callback()).then(() => {
+				completionTrigger.wake();
+			});
+		});
+		this._scheduled = true;
+	}
+	/**
+	* Schedule the task to run and wait for it to finish.
+	*/
+	async runBlocking() {
+		if (this._ctx.disposed) throw new ContextDisposedError();
+		this.schedule();
+		await this._nextTask.wait();
+	}
+	/**
+	* Waits for the current task to finish if it is running.
+	* Does not schedule a new task.
+	*/
+	async join() {
+		await this._currentTask;
+	}
+};
+var AsyncTask = class {
+	#callback;
+	#ctx = void 0;
+	#scheduled = false;
+	#currentTask = null;
+	#nextTask = new Trigger();
+	constructor(callback) {
+		this.#callback = callback;
+	}
+	get scheduled() {
+		return this.#scheduled;
+	}
+	/**
+	* Context of the resource that owns the task.
+	* When the context is disposed, the task is cancelled and cannot be scheduled again.
+	*/
+	open() {
+		this.#ctx = new Context(void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$2,
+			L: 106
+		});
+	}
+	/**
+	* Closes the task and waits for it to finish if it is running.
+	*/
+	async close() {
+		await this.#ctx?.dispose();
+		await this.join();
+		this.#ctx = void 0;
+	}
+	[Symbol.asyncDispose]() {
+		return this.close();
+	}
+	/**
+	* Schedule the task to run asynchronously.
+	*/
+	schedule() {
+		if (!this.#ctx || this.#ctx.disposed) throw new Error("AsyncTask not open");
+		if (this.#scheduled) return;
+		scheduleTask(this.#ctx, async () => {
+			await this.#currentTask;
+			if (!this.#ctx || this.#ctx.disposed) return;
+			this.#scheduled = false;
+			const completionTrigger = this.#nextTask;
+			this.#nextTask = new Trigger();
+			this.#currentTask = runInContextAsync(this.#ctx, () => this.#callback()).then(() => {
+				completionTrigger.wake();
+			});
+		});
+		this.#scheduled = true;
+	}
+	/**
+	* Schedule the task to run and wait for it to finish.
+	*/
+	async runBlocking() {
+		if (this.#ctx?.disposed) throw new ContextDisposedError();
+		this.schedule();
+		await this.#nextTask.wait();
+	}
+	/**
+	* Waits for the current task to finish if it is running.
+	* Does not schedule a new task.
+	*/
+	async join() {
+		await this.#currentTask;
+	}
+};
+var runInContext = (ctx, fn) => {
+	try {
+		fn();
+	} catch (err) {
+		ctx.raise(err);
+	}
+};
+var runInContextAsync = async (ctx, fn) => {
+	try {
+		await fn();
+	} catch (err) {
+		ctx.raise(err);
+	}
+};
+var scheduleMicroTask = (ctx, fn) => {
+	queueMicrotask(async () => {
+		if (ctx.disposed) return;
+		await runInContextAsync(ctx, fn);
+	});
+};
+var scheduleTask = (ctx, fn, afterMs) => {
+	const clearTracking = trackResource(() => ({
+		name: `task (${fn.name || "anonymous"})`,
+		openStack: new StackTrace()
+	}));
+	const timeout = setTimeout(async () => {
+		clearDispose();
+		await runInContextAsync(ctx, fn);
+		clearTracking();
+	}, afterMs);
+	const clearDispose = ctx.onDispose(() => {
+		clearTracking();
+		clearTimeout(timeout);
+	});
+};
+/**
+* Run the task in the next event loop iteration, and then repeat in `interval` ms after the previous iteration completes.
+*/
+var scheduleTaskInterval = (ctx, task, interval) => {
+	const clearTracking = trackResource(() => ({
+		name: `repeating task (${task.name || "anonymous"})`,
+		openStack: new StackTrace()
+	}));
+	let timeoutId;
+	const run = async () => {
+		await runInContextAsync(ctx, task);
+		if (ctx.disposed) return;
+		timeoutId = setTimeout(run, interval);
+	};
+	timeoutId = setTimeout(run, interval);
+	ctx.onDispose(() => {
+		clearTracking();
+		clearTimeout(timeoutId);
+	});
+};
+var scheduleExponentialBackoffTaskInterval = (ctx, task, initialInterval) => {
+	const clearTracking = trackResource(() => ({
+		name: `repeating task (${task.name || "anonymous"})`,
+		openStack: new StackTrace()
+	}));
+	let timeoutId;
+	let interval = initialInterval;
+	const repeat = async () => {
+		await runInContextAsync(ctx, task);
+		if (ctx.disposed) return;
+		interval *= 2;
+		timeoutId = setTimeout(repeat, interval);
+	};
+	timeoutId = setTimeout(repeat, interval);
+	ctx.onDispose(() => {
+		clearTracking();
+		clearTimeout(timeoutId);
+	});
+};
+//#endregion
+//#region \0@oxc-project+runtime@0.139.0/helpers/esm/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+//#endregion
+//#region src/persistent-lifecycle.ts
+var __dxlog_file$1 = "/__w/dxos/dxos/packages/common/async/src/persistent-lifecycle.ts";
+var INIT_RESTART_DELAY = 100;
+var DEFAULT_MAX_RESTART_DELAY = 5e3;
+/**
+* Minimum duration a connection must stay up before it is considered stable and the backoff is
+* reset. A connection that drops sooner keeps escalating the delay, so an endpoint that accepts
+* then immediately closes the connection cannot produce a zero-delay reconnect loop.
+*/
+var STABLE_CONNECTION_THRESHOLD = 5e3;
+/**
+* Handles restarts (e.g. persists connection).
+* Restarts are scheduled with exponential backoff.
+*/
+var PersistentLifecycle = class extends Resource {
+	_start;
+	_stop;
+	_onRestart;
+	_maxRestartDelay;
+	_currentState = void 0;
+	_restartTask = void 0;
+	_restartAfter = 0;
+	_connectedAt = void 0;
+	constructor({ start, stop, onRestart, maxRestartDelay = DEFAULT_MAX_RESTART_DELAY }) {
+		super();
+		this._start = start;
+		this._stop = stop;
+		this._onRestart = onRestart;
+		this._maxRestartDelay = maxRestartDelay;
+	}
+	get state() {
+		return this._currentState;
+	}
+	async _open() {
+		this._restartTask = new DeferredTask(this._ctx, async () => {
+			try {
+				await this._restart();
+			} catch (err) {
+				if (this._ctx?.disposed) return;
+				log.warn("Restart failed", { err }, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$1,
+					L: 84,
+					S: this
+				});
+				this._restartTask?.schedule();
+			}
+		});
+		try {
+			this._currentState = await this._start();
+			this._connectedAt = Date.now();
+		} catch (err) {
+			if (this._ctx?.disposed) return;
+			log.warn("Start failed", { err }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 97,
+				S: this
+			});
+			this._restartTask?.schedule();
+		}
+	}
+	async _close() {
+		await this._restartTask?.join();
+		await this._stopCurrentState();
+		this._restartTask = void 0;
+	}
+	async _restart() {
+		log(`restarting in ${this._restartAfter}ms`, { state: this._lifecycleState }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 109,
+			S: this
+		});
+		if (this._connectedAt !== void 0 && Date.now() - this._connectedAt >= STABLE_CONNECTION_THRESHOLD) this._restartAfter = 0;
+		this._connectedAt = void 0;
+		await this._stopCurrentState();
+		if (this._lifecycleState !== LifecycleState.OPEN) return;
+		await cancelWithContext(this._ctx, sleep(this._restartAfter));
+		this._restartAfter = Math.min(Math.max(this._restartAfter * 2, INIT_RESTART_DELAY), this._maxRestartDelay);
+		await warnAfterTimeout(5e3, "Connection establishment takes too long", async () => {
+			this._currentState = await this._start();
+		});
+		this._connectedAt = Date.now();
+		await this._onRestart?.();
+	}
+	async _stopCurrentState() {
+		if (this._currentState) {
+			try {
+				await this._stop(this._currentState);
+			} catch (err) {
+				log.catch(err, void 0, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$1,
+					L: 140,
+					S: this
+				});
+			}
+			this._currentState = void 0;
+		}
+	}
+	/**
+	* Scheduling restart should be done from outside.
+	*/
+	async scheduleRestart() {
+		if (this._lifecycleState !== LifecycleState.OPEN) return;
+		this._restartTask.schedule();
+	}
+};
+__decorate([synchronized], PersistentLifecycle.prototype, "_open", null);
+__decorate([synchronized], PersistentLifecycle.prototype, "scheduleRestart", null);
+//#endregion
+//#region src/push-iterable.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/common/async/src/push-iterable.ts";
+/**
+* Creates an async iterable where the data is pushed by calling methods on the iterable.
+*/
+var makePushIterable = () => {
+	const buf = [];
+	const trigger = new Trigger({ autoReset: true });
+	return {
+		[Symbol.asyncIterator]() {
+			return { next: async () => {
+				while (buf.length === 0) await trigger.wait();
+				const item = buf.shift();
+				invariant(item, void 0, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file,
+					L: 42,
+					S: this,
+					A: ["item", ""]
+				});
+				switch (item.kind) {
+					case "next": return {
+						value: item.value,
+						done: false
+					};
+					case "return": return {
+						value: item.value,
+						done: true
+					};
+					case "throw": throw item.value;
+				}
+			} };
+		},
+		next: (value) => {
+			buf.push({
+				kind: "next",
+				value
+			});
+			trigger.wake();
+		},
+		return: (value) => {
+			buf.push({
+				kind: "return",
+				value
+			});
+			trigger.wake();
+		},
+		throw: (value) => {
+			buf.push({
+				kind: "throw",
+				value
+			});
+			trigger.wake();
+		}
+	};
+};
+//#endregion
+//#region src/stream-to-array.ts
+/**
+* Concatenate a readable stream's data into a single array.
+*
+* From https://github.com/stream-utils/stream-to-array, but does not depend on
+* any-promise which does not work in web workers due to using window in its
+* browser shim.
+*/
+var streamToArray = (stream) => {
+	let deferred;
+	if (!stream.readable) deferred = Promise.resolve([]);
+	else deferred = new Promise((resolve, reject) => {
+		if (!stream.readable) return resolve([]);
+		let arr = [];
+		const onData = (doc) => {
+			arr?.push(doc);
+		};
+		const onEnd = (err) => {
+			if (err) reject(err);
+			else resolve(arr);
+			cleanup();
+		};
+		const onClose = () => {
+			resolve(arr);
+			cleanup();
+		};
+		const cleanup = () => {
+			arr = [];
+			stream.removeListener("data", onData);
+			stream.removeListener("end", onEnd);
+			stream.removeListener("error", onEnd);
+			stream.removeListener("close", onClose);
+		};
+		stream.on("data", onData);
+		stream.on("end", onEnd);
+		stream.on("error", onEnd);
+		stream.on("close", onClose);
+	});
+	return deferred;
+};
+//#endregion
+//#region src/testing.ts
+/**
+* NOTE: THIS SHOULD ONLY BE USED IN TESTS.
+*
+* Returns a Promise which resolves when `condFn` returns truthy.
+* The value returned by `condFn` is used to resolve the Promise.
+* @param condition Function to call.
+* @param [timeout] How long to wait, in milliseconds (0 = no timeout).
+* @param [interval=10] How frequently to check, in milliseconds.
+*/
+var waitForCondition = ({ condition, timeout = 0, interval = 10, error, breakOnError = false }) => {
+	const stopTime = timeout ? Date.now() + timeout : 0;
+	const trigger = new Trigger();
+	const waiter = async () => {
+		while (!stopTime || Date.now() < stopTime) {
+			try {
+				const value = await condition();
+				if (value) {
+					trigger.wake(value);
+					break;
+				}
+			} catch (err) {
+				if (breakOnError === true) trigger.throw(err);
+			}
+			await sleep(interval);
+		}
+	};
+	setTimeout(waiter, 0);
+	return trigger.wait({ timeout });
+};
+/**
+* Awaits promise.
+*/
+var until = (cb, timeout) => {
+	return new Promise((resolve, reject) => {
+		const t = timeout && setTimeout(() => {
+			reject(/* @__PURE__ */ new Error(`Timeout after ${t}ms`));
+		}, timeout);
+		setTimeout(async () => {
+			try {
+				await cb((value) => {
+					t && clearTimeout(t);
+					resolve(value);
+				}, (error) => {
+					t && clearTimeout(t);
+					reject(error);
+				});
+			} catch (err) {
+				reject(err);
+			}
+		});
+	});
+};
+/**
+* Wait until promise resolves.
+*/
+var untilPromise = (cb) => cb();
+/**
+* Wait until error is thrown.
+*/
+var untilError = (cb) => {
+	return new Promise((resolve, reject) => {
+		setTimeout(async () => {
+			try {
+				await cb();
+				reject(/* @__PURE__ */ new Error("No error was thrown."));
+			} catch (err) {
+				resolve(err);
+			}
+		});
+	});
+};
+//#endregion
+//#region src/timer.ts
+/**
+* Manages callback invocations at a interval with a possible jitter.
+* Note: The interval excludes the running time of the callback.
+*/
+var Timer = class {
+	_callback;
+	_state = new Event();
+	_timer;
+	_count = 0;
+	constructor(_callback) {
+		this._callback = _callback;
+	}
+	get state() {
+		return this._state;
+	}
+	get running() {
+		return !!this._timer;
+	}
+	start(options, cb) {
+		if (isNaN(options.count) || isNaN(options.interval)) throw new Error(`Invalid options: ${JSON.stringify(options)}`);
+		if (this.running) this.stop();
+		const stop = () => {
+			this.stop();
+			cb?.();
+		};
+		const run = () => {
+			if (this._count >= (options.count ?? 0)) stop();
+			else {
+				const interval = (options.interval ?? 0) + Math.random() * (options.jitter ?? 0);
+				this._timer = setTimeout(async () => {
+					await this._callback(this._count++);
+					run();
+				}, interval);
+			}
+		};
+		this._state.emit(true);
+		this._count = 0;
+		setTimeout(run);
+		return this;
+	}
+	stop() {
+		clearInterval(this._timer);
+		this._timer = void 0;
+		this._state.emit(false);
+		return this;
+	}
+};
+//#endregion
+//#region src/update-scheduler.ts
+/**
+* Time period for update counting.
+*/
+var TIME_PERIOD = 1e3;
+/**
+* Runs a non-reentrant callback at most once at a time, coalescing triggers (optionally rate-limited
+* via {@link UpdateSchedulerOptions.maxFrequency}).
+*
+* The runner inside {@link trigger} is the only place the callback starts; `runBlocking` and
+* `forceTrigger` funnel into it. That, plus `_scheduled` collapsing triggers into one pending
+* runner, is what makes mutual exclusion hold by construction (dxos/edge#758).
+*/
+var UpdateScheduler = class {
+	_ctx;
+	_callback;
+	_params;
+	/** The running pass; never rejects, non-null exactly while a run is executing. */
+	_currentTask = null;
+	_scheduled = false;
+	/**
+	* Armed by the `trigger` that schedules a runner, woken by that runner when it claims — with the
+	* run's promise, which `Trigger` adopts, so waiters resume when the run *finishes*. Lets
+	* `runBlocking` await a run that does not exist in `_currentTask` yet.
+	*
+	* `reset()` abandons parked waiters, so it may only be armed in `trigger`'s non-coalesced branch:
+	* waiters park only while `_scheduled` is true, and that branch requires it false.
+	*/
+	_runOutcome = new Trigger();
+	/** Woken to make the pending runner skip its throttle delay. Replaced at claim time. */
+	_skipDelay = new Trigger();
+	/**
+	* `runBlocking` callers in flight, incremented synchronously before triggering. A failing run uses
+	* it to tell whether someone will throw the error; counting microtask hops to a waiter's resume
+	* would be a race.
+	*/
+	_observers = 0;
+	_lastUpdateTime = -1e3;
+	constructor(_ctx, _callback, _params = {}) {
+		this._ctx = _ctx;
+		this._callback = _callback;
+		this._params = _params;
+		_ctx.onDispose(async () => {
+			await this._currentTask;
+			this._runOutcome.wake(Promise.resolve(void 0));
+		});
+	}
+	get scheduled() {
+		return this._scheduled;
+	}
+	/**
+	* Schedule the callback to run asynchronously. Triggers issued while a run is pending or in flight
+	* coalesce into the next run.
+	*/
+	trigger() {
+		if (this._scheduled) return;
+		this._scheduled = true;
+		this._runOutcome.reset();
+		scheduleMicroTask(this._ctx, async () => {
+			await this._currentTask;
+			if (this._params.maxFrequency) {
+				const now = performance.now();
+				const delay = this._lastUpdateTime + TIME_PERIOD / this._params.maxFrequency - now;
+				if (delay > 0) {
+					const skipDelay = this._skipDelay;
+					await new Promise((resolve) => {
+						const timeoutId = setTimeout(() => {
+							clearContext();
+							resolve();
+						}, delay);
+						const clearContext = this._ctx.onDispose(() => {
+							clearTimeout(timeoutId);
+							resolve();
+						});
+						skipDelay.wait().then(() => {
+							clearTimeout(timeoutId);
+							clearContext();
+							resolve();
+						});
+					});
+				}
+			}
+			if (this._ctx.disposed) {
+				this._runOutcome.wake(Promise.resolve(void 0));
+				return;
+			}
+			this._scheduled = false;
+			this._skipDelay = new Trigger();
+			this._lastUpdateTime = performance.now();
+			const run = this._callback().then(() => void 0, (error) => {
+				const failure = error;
+				if (this._observers === 0) this._ctx.raise(failure);
+				return failure;
+			});
+			const task = run.then(() => {
+				if (this._currentTask === task) this._currentTask = null;
+			});
+			this._currentTask = task;
+			this._runOutcome.wake(run);
+		});
+	}
+	/**
+	* Run as soon as possible: schedules (coalescing with any pending run) and skips the throttle
+	* delay. Does not start a concurrent callback.
+	*/
+	forceTrigger() {
+		this.trigger();
+		this._skipDelay.wake();
+	}
+	/**
+	* Waits for the current task to finish if it is running.
+	* Does not schedule a new task, and does not wait for one that is merely scheduled.
+	*/
+	async join() {
+		await this._currentTask;
+	}
+	/**
+	* Ensure a run that observes everything enqueued so far, and wait for it to finish. Waits for the
+	* pending run to claim, then for its result; that run necessarily claims after this call, so its
+	* drain includes everything enqueued before it. Rejects with the run's error so a flush barrier can
+	* see its batch was not handed off. No-op once disposed.
+	*/
+	async runBlocking() {
+		if (this._ctx.disposed) return;
+		this._observers++;
+		try {
+			this.trigger();
+			this._skipDelay.wake();
+			const error = await this._runOutcome.wait();
+			if (error !== void 0) throw error;
+		} finally {
+			this._observers--;
+		}
+	}
+};
+//#endregion
+export { AsyncTask, CancellableObservableProvider, DeferredTask, Event, MulticastObservable, Mutex, MutexGuard, Observable, ObservableProvider, PersistentLifecycle, PushStream, SubscriptionList, SubscriptionSet, TimeoutError, Timer, Trigger, TriggerState, UpdateScheduler, addEventListener, addListener, asyncReturn, asyncTimeout, chain, combine, debounce, debounceAndThrottle, delay, dumpLeaks, interval, latch, makePushIterable, observableError, onEvent, promiseFromCallback, runInContext, runInContextAsync, scheduleExponentialBackoffTaskInterval, scheduleMicroTask, scheduleTask, scheduleTaskInterval, sleep, sleepWithContext, streamToArray, synchronized, throttle, timeout, toError, trackLeaks, trackResource, trigger, unrefTimeout, until, untilError, untilPromise, waitForCondition, waitForEvent };
+
+//# sourceMappingURL=index.mjs.map