@dxos/async 0.8.4-main.e098934 → 0.8.4-main.e250131250

package/dist/lib/browser/index.mjs

@@ -20,22 +20,9 @@ var chain = (chain2) => async (elements) => {
 
 // src/cleanup.ts
 import { ComplexMap } from "@dxos/util";
-function _define_property(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
 var combine = (...cleanupFns) => {
   return () => {
-    cleanupFns.flat().forEach((cleanupFn) => cleanupFn());
+    cleanupFns.flat().filter((f) => typeof f === "function").forEach((cleanupFn) => cleanupFn());
   };
 };
 var timeout = (cb, ms = 0) => {
@@ -51,19 +38,21 @@ var addEventListener = (target, type, listener, options) => {
   return () => target.removeEventListener(type, listener, options);
 };
 var SubscriptionList = class {
-  add(cb) {
-    this._cleanups.push(cb);
+  _cleanups = [];
+  add(...cb) {
+    this._cleanups.push(...cb);
     return this;
   }
   clear() {
     this._cleanups.forEach((cb) => cb());
     this._cleanups.length = 0;
   }
-  constructor() {
-    _define_property(this, "_cleanups", []);
-  }
 };
 var SubscriptionSet = class {
+  _cleanupMap;
+  constructor(keyProjection) {
+    this._cleanupMap = new ComplexMap(keyProjection);
+  }
   set(key, cb) {
     this._cleanupMap.set(key, cb);
     return this;
@@ -72,36 +61,58 @@ var SubscriptionSet = class {
     this._cleanupMap.forEach((cb) => cb());
     this._cleanupMap.clear();
   }
-  constructor(keyProjection) {
-    _define_property(this, "_cleanupMap", void 0);
-    this._cleanupMap = new ComplexMap(keyProjection);
-  }
 };
 
 // src/debounce.ts
-var debounce = (cb, delay = 100) => {
+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), delay);
+    t = setTimeout(() => cb(...args), delay2);
   };
 };
-var throttle = (cb, delay = 100) => {
+var throttle = (cb, delay2 = 100) => {
   let lastCall = 0;
   return (...args) => {
     const now = Date.now();
-    if (now - lastCall >= delay) {
+    if (now - lastCall >= delay2) {
       cb(...args);
       lastCall = now;
     }
   };
 };
-var debounceAndThrottle = (cb, delay = 100) => {
-  const debounced = debounce(cb, delay);
-  const throttled = throttle(cb, delay);
+var debounceAndThrottle = (cb, delay2 = 100) => {
+  let timeout2;
+  let lastCall = 0;
   return (...args) => {
-    debounced(...args);
-    throttled(...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);
+    }
   };
 };
 
@@ -155,6 +166,9 @@ var sleepWithContext = (ctx, ms) => {
 };
 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) => {
@@ -163,9 +177,8 @@ var asyncTimeout = async (promise, timeout2, err) => {
     }, timeout2);
     unrefTimeout(timeoutId);
   });
-  const conditionTimeout = typeof promise === "function" ? promiseFromCallback(promise) : promise;
   return await Promise.race([
-    conditionTimeout,
+    promise,
     timeoutPromise
   ]).finally(() => {
     clearTimeout(timeoutId);
@@ -202,19 +215,6 @@ var waitForEvent = (eventEmitter, eventName, test, timeout2, error) => {
 
 // src/events.ts
 import { Context } from "@dxos/context";
-function _define_property2(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
 var __dxlog_file = "/__w/dxos/dxos/packages/common/async/src/events.ts";
 var DO_NOT_ERROR_ON_ASYNC_CALLBACK = true;
 var Event = class _Event {
@@ -230,6 +230,8 @@ var Event = class _Event {
     });
     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.
@@ -471,12 +473,30 @@ var Event = class _Event {
       handle.cleanup = void 0;
     }
   }
-  constructor() {
-    _define_property2(this, "_listeners", /* @__PURE__ */ new Set());
-    _define_property2(this, "_effects", /* @__PURE__ */ new Set());
-  }
 };
 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;
   }
@@ -506,29 +526,6 @@ var EventListener = class {
     this._clearDispose?.();
     weakListeners().registry?.unregister(this);
   }
-  constructor(event, listener, ctx, once, weak) {
-    _define_property2(this, "ctx", void 0);
-    _define_property2(this, "once", void 0);
-    _define_property2(this, "weak", void 0);
-    _define_property2(this, "callback", void 0);
-    _define_property2(this, "_clearDispose", void 0);
-    this.ctx = ctx;
-    this.once = once;
-    this.weak = weak;
-    this._clearDispose = void 0;
-    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;
-    }
-  }
 };
 var weakListenersState = null;
 var FINALIZATION_REGISTRY_SUPPORTED = !!globalThis.FinalizationRegistry;
@@ -538,9 +535,9 @@ var weakListeners = () => {
       registry: void 0
     };
   }
-  weakListenersState ?? (weakListenersState = new FinalizationRegistry(({ event, listener }) => {
+  weakListenersState ??= new FinalizationRegistry(({ event, listener }) => {
     event.deref()?._removeListener(listener);
-  }));
+  });
   return {
     registry: weakListenersState
   };
@@ -549,20 +546,10 @@ var weakListeners = () => {
 // src/mutex.ts
 import "@dxos/util";
 import { warnAfterTimeout } from "@dxos/debug";
-function _define_property3(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
 var Mutex = class {
+  _queue = Promise.resolve();
+  _queueLength = 0;
+  _tag = null;
   get tag() {
     return this._tag;
   }
@@ -606,13 +593,12 @@ var Mutex = class {
       guard.release();
     }
   }
-  constructor() {
-    _define_property3(this, "_queue", Promise.resolve());
-    _define_property3(this, "_queueLength", 0);
-    _define_property3(this, "_tag", null);
-  }
 };
 var MutexGuard = class {
+  _release;
+  constructor(_release) {
+    this._release = _release;
+  }
   /**
   * Releases the lock.
   */
@@ -622,19 +608,14 @@ var MutexGuard = class {
   [Symbol.dispose]() {
     this.release();
   }
-  constructor(_release) {
-    _define_property3(this, "_release", void 0);
-    this._release = _release;
-  }
 };
-var classMutexSymbol = Symbol("class-mutex");
+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) {
-    var _classMutexSymbol;
-    const mutex = this[_classMutexSymbol = classMutexSymbol] ?? (this[_classMutexSymbol] = new Mutex());
+    const mutex = this[classMutexSymbol] ??= new Mutex();
     const tag = `${target.constructor.name}.${propertyName}`;
     let guard;
     if (!enableWarning) {
@@ -659,19 +640,6 @@ import PushStream from "zen-push";
 
 // src/trigger.ts
 import { invariant } from "@dxos/invariant";
-function _define_property4(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
 var __dxlog_file2 = "/__w/dxos/dxos/packages/common/async/src/trigger.ts";
 var trigger = (timeout2) => {
   let callback;
@@ -688,13 +656,24 @@ var trigger = (timeout2) => {
     resolver
   ];
 };
-var TriggerState = /* @__PURE__ */ function(TriggerState2) {
+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;
   }
@@ -751,18 +730,6 @@ var Trigger = class {
     }
     return this;
   }
-  constructor(_options = {
-    autoReset: false
-  }) {
-    _define_property4(this, "_options", void 0);
-    _define_property4(this, "_promise", void 0);
-    _define_property4(this, "_resolve", void 0);
-    _define_property4(this, "_reject", void 0);
-    _define_property4(this, "_state", void 0);
-    this._options = _options;
-    this._state = "WAITING";
-    this.reset();
-  }
 };
 var latch = ({ count = 1, timeout: timeout2 } = {}) => {
   invariant(count >= 0, void 0, {
@@ -812,20 +779,16 @@ var latch = ({ count = 1, timeout: timeout2 } = {}) => {
 };
 
 // src/observable.ts
-function _define_property5(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
 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) => {
@@ -906,42 +869,30 @@ var MulticastObservable = class _MulticastObservable extends Observable {
       this._observers.delete(observer);
     };
   }
-  constructor(subscriber, _value) {
-    super((observer) => this._subscribe(observer)), _define_property5(this, "_value", void 0), _define_property5(this, "_observers", void 0), _define_property5(this, "_observable", void 0), _define_property5(this, "_completed", void 0), _define_property5(this, "_handlers", void 0), this._value = _value, this._observers = /* @__PURE__ */ new Set(), this._completed = new Trigger(), this._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?.());
-      }
-    };
-    this._observable = typeof subscriber === "function" ? new Observable(subscriber) : subscriber;
-    this._observable.subscribe(this._handlers);
-  }
+  _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";
-function _define_property6(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
 var ObservableProvider = class {
+  _handlers = /* @__PURE__ */ new Set();
+  _proxy = createSetDispatch({
+    handlers: this._handlers
+  });
+  _value;
   /**
   * Proxy used to dispatch callbacks to each subscription.
   */
@@ -960,15 +911,13 @@ var ObservableProvider = class {
       this._handlers.delete(handler);
     };
   }
-  constructor() {
-    _define_property6(this, "_handlers", /* @__PURE__ */ new Set());
-    _define_property6(this, "_proxy", createSetDispatch({
-      handlers: this._handlers
-    }));
-    _define_property6(this, "_value", void 0);
-  }
 };
 var CancellableObservableProvider = class extends ObservableProvider {
+  _handleCancel;
+  _cancelled = false;
+  constructor(_handleCancel) {
+    super(), this._handleCancel = _handleCancel;
+  }
   get cancelled() {
     return this._cancelled;
   }
@@ -980,9 +929,6 @@ var CancellableObservableProvider = class extends ObservableProvider {
     await this._handleCancel?.();
     this.callback.onCancelled?.();
   }
-  constructor(_handleCancel) {
-    super(), _define_property6(this, "_handleCancel", void 0), _define_property6(this, "_cancelled", void 0), this._handleCancel = _handleCancel, this._cancelled = false;
-  }
 };
 
 // src/persistent-lifecycle.ts
@@ -991,7 +937,7 @@ import { warnAfterTimeout as warnAfterTimeout2 } from "@dxos/debug";
 import { log as log2 } from "@dxos/log";
 
 // src/task-scheduling.ts
-import { ContextDisposedError as ContextDisposedError2 } from "@dxos/context";
+import { Context as Context2, ContextDisposedError as ContextDisposedError2 } from "@dxos/context";
 import { StackTrace as StackTrace2 } from "@dxos/debug";
 
 // src/track-leaks.ts
@@ -1000,7 +946,7 @@ import { log } from "@dxos/log";
 var __dxlog_file3 = "/__w/dxos/dxos/packages/common/async/src/track-leaks.ts";
 var enabled = typeof process !== "undefined" && !!process.env.DX_TRACK_LEAKS;
 var openResources = /* @__PURE__ */ new Set();
-var handleSymbol = Symbol("checkLeaksHandle");
+var handleSymbol = /* @__PURE__ */ Symbol("checkLeaksHandle");
 var trackResource = (resourceProvider) => {
   if (!enabled) {
     return () => {
@@ -1079,20 +1025,17 @@ if (enabled) {
 }
 
 // src/task-scheduling.ts
-function _define_property7(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
+var __dxlog_file4 = "/__w/dxos/dxos/packages/common/async/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;
   }
@@ -1131,17 +1074,81 @@ var DeferredTask = class {
   async join() {
     await this._currentTask;
   }
-  constructor(_ctx, _callback) {
-    _define_property7(this, "_ctx", void 0);
-    _define_property7(this, "_callback", void 0);
-    _define_property7(this, "_scheduled", void 0);
-    _define_property7(this, "_currentTask", void 0);
-    _define_property7(this, "_nextTask", void 0);
-    this._ctx = _ctx;
-    this._callback = _callback;
-    this._scheduled = false;
-    this._currentTask = null;
-    this._nextTask = new Trigger();
+};
+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(void 0, {
+      F: __dxlog_file4,
+      L: 102
+    });
+  }
+  /**
+  * 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) => {
@@ -1223,29 +1230,30 @@ var scheduleExponentialBackoffTaskInterval = (ctx, task, initialInterval) => {
 };
 
 // src/persistent-lifecycle.ts
-function _define_property8(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
 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 = "/__w/dxos/dxos/packages/common/async/src/persistent-lifecycle.ts";
+var __dxlog_file5 = "/__w/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 {
+  _start;
+  _stop;
+  _onRestart;
+  _maxRestartDelay;
+  _currentState = void 0;
+  _restartTask = void 0;
+  _restartAfter = 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;
   }
@@ -1257,7 +1265,7 @@ var PersistentLifecycle = class extends Resource {
         log2.warn("Restart failed", {
           err
         }, {
-          F: __dxlog_file4,
+          F: __dxlog_file5,
           L: 72,
           S: this,
           C: (f, a) => f(...a)
@@ -1269,7 +1277,7 @@ var PersistentLifecycle = class extends Resource {
       log2.warn("Start failed", {
         err
       }, {
-        F: __dxlog_file4,
+        F: __dxlog_file5,
         L: 78,
         S: this,
         C: (f, a) => f(...a)
@@ -1287,7 +1295,7 @@ var PersistentLifecycle = class extends Resource {
     log2(`restarting in ${this._restartAfter}ms`, {
       state: this._lifecycleState
     }, {
-      F: __dxlog_file4,
+      F: __dxlog_file5,
       L: 91,
       S: this,
       C: (f, a) => f(...a)
@@ -1310,7 +1318,7 @@ var PersistentLifecycle = class extends Resource {
         await this._stop(this._currentState);
       } catch (err) {
         log2.catch(err, void 0, {
-          F: __dxlog_file4,
+          F: __dxlog_file5,
           L: 113,
           S: this,
           C: (f, a) => f(...a)
@@ -1328,13 +1336,6 @@ var PersistentLifecycle = class extends Resource {
     }
     this._restartTask.schedule();
   }
-  constructor({ start, stop, onRestart, maxRestartDelay = DEFAULT_MAX_RESTART_DELAY }) {
-    super(), _define_property8(this, "_start", void 0), _define_property8(this, "_stop", void 0), _define_property8(this, "_onRestart", void 0), _define_property8(this, "_maxRestartDelay", void 0), _define_property8(this, "_currentState", void 0), _define_property8(this, "_restartTask", void 0), _define_property8(this, "_restartAfter", 0);
-    this._start = start;
-    this._stop = stop;
-    this._onRestart = onRestart;
-    this._maxRestartDelay = maxRestartDelay;
-  }
 };
 _ts_decorate([
   synchronized
@@ -1345,7 +1346,7 @@ _ts_decorate([
 
 // src/push-iterable.ts
 import { invariant as invariant2 } from "@dxos/invariant";
-var __dxlog_file5 = "/__w/dxos/dxos/packages/common/async/src/push-iterable.ts";
+var __dxlog_file6 = "/__w/dxos/dxos/packages/common/async/src/push-iterable.ts";
 var makePushIterable = () => {
   const buf = [];
   const trigger2 = new Trigger({
@@ -1360,7 +1361,7 @@ var makePushIterable = () => {
           }
           const item = buf.shift();
           invariant2(item, void 0, {
-            F: __dxlog_file5,
+            F: __dxlog_file6,
             L: 42,
             S: this,
             A: [
@@ -1453,19 +1454,6 @@ var streamToArray = (stream) => {
 
 // src/test-stream.ts
 import { Duplex } from "@dxos/node-std/stream";
-function _define_property9(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
 var TestStream = class extends Duplex {
   static async assertConnectivity(stream1, stream2, { timeout: timeout2 = 200 } = {}) {
     stream1.push("ping");
@@ -1479,6 +1467,8 @@ var TestStream = class extends Duplex {
       })
     ]);
   }
+  _received = Buffer.alloc(0);
+  _onWrite = new Event();
   _write(chunk, encoding, callback) {
     this._received = Buffer.concat([
       this._received,
@@ -1493,9 +1483,6 @@ var TestStream = class extends Duplex {
     const dataBuffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
     return asyncTimeout(this._onWrite.waitForCondition(() => this._received.equals(dataBuffer)), timeout2);
   }
-  constructor(...args) {
-    super(...args), _define_property9(this, "_received", Buffer.alloc(0)), _define_property9(this, "_onWrite", new Event());
-  }
 };
 
 // src/testing.ts
@@ -1558,20 +1545,14 @@ var untilError = (cb) => {
 };
 
 // src/timer.ts
-function _define_property10(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
 var Timer = class {
+  _callback;
+  _state = new Event();
+  _timer;
+  _count = 0;
+  constructor(_callback) {
+    this._callback = _callback;
+  }
   get state() {
     return this._state;
   }
@@ -1611,33 +1592,29 @@ var Timer = class {
     this._state.emit(false);
     return this;
   }
-  constructor(_callback) {
-    _define_property10(this, "_callback", void 0);
-    _define_property10(this, "_state", void 0);
-    _define_property10(this, "_timer", void 0);
-    _define_property10(this, "_count", void 0);
-    this._callback = _callback;
-    this._state = new Event();
-    this._count = 0;
-  }
 };
 
 // src/update-scheduler.ts
-function _define_property11(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
 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;
@@ -1646,13 +1623,13 @@ var UpdateScheduler = class {
       await this._promise;
       if (this._params.maxFrequency) {
         const now = performance.now();
-        const delay = this._lastUpdateTime + TIME_PERIOD / this._params.maxFrequency - now;
-        if (delay > 0) {
+        const delay2 = this._lastUpdateTime + TIME_PERIOD / this._params.maxFrequency - now;
+        if (delay2 > 0) {
           await new Promise((resolve) => {
             const timeoutId = setTimeout(() => {
               clearContext();
               resolve();
-            }, delay);
+            }, delay2);
             const clearContext = this._ctx.onDispose(() => {
               clearTimeout(timeoutId);
               resolve();
@@ -1694,25 +1671,9 @@ var UpdateScheduler = class {
     this._promise = this._callback();
     await this._promise;
   }
-  constructor(_ctx, _callback, _params = {}) {
-    _define_property11(this, "_ctx", void 0);
-    _define_property11(this, "_callback", void 0);
-    _define_property11(this, "_params", void 0);
-    _define_property11(this, "_promise", void 0);
-    _define_property11(this, "_scheduled", void 0);
-    _define_property11(this, "_lastUpdateTime", void 0);
-    this._ctx = _ctx;
-    this._callback = _callback;
-    this._params = _params;
-    this._promise = null;
-    this._scheduled = false;
-    this._lastUpdateTime = -TIME_PERIOD;
-    _ctx.onDispose(async () => {
-      await this._promise;
-    });
-  }
 };
 export {
+  AsyncTask,
   CancellableObservableProvider,
   DeferredTask,
   Event,
@@ -1739,6 +1700,7 @@ export {
   combine,
   debounce,
   debounceAndThrottle,
+  delay,
   dumpLeaks,
   interval,
   latch,