@dxos/async 0.10.0 → 0.11.0

package/dist/lib/browser/index.mjs

@@ -1,1677 +0,0 @@
-// src/callback.ts
-var promiseFromCallback = (run) => new Promise((resolve, reject) => {
-  run((error, value) => {
-    if (error) {
-      reject(error);
-    } else {
-      resolve(value);
-    }
-  });
-});
-
-// src/chain.ts
-var chain = (chain2) => async (elements) => {
-  let result = await elements;
-  for (const part of chain2) {
-    result = await Promise.all(result.map(async (element) => await part(element)));
-  }
-  return result;
-};
-
-// src/cleanup.ts
-import { ComplexMap } from "@dxos/util";
-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);
-};
-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();
-  }
-};
-
-// src/debounce.ts
-var delay = (cb, delay2 = 100) => {
-  let pending = false;
-  return (...args) => {
-    if (pending) {
-      return;
-    }
-    pending = true;
-    setTimeout(() => {
-      try {
-        cb(...args);
-      } finally {
-        pending = false;
-      }
-    }, delay2);
-  };
-};
-var debounce = (cb, delay2 = 100) => {
-  let t;
-  return (...args) => {
-    clearTimeout(t);
-    t = setTimeout(() => cb(...args), delay2);
-  };
-};
-var throttle = (cb, delay2 = 100) => {
-  let lastCall = 0;
-  return (...args) => {
-    const now = Date.now();
-    if (now - lastCall >= delay2) {
-      cb(...args);
-      lastCall = now;
-    }
-  };
-};
-var debounceAndThrottle = (cb, delay2 = 100) => {
-  let timeout2;
-  let lastCall = 0;
-  return (...args) => {
-    const now = Date.now();
-    const delta = now - lastCall;
-    clearTimeout(timeout2);
-    if (delta >= delay2) {
-      cb(...args);
-      lastCall = now;
-    } else {
-      timeout2 = setTimeout(() => {
-        cb(...args);
-        lastCall = Date.now();
-      }, delay2 - delta);
-    }
-  };
-};
-
-// src/errors.ts
-var toError = (err) => err === void 0 || typeof err === "string" ? new Error(err) : err;
-var TimeoutError = class extends Error {
-  constructor(timeout2, label) {
-    super(timeout2 ? `Timeout [${timeout2.toLocaleString()}ms]${label === void 0 ? "" : `: ${label}`}` : "Timeout");
-  }
-};
-var observableError = (observable, err) => {
-  if (err instanceof TimeoutError) {
-    observable.callback.onTimeout?.(err);
-  } else {
-    observable.callback.onError(toError(err));
-  }
-};
-
-// src/timeout.ts
-import { ContextDisposedError } from "@dxos/context";
-var sleep = (ms) => {
-  return new Promise((resolve) => {
-    const finish = Date.now() + ms;
-    const sleeper = () => {
-      const delta = finish - Date.now();
-      if (delta > 0) {
-        setTimeout(sleeper, delta);
-      } else {
-        resolve();
-      }
-    };
-    sleeper();
-  });
-};
-var sleepWithContext = (ctx, ms) => {
-  const error = new ContextDisposedError();
-  return new Promise((resolve, reject) => {
-    if (ctx.disposed) {
-      reject(error);
-      return;
-    }
-    const timeout2 = setTimeout(() => {
-      clearDispose();
-      resolve();
-    }, ms);
-    const clearDispose = ctx.onDispose(() => {
-      clearTimeout(timeout2);
-      reject(error);
-    });
-  });
-};
-var asyncReturn = () => sleep(0);
-var asyncTimeout = async (promise, timeout2, err) => {
-  if (typeof promise === "function") {
-    throw new Error("First argument must be a promise.");
-  }
-  let timeoutId;
-  const throwable = err === void 0 || typeof err === "string" ? new TimeoutError(timeout2, err) : err;
-  const timeoutPromise = new Promise((resolve, reject) => {
-    timeoutId = setTimeout(() => {
-      reject(throwable);
-    }, timeout2);
-    unrefTimeout(timeoutId);
-  });
-  return await Promise.race([
-    promise,
-    timeoutPromise
-  ]).finally(() => {
-    clearTimeout(timeoutId);
-  });
-};
-var unrefTimeout = (timeoutId) => {
-  if (typeof timeoutId === "object" && "unref" in timeoutId) {
-    timeoutId.unref();
-  }
-};
-
-// src/event-emitter.ts
-var onEvent = (eventEmitter, eventName, callback) => {
-  eventEmitter.on(eventName, callback);
-  return () => eventEmitter.off(eventName, callback);
-};
-var addListener = (eventEmitter, eventName, callback) => {
-  const off = onEvent(eventEmitter, eventName, callback);
-  return {
-    remove: () => off()
-  };
-};
-var waitForEvent = (eventEmitter, eventName, test, timeout2, error) => {
-  let off;
-  const promise = new Promise((resolve) => {
-    off = onEvent(eventEmitter, eventName, (...args) => {
-      if (!test || test(...args)) {
-        resolve(...args);
-      }
-    });
-  });
-  return timeout2 ? asyncTimeout(promise, timeout2, error ?? new Error()).finally(off) : promise.finally(off);
-};
-
-// src/events.ts
-import { Context } from "@dxos/context";
-var DO_NOT_ERROR_ON_ASYNC_CALLBACK = true;
-var Event = class _Event {
-  /**
-  * Wrap objects that have on/off style event emitters.
-  */
-  static wrap(emitter, eventName) {
-    const event = new _Event();
-    event.addEffect(() => {
-      const onEvent2 = (data) => event.emit(data);
-      emitter.on(eventName, onEvent2);
-      return () => emitter.off(eventName, onEvent2);
-    });
-    return event;
-  }
-  _listeners = /* @__PURE__ */ new Set();
-  _effects = /* @__PURE__ */ new Set();
-  /**
-  * Emit an event.
-  * In most cases should only be called by the class or entity containing the event.
-  * All listeners are called in order of subscription with persistent ones first.
-  * Listeners are called synchronously in the same stack.
-  * A thrown exception in the listener will stop the event from being emitted to the rest of the listeners.
-  *
-  * @param data param that will be passed to all listeners.
-  */
-  emit(data) {
-    for (const listener of this._listeners) {
-      listener.trigger(data);
-      if (listener.once) {
-        this._listeners.delete(listener);
-      }
-    }
-  }
-  /**
-  * Emit an event and wait for async listeners to complete.
-  * In most cases should only be called by the class or entity containing the event.
-  * All listeners are called in order of subscription with persistent ones first.
-  * Listeners are called sequentially.
-  *
-  * @param data param that will be passed to all listeners.
-  */
-  async emitAsync(data) {
-    for (const listener of this._listeners) {
-      await listener.triggerAsync(data);
-      if (listener.once) {
-        this._listeners.delete(listener);
-      }
-    }
-  }
-  on(_ctx, _callback, options) {
-    const [ctx, callback] = _ctx instanceof Context ? [
-      _ctx,
-      _callback
-    ] : [
-      new Context(),
-      _ctx
-    ];
-    const weak = !!options?.weak;
-    const once = !!options?.once;
-    const listener = new EventListener(this, callback, ctx, once, weak);
-    this._addListener(listener);
-    return () => {
-      this._removeListener(listener);
-    };
-  }
-  /**
-  * Unsubscribe this callback from new events. Includes persistent and once-listeners.
-  * NOTE: It is recommended to use `Event.on`'s return value instead.
-  * If the callback is not subscribed this is no-op.
-  *
-  * @param callback
-  */
-  off(callback) {
-    for (const listener of this._listeners) {
-      if (listener.derefCallback() === callback) {
-        this._removeListener(listener);
-      }
-    }
-  }
-  once(_ctx, _callback) {
-    const [ctx, callback] = _ctx instanceof Context ? [
-      _ctx,
-      _callback
-    ] : [
-      new Context(),
-      _ctx
-    ];
-    const listener = new EventListener(this, callback, ctx, true, false);
-    this._addListener(listener);
-    return () => {
-      this._removeListener(listener);
-    };
-  }
-  /**
-  * An async iterator that iterates over events.
-  * This iterator runs indefinitely.
-  */
-  async *[Symbol.asyncIterator]() {
-    while (true) {
-      yield await new Promise((resolve) => {
-        this.once(resolve);
-      });
-    }
-  }
-  /**
-  * Returns a promise that resolves with the first event emitted that matches the provided predicate.
-  *
-  * @param predicate
-  */
-  waitFor(predicate) {
-    return new Promise((resolve) => {
-      const unsubscribe = this.on((data) => {
-        if (predicate(data)) {
-          unsubscribe();
-          resolve(data);
-        }
-      });
-    });
-  }
-  /**
-  * Returns a promise that resolves once a specific number of events was emitted since this method was called.
-  *
-  * @param expectedCount
-  */
-  waitForCount(expectedCount) {
-    let count = 0;
-    return this.waitFor(() => ++count === expectedCount);
-  }
-  /**
-  * Similar to waitFor, but the promise resolves immediately if the condition is already true.
-  */
-  // TODO(burdon): Should pass event property to predicate.
-  async waitForCondition(predicate) {
-    if (!predicate()) {
-      await this.waitFor(predicate);
-    }
-  }
-  /**
-  * Returns the number of persistent listeners.
-  */
-  listenerCount() {
-    return this._listeners.size;
-  }
-  /**
-  * Add a side effect that will be activated once the event has at least one subscriber.
-  * The provided callback can return a function that will be used to clean up after the last subscriber unsubscribes from the event.
-  * The API is similar to `useEffect` from React.
-  *
-  * ## Example:
-  * ```typescript
-  * event.addEffect(() => {
-  *   // do stuff
-  *   return () => {
-  *     // clean-up
-  *   };
-  * });
-  * ```
-  *
-  * @returns Callback that will remove this effect once called.
-  */
-  addEffect(effect) {
-    const handle = {
-      effect,
-      cleanup: void 0
-    };
-    if (this.listenerCount() > 0) {
-      handle.cleanup = handle.effect();
-    }
-    this._effects.add(handle);
-    return () => {
-      handle.cleanup?.();
-      this._effects.delete(handle);
-    };
-  }
-  /**
-  * Triggers an event with at least `timeout` milliseconds between each event.
-  * If the event is triggered more often, the event is delayed until the timeout is reached.
-  * If event is emitted for the first time or event wasn't fired for `timeout` milliseconds,
-  * the event is emitted after `timeout / 8` ms.
-  */
-  // TODO(burdon): Factor out generic function.
-  debounce(timeout2 = 0) {
-    let firing;
-    let lastFired;
-    const debouncedEvent = new _Event();
-    debouncedEvent.addEffect(() => {
-      const unsubscribe = this.on(() => {
-        if (!firing) {
-          const fireIn = !lastFired || Date.now() - lastFired > timeout2 ? timeout2 / 8 : timeout2;
-          firing = setTimeout(() => {
-            lastFired = Date.now();
-            firing = void 0;
-            debouncedEvent.emit();
-          }, fireIn);
-        }
-      });
-      return () => {
-        unsubscribe();
-        clearTimeout(firing);
-      };
-    });
-    return debouncedEvent;
-  }
-  /**
-  * Turn any variant of `Event<T>` into an `Event<void>` discarding the callback parameter.
-  */
-  discardParameter() {
-    return this;
-  }
-  /**
-  * Pipe the events into another event.
-  * @param event
-  */
-  pipeInto(event) {
-    return this.on((data) => event.emit(data));
-  }
-  /**
-  * Overridden to not return implementation details.
-  */
-  toJSON() {
-    return {
-      listenerCount: this.listenerCount()
-    };
-  }
-  _addListener(listener) {
-    this._listeners.add(listener);
-    if (this.listenerCount() === 1) {
-      this._runEffects();
-    }
-  }
-  /**
-  * @internal
-  */
-  _removeListener(listener) {
-    this._listeners.delete(listener);
-    listener.remove();
-    if (this.listenerCount() === 0) {
-      this._cleanupEffects();
-    }
-  }
-  _runEffects() {
-    for (const handle of this._effects) {
-      handle.cleanup = handle.effect();
-    }
-  }
-  _cleanupEffects() {
-    for (const handle of this._effects) {
-      handle.cleanup?.();
-      handle.cleanup = void 0;
-    }
-  }
-};
-var EventListener = class {
-  ctx;
-  once;
-  weak;
-  callback;
-  _clearDispose = void 0;
-  constructor(event, listener, ctx, once, weak) {
-    this.ctx = ctx;
-    this.once = once;
-    this.weak = weak;
-    this._clearDispose = ctx.onDispose(() => {
-      event._removeListener(this);
-    });
-    if (weak) {
-      this.callback = new WeakRef(listener);
-      weakListeners().registry?.register(listener, {
-        event: new WeakRef(event),
-        listener: this
-      }, this);
-    } else {
-      this.callback = listener;
-    }
-  }
-  derefCallback() {
-    return this.weak ? this.callback.deref() : this.callback;
-  }
-  trigger(data) {
-    let result;
-    try {
-      const callback = this.derefCallback();
-      result = callback?.(data);
-    } catch (err) {
-      this.ctx.raise(err);
-    }
-    if (!DO_NOT_ERROR_ON_ASYNC_CALLBACK) {
-      if (result instanceof Promise) {
-        throw new TypeError("Event has async callbacks, use emitAsync instead");
-      }
-    }
-  }
-  async triggerAsync(data) {
-    try {
-      const callback = this.derefCallback();
-      await callback?.(data);
-    } catch (err) {
-      this.ctx.raise(err);
-    }
-  }
-  remove() {
-    this._clearDispose?.();
-    weakListeners().registry?.unregister(this);
-  }
-};
-var weakListenersState = null;
-var FINALIZATION_REGISTRY_SUPPORTED = !!globalThis.FinalizationRegistry;
-var weakListeners = () => {
-  if (!FINALIZATION_REGISTRY_SUPPORTED) {
-    return {
-      registry: void 0
-    };
-  }
-  weakListenersState ??= new FinalizationRegistry(({ event, listener }) => {
-    event.deref()?._removeListener(listener);
-  });
-  return {
-    registry: weakListenersState
-  };
-};
-
-// src/mutex.ts
-import "@dxos/util";
-import { warnAfterTimeout } from "@dxos/debug";
-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 = /* @__PURE__ */ Symbol("class-mutex");
-var FORCE_DISABLE_WARNING = false;
-var enableWarning = !FORCE_DISABLE_WARNING && globalThis.mochaExecutor;
-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"
-  });
-};
-
-// src/observable.ts
-import Observable from "zen-observable";
-import PushStream from "zen-push";
-
-// src/trigger.ts
-import { invariant } from "@dxos/invariant";
-var trigger = (timeout2) => {
-  let callback;
-  const promise = new Promise((resolve, reject) => {
-    if (timeout2) {
-      setTimeout(() => reject(new Error(`Timed out after ${timeout2.toLocaleString()}ms`)), timeout2);
-    }
-    callback = resolve;
-  });
-  const provider = () => promise;
-  const resolver = (value) => callback(value);
-  return [
-    provider,
-    resolver
-  ];
-};
-var TriggerState = /* @__PURE__ */ (function(TriggerState2) {
-  TriggerState2["WAITING"] = "WAITING";
-  TriggerState2["RESOLVED"] = "RESOLVED";
-  TriggerState2["REJECTED"] = "REJECTED";
-  return TriggerState2;
-})({});
-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: timeout2 } = {}) {
-    if (timeout2) {
-      return asyncTimeout(this._promise, timeout2, new TimeoutError(timeout2));
-    } 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;
-  }
-};
-var latch = ({ count = 1, timeout: timeout2 } = {}) => {
-  invariant(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 (timeout2) {
-      t = setTimeout(() => {
-        doReject(new Error(`Timed out after ${timeout2.toLocaleString()}ms`));
-      }, timeout2);
-    }
-  }
-  let i = 0;
-  return [
-    async () => await promise,
-    () => {
-      if (++i === count) {
-        doResolve(i);
-      }
-      return i;
-    },
-    (err) => doReject(err)
-  ];
-};
-
-// src/observable.ts
-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: timeout2 } = {}) {
-    await this._completed.wait({
-      timeout: timeout2
-    });
-    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);
-
-// src/observable-value.ts
-import { createSetDispatch } from "@dxos/util";
-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);
-    };
-  }
-};
-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?.();
-  }
-};
-
-// src/persistent-lifecycle.ts
-import { LifecycleState, Resource, cancelWithContext } from "@dxos/context";
-import { warnAfterTimeout as warnAfterTimeout2 } from "@dxos/debug";
-import { log as log2 } from "@dxos/log";
-
-// src/task-scheduling.ts
-import { Context as Context2, ContextDisposedError as ContextDisposedError2 } from "@dxos/context";
-import { StackTrace as StackTrace2 } from "@dxos/debug";
-
-// src/track-leaks.ts
-import { StackTrace } from "@dxos/debug";
-import { log } from "@dxos/log";
-var enabled = typeof process !== "undefined" && !!process.env.DX_TRACK_LEAKS;
-var openResources = /* @__PURE__ */ new Set();
-var handleSymbol = /* @__PURE__ */ Symbol("checkLeaksHandle");
-var trackResource = (resourceProvider) => {
-  if (!enabled) {
-    return () => {
-    };
-  }
-  const resource = resourceProvider();
-  openResources.add(resource);
-  return () => {
-    openResources.delete(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}:`);
-  for (const resource of openResources) {
-    log.info(`- ${resource.name} at`);
-    log.info(resource.openStack.getStack(1));
-    log.info("\n");
-  }
-};
-if (enabled) {
-  global.dxDumpLeaks = dumpLeaks;
-}
-
-// src/task-scheduling.ts
-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 ContextDisposedError2();
-    }
-    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 Context2();
-  }
-  /**
-  * 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.
-  */
-  // TODO(dmaretskyi): Add scheduleAt. Where the earlier time will override the later one.
-  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 ContextDisposedError2();
-    }
-    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 StackTrace2()
-  }));
-  const timeout2 = setTimeout(async () => {
-    clearDispose();
-    await runInContextAsync(ctx, fn);
-    clearTracking();
-  }, afterMs);
-  const clearDispose = ctx.onDispose(() => {
-    clearTracking();
-    clearTimeout(timeout2);
-  });
-};
-var scheduleTaskInterval = (ctx, task, interval2) => {
-  const clearTracking = trackResource(() => ({
-    name: `repeating task (${task.name || "anonymous"})`,
-    openStack: new StackTrace2()
-  }));
-  let timeoutId;
-  const run = async () => {
-    await runInContextAsync(ctx, task);
-    if (ctx.disposed) {
-      return;
-    }
-    timeoutId = setTimeout(run, interval2);
-  };
-  timeoutId = setTimeout(run, interval2);
-  ctx.onDispose(() => {
-    clearTracking();
-    clearTimeout(timeoutId);
-  });
-};
-var scheduleExponentialBackoffTaskInterval = (ctx, task, initialInterval) => {
-  const clearTracking = trackResource(() => ({
-    name: `repeating task (${task.name || "anonymous"})`,
-    openStack: new StackTrace2()
-  }));
-  let timeoutId;
-  let interval2 = initialInterval;
-  const repeat = async () => {
-    await runInContextAsync(ctx, task);
-    if (ctx.disposed) {
-      return;
-    }
-    interval2 *= 2;
-    timeoutId = setTimeout(repeat, interval2);
-  };
-  timeoutId = setTimeout(repeat, interval2);
-  ctx.onDispose(() => {
-    clearTracking();
-    clearTimeout(timeoutId);
-  });
-};
-
-// src/persistent-lifecycle.ts
-function _ts_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;
-}
-var INIT_RESTART_DELAY = 100;
-var DEFAULT_MAX_RESTART_DELAY = 5e3;
-var STABLE_CONNECTION_THRESHOLD = 5e3;
-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;
-        }
-        log2.warn("Restart failed", {
-          err
-        });
-        this._restartTask?.schedule();
-      }
-    });
-    try {
-      this._currentState = await this._start();
-      this._connectedAt = Date.now();
-    } catch (err) {
-      if (this._ctx?.disposed) {
-        return;
-      }
-      log2.warn("Start failed", {
-        err
-      });
-      this._restartTask?.schedule();
-    }
-  }
-  async _close() {
-    await this._restartTask?.join();
-    await this._stopCurrentState();
-    this._restartTask = void 0;
-  }
-  async _restart() {
-    log2(`restarting in ${this._restartAfter}ms`, {
-      state: this._lifecycleState
-    });
-    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 warnAfterTimeout2(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) {
-        log2.catch(err);
-      }
-      this._currentState = void 0;
-    }
-  }
-  /**
-  * Scheduling restart should be done from outside.
-  */
-  async scheduleRestart() {
-    if (this._lifecycleState !== LifecycleState.OPEN) {
-      return;
-    }
-    this._restartTask.schedule();
-  }
-};
-_ts_decorate([
-  synchronized
-], PersistentLifecycle.prototype, "_open", null);
-_ts_decorate([
-  synchronized
-], PersistentLifecycle.prototype, "scheduleRestart", null);
-
-// src/push-iterable.ts
-import { invariant as invariant2 } from "@dxos/invariant";
-var makePushIterable = () => {
-  const buf = [];
-  const trigger2 = new Trigger({
-    autoReset: true
-  });
-  return {
-    [Symbol.asyncIterator]() {
-      return {
-        next: async () => {
-          while (buf.length === 0) {
-            await trigger2.wait();
-          }
-          const item = buf.shift();
-          invariant2(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
-      });
-      trigger2.wake();
-    },
-    return: (value) => {
-      buf.push({
-        kind: "return",
-        value
-      });
-      trigger2.wake();
-    },
-    throw: (value) => {
-      buf.push({
-        kind: "throw",
-        value
-      });
-      trigger2.wake();
-    }
-  };
-};
-
-// src/stream-to-array.ts
-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;
-};
-
-// src/test-stream.ts
-import { Duplex } from "@dxos/node-std/stream";
-var TestStream = class extends Duplex {
-  static async assertConnectivity(stream1, stream2, { timeout: timeout2 = 200 } = {}) {
-    stream1.push("ping");
-    stream2.push("pong");
-    await Promise.all([
-      stream2.assertReceivedAsync("ping", {
-        timeout: timeout2
-      }),
-      stream1.assertReceivedAsync("pong", {
-        timeout: timeout2
-      })
-    ]);
-  }
-  _received = Buffer.alloc(0);
-  _onWrite = new Event();
-  _write(chunk, encoding, callback) {
-    this._received = Buffer.concat([
-      this._received,
-      chunk
-    ]);
-    this._onWrite.emit();
-    callback();
-  }
-  _read(size) {
-  }
-  assertReceivedAsync(data, { timeout: timeout2 = 200 } = {}) {
-    const dataBuffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
-    return asyncTimeout(this._onWrite.waitForCondition(() => this._received.equals(dataBuffer)), timeout2);
-  }
-};
-
-// src/testing.ts
-var waitForCondition = ({ condition, timeout: timeout2 = 0, interval: interval2 = 10, error, breakOnError = false }) => {
-  const stopTime = timeout2 ? Date.now() + timeout2 : 0;
-  const trigger2 = new Trigger();
-  const waiter = async () => {
-    while (!stopTime || Date.now() < stopTime) {
-      try {
-        const value = await condition();
-        if (value) {
-          trigger2.wake(value);
-          break;
-        }
-      } catch (err) {
-        if (breakOnError === true) {
-          trigger2.throw(err);
-        }
-      }
-      await sleep(interval2);
-    }
-  };
-  setTimeout(waiter, 0);
-  return trigger2.wait({
-    timeout: timeout2
-  });
-};
-var until = (cb, timeout2) => {
-  return new Promise((resolve, reject) => {
-    const t = timeout2 && setTimeout(() => {
-      reject(new Error(`Timeout after ${t}ms`));
-    }, timeout2);
-    setTimeout(async () => {
-      try {
-        await cb((value) => {
-          t && clearTimeout(t);
-          resolve(value);
-        }, (error) => {
-          t && clearTimeout(t);
-          reject(error);
-        });
-      } catch (err) {
-        reject(err);
-      }
-    });
-  });
-};
-var untilPromise = (cb) => cb();
-var untilError = (cb) => {
-  return new Promise((resolve, reject) => {
-    setTimeout(async () => {
-      try {
-        await cb();
-        reject(new Error("No error was thrown."));
-      } catch (err) {
-        resolve(err);
-      }
-    });
-  });
-};
-
-// src/timer.ts
-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 interval2 = (options.interval ?? 0) + Math.random() * (options.jitter ?? 0);
-        this._timer = setTimeout(async () => {
-          await this._callback(this._count++);
-          run();
-        }, interval2);
-      }
-    };
-    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;
-  }
-};
-
-// src/update-scheduler.ts
-var TIME_PERIOD = 1e3;
-var UpdateScheduler = class {
-  _ctx;
-  _callback;
-  _params;
-  /**
-  * Promise that resolves when the callback is done.
-  * Never rejects.
-  */
-  _promise = null;
-  _scheduled = false;
-  _lastUpdateTime = -TIME_PERIOD;
-  constructor(_ctx, _callback, _params = {}) {
-    this._ctx = _ctx;
-    this._callback = _callback;
-    this._params = _params;
-    _ctx.onDispose(async () => {
-      await this._promise;
-    });
-  }
-  trigger() {
-    if (this._scheduled) {
-      return;
-    }
-    scheduleMicroTask(this._ctx, async () => {
-      await this._promise;
-      if (this._params.maxFrequency) {
-        const now = performance.now();
-        const delay2 = this._lastUpdateTime + TIME_PERIOD / this._params.maxFrequency - now;
-        if (delay2 > 0) {
-          await new Promise((resolve) => {
-            const timeoutId = setTimeout(() => {
-              clearContext();
-              resolve();
-            }, delay2);
-            const clearContext = this._ctx.onDispose(() => {
-              clearTimeout(timeoutId);
-              resolve();
-            });
-          });
-        }
-      }
-      if (this._ctx.disposed) {
-        return;
-      }
-      this._lastUpdateTime = performance.now();
-      this._scheduled = false;
-      this._promise = this._callback().then(() => {
-        this._promise = null;
-      }, (error) => {
-        this._promise = null;
-        this._ctx.raise(error);
-      });
-    });
-    this._scheduled = true;
-  }
-  forceTrigger() {
-    scheduleMicroTask(this._ctx, async () => {
-      this._callback().catch((err) => this._ctx.raise(err));
-    });
-  }
-  /**
-  * Waits for the current task to finish if it is running.
-  * Does not schedule a new task.
-  */
-  async join() {
-    await this._promise;
-  }
-  /**
-  * Force schedule the task to run and wait for it to finish.
-  */
-  async runBlocking() {
-    await this._promise;
-    this._promise = this._callback();
-    await this._promise;
-  }
-};
-export {
-  AsyncTask,
-  CancellableObservableProvider,
-  DeferredTask,
-  Event,
-  MulticastObservable,
-  Mutex,
-  MutexGuard,
-  Observable,
-  ObservableProvider,
-  PersistentLifecycle,
-  PushStream,
-  SubscriptionList,
-  SubscriptionSet,
-  TestStream,
-  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