@dxos/async 0.8.3 → 0.8.4-main.03d5cd7b56

package/dist/lib/node-esm/index.mjs

@@ -1,7 +1,7 @@
 import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
 
-// packages/common/async/src/callback.ts
-var createPromiseFromCallback = (run) => new Promise((resolve, reject) => {
+// src/callback.ts
+var promiseFromCallback = (run) => new Promise((resolve, reject) => {
   run((error, value) => {
     if (error) {
       reject(error);
@@ -11,20 +11,20 @@ var createPromiseFromCallback = (run) => new Promise((resolve, reject) => {
   });
 });
 
-// packages/common/async/src/chain.ts
-var asyncChain = (chain) => async (elements) => {
+// src/chain.ts
+var chain = (chain2) => async (elements) => {
   let result = await elements;
-  for (const part of chain) {
+  for (const part of chain2) {
     result = await Promise.all(result.map(async (element) => await part(element)));
   }
   return result;
 };
 
-// packages/common/async/src/cleanup.ts
+// src/cleanup.ts
 import { ComplexMap } from "@dxos/util";
 var combine = (...cleanupFns) => {
   return () => {
-    cleanupFns.flat().forEach((cleanupFn) => cleanupFn());
+    cleanupFns.flat().filter((f) => typeof f === "function").forEach((cleanupFn) => cleanupFn());
   };
 };
 var timeout = (cb, ms = 0) => {
@@ -35,16 +35,14 @@ var interval = (cb, ms) => {
   const t = setInterval(cb, ms);
   return () => clearInterval(t);
 };
-function addEventListener(target, type, listener, options) {
+var addEventListener = (target, type, listener, options) => {
   target.addEventListener(type, listener, options);
   return () => target.removeEventListener(type, listener, options);
-}
+};
 var SubscriptionList = class {
-  constructor() {
-    this._cleanups = [];
-  }
-  add(cb) {
-    this._cleanups.push(cb);
+  _cleanups = [];
+  add(...cb) {
+    this._cleanups.push(...cb);
     return this;
   }
   clear() {
@@ -53,6 +51,7 @@ var SubscriptionList = class {
   }
 };
 var SubscriptionSet = class {
+  _cleanupMap;
   constructor(keyProjection) {
     this._cleanupMap = new ComplexMap(keyProjection);
   }
@@ -66,16 +65,60 @@ var SubscriptionSet = class {
   }
 };
 
-// packages/common/async/src/debounce.ts
-var debounce = (cb, wait = 100) => {
+// src/debounce.ts
+var delay = (cb, delay2 = 100) => {
+  let pending = false;
+  return (...args) => {
+    if (pending) {
+      return;
+    }
+    pending = true;
+    setTimeout(() => {
+      try {
+        cb(...args);
+      } finally {
+        pending = false;
+      }
+    }, delay2);
+  };
+};
+var debounce = (cb, delay2 = 100) => {
   let t;
   return (...args) => {
     clearTimeout(t);
-    t = setTimeout(() => cb(...args), wait);
+    t = setTimeout(() => cb(...args), delay2);
+  };
+};
+var throttle = (cb, delay2 = 100) => {
+  let lastCall = 0;
+  return (...args) => {
+    const now = Date.now();
+    if (now - lastCall >= delay2) {
+      cb(...args);
+      lastCall = now;
+    }
+  };
+};
+var debounceAndThrottle = (cb, delay2 = 100) => {
+  let timeout2;
+  let lastCall = 0;
+  return (...args) => {
+    const now = Date.now();
+    const delta = now - lastCall;
+    clearTimeout(timeout2);
+    if (delta >= delay2) {
+      cb(...args);
+      lastCall = now;
+    } else {
+      timeout2 = setTimeout(() => {
+        cb(...args);
+        lastCall = Date.now();
+      }, delay2 - delta);
+    }
   };
 };
 
-// packages/common/async/src/errors.ts
+// src/errors.ts
 var toError = (err) => err === void 0 || typeof err === "string" ? new Error(err) : err;
 var TimeoutError = class extends Error {
   constructor(timeout2, label) {
@@ -90,7 +133,7 @@ var observableError = (observable, err) => {
   }
 };
 
-// packages/common/async/src/timeout.ts
+// src/timeout.ts
 import { ContextDisposedError } from "@dxos/context";
 var sleep = (ms) => {
   return new Promise((resolve) => {
@@ -106,8 +149,28 @@ var sleep = (ms) => {
     sleeper();
   });
 };
+var sleepWithContext = (ctx, ms) => {
+  const error = new ContextDisposedError();
+  return new Promise((resolve, reject) => {
+    if (ctx.disposed) {
+      reject(error);
+      return;
+    }
+    const timeout2 = setTimeout(() => {
+      clearDispose();
+      resolve();
+    }, ms);
+    const clearDispose = ctx.onDispose(() => {
+      clearTimeout(timeout2);
+      reject(error);
+    });
+  });
+};
 var asyncReturn = () => sleep(0);
 var asyncTimeout = async (promise, timeout2, err) => {
+  if (typeof promise === "function") {
+    throw new Error("First argument must be a promise.");
+  }
   let timeoutId;
   const throwable = err === void 0 || typeof err === "string" ? new TimeoutError(timeout2, err) : err;
   const timeoutPromise = new Promise((resolve, reject) => {
@@ -116,9 +179,8 @@ var asyncTimeout = async (promise, timeout2, err) => {
     }, timeout2);
     unrefTimeout(timeoutId);
   });
-  const conditionTimeout = typeof promise === "function" ? createPromiseFromCallback(promise) : promise;
   return await Promise.race([
-    conditionTimeout,
+    promise,
     timeoutPromise
   ]).finally(() => {
     clearTimeout(timeoutId);
@@ -129,25 +191,8 @@ var unrefTimeout = (timeoutId) => {
     timeoutId.unref();
   }
 };
-var sleepWithContext = (ctx, ms) => {
-  const error = new ContextDisposedError();
-  return new Promise((resolve, reject) => {
-    if (ctx.disposed) {
-      reject(error);
-      return;
-    }
-    const timeout2 = setTimeout(() => {
-      clearDispose();
-      resolve();
-    }, ms);
-    const clearDispose = ctx.onDispose(() => {
-      clearTimeout(timeout2);
-      reject(error);
-    });
-  });
-};
 
-// packages/common/async/src/event-emitter.ts
+// src/event-emitter.ts
 var onEvent = (eventEmitter, eventName, callback) => {
   eventEmitter.on(eventName, callback);
   return () => eventEmitter.off(eventName, callback);
@@ -170,15 +215,10 @@ var waitForEvent = (eventEmitter, eventName, test, timeout2, error) => {
   return timeout2 ? asyncTimeout(promise, timeout2, error ?? new Error()).finally(off) : promise.finally(off);
 };
 
-// packages/common/async/src/events.ts
+// src/events.ts
 import { Context } from "@dxos/context";
-var __dxlog_file = "/home/runner/work/dxos/dxos/packages/common/async/src/events.ts";
 var DO_NOT_ERROR_ON_ASYNC_CALLBACK = true;
 var Event = class _Event {
-  constructor() {
-    this._listeners = /* @__PURE__ */ new Set();
-    this._effects = /* @__PURE__ */ new Set();
-  }
   /**
   * Wrap objects that have on/off style event emitters.
   */
@@ -191,6 +231,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.
@@ -229,10 +271,7 @@ var Event = class _Event {
       _ctx,
       _callback
     ] : [
-      new Context(void 0, {
-        F: __dxlog_file,
-        L: 132
-      }),
+      new Context(),
       _ctx
     ];
     const weak = !!options?.weak;
@@ -262,10 +301,7 @@ var Event = class _Event {
       _ctx,
       _callback
     ] : [
-      new Context(void 0, {
-        F: __dxlog_file,
-        L: 169
-      }),
+      new Context(),
       _ctx
     ];
     const listener = new EventListener(this, callback, ctx, true, false);
@@ -434,11 +470,15 @@ var Event = class _Event {
   }
 };
 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 = void 0;
     this._clearDispose = ctx.onDispose(() => {
       event._removeListener(this);
     });
@@ -498,65 +538,13 @@ var weakListeners = () => {
   };
 };
 
-// packages/common/async/src/latch.ts
-import { invariant } from "@dxos/invariant";
-var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/common/async/src/latch.ts";
-var latch = ({ count = 1, timeout: timeout2 } = {}) => {
-  invariant(count >= 0, void 0, {
-    F: __dxlog_file2,
-    L: 19,
-    S: void 0,
-    A: [
-      "count >= 0",
-      ""
-    ]
-  });
-  let t;
-  let doResolve;
-  let doReject;
-  const promise = new Promise((resolve, reject) => {
-    doResolve = (value) => {
-      clearTimeout(t);
-      resolve(value);
-    };
-    doReject = (err) => {
-      clearTimeout(t);
-      reject(err);
-    };
-  });
-  if (count === 0) {
-    setTimeout(() => {
-      doResolve(0);
-    });
-  } else {
-    if (timeout2) {
-      t = setTimeout(() => {
-        doReject(new Error(`Timed out after ${timeout2.toLocaleString()}ms`));
-      }, timeout2);
-    }
-  }
-  let i = 0;
-  return [
-    async () => await promise,
-    () => {
-      if (++i === count) {
-        doResolve(i);
-      }
-      return i;
-    },
-    (err) => doReject(err)
-  ];
-};
-
-// packages/common/async/src/mutex.ts
+// 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;
-  }
+  _queue = Promise.resolve();
+  _queueLength = 0;
+  _tag = null;
   get tag() {
     return this._tag;
   }
@@ -602,6 +590,7 @@ var Mutex = class {
   }
 };
 var MutexGuard = class {
+  _release;
   constructor(_release) {
     this._release = _release;
   }
@@ -615,7 +604,7 @@ var MutexGuard = class {
     this.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) => {
@@ -640,11 +629,12 @@ var synchronized = (target, propertyName, descriptor) => {
   });
 };
 
-// packages/common/async/src/observable.ts
+// src/observable.ts
 import Observable from "zen-observable";
 import PushStream from "zen-push";
 
-// packages/common/async/src/trigger.ts
+// src/trigger.ts
+import { invariant } from "@dxos/invariant";
 var trigger = (timeout2) => {
   let callback;
   const promise = new Promise((resolve, reject) => {
@@ -660,18 +650,22 @@ 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._state = "WAITING";
     this.reset();
   }
   get state() {
@@ -731,23 +725,53 @@ var Trigger = class {
     return this;
   }
 };
+var latch = ({ count = 1, timeout: timeout2 } = {}) => {
+  invariant(count >= 0);
+  let t;
+  let doResolve;
+  let doReject;
+  const promise = new Promise((resolve, reject) => {
+    doResolve = (value) => {
+      clearTimeout(t);
+      resolve(value);
+    };
+    doReject = (err) => {
+      clearTimeout(t);
+      reject(err);
+    };
+  });
+  if (count === 0) {
+    setTimeout(() => {
+      doResolve(0);
+    });
+  } else {
+    if (timeout2) {
+      t = setTimeout(() => {
+        doReject(new Error(`Timed out after ${timeout2.toLocaleString()}ms`));
+      }, timeout2);
+    }
+  }
+  let i = 0;
+  return [
+    async () => await promise,
+    () => {
+      if (++i === count) {
+        doResolve(i);
+      }
+      return i;
+    },
+    (err) => doReject(err)
+  ];
+};
 
-// packages/common/async/src/observable.ts
+// src/observable.ts
 var MulticastObservable = class _MulticastObservable extends Observable {
+  _value;
+  _observers = /* @__PURE__ */ new Set();
+  _observable;
+  _completed = new Trigger();
   constructor(subscriber, _value) {
-    super((observer) => this._subscribe(observer)), this._value = _value, this._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?.());
-      }
-    };
+    super((observer) => this._subscribe(observer)), this._value = _value;
     this._observable = typeof subscriber === "function" ? new Observable(subscriber) : subscriber;
     this._observable.subscribe(this._handlers);
   }
@@ -831,18 +855,30 @@ var MulticastObservable = class _MulticastObservable extends Observable {
       this._observers.delete(observer);
     };
   }
+  _handlers = {
+    next: (value) => {
+      this._value = value;
+      this._observers.forEach((observer) => observer.next?.(value));
+    },
+    error: (err) => {
+      this._observers.forEach((observer) => observer.error?.(err));
+    },
+    complete: () => {
+      this._completed.wake();
+      this._observers.forEach((observer) => observer.complete?.());
+    }
+  };
 };
 var EMPTY_OBSERVABLE = MulticastObservable.of(null);
 
-// packages/common/async/src/observable-value.ts
+// src/observable-value.ts
 import { createSetDispatch } from "@dxos/util";
 var ObservableProvider = class {
-  constructor() {
-    this._handlers = /* @__PURE__ */ new Set();
-    this._proxy = createSetDispatch({
-      handlers: this._handlers
-    });
-  }
+  _handlers = /* @__PURE__ */ new Set();
+  _proxy = createSetDispatch({
+    handlers: this._handlers
+  });
+  _value;
   /**
   * Proxy used to dispatch callbacks to each subscription.
   */
@@ -863,8 +899,10 @@ var ObservableProvider = class {
   }
 };
 var CancellableObservableProvider = class extends ObservableProvider {
+  _handleCancel;
+  _cancelled = false;
   constructor(_handleCancel) {
-    super(), this._handleCancel = _handleCancel, this._cancelled = false;
+    super(), this._handleCancel = _handleCancel;
   }
   get cancelled() {
     return this._cancelled;
@@ -879,22 +917,21 @@ var CancellableObservableProvider = class extends ObservableProvider {
   }
 };
 
-// packages/common/async/src/persistent-lifecycle.ts
+// 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";
+// src/task-scheduling.ts
+import { Context as Context2, ContextDisposedError as ContextDisposedError2 } from "@dxos/context";
 import { StackTrace as StackTrace2 } from "@dxos/debug";
 
-// packages/common/async/src/track-leaks.ts
+// 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 handleSymbol = /* @__PURE__ */ Symbol("checkLeaksHandle");
 var trackResource = (resourceProvider) => {
   if (!enabled) {
     return () => {
@@ -941,45 +978,27 @@ 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)
-  });
+  log.info(`Leaked resources ${openResources.size}:`);
   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(`- ${resource.name} at`);
+    log.info(resource.openStack.getStack(1));
+    log.info("\n");
   }
 };
 if (enabled) {
   global.dxDumpLeaks = dumpLeaks;
 }
 
-// packages/common/async/src/task-scheduling.ts
+// 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;
-    this._scheduled = false;
-    this._currentTask = null;
-    this._nextTask = new Trigger();
   }
   get scheduled() {
     return this._scheduled;
@@ -1020,6 +1039,79 @@ var DeferredTask = class {
     await this._currentTask;
   }
 };
+var AsyncTask = class {
+  #callback;
+  #ctx = void 0;
+  #scheduled = false;
+  #currentTask = null;
+  #nextTask = new Trigger();
+  constructor(callback) {
+    this.#callback = callback;
+  }
+  get scheduled() {
+    return this.#scheduled;
+  }
+  /**
+  * Context of the resource that owns the task.
+  * When the context is disposed, the task is cancelled and cannot be scheduled again.
+  */
+  open() {
+    this.#ctx = new Context2();
+  }
+  /**
+  * Closes the task and waits for it to finish if it is running.
+  */
+  async close() {
+    await this.#ctx?.dispose();
+    await this.join();
+    this.#ctx = void 0;
+  }
+  [Symbol.asyncDispose]() {
+    return this.close();
+  }
+  /**
+  * Schedule the task to run asynchronously.
+  */
+  // TODO(dmaretskyi): Add scheduleAt. Where the earlier time will override the later one.
+  schedule() {
+    if (!this.#ctx || this.#ctx.disposed) {
+      throw new Error("AsyncTask not open");
+    }
+    if (this.#scheduled) {
+      return;
+    }
+    scheduleTask(this.#ctx, async () => {
+      await this.#currentTask;
+      if (!this.#ctx || this.#ctx.disposed) {
+        return;
+      }
+      this.#scheduled = false;
+      const completionTrigger = this.#nextTask;
+      this.#nextTask = new Trigger();
+      this.#currentTask = runInContextAsync(this.#ctx, () => this.#callback()).then(() => {
+        completionTrigger.wake();
+      });
+    });
+    this.#scheduled = true;
+  }
+  /**
+  * Schedule the task to run and wait for it to finish.
+  */
+  async runBlocking() {
+    if (this.#ctx?.disposed) {
+      throw new ContextDisposedError2();
+    }
+    this.schedule();
+    await this.#nextTask.wait();
+  }
+  /**
+  * Waits for the current task to finish if it is running.
+  * Does not schedule a new task.
+  */
+  async join() {
+    await this.#currentTask;
+  }
+};
 var runInContext = (ctx, fn) => {
   try {
     fn();
@@ -1098,22 +1190,25 @@ var scheduleExponentialBackoffTaskInterval = (ctx, task, initialInterval) => {
   });
 };
 
-// packages/common/async/src/persistent-lifecycle.ts
+// 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 {
+  _start;
+  _stop;
+  _onRestart;
+  _maxRestartDelay;
+  _currentState = void 0;
+  _restartTask = void 0;
+  _restartAfter = 0;
   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;
@@ -1127,25 +1222,21 @@ var PersistentLifecycle = class extends Resource {
       try {
         await this._restart();
       } catch (err) {
+        if (this._ctx?.disposed) {
+          return;
+        }
         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) => {
+      if (this._ctx?.disposed) {
+        return void 0;
+      }
       log2.warn("Start failed", {
         err
-      }, {
-        F: __dxlog_file4,
-        L: 78,
-        S: this,
-        C: (f, a) => f(...a)
       });
       this._restartTask?.schedule();
       return void 0;
@@ -1159,11 +1250,6 @@ var PersistentLifecycle = class extends Resource {
   async _restart() {
     log2(`restarting in ${this._restartAfter}ms`, {
       state: this._lifecycleState
-    }, {
-      F: __dxlog_file4,
-      L: 91,
-      S: this,
-      C: (f, a) => f(...a)
     });
     await this._stopCurrentState();
     if (this._lifecycleState !== LifecycleState.OPEN) {
@@ -1182,12 +1268,7 @@ var PersistentLifecycle = class extends Resource {
       try {
         await this._stop(this._currentState);
       } catch (err) {
-        log2.catch(err, void 0, {
-          F: __dxlog_file4,
-          L: 113,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        log2.catch(err);
       }
       this._currentState = void 0;
     }
@@ -1209,9 +1290,8 @@ _ts_decorate([
   synchronized
 ], PersistentLifecycle.prototype, "scheduleRestart", null);
 
-// packages/common/async/src/push-iterable.ts
+// src/push-iterable.ts
 import { invariant as invariant2 } from "@dxos/invariant";
-var __dxlog_file5 = "/home/runner/work/dxos/dxos/packages/common/async/src/push-iterable.ts";
 var makePushIterable = () => {
   const buf = [];
   const trigger2 = new Trigger({
@@ -1225,15 +1305,7 @@ var makePushIterable = () => {
             await trigger2.wait();
           }
           const item = buf.shift();
-          invariant2(item, void 0, {
-            F: __dxlog_file5,
-            L: 42,
-            S: this,
-            A: [
-              "item",
-              ""
-            ]
-          });
+          invariant2(item);
           switch (item.kind) {
             case "next":
               return {
@@ -1275,21 +1347,7 @@ var makePushIterable = () => {
   };
 };
 
-// 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
+// src/stream-to-array.ts
 var streamToArray = (stream) => {
   let deferred;
   if (!stream.readable) {
@@ -1331,14 +1389,9 @@ var streamToArray = (stream) => {
   return deferred;
 };
 
-// packages/common/async/src/test-stream.ts
+// src/test-stream.ts
 import { Duplex } from "node:stream";
 var TestStream = class extends Duplex {
-  constructor() {
-    super(...arguments);
-    this._received = Buffer.alloc(0);
-    this._onWrite = new Event();
-  }
   static async assertConnectivity(stream1, stream2, { timeout: timeout2 = 200 } = {}) {
     stream1.push("ping");
     stream2.push("pong");
@@ -1351,6 +1404,8 @@ var TestStream = class extends Duplex {
       })
     ]);
   }
+  _received = Buffer.alloc(0);
+  _onWrite = new Event();
   _write(chunk, encoding, callback) {
     this._received = Buffer.concat([
       this._received,
@@ -1367,7 +1422,7 @@ var TestStream = class extends Duplex {
   }
 };
 
-// packages/common/async/src/testing.ts
+// src/testing.ts
 var waitForCondition = ({ condition, timeout: timeout2 = 0, interval: interval2 = 10, error, breakOnError = false }) => {
   const stopTime = timeout2 ? Date.now() + timeout2 : 0;
   const trigger2 = new Trigger();
@@ -1392,13 +1447,48 @@ var waitForCondition = ({ condition, timeout: timeout2 = 0, interval: interval2
     timeout: timeout2
   });
 };
+var until = (cb, timeout2) => {
+  return new Promise((resolve, reject) => {
+    const t = timeout2 && setTimeout(() => {
+      reject(new Error(`Timeout after ${t}ms`));
+    }, timeout2);
+    setTimeout(async () => {
+      try {
+        await cb((value) => {
+          t && clearTimeout(t);
+          resolve(value);
+        }, (error) => {
+          t && clearTimeout(t);
+          reject(error);
+        });
+      } catch (err) {
+        reject(err);
+      }
+    });
+  });
+};
+var untilPromise = (cb) => cb();
+var untilError = (cb) => {
+  return new Promise((resolve, reject) => {
+    setTimeout(async () => {
+      try {
+        await cb();
+        reject(new Error("No error was thrown."));
+      } catch (err) {
+        resolve(err);
+      }
+    });
+  });
+};
 
-// packages/common/async/src/timer.ts
+// src/timer.ts
 var Timer = class {
+  _callback;
+  _state = new Event();
+  _timer;
+  _count = 0;
   constructor(_callback) {
     this._callback = _callback;
-    this._state = new Event();
-    this._count = 0;
   }
   get state() {
     return this._state;
@@ -1441,51 +1531,23 @@ var Timer = class {
   }
 };
 
-// packages/common/async/src/until.ts
-var until = (cb, timeout2) => {
-  return new Promise((resolve, reject) => {
-    const t = timeout2 && setTimeout(() => {
-      reject(new Error(`Timeout after ${t}ms`));
-    }, timeout2);
-    setTimeout(async () => {
-      try {
-        await cb((value) => {
-          t && clearTimeout(t);
-          resolve(value);
-        }, (error) => {
-          t && clearTimeout(t);
-          reject(error);
-        });
-      } catch (err) {
-        reject(err);
-      }
-    });
-  });
-};
-var untilPromise = (cb) => cb();
-var untilError = (cb) => {
-  return new Promise((resolve, reject) => {
-    setTimeout(async () => {
-      try {
-        await cb();
-        reject(new Error("No error was thrown."));
-      } catch (err) {
-        resolve(err);
-      }
-    });
-  });
-};
-
-// packages/common/async/src/update-scheduler.ts
+// src/update-scheduler.ts
 var TIME_PERIOD = 1e3;
 var UpdateScheduler = class {
+  _ctx;
+  _callback;
+  _params;
+  /**
+  * Promise that resolves when the callback is done.
+  * Never rejects.
+  */
+  _promise = null;
+  _scheduled = false;
+  _lastUpdateTime = -TIME_PERIOD;
   constructor(_ctx, _callback, _params = {}) {
     this._ctx = _ctx;
     this._callback = _callback;
     this._params = _params;
-    this._promise = null;
-    this._scheduled = false;
-    this._lastUpdateTime = -TIME_PERIOD;
     _ctx.onDispose(async () => {
       await this._promise;
     });
@@ -1498,13 +1560,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();
@@ -1548,6 +1610,7 @@ var UpdateScheduler = class {
   }
 };
 export {
+  AsyncTask,
   CancellableObservableProvider,
   DeferredTask,
   Event,
@@ -1568,29 +1631,31 @@ export {
   UpdateScheduler,
   addEventListener,
   addListener,
-  asyncChain,
   asyncReturn,
   asyncTimeout,
+  chain,
   combine,
-  createPromiseFromCallback,
   debounce,
+  debounceAndThrottle,
+  delay,
   dumpLeaks,
   interval,
   latch,
   makePushIterable,
   observableError,
   onEvent,
+  promiseFromCallback,
   runInContext,
   runInContextAsync,
   scheduleExponentialBackoffTaskInterval,
   scheduleMicroTask,
   scheduleTask,
   scheduleTaskInterval,
-  sink,
   sleep,
   sleepWithContext,
   streamToArray,
   synchronized,
+  throttle,
   timeout,
   toError,
   trackLeaks,