@dxos/async 0.7.5-main.e9bb01b → 0.7.5-staging.2ff1350

package/dist/lib/browser/index.mjs

@@ -137,6 +137,7 @@ var EventSubscriptions = class {
     this._listeners.length = 0;
   }
 };
+var DO_NOT_ERROR_ON_ASYNC_CALLBACK = true;
 var Event = class _Event {
   constructor() {
     this._listeners = /* @__PURE__ */ new Set();
@@ -165,7 +166,23 @@ var Event = class _Event {
   */
   emit(data) {
     for (const listener of this._listeners) {
-      void listener.trigger(data);
+      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);
       }
@@ -178,7 +195,7 @@ var Event = class _Event {
     ] : [
       new Context(void 0, {
         F: __dxlog_file,
-        L: 124
+        L: 148
       }),
       _ctx
     ];
@@ -211,7 +228,7 @@ var Event = class _Event {
     ] : [
       new Context(void 0, {
         F: __dxlog_file,
-        L: 161
+        L: 185
       }),
       _ctx
     ];
@@ -395,7 +412,21 @@ var EventListener = class {
   derefCallback() {
     return this.weak ? this.callback.deref() : this.callback;
   }
-  async trigger(data) {
+  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);
@@ -474,6 +505,98 @@ var latch = ({ count = 1, timeout } = {}) => {
   ];
 };
 
+// packages/common/async/src/mutex.ts
+import "@dxos/util";
+import { warnAfterTimeout } from "@dxos/debug";
+var Mutex = class {
+  constructor() {
+    this._queue = Promise.resolve();
+    this._queueLength = 0;
+    this._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 {
+  constructor(_release) {
+    this._release = _release;
+  }
+  /**
+  * Releases the lock.
+  */
+  release() {
+    this._release();
+  }
+  [Symbol.dispose]() {
+    this.release();
+  }
+};
+var classMutexSymbol = 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"
+  });
+};
+
 // packages/common/async/src/observable.ts
 import Observable from "zen-observable";
 import PushStream from "zen-push";
@@ -719,340 +842,93 @@ var CancellableObservableProvider = class extends ObservableProvider {
   }
 };
 
-// packages/common/async/src/mutex.ts
-import "@dxos/util";
-import { warnAfterTimeout } from "@dxos/debug";
-var Mutex = class {
-  constructor() {
-    this._queue = Promise.resolve();
-    this._queueLength = 0;
-    this._tag = null;
+// packages/common/async/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";
+
+// packages/common/async/src/task-scheduling.ts
+import { ContextDisposedError as ContextDisposedError2 } from "@dxos/context";
+import { StackTrace as StackTrace2 } from "@dxos/debug";
+
+// packages/common/async/src/track-leaks.ts
+import { StackTrace } from "@dxos/debug";
+import { log } from "@dxos/log";
+var __dxlog_file3 = "/home/runner/work/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 () => {
+    };
   }
-  get tag() {
-    return this._tag;
+  const resource = resourceProvider();
+  openResources.add(resource);
+  return () => {
+    openResources.delete(resource);
+  };
+};
+var trackLeaks = (open, close) => (target) => {
+  if (!enabled) {
+    return;
   }
-  isLocked() {
-    return this._queueLength > 0;
+  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}`);
   }
-  /**
-  * 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();
-      });
+  {
+    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"
     });
-    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();
-    }
+  {
+    target.prototype[close] = async function(...args) {
+      this[handleSymbol]?.();
+      return closeMethod.apply(this, args);
+    };
+    Object.defineProperty(target.prototype[close], "name", {
+      value: close + "$checkLeaks"
+    });
   }
 };
-var MutexGuard = class {
-  constructor(_release) {
-    this._release = _release;
-  }
-  /**
-  * Releases the lock.
-  */
-  release() {
-    this._release();
+var dumpLeaks = () => {
+  if (!enabled) {
+    return;
   }
-  [Symbol.dispose]() {
-    this.release();
-  }
-};
-var classMutexSymbol = 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"
-  });
-};
-
-// packages/common/async/src/sink.ts
-var sink = (emitter, event, count = 1) => {
-  const [getPromise, resolve] = trigger();
-  let counter = 0;
-  const listener = () => {
-    if (++counter === count) {
-      emitter.off(event, listener);
-      resolve();
-    }
-  };
-  emitter.on(event, listener);
-  return getPromise();
-};
-
-// packages/common/async/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;
-};
-
-// packages/common/async/src/timer.ts
-var Timer = class {
-  constructor(_callback) {
-    this._callback = _callback;
-    this._state = new Event();
-    this._count = 0;
-  }
-  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;
-  }
-};
-
-// packages/common/async/src/testing.ts
-var waitForCondition = ({ condition, timeout = 0, interval = 10, error }) => {
-  const stopTime = timeout ? Date.now() + timeout : 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) {
-      }
-      await sleep(interval);
-    }
-  };
-  setTimeout(waiter, 0);
-  return timeout ? asyncTimeout(trigger2.wait(), timeout, error ?? new Error("Timeout")) : trigger2.wait();
-};
-
-// packages/common/async/src/until.ts
-var until = (cb, timeout) => {
-  return new Promise((resolve, reject) => {
-    const t = timeout && setTimeout(() => {
-      reject(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);
-      }
-    });
-  });
-};
-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);
-      }
-    });
-  });
-};
-
-// packages/common/async/src/task-scheduling.ts
-import { ContextDisposedError as ContextDisposedError2 } from "@dxos/context";
-import { StackTrace as StackTrace2 } from "@dxos/debug";
-
-// packages/common/async/src/track-leaks.ts
-import { StackTrace } from "@dxos/debug";
-import { log } from "@dxos/log";
-var __dxlog_file3 = "/home/runner/work/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);
-  };
-};
-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, {
-    F: __dxlog_file3,
-    L: 82,
-    S: void 0,
-    C: (f, a) => f(...a)
-  });
-  for (const resource of openResources) {
-    log.info(`- ${resource.name} at`, void 0, {
-      F: __dxlog_file3,
-      L: 84,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
-    log.info(resource.openStack.getStack(1), void 0, {
-      F: __dxlog_file3,
-      L: 85,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
-    log.info("\n", void 0, {
-      F: __dxlog_file3,
-      L: 86,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
+  log.info(`Leaked resources ${openResources.size}:`, void 0, {
+    F: __dxlog_file3,
+    L: 82,
+    S: void 0,
+    C: (f, a) => f(...a)
+  });
+  for (const resource of openResources) {
+    log.info(`- ${resource.name} at`, void 0, {
+      F: __dxlog_file3,
+      L: 84,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    log.info(resource.openStack.getStack(1), void 0, {
+      F: __dxlog_file3,
+      L: 85,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    log.info("\n", void 0, {
+      F: __dxlog_file3,
+      L: 86,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
   }
 };
 if (enabled) {
@@ -1068,6 +944,9 @@ var DeferredTask = class {
     this._currentTask = null;
     this._nextTask = new Trigger();
   }
+  get scheduled() {
+    return this._scheduled;
+  }
   /**
   * Schedule the task to run asynchronously.
   */
@@ -1182,6 +1061,173 @@ var scheduleExponentialBackoffTaskInterval = (ctx, task, initialInterval) => {
   });
 };
 
+// packages/common/async/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 __dxlog_file4 = "/home/runner/work/dxos/dxos/packages/common/async/src/persistent-lifecycle.ts";
+var INIT_RESTART_DELAY = 100;
+var DEFAULT_MAX_RESTART_DELAY = 5e3;
+var PersistentLifecycle = class extends Resource {
+  constructor({ start, stop, onRestart, maxRestartDelay = DEFAULT_MAX_RESTART_DELAY }) {
+    super();
+    this._currentState = void 0;
+    this._restartTask = void 0;
+    this._restartAfter = 0;
+    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) {
+        log2.warn("Restart failed", {
+          err
+        }, {
+          F: __dxlog_file4,
+          L: 72,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        this._restartTask?.schedule();
+      }
+    });
+    this._currentState = await this._start().catch((err) => {
+      log2.warn("Start failed", {
+        err
+      }, {
+        F: __dxlog_file4,
+        L: 77,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      this._restartTask?.schedule();
+      return void 0;
+    });
+  }
+  async _close() {
+    await this._restartTask?.join();
+    await this._stopCurrentState();
+    this._restartTask = void 0;
+  }
+  async _restart() {
+    log2(`restarting in ${this._restartAfter}ms`, {
+      state: this._lifecycleState
+    }, {
+      F: __dxlog_file4,
+      L: 90,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    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._restartAfter = 0;
+    await this._onRestart?.();
+  }
+  async _stopCurrentState() {
+    if (this._currentState) {
+      try {
+        await this._stop(this._currentState);
+      } catch (err) {
+        log2.catch(err, void 0, {
+          F: __dxlog_file4,
+          L: 112,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      }
+      this._currentState = void 0;
+    }
+  }
+  /**
+  * Scheduling restart should be done from outside.
+  */
+  scheduleRestart() {
+    if (this._lifecycleState !== LifecycleState.OPEN) {
+      return;
+    }
+    this._restartTask.schedule();
+  }
+};
+_ts_decorate([
+  synchronized
+], PersistentLifecycle.prototype, "_open", null);
+_ts_decorate([
+  synchronized
+], PersistentLifecycle.prototype, "scheduleRestart", null);
+
+// packages/common/async/src/sink.ts
+var sink = (emitter, event, count = 1) => {
+  const [getPromise, resolve] = trigger();
+  let counter = 0;
+  const listener = () => {
+    if (++counter === count) {
+      emitter.off(event, listener);
+      resolve();
+    }
+  };
+  emitter.on(event, listener);
+  return getPromise();
+};
+
+// packages/common/async/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;
+};
+
 // packages/common/async/src/test-stream.ts
 import { Duplex } from "@dxos/node-std/stream";
 var TestStream = class extends Duplex {
@@ -1218,6 +1264,110 @@ var TestStream = class extends Duplex {
   }
 };
 
+// packages/common/async/src/testing.ts
+var waitForCondition = ({ condition, timeout = 0, interval = 10, error }) => {
+  const stopTime = timeout ? Date.now() + timeout : 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) {
+      }
+      await sleep(interval);
+    }
+  };
+  setTimeout(waiter, 0);
+  return timeout ? asyncTimeout(trigger2.wait(), timeout, error ?? new Error("Timeout")) : trigger2.wait();
+};
+
+// packages/common/async/src/timer.ts
+var Timer = class {
+  constructor(_callback) {
+    this._callback = _callback;
+    this._state = new Event();
+    this._count = 0;
+  }
+  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;
+  }
+};
+
+// packages/common/async/src/until.ts
+var until = (cb, timeout) => {
+  return new Promise((resolve, reject) => {
+    const t = timeout && setTimeout(() => {
+      reject(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);
+      }
+    });
+  });
+};
+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);
+      }
+    });
+  });
+};
+
 // packages/common/async/src/update-scheduler.ts
 var TIME_PERIOD = 1e3;
 var UpdateScheduler = class {
@@ -1299,6 +1449,7 @@ export {
   MutexGuard,
   Observable,
   ObservableProvider,
+  PersistentLifecycle,
   PushStream,
   TestStream,
   TimeoutError,