uneventful 0.0.4 → 0.0.6

package/dist/mod.mjs

@@ -1,513 +1,6 @@
-let defer = typeof queueMicrotask === "function" ? queueMicrotask : ((p) => (cb) => p.then(cb))(Promise.resolve());
-
-function resolve(request, val) {
-  request("next", val);
-}
-function reject(request, reason) {
-  request("throw", void 0, reason);
-}
-function resolver(request) {
-  return request.bind(null, "next");
-}
-function rejecter(request) {
-  return request.bind(null, "throw", void 0);
-}
-function noop() {
-}
-function mkResult(op, val, err) {
-  return { op, val, err };
-}
-const CancelResult = Object.freeze(mkResult("cancel"));
-function ValueResult(val) {
-  return mkResult("next", val);
-}
-function ErrorResult(err) {
-  return mkResult("throw", void 0, err);
-}
-function isCancel(res) {
-  return res === CancelResult;
-}
-function isValue(res) {
-  return res ? res.op === "next" : false;
-}
-function isError(res) {
-  return res ? res.op === "throw" : false;
-}
-function isUnhandled(res) {
-  return isError(res) && res.val === void 0;
-}
-function isHandled(res) {
-  return isError(res) && res.val === null;
-}
-function markHandled(res) {
-  res.val = null;
-  return res.err;
-}
-function getResult(res) {
-  if (isValue(res))
-    return res.val;
-  res.op;
-  fulfillPromise(noop, (e) => {
-    throw e;
-  }, res);
-}
-function fulfillPromise(resolve2, reject2, res) {
-  if (isError(res))
-    reject2(markHandled(res));
-  else if (isCancel(res))
-    reject2(new CancelError("Job canceled"));
-  else
-    resolve2(res.val);
-}
-function propagateResult(job, res) {
-  if (!job.result())
-    fulfillPromise(job.return.bind(job), job.throw.bind(job), res);
-}
-class CancelError extends Error {
-}
-
-var current = makeCtx();
-function swapCtx(future) {
-  const now = current;
-  current = future;
-  return now;
-}
-var freelist = [];
-function makeCtx(job, cell) {
-  if (freelist && freelist.length) {
-    const s = freelist.pop();
-    s.job = job;
-    s.cell = cell;
-    return s;
-  }
-  return { job, cell };
-}
-function freeCtx(s) {
-  s.job = s.cell = null;
-  freelist.push(s);
-}
-
-const catchers = /* @__PURE__ */ new WeakMap(), defaultCatch = (e) => {
-  Promise.reject(e);
-};
-const nullCtx = makeCtx();
-const owners = /* @__PURE__ */ new WeakMap();
-
-function chain() {
-  return link(0, void 0, void 0);
-}
-function recycle(c) {
-  while (c.v)
-    unlink(c, c.n);
-  c.u = void 0;
-  unlink(c, c);
-}
-function unshift(c, v) {
-  ++c.v;
-  link(v, c.n, c);
-}
-function push(c, v) {
-  ++c.v;
-  link(v, c, c.p);
-}
-function pushCB(c, v) {
-  ++c.v;
-  return unlinker(c, link(v, c, c.p));
-}
-function isEmpty(c) {
-  return !c || c.v === 0;
-}
-function qlen(c) {
-  return c ? c.v : 0;
-}
-function pop(c) {
-  if (qlen(c))
-    return unlink(c, c.p);
-}
-class Node {
-  constructor() {
-    /** The next node (or the start node if this is a chain head) */
-    this.n = this;
-    /** The previous node (or the end node if this is a chain head) */
-    this.p = this;
-    /** The value held by the node (or the chain length if this is a chain head) */
-    this.v = 0;
-    /** The most recently created undo callback for this node */
-    this.u = void 0;
-  }
-}
-var free;
-function link(v, n, p) {
-  let node = free;
-  if (node) {
-    free = node.n;
-    node.n = n || node;
-    node.p = p || node;
-  } else {
-    node = new Node();
-    if (n)
-      node.n = n;
-    if (p)
-      node.p = p;
-  }
-  node.v = v;
-  node.n.p = node;
-  node.p.n = node;
-  return node;
-}
-function unlink(c, node) {
-  --c.v;
-  var v = node.v, u = node.u;
-  node.n && (node.n.p = node.p);
-  node.p && (node.p.n = node.n);
-  node.u = node.v = node.p = void 0;
-  node.n = free;
-  free = node;
-  if (u)
-    u();
-  return v;
-}
-function unlinker(chain2, node) {
-  let u = node.u ||= () => {
-    if (u) {
-      if (u === node.u)
-        unlink(chain2, node);
-      u = chain2 = node = void 0;
-    }
-  };
-  return u;
-}
-
-function isFunction(f) {
-  return typeof f === "function";
-}
-function getJob() {
-  const { job } = current;
-  if (job)
-    return job;
-  throw new Error("No job is currently active");
-}
-function recalcJob(job) {
-  return (cb) => {
-    current.job.must(job.release(cb));
-  };
-}
-function runChain(res, cbs) {
-  while (qlen(cbs))
-    try {
-      pop(cbs)(res);
-    } catch (e) {
-      detached.asyncThrow(e);
-    }
-  cbs && recycle(cbs);
-  return void 0;
-}
-var inProcess = /* @__PURE__ */ new Set();
-class _Job {
-  constructor() {
-    this.end = () => {
-      const res = this._done ||= CancelResult, cbs = this._cbs;
-      if (!cbs && !isUnhandled(res))
-        return;
-      const ct = inProcess.size, old = swapCtx(nullCtx);
-      if (!ct)
-        inProcess.add(null);
-      if (cbs && cbs.u)
-        cbs.u = runChain(res, cbs.u);
-      inProcess.add(this);
-      if (ct) {
-        swapCtx(old);
-        return;
-      }
-      inProcess.delete(null);
-      for (const item of inProcess) {
-        if (item._cbs)
-          item._cbs = runChain(item._done, item._cbs);
-        inProcess.delete(item);
-        if (isUnhandled(item._done))
-          item.throw(markHandled(item._done));
-      }
-      swapCtx(old);
-    };
-    this._done = void 0;
-    // Chain whose .u stores a second chain for `release()` callbacks
-    this._cbs = void 0;
-  }
-  /** @internal */
-  static create(parent, stop) {
-    const job = new _Job();
-    if (parent || stop) {
-      job.must((parent ||= getJob()).release(stop || job.end));
-      owners.set(job, parent);
-    }
-    return job;
-  }
-  do(cleanup) {
-    unshift(this._chain(), cleanup);
-    return this;
-  }
-  onError(cb) {
-    return this.do((r) => {
-      if (isError(r))
-        cb(markHandled(r));
-    });
-  }
-  onValue(cb) {
-    return this.do((r) => {
-      if (isValue(r))
-        cb(r.val);
-    });
-  }
-  onCancel(cb) {
-    return this.do((r) => {
-      if (isCancel(r))
-        cb();
-    });
-  }
-  result() {
-    return this._done || current.cell?.recalcWhen(this, recalcJob) || void 0;
-  }
-  get [Symbol.toStringTag]() {
-    return "Job";
-  }
-  restart() {
-    if (!this._done && inProcess.size) {
-      const old = inProcess;
-      inProcess = /* @__PURE__ */ new Set();
-      this.end();
-      inProcess = old;
-    } else {
-      this._end(CancelResult);
-    }
-    this._done = void 0;
-    promises.delete(this);
-    return this;
-  }
-  _end(res) {
-    if (this._done)
-      throw new Error("Job already ended");
-    if (this !== detached)
-      this._done = res;
-    this.end();
-    return this;
-  }
-  throw(err) {
-    if (this._done) {
-      (owners.get(this) || detached).asyncThrow(err);
-      return this;
-    }
-    return this._end(ErrorResult(err));
-  }
-  return(val) {
-    return this._end(ValueResult(val));
-  }
-  then(onfulfilled, onrejected) {
-    return nativePromise(this).then(onfulfilled, onrejected);
-  }
-  catch(onrejected) {
-    return nativePromise(this).catch(onrejected);
-  }
-  finally(onfinally) {
-    return nativePromise(this).finally(onfinally);
-  }
-  *[Symbol.iterator]() {
-    if (this._done) {
-      return getResult(this._done);
-    } else
-      return yield (req) => {
-        this.do((res) => fulfillPromise(resolver(req), rejecter(req), res));
-      };
-  }
-  start(fnOrCtx, fn) {
-    if (!fnOrCtx)
-      return makeJob(this);
-    let init, result;
-    if (isFunction(fn)) {
-      init = fn.bind(fnOrCtx);
-    } else if (isFunction(fnOrCtx)) {
-      init = fnOrCtx;
-    } else if (fnOrCtx instanceof _Job) {
-      return fnOrCtx;
-    } else {
-      result = fnOrCtx;
-    }
-    const job = makeJob(this);
-    try {
-      if (init)
-        result = job.run(init, job);
-      if (result != null) {
-        if (result instanceof _Job) {
-          if (result !== job)
-            result.do((res) => propagateResult(job, res));
-        } else if (isFunction(result.then)) {
-          result.then(
-            (v) => {
-              job.result() || job.return(v);
-            },
-            (e) => {
-              job.result() || job.throw(e);
-            }
-          );
-          return job;
-        } else if (isFunction(result[Symbol.iterator]) && typeof result !== "string") {
-          job.run(runGen, result, job);
-        } else if (isFunction(result)) {
-          job.must(result);
-        } else {
-          throw new TypeError("Invalid value/return for start()");
-        }
-      }
-      return job;
-    } catch (e) {
-      job.end();
-      throw e;
-    }
-  }
-  connect(src, sink, inlet) {
-    return this.start((job) => void src(sink, job, inlet));
-  }
-  run(fn, ...args) {
-    const old = swapCtx(makeCtx(this));
-    try {
-      return fn.apply(null, args);
-    } finally {
-      freeCtx(swapCtx(old));
-    }
-  }
-  bind(fn) {
-    const job = this;
-    return function() {
-      const old = swapCtx(makeCtx(job));
-      try {
-        return fn.apply(this, arguments);
-      } finally {
-        freeCtx(swapCtx(old));
-      }
-    };
-  }
-  must(cleanup) {
-    if (isFunction(cleanup))
-      push(this._chain(), cleanup);
-    return this;
-  }
-  release(cleanup) {
-    if (this === detached)
-      return noop;
-    let cbs = this._chain();
-    if (!this._done || cbs.u)
-      cbs = cbs.u ||= chain();
-    return pushCB(cbs, cleanup);
-  }
-  asyncThrow(err) {
-    try {
-      (catchers.get(this) || this.throw).call(this, err);
-    } catch (e) {
-      if (this === detached)
-        catchers.set(this, defaultCatch);
-      else
-        catchers.delete(this);
-      const catcher = catchers.get(this) || this.throw;
-      catcher.call(this, err);
-      catcher.call(this, e);
-    }
-    return this;
-  }
-  asyncCatch(handler) {
-    if (isFunction(handler))
-      catchers.set(this, handler);
-    else if (handler === null)
-      catchers.delete(this);
-    return this;
-  }
-  _chain() {
-    if (this === detached)
-      this.end();
-    if (this._done && isEmpty(this._cbs))
-      defer(this.end);
-    return this._cbs ||= chain();
-  }
-}
-const promises = /* @__PURE__ */ new WeakMap();
-function nativePromise(job = getJob()) {
-  if (!promises.has(job)) {
-    promises.set(job, new Promise((res, rej) => {
-      const toPromise = fulfillPromise.bind(null, res, rej);
-      if (job.result())
-        toPromise(job.result());
-      else
-        job.do(toPromise);
-    }));
-  }
-  return promises.get(job);
-}
-const makeJob = _Job.create;
-const detached = makeJob();
-detached.end = () => {
-  throw new Error("Can't do that with the detached job");
-};
-detached.asyncCatch(defaultCatch);
-function runGen(g, job) {
-  let it = g[Symbol.iterator](), running = true, ctx = makeCtx(job), ct = 0;
-  let done = ctx.job.release(() => {
-    job = void 0;
-    ++ct;
-    step("return", void 0);
-  });
-  defer(() => {
-    running = false;
-    step("next", void 0);
-  });
-  function step(method, arg) {
-    if (!it)
-      return;
-    if (running) {
-      return defer(step.bind(null, method, arg));
-    }
-    const old = swapCtx(ctx);
-    try {
-      running = true;
-      try {
-        for (; ; ) {
-          ++ct;
-          const { done: done2, value } = it[method](arg);
-          if (done2) {
-            job && job.return(value);
-            job = void 0;
-            break;
-          } else if (!isFunction(value)) {
-            method = "throw";
-            arg = new TypeError("Jobs must yield functions (or yield* Yielding<T>s)");
-            continue;
-          } else {
-            let called = false, returned = false, count = ct;
-            value((op, val, err) => {
-              if (called)
-                return;
-              else
-                called = true;
-              method = op;
-              arg = op === "next" ? val : err;
-              if (returned && count === ct)
-                step(op, arg);
-            });
-            returned = true;
-            if (!called)
-              return;
-          }
-        }
-      } catch (e) {
-        it = job = void 0;
-        ctx.job.throw(e);
-      }
-      it = void 0;
-      done?.();
-      done = void 0;
-    } finally {
-      swapCtx(old);
-      running = false;
-    }
-  }
-}
+import { r as resolver, a as rejecter, b as resolve, I as IsStream, c as backpressure, m as must, s as start, g as getJob, n as noop, d as defer, t as throttle, e as detached, i as isCancel, f as isUnhandled, h as markHandled, j as isError, k as connect, l as fulfillPromise, o as callOrWait, p as restarting, q as current, u as mustBeSourceOrSignal, v as isValue } from './call-or-wait-DHkBd_bM.mjs';
+export { A as CancelError, C as CancelResult, E as ErrorResult, V as ValueResult, L as abortSignal, G as compose, y as getResult, H as into, x as isHandled, J as isJobActive, D as makeJob, B as nativePromise, F as pipe, z as propagateResult, w as reject, M as task, K as timeout } from './call-or-wait-DHkBd_bM.mjs';
+import { isFunction } from './utils.mjs';
 
 function* to(p) {
   return yield (res) => Promise.resolve(p).then(resolver(res), rejecter(res));
@@ -527,809 +20,6 @@ function* sleep(ms) {
   }
 }
 
-class RunQueue {
-  constructor(sched, reap) {
-    this.sched = sched;
-    this.reap = reap;
-    this._flags = 0 /* Unset */;
-    this.q = /* @__PURE__ */ new Set();
-    this._run = () => {
-      this._flags &= ~2 /* Scheduled */;
-      this.flush();
-    };
-    /** Run all pending items */
-    this.flush = () => {
-      if (this._flags & 1 /* Running */)
-        return;
-      const { q: queue } = this;
-      if (!queue.size)
-        return;
-      this._flags |= 1 /* Running */;
-      try {
-        this.reap(queue);
-      } finally {
-        this._flags &= ~1 /* Running */;
-        !queue.size || this._flags & 2 /* Scheduled */ || this._sched();
-      }
-    };
-  }
-  /** Is this queue currently running? */
-  isRunning() {
-    return !!(this._flags & 1 /* Running */);
-  }
-  /** Is this queue currently empty? */
-  isEmpty() {
-    return !this.q.size;
-  }
-  add(subject) {
-    this.q.size || this._flags & (1 /* Running */ | 2 /* Scheduled */) || this._sched();
-    this.q.add(subject);
-  }
-  delete(subject) {
-    this.q.delete(subject);
-  }
-  _sched() {
-    this._flags |= 2 /* Scheduled */;
-    this.sched(this._run);
-  }
-}
-var currentRule;
-var currentQueue;
-const ruleQueues = /* @__PURE__ */ new WeakMap();
-class RuleQueue extends RunQueue {
-  constructor(sched) {
-    super(sched, function(q) {
-      if (currentQueue)
-        return;
-      currentQueue = this;
-      try {
-        for (currentRule of q) {
-          currentRule.catchUp();
-          q.delete(currentRule);
-        }
-      } finally {
-        currentQueue = currentRule = void 0;
-      }
-    });
-  }
-}
-function ruleQueue(scheduleFn = defer) {
-  ruleQueues.has(scheduleFn) || ruleQueues.set(scheduleFn, new RuleQueue(scheduleFn));
-  return ruleQueues.get(scheduleFn);
-}
-const defaultQ = /* @__PURE__ */ ruleQueue(defer);
-const pulls = new RunQueue(defer, (pulls2) => {
-  for (const conn of pulls2) {
-    pulls2.delete(conn);
-    conn.doPull();
-  }
-});
-pulls.flush;
-
-function backpressure(inlet = defaultInlet) {
-  const job = getJob();
-  return (cb) => {
-    if (!job.result() && inlet.isOpen()) {
-      if (cb)
-        inlet.onReady(cb, job);
-      return inlet.isReady();
-    }
-    return false;
-  };
-}
-const IsStream = "uneventful/is-stream";
-function connect(src, sink, inlet) {
-  return getJob().connect(src, sink, inlet);
-}
-function throttle(job = current.job) {
-  return new _Throttle(job);
-}
-class _Throttle {
-  /** @internal */
-  constructor(_job) {
-    this._job = _job;
-    /** @internal */
-    this._callbacks = void 0;
-    this._isReady = true;
-    this._isPulling = false;
-  }
-  isOpen() {
-    return !this._job?.result();
-  }
-  /** Is the conduit currently ready to receive data? */
-  isReady() {
-    return this.isOpen() && this._isReady;
-  }
-  onReady(cb, job) {
-    if (!this.isOpen())
-      return this;
-    const _callbacks = this._callbacks ||= /* @__PURE__ */ new Map();
-    const unlink = job.release(() => _callbacks.delete(cb));
-    if (this.isReady() && this && !_callbacks.size) {
-      pulls.add(this);
-    }
-    _callbacks.set(cb, unlink);
-    return this;
-  }
-  pause() {
-    this._isReady = false;
-    return this;
-  }
-  doPull() {
-    if (this._isPulling)
-      return;
-    const { _callbacks } = this;
-    if (!_callbacks?.size)
-      return;
-    this._isPulling = true;
-    try {
-      for (let [cb, unlink] of _callbacks) {
-        if (!this.isReady())
-          break;
-        unlink();
-        _callbacks.delete(cb);
-        cb();
-      }
-    } finally {
-      this._isPulling = false;
-    }
-  }
-  resume() {
-    if (this.isOpen()) {
-      this._isReady = true;
-      this.doPull();
-    }
-  }
-}
-const defaultInlet = throttle();
-function pipe() {
-  var v = arguments[0];
-  for (var i = 1; i < arguments.length; i++)
-    v = arguments[i](v);
-  return v;
-}
-function compose(...fns) {
-  return (val) => pipe(val, ...fns);
-}
-function into(...args) {
-  return (src) => src(...args);
-}
-
-function setMap(map, key, val) {
-  map.set(key, val);
-  return val;
-}
-function CallableObject(fn) {
-  return Object.setPrototypeOf(fn, new.target.prototype);
-}
-CallableObject.prototype = Function.prototype;
-
-class WriteConflict extends Error {
-}
-class CircularDependency extends Error {
-}
-var timestamp = 1;
-const fntrackers = /* @__PURE__ */ new WeakMap();
-const obtrackers = /* @__PURE__ */ new WeakMap();
-const dirtyStack = [];
-function markDependentsDirty(cell) {
-  const latestSource = cell.latestSource = timestamp;
-  for (; cell; cell = dirtyStack.pop()) {
-    for (let sub = cell.subscribers; sub; sub = sub.nT) {
-      const tgt = sub.tgt;
-      if (tgt.latestSource >= latestSource)
-        continue;
-      tgt.latestSource = latestSource;
-      if (tgt.flags & 1 /* Rule */)
-        tgt.value.q.add(tgt);
-      if (tgt.subscribers)
-        dirtyStack.push(tgt);
-    }
-  }
-}
-function returnValue() {
-  return this.value;
-}
-function throwValue() {
-  throw this.value;
-}
-const notCaughtUp = [];
-var freesubs;
-function mksub(source, target) {
-  let sub = freesubs;
-  if (sub) {
-    freesubs = sub.old;
-    sub.src = source;
-    sub.nS = void 0;
-    sub.pS = target.sources;
-    sub.tgt = target;
-    sub.nT = sub.pT = void 0;
-    sub.ts = source.lastChanged;
-    sub.old = source.adding;
-  } else
-    sub = {
-      src: source,
-      nS: void 0,
-      pS: target.sources,
-      tgt: target,
-      nT: void 0,
-      pT: void 0,
-      ts: source.lastChanged,
-      old: source.adding
-    };
-  if (target.sources)
-    target.sources.nS = sub;
-  target.sources = sub;
-  source.adding = sub;
-  if (target.subscribers || target.flags & 1 /* Rule */)
-    source.subscribe(sub);
-}
-function delsub(sub) {
-  sub.src.unsubscribe(sub);
-  if (sub.nS)
-    sub.nS.pS = sub.pS;
-  if (sub.pS)
-    sub.pS.nS = sub.nS;
-  sub.src = sub.tgt = sub.nS = sub.pS = sub.nT = sub.pT = void 0;
-  sub.old = freesubs;
-  freesubs = sub;
-}
-const sentinel = {};
-class Cell {
-  constructor() {
-    this.value = void 0;
-    // the value, or, for a rule, the `{q, rm}` struct
-    this.validThrough = 0;
-    // timestamp of most recent validation or recalculation
-    this.lastChanged = 0;
-    // timestamp of last value change
-    this.latestSource = timestamp;
-    // max lastChanged of this cell or any ancestor source
-    this.flags = 0;
-    this.ctx = void 0;
-    /** The subscription being added during the current calculation - used for uniqueness */
-    this.adding = void 0;
-    /** Linked list of sources */
-    this.sources = void 0;
-    /** Linked list of targets */
-    this.subscribers = void 0;
-    /**
-     * The computation to be performed (if {@link Is.Calc} or {@link Is.Rule})
-     * or the setup/teardown for {@link Is.Stream}.
-     */
-    this.compute = returnValue;
-  }
-  stream(sink, _conn, inlet) {
-    let lastValue = sentinel;
-    Cell.mkRule(() => {
-      const val = this.getValue();
-      if (val !== lastValue) {
-        const old = swapCtx(nullCtx);
-        try {
-          sink(lastValue = val);
-        } finally {
-          swapCtx(old);
-        }
-      }
-    }, inlet ? ruleQueue(backpressure(inlet)) : defaultQ);
-    return IsStream;
-  }
-  getValue() {
-    if (arguments.length)
-      return this.stream.apply(this, arguments);
-    this.catchUp();
-    const dep = current.cell;
-    if (dep && this.flags & 133 /* Variable */) {
-      if (this.flags & 32 /* Running */)
-        throw new CircularDependency("Cached function dependency cycle");
-      let s = this.adding;
-      if (!s || s.tgt !== dep) {
-        mksub(this, dep);
-      } else {
-        if (s.ts === -1) {
-          s.ts = this.lastChanged;
-          if (s.nS) {
-            s.nS.pS = s.pS;
-            if (s.pS)
-              s.pS.nS = s.nS;
-            s.nS = void 0;
-            s.pS = dep.sources;
-            dep.sources.nS = s;
-            dep.sources = s;
-          }
-        }
-      }
-    }
-    if (this.flags & 16 /* Error */)
-      throw this.value;
-    return this.value;
-  }
-  shouldWrite(changed) {
-    const cell = current.cell || currentRule;
-    if (cell) {
-      if (cell.flags & 4 /* Calc */)
-        throw new WriteConflict("Side-effects not allowed in cached functions");
-      if (this.adding && this.adding.tgt === cell)
-        throw new CircularDependency("Can't update direct dependency");
-      if (this.validThrough === timestamp || this.hasBeenRead())
-        throw new WriteConflict("Value already used");
-    } else if (changed) {
-      if (this.validThrough === timestamp || notCaughtUp.length) {
-        ++timestamp;
-        notCaughtUp.length = 0;
-      }
-    } else {
-      return false;
-    }
-    this.lastChanged === timestamp || markDependentsDirty(this);
-    if (this.sources)
-      this.sources.ts = 0;
-    return true;
-  }
-  setValue(val, isErr) {
-    if (this.shouldWrite(val !== this.value || isErr !== !!(this.flags & 16 /* Error */))) {
-      this.value = val;
-      this.lastChanged = timestamp;
-      this.flags = isErr ? this.flags | 16 /* Error */ : this.flags & ~16 /* Error */;
-    }
-    this.compute = isErr ? throwValue : returnValue;
-  }
-  setCalc(compute) {
-    if (this.shouldWrite(compute !== this.compute)) {
-      this.flags |= 4 /* Calc */;
-      this.compute = compute;
-      this.ctx ||= makeCtx(null, this);
-    }
-  }
-  hasBeenRead() {
-    if (notCaughtUp.length) {
-      for (const cell of notCaughtUp)
-        cell.catchUp();
-      notCaughtUp.length = 0;
-    }
-    return this.validThrough === timestamp;
-  }
-  catchUp() {
-    const { validThrough } = this;
-    if (validThrough === timestamp)
-      return;
-    this.validThrough = timestamp;
-    if (!(this.flags & 5 /* Computed */))
-      return;
-    if (this.sources) {
-      for (let sub = this.sources; sub; sub = sub.nS) {
-        const s = sub.src;
-        if (sub.ts !== s.lastChanged)
-          return this.doRecalc();
-        if (s.subscribers && s.latestSource <= validThrough)
-          continue;
-        s.catchUp();
-        if (s.lastChanged > validThrough) {
-          return this.doRecalc();
-        }
-      }
-      for (let sub = this.sources; sub; sub = sub.nS) {
-        if (sub.src.validThrough !== timestamp)
-          notCaughtUp.push(sub.src);
-      }
-    } else
-      return this.doRecalc();
-  }
-  doRecalc() {
-    const oldCtx = swapCtx(this.ctx);
-    for (let sub = this.sources; sub; sub = sub.nS) {
-      sub.ts = -1;
-      sub.old = sub.src.adding;
-      sub.src.adding = sub;
-      this.sources = sub;
-    }
-    this.flags |= 32 /* Running */;
-    try {
-      if (this.flags & 4 /* Calc */) {
-        try {
-          const future = this.compute();
-          if (future !== this.value || !this.lastChanged || this.flags & 16 /* Error */) {
-            this.value = future;
-            this.lastChanged = timestamp;
-          }
-          this.flags &= ~16 /* Error */;
-        } catch (e) {
-          this.flags |= 16 /* Error */;
-          this.value = e;
-          this.lastChanged = timestamp;
-        }
-      } else {
-        const { job } = this.ctx;
-        job.restart();
-        try {
-          job.must(this.compute());
-          this.lastChanged = timestamp;
-        } catch (e) {
-          this.disposeRule();
-          throw e;
-        }
-      }
-    } finally {
-      this.flags &= ~32 /* Running */;
-      swapCtx(oldCtx);
-      let head;
-      for (let sub = this.sources; sub; ) {
-        const pS = sub.pS;
-        sub.src.adding = sub.old;
-        sub.old = void 0;
-        if (sub.ts === -1)
-          delsub(sub);
-        else
-          head = sub;
-        sub = pS;
-      }
-      this.sources = head;
-      if (!head) {
-        this.flags &= ~4 /* Calc */;
-      }
-      if (this.flags & 8 /* Dead */)
-        this.disposeRule();
-    }
-  }
-  disposeRule() {
-    this.ctx.job.end();
-    this.flags |= 8 /* Dead */;
-    this.value.q.delete(this);
-    this.value.rm();
-    if (current !== this.ctx) {
-      for (let s = this.sources; s; ) {
-        let nS = s.nS;
-        delsub(s);
-        s = nS;
-      }
-      this.sources = void 0;
-    }
-  }
-  subscribe(sub) {
-    if (!this.subscribers) {
-      if (this.flags & 4 /* Calc */) {
-        for (let s = this.sources; s; s = s.nS)
-          s.src.subscribe(s);
-      }
-      if (this.flags & 64 /* Stream */)
-        this.compute(true);
-    }
-    if (this.subscribers !== sub && !sub.pT) {
-      sub.nT = this.subscribers;
-      if (this.subscribers)
-        this.subscribers.pT = sub;
-      this.subscribers = sub;
-    }
-  }
-  unsubscribe(sub) {
-    if (sub.nT)
-      sub.nT.pT = sub.pT;
-    if (sub.pT)
-      sub.pT.nT = sub.nT;
-    if (this.subscribers === sub)
-      this.subscribers = sub.nT;
-    if (!this.subscribers) {
-      if (this.flags & 4 /* Calc */) {
-        for (let s = this.sources; s; s = s.nS)
-          s.src.unsubscribe(s);
-      }
-      if (this.flags & 64 /* Stream */)
-        this.compute(false);
-    }
-  }
-  static mkValue(val) {
-    const cell = new Cell();
-    cell.flags = 128 /* Mutable */;
-    cell.value = val;
-    cell.lastChanged = timestamp;
-    return cell;
-  }
-  static mkStream(src, val) {
-    const cell = this.mkValue(val);
-    cell.flags |= 64 /* Stream */;
-    cell.ctx = makeCtx();
-    const write = (v) => {
-      cell.setValue(v, false);
-      cell.compute = compute;
-    };
-    let job;
-    const compute = cell.compute = (sub) => {
-      if (!sub) {
-        cell.value = val;
-        cell.flags &= ~16 /* Error */;
-        job?.end();
-        return;
-      }
-      if (job)
-        return;
-      job = cell.ctx.job = makeJob().do((r) => {
-        if (isError(r)) {
-          cell.setValue(markHandled(r), true);
-        } else if (isValue(r)) {
-          cell.setValue(val, false);
-        }
-        cell.compute = compute;
-        cell.ctx.job = job = void 0;
-      });
-      const old = swapCtx(cell.ctx);
-      try {
-        src(write, job);
-      } catch (e) {
-        job.end();
-        throw e;
-      } finally {
-        swapCtx(old);
-      }
-    };
-    return cell;
-  }
-  recalcWhen(fnOrKey, fn) {
-    let trackers = fn ? obtrackers.get(fn) || setMap(obtrackers, fn, /* @__PURE__ */ new WeakMap()) : fntrackers;
-    let signal = trackers.get(fnOrKey);
-    if (!signal) {
-      const src = fn ? fn(fnOrKey) : fnOrKey;
-      let ct = 0;
-      const c = Cell.mkStream((s) => (src(() => s(++ct)), IsStream), ct);
-      trackers.set(fnOrKey, signal = c.getValue.bind(c));
-    }
-    signal();
-  }
-  static mkCached(compute) {
-    const cell = new Cell();
-    cell.compute = compute;
-    cell.ctx = makeCtx(null, cell);
-    cell.flags = 4 /* Calc */;
-    return cell;
-  }
-  static mkRule(fn, q) {
-    var cell = new Cell(), job = makeJob();
-    const stop = cell.disposeRule.bind(cell);
-    cell.value = { q, rm: getJob().release(stop) };
-    cell.compute = fn.bind(null, stop);
-    cell.ctx = makeCtx(job, cell);
-    cell.flags = 1 /* Rule */;
-    q.add(cell);
-    return stop;
-  }
-}
-
-class RF extends CallableObject {
-  constructor(q) {
-    super((fn) => Cell.mkRule(fn, q));
-  }
-  stop() {
-    if (currentRule)
-      return currentRule.disposeRule();
-    throw new Error("No rule active");
-  }
-  if(condition, action) {
-    const cond = Cell.mkCached(() => !!condition());
-    return this(() => cond.getValue() ? action() : void 0);
-  }
-  get method() {
-    const self = this;
-    return (fn, _ctxOrName, desc) => {
-      if (desc)
-        return void (desc.value = this.method(desc.value));
-      return function(...args) {
-        return self(() => fn.apply(this, args));
-      };
-    };
-  }
-  factory(scheduleFn) {
-    return factories.get(scheduleFn) || setMap(factories, scheduleFn, new RF(ruleQueue(scheduleFn)));
-  }
-}
-const factories = /* @__PURE__ */ new WeakMap();
-const rule = RF.prototype.factory(defer);
-function runRules(scheduleFn) {
-  (scheduleFn ? ruleQueue(scheduleFn) : defaultQ).flush();
-}
-
-class SignalImpl extends CallableObject {
-  constructor(_c) {
-    super(_c.getValue.bind(_c));
-    this._c = _c;
-  }
-  get value() {
-    return this();
-  }
-  valueOf() {
-    return this();
-  }
-  toString() {
-    return "" + this();
-  }
-  toJSON() {
-    return this();
-  }
-  peek() {
-    return peek(this);
-  }
-  asReadonly() {
-    return this;
-  }
-  withSet(set) {
-    return Object.assign(new WritableImpl(this._c), { set });
-  }
-  *"uneventful.next"() {
-    return yield (r) => {
-      let seen = false, res;
-      rule((stop) => {
-        try {
-          res = this();
-        } catch (e) {
-          stop();
-          reject(r, e);
-        }
-        if (seen) {
-          stop();
-          resolve(r, res);
-        }
-        seen = true;
-      });
-    };
-  }
-  *"uneventful.until"() {
-    return yield (r) => {
-      let res;
-      try {
-        res = this();
-      } catch (e) {
-        reject(r, e);
-        return;
-      }
-      if (res)
-        return resolve(r, res);
-      rule((stop) => {
-        try {
-          res = this();
-        } catch (e) {
-          stop();
-          reject(r, e);
-        }
-        if (res) {
-          stop();
-          resolve(r, res);
-        }
-      });
-    };
-  }
-}
-class WritableImpl extends SignalImpl {
-  constructor() {
-    super(...arguments);
-    this.set = (val) => {
-      this._c.setValue(val, false);
-    };
-  }
-  get value() {
-    return this();
-  }
-  set value(val) {
-    this.set(val);
-  }
-  asReadonly() {
-    return new SignalImpl(this._c);
-  }
-}
-class ConfigurableImpl extends WritableImpl {
-  setf(expr) {
-    this._c.setCalc(expr);
-    return this;
-  }
-}
-function value(val) {
-  const cell = Cell.mkValue(val);
-  return new ConfigurableImpl(cell);
-}
-function cached(compute, initVal) {
-  if (compute instanceof SignalImpl)
-    return compute;
-  return new SignalImpl(
-    compute.length ? Cell.mkStream(compute, initVal) : Cell.mkCached(compute)
-  );
-}
-function peek(fn, ...args) {
-  if (!current.cell)
-    return fn(...args);
-  const old = swapCtx(makeCtx(current.job));
-  try {
-    return fn.apply(null, args);
-  } finally {
-    freeCtx(swapCtx(old));
-  }
-}
-function recalcWhen(fnOrKey, fn) {
-  current.cell?.recalcWhen(fnOrKey, fn);
-}
-function action(fn, _ctx, desc) {
-  if (desc)
-    return { ...desc, value: action(desc.value) };
-  return function() {
-    if (!current.cell)
-      return fn.apply(this, arguments);
-    const old = swapCtx(makeCtx(current.job));
-    try {
-      return fn.apply(this, arguments);
-    } finally {
-      freeCtx(swapCtx(old));
-    }
-  };
-}
-
-function must(cleanup) {
-  return getJob().must(cleanup);
-}
-function start(init, fn) {
-  return getJob().start(init, fn);
-}
-function isJobActive() {
-  return !!current.job;
-}
-const timers = /* @__PURE__ */ new WeakMap();
-function timeout(ms = 0, job = getJob()) {
-  let timer = timers.get(job);
-  if (timer) {
-    clearTimeout(timer);
-  } else if (timer === void 0 && !job.result()) {
-    job.must(timeout.bind(null, 0, job));
-  }
-  if (job.result()) {
-    timers.delete(job);
-  } else if (ms) {
-    timers.set(job, setTimeout(() => {
-      timers.set(job, null);
-      job.end();
-    }, ms));
-  } else {
-    timers.set(job, null);
-  }
-  return job;
-}
-const abortSignals = /* @__PURE__ */ new WeakMap();
-function abortSignal(job = getJob()) {
-  let signal = abortSignals.get(job);
-  if (!signal) {
-    const ctrl = new AbortController();
-    signal = ctrl.signal;
-    job.do(() => {
-      abortSignals.set(job, null);
-      ctrl.abort();
-    });
-    abortSignals.set(job, signal);
-    if (job.result())
-      ctrl.abort();
-  }
-  return signal;
-}
-function restarting(task2) {
-  const outer = getJob(), inner = makeJob(outer), { end } = inner;
-  task2 ||= (f) => {
-    inner.must(f());
-  };
-  inner.asyncCatch((e) => outer.asyncThrow(e));
-  return function() {
-    inner.restart().must(outer.release(end));
-    const old = swapCtx(makeCtx(inner));
-    try {
-      return task2.apply(this, arguments);
-    } catch (e) {
-      inner.restart();
-      throw e;
-    } finally {
-      freeCtx(swapCtx(old));
-    }
-  };
-}
-function task(fn, _ctx, desc) {
-  if (desc)
-    return { ...desc, value: task(desc.value) };
-  return function(...args) {
-    return start(() => fn.apply(this, args));
-  };
-}
-
 function emitter() {
   const emit = mockSource();
   emit.source = share(emit.source);
@@ -1523,7 +213,7 @@ function share(source) {
 function* each(src) {
   let yielded = false, waiter;
   const result = { value: { item: void 0, next: next2 }, done: false };
-  const t = throttle(), conn = getJob().connect(src, (v) => {
+  const t = throttle(), conn = connect(src, (v) => {
     t.pause();
     if (!waiter || conn.result())
       return;
@@ -1568,38 +258,12 @@ function* each(src) {
     }
   }
 }
-function until(source) {
-  return callOrWait(source, "uneventful.until", waitTruthy, recache);
-}
-function recache(s) {
-  return until(cached(s));
-}
-function waitTruthy(job, v) {
-  v && job.return(v);
-}
 function next(source) {
   return callOrWait(source, "uneventful.next", waitAny, mustBeSourceOrSignal);
 }
 function waitAny(job, v) {
   job.return(v);
 }
-function callOrWait(source, method, handler, noArgs) {
-  if (source && isFunction(source[method]))
-    return source[method]();
-  if (isFunction(source))
-    return (source.length === 0 ? noArgs(source) : false) || start((job) => {
-      connect(source, (v) => handler(job, v)).do((r) => {
-        if (isValue(r))
-          job.throw(new Error("Stream ended"));
-        else if (isError(r))
-          job.throw(markHandled(r));
-      });
-    });
-  mustBeSourceOrSignal();
-}
-function mustBeSourceOrSignal() {
-  throw new TypeError("not a source or signal");
-}
 function forEach(src, sink, inlet) {
   if (isFunction(sink))
     return start((j) => {
@@ -1609,6 +273,9 @@ function forEach(src, sink, inlet) {
   sink = src;
   return (src2) => forEach(src2, sink, inlet);
 }
+function recalcWhen(fnOrKey, fn) {
+  current.cell?.recalcWhen(fnOrKey, fn);
+}
 
 function concat(sources) {
   return concatAll(fromIterable(sources));
@@ -1768,5 +435,5 @@ function takeWhile(condition) {
   };
 }
 
-export { CancelError, CancelResult, CircularDependency, ConfigurableImpl, ErrorResult, IsStream, SignalImpl, ValueResult, WritableImpl, WriteConflict, abortSignal, action, backpressure, cached, compose, concat, concatAll, concatMap, connect, defer, detached, each, emitter, empty, filter, forEach, fromAsyncIterable, fromDomEvent, fromIterable, fromPromise, fromSubscribe, fromValue, fulfillPromise, getJob, getResult, interval, into, isCancel, isError, isFunction, isHandled, isJobActive, isUnhandled, isValue, lazy, makeJob, map, markHandled, merge, mergeAll, mergeMap, mockSource, must, nativePromise, never, next, noop, peek, pipe, propagateResult, recalcWhen, reject, rejecter, resolve, resolver, restarting, rule, runRules, share, skip, skipUntil, skipWhile, slack, sleep, start, switchAll, switchMap, take, takeUntil, takeWhile, task, throttle, timeout, to, until, value };
+export { IsStream, backpressure, concat, concatAll, concatMap, connect, defer, detached, each, emitter, empty, filter, forEach, fromAsyncIterable, fromDomEvent, fromIterable, fromPromise, fromSubscribe, fromValue, fulfillPromise, getJob, interval, isCancel, isError, isUnhandled, isValue, lazy, map, markHandled, merge, mergeAll, mergeMap, mockSource, must, never, next, noop, recalcWhen, rejecter, resolve, resolver, restarting, share, skip, skipUntil, skipWhile, slack, sleep, start, switchAll, switchMap, take, takeUntil, takeWhile, throttle, to };
 //# sourceMappingURL=mod.mjs.map