@dxos/async 0.7.5-main.9d26e3a → 0.7.5-main.b19bfc8

package/dist/lib/node/index.cjs

@@ -37,6 +37,7 @@ __export(node_exports, {
   MutexGuard: () => MutexGuard,
   Observable: () => import_zen_observable.default,
   ObservableProvider: () => ObservableProvider,
+  PersistentLifecycle: () => PersistentLifecycle,
   PushStream: () => import_zen_push.default,
   TestStream: () => TestStream,
   TimeoutError: () => TimeoutError,
@@ -80,15 +81,18 @@ module.exports = __toCommonJS(node_exports);
 var import_context = require("@dxos/context");
 var import_context2 = require("@dxos/context");
 var import_invariant = require("@dxos/invariant");
+var import_util = require("@dxos/util");
+var import_debug = require("@dxos/debug");
 var import_zen_observable = __toESM(require("zen-observable"));
 var import_zen_push = __toESM(require("zen-push"));
-var import_util = require("@dxos/util");
 var import_util2 = require("@dxos/util");
-var import_debug = require("@dxos/debug");
 var import_context3 = require("@dxos/context");
 var import_debug2 = require("@dxos/debug");
-var import_debug3 = require("@dxos/debug");
 var import_log = require("@dxos/log");
+var import_context4 = require("@dxos/context");
+var import_debug3 = require("@dxos/debug");
+var import_debug4 = require("@dxos/debug");
+var import_log2 = require("@dxos/log");
 var import_node_stream = require("node:stream");
 var createPromiseFromCallback = (run) => new Promise((resolve, reject) => {
   run((error, value) => {
@@ -214,6 +218,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();
@@ -242,7 +247,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);
       }
@@ -255,7 +276,7 @@ var Event = class _Event {
     ] : [
       new import_context2.Context(void 0, {
         F: __dxlog_file,
-        L: 124
+        L: 148
       }),
       _ctx
     ];
@@ -288,7 +309,7 @@ var Event = class _Event {
     ] : [
       new import_context2.Context(void 0, {
         F: __dxlog_file,
-        L: 161
+        L: 185
       }),
       _ctx
     ];
@@ -472,7 +493,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);
@@ -547,6 +582,94 @@ var latch = ({ count = 1, timeout } = {}) => {
     (err) => doReject(err)
   ];
 };
+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 (0, import_debug.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"
+  });
+};
 var trigger = (timeout) => {
   let callback;
   const promise = new Promise((resolve, reject) => {
@@ -740,7 +863,7 @@ var EMPTY_OBSERVABLE = MulticastObservable.of(null);
 var ObservableProvider = class {
   constructor() {
     this._handlers = /* @__PURE__ */ new Set();
-    this._proxy = (0, import_util.createSetDispatch)({
+    this._proxy = (0, import_util2.createSetDispatch)({
       handlers: this._handlers
     });
   }
@@ -781,94 +904,319 @@ var CancellableObservableProvider = class extends ObservableProvider {
     this.callback.onCancelled?.();
   }
 };
-var Mutex = class {
-  constructor() {
-    this._queue = Promise.resolve();
-    this._queueLength = 0;
-    this._tag = null;
+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}`);
+  }
+  {
+    target.prototype[open] = async function(...args) {
+      this[handleSymbol] = trackResource(() => ({
+        name: target.name,
+        openStack: new import_debug4.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;
+  }
+  import_log2.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) {
+    import_log2.log.info(`- ${resource.name} at`, void 0, {
+      F: __dxlog_file3,
+      L: 84,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    import_log2.log.info(resource.openStack.getStack(1), void 0, {
+      F: __dxlog_file3,
+      L: 85,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    import_log2.log.info("\n", void 0, {
+      F: __dxlog_file3,
+      L: 86,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+  }
+};
+if (enabled) {
+  global.dxDumpLeaks = dumpLeaks;
+}
+var DeferredTask = class {
+  constructor(_ctx, _callback) {
+    this._ctx = _ctx;
+    this._callback = _callback;
+    this._scheduled = false;
+    this._currentTask = null;
+    this._nextTask = new Trigger();
+  }
+  get scheduled() {
+    return this._scheduled;
   }
   /**
-  * 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
+  * Schedule the task to run asynchronously.
   */
-  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();
+  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();
       });
     });
-    await prev;
-    if (tag !== void 0) {
-      this._tag = tag;
-    }
-    return guard;
+    this._scheduled = true;
   }
   /**
-  * 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.
+  * Schedule the task to run and wait for it to finish.
   */
-  async executeSynchronized(fun) {
-    const guard = await this.acquire();
-    try {
-      return await fun();
-    } finally {
-      guard.release();
+  async runBlocking() {
+    if (this._ctx.disposed) {
+      throw new import_context4.ContextDisposedError();
     }
-  }
-};
-var MutexGuard = class {
-  constructor(_release) {
-    this._release = _release;
+    this.schedule();
+    await this._nextTask.wait();
   }
   /**
-  * Releases the lock.
+  * Waits for the current task to finish if it is running.
+  * Does not schedule a new task.
   */
-  release() {
-    this._release();
+  async join() {
+    await this._currentTask;
   }
-  [Symbol.dispose]() {
-    this.release();
+};
+var runInContext = (ctx, fn) => {
+  try {
+    fn();
+  } catch (err) {
+    ctx.raise(err);
   }
 };
-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 (0, import_debug.warnAfterTimeout)(1e4, `lock on ${tag} (taken by ${mutex.tag})`, () => mutex.acquire(tag));
+var runInContextAsync = async (ctx, fn) => {
+  try {
+    await fn();
+  } catch (err) {
+    ctx.raise(err);
+  }
+};
+var scheduleMicroTask = (ctx, fn) => {
+  queueMicrotask(async () => {
+    if (ctx.disposed) {
+      return;
     }
-    try {
-      return await method.apply(this, args);
-    } finally {
-      guard.release();
+    await runInContextAsync(ctx, fn);
+  });
+};
+var scheduleTask = (ctx, fn, afterMs) => {
+  const clearTracking = trackResource(() => ({
+    name: `task (${fn.name || "anonymous"})`,
+    openStack: new import_debug3.StackTrace()
+  }));
+  const timeout = setTimeout(async () => {
+    clearDispose();
+    await runInContextAsync(ctx, fn);
+    clearTracking();
+  }, afterMs);
+  const clearDispose = ctx.onDispose(() => {
+    clearTracking();
+    clearTimeout(timeout);
+  });
+};
+var scheduleTaskInterval = (ctx, task, interval) => {
+  const clearTracking = trackResource(() => ({
+    name: `repeating task (${task.name || "anonymous"})`,
+    openStack: new import_debug3.StackTrace()
+  }));
+  let timeoutId;
+  const run = async () => {
+    await runInContextAsync(ctx, task);
+    if (ctx.disposed) {
+      return;
     }
+    timeoutId = setTimeout(run, interval);
   };
-  Object.defineProperty(descriptor.value, "name", {
-    value: propertyName + "$synchronized"
+  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 import_debug3.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);
+  });
+};
+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 import_context3.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) {
+        import_log.log.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) => {
+      import_log.log.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() {
+    (0, import_log.log)(`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 !== import_context3.LifecycleState.OPEN) {
+      return;
+    }
+    await (0, import_context3.cancelWithContext)(this._ctx, sleep(this._restartAfter));
+    this._restartAfter = Math.min(Math.max(this._restartAfter * 2, INIT_RESTART_DELAY), this._maxRestartDelay);
+    await (0, import_debug2.warnAfterTimeout)(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) {
+        import_log.log.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 !== import_context3.LifecycleState.OPEN) {
+      return;
+    }
+    this._restartTask.schedule();
+  }
+};
+_ts_decorate([
+  synchronized
+], PersistentLifecycle.prototype, "_open", null);
+_ts_decorate([
+  synchronized
+], PersistentLifecycle.prototype, "scheduleRestart", null);
 var sink = (emitter, event, count = 1) => {
   const [getPromise, resolve] = trigger();
   let counter = 0;
@@ -921,6 +1269,58 @@ var streamToArray = (stream) => {
   }
   return deferred;
 };
+var TestStream = class extends import_node_stream.Duplex {
+  constructor() {
+    super(...arguments);
+    this._received = Buffer.alloc(0);
+    this._onWrite = new Event();
+  }
+  static async assertConnectivity(stream1, stream2, { timeout = 200 } = {}) {
+    stream1.push("ping");
+    stream2.push("pong");
+    await Promise.all([
+      stream2.assertReceivedAsync("ping", {
+        timeout
+      }),
+      stream1.assertReceivedAsync("pong", {
+        timeout
+      })
+    ]);
+  }
+  _write(chunk, encoding, callback) {
+    this._received = Buffer.concat([
+      this._received,
+      chunk
+    ]);
+    this._onWrite.emit();
+    callback();
+  }
+  _read(size) {
+  }
+  assertReceivedAsync(data, { timeout = 200 } = {}) {
+    const dataBuffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
+    return asyncTimeout(this._onWrite.waitForCondition(() => this._received.equals(dataBuffer)), timeout);
+  }
+};
+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();
+};
 var Timer = class {
   constructor(_callback) {
     this._callback = _callback;
@@ -967,25 +1367,6 @@ var Timer = class {
     return this;
   }
 };
-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();
-};
 var until = (cb, timeout) => {
   return new Promise((resolve, reject) => {
     const t = timeout && setTimeout(() => {
@@ -1019,240 +1400,6 @@ var untilError = (cb) => {
     });
   });
 };
-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 import_debug3.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;
-  }
-  import_log.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) {
-    import_log.log.info(`- ${resource.name} at`, void 0, {
-      F: __dxlog_file3,
-      L: 84,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
-    import_log.log.info(resource.openStack.getStack(1), void 0, {
-      F: __dxlog_file3,
-      L: 85,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
-    import_log.log.info("\n", void 0, {
-      F: __dxlog_file3,
-      L: 86,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
-  }
-};
-if (enabled) {
-  global.dxDumpLeaks = dumpLeaks;
-}
-var DeferredTask = class {
-  constructor(_ctx, _callback) {
-    this._ctx = _ctx;
-    this._callback = _callback;
-    this._scheduled = false;
-    this._currentTask = null;
-    this._nextTask = new Trigger();
-  }
-  /**
-  * 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 import_context3.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 import_debug2.StackTrace()
-  }));
-  const timeout = setTimeout(async () => {
-    clearDispose();
-    await runInContextAsync(ctx, fn);
-    clearTracking();
-  }, afterMs);
-  const clearDispose = ctx.onDispose(() => {
-    clearTracking();
-    clearTimeout(timeout);
-  });
-};
-var scheduleTaskInterval = (ctx, task, interval) => {
-  const clearTracking = trackResource(() => ({
-    name: `repeating task (${task.name || "anonymous"})`,
-    openStack: new import_debug2.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 import_debug2.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);
-  });
-};
-var TestStream = class extends import_node_stream.Duplex {
-  constructor() {
-    super(...arguments);
-    this._received = Buffer.alloc(0);
-    this._onWrite = new Event();
-  }
-  static async assertConnectivity(stream1, stream2, { timeout = 200 } = {}) {
-    stream1.push("ping");
-    stream2.push("pong");
-    await Promise.all([
-      stream2.assertReceivedAsync("ping", {
-        timeout
-      }),
-      stream1.assertReceivedAsync("pong", {
-        timeout
-      })
-    ]);
-  }
-  _write(chunk, encoding, callback) {
-    this._received = Buffer.concat([
-      this._received,
-      chunk
-    ]);
-    this._onWrite.emit();
-    callback();
-  }
-  _read(size) {
-  }
-  assertReceivedAsync(data, { timeout = 200 } = {}) {
-    const dataBuffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
-    return asyncTimeout(this._onWrite.waitForCondition(() => this._received.equals(dataBuffer)), timeout);
-  }
-};
 var TIME_PERIOD = 1e3;
 var UpdateScheduler = class {
   constructor(_ctx, _callback, _params = {}) {
@@ -1334,6 +1481,7 @@ var UpdateScheduler = class {
   MutexGuard,
   Observable,
   ObservableProvider,
+  PersistentLifecycle,
   PushStream,
   TestStream,
   TimeoutError,