@dxos/async 0.7.5-labs.e27f9b9 → 0.7.5-labs.f400bbc

package/dist/lib/browser/index.mjs

@@ -505,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";
@@ -750,98 +842,336 @@ 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}`);
+  }
+  {
+    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)
+    });
+  }
+};
+if (enabled) {
+  global.dxDumpLeaks = dumpLeaks;
+}
+
+// packages/common/async/src/task-scheduling.ts
+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 ContextDisposedError2();
     }
-  }
-};
-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 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 StackTrace2()
+  }));
+  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 StackTrace2()
+  }));
+  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 StackTrace2()
+  }));
+  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);
   });
 };
 
+// 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();
@@ -898,6 +1228,63 @@ var streamToArray = (stream) => {
   return deferred;
 };
 
+// packages/common/async/src/test-stream.ts
+import { Duplex } from "@dxos/node-std/stream";
+var TestStream = class extends 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);
+  }
+};
+
+// 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) {
@@ -946,27 +1333,6 @@ var Timer = class {
   }
 };
 
-// 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) => {
@@ -1002,253 +1368,6 @@ var untilError = (cb) => {
   });
 };
 
-// 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)
-    });
-  }
-};
-if (enabled) {
-  global.dxDumpLeaks = dumpLeaks;
-}
-
-// packages/common/async/src/task-scheduling.ts
-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 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 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 StackTrace2()
-  }));
-  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 StackTrace2()
-  }));
-  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);
-  });
-};
-
-// packages/common/async/src/test-stream.ts
-import { Duplex } from "@dxos/node-std/stream";
-var TestStream = class extends 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);
-  }
-};
-
 // packages/common/async/src/update-scheduler.ts
 var TIME_PERIOD = 1e3;
 var UpdateScheduler = class {
@@ -1330,6 +1449,7 @@ export {
   MutexGuard,
   Observable,
   ObservableProvider,
+  PersistentLifecycle,
   PushStream,
   TestStream,
   TimeoutError,