@graphrefly/graphrefly 0.45.0 → 0.46.0

package/dist/base/sources/index.cjs

@@ -0,0 +1,755 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/base/resilience/_internal.ts
+function operatorOpts(opts) {
+  return { describeKind: "derived", ...opts };
+}
+function isNode(x) {
+  return x != null && typeof x === "object" && "cache" in x && typeof x.subscribe === "function";
+}
+var import_core3;
+var init_internal = __esm({
+  "src/base/resilience/_internal.ts"() {
+    "use strict";
+    import_core3 = require("@graphrefly/pure-ts/core");
+  }
+});
+
+// src/base/resilience/backoff.ts
+var backoff_exports = {};
+__export(backoff_exports, {
+  NS_PER_MS: () => NS_PER_MS,
+  NS_PER_SEC: () => NS_PER_SEC,
+  constant: () => constant,
+  decorrelatedJitter: () => decorrelatedJitter,
+  exponential: () => exponential,
+  fibonacci: () => fibonacci,
+  linear: () => linear,
+  resolveBackoffPreset: () => resolveBackoffPreset,
+  withMaxAttempts: () => withMaxAttempts
+});
+function clampNonNegative(value) {
+  return value < 0 ? 0 : value;
+}
+function applyJitter(delay, jitter) {
+  if (jitter === "none") return delay;
+  if (jitter === "full") return Math.random() * delay;
+  return delay / 2 + Math.random() * (delay / 2);
+}
+function randomBetween(min, max) {
+  return min + Math.random() * (max - min);
+}
+function constant(delayNs) {
+  const safe = clampNonNegative(delayNs);
+  return () => safe;
+}
+function linear(baseNs, stepNs) {
+  const safeBase = clampNonNegative(baseNs);
+  const safeStep = stepNs === void 0 ? safeBase : clampNonNegative(stepNs);
+  return (attempt) => safeBase + safeStep * Math.max(0, attempt);
+}
+function exponential(options) {
+  const baseNs = clampNonNegative(options?.baseNs ?? 100 * NS_PER_MS);
+  const factor = options?.factor !== void 0 && options.factor < 1 ? 1 : options?.factor ?? 2;
+  const maxDelayNs = clampNonNegative(options?.maxDelayNs ?? 30 * NS_PER_SEC);
+  const jitter = options?.jitter ?? "none";
+  return (attempt) => {
+    let delay;
+    if (baseNs === 0) {
+      delay = 0;
+    } else if (factor === 1) {
+      delay = baseNs;
+    } else {
+      const capRatio = maxDelayNs / baseNs;
+      let growth = 1;
+      for (let i = 0; i < Math.max(0, attempt); i++) {
+        if (growth >= capRatio) {
+          growth = capRatio;
+          break;
+        }
+        growth *= factor;
+      }
+      delay = baseNs * growth;
+      if (delay > maxDelayNs) delay = maxDelayNs;
+    }
+    return applyJitter(delay, jitter);
+  };
+}
+function fibonacci(baseNs = 100 * NS_PER_MS, maxDelayNs = 30 * NS_PER_SEC) {
+  const safeBase = clampNonNegative(baseNs);
+  const safeMax = clampNonNegative(maxDelayNs);
+  function fibUnit(attempt) {
+    if (attempt <= 0) return 1;
+    let prev = 1;
+    let cur = 2;
+    for (let i = 1; i < attempt; i++) {
+      const next = prev + cur;
+      prev = cur;
+      cur = next;
+    }
+    return cur;
+  }
+  return (attempt) => {
+    const raw = fibUnit(attempt) * safeBase;
+    return raw <= safeMax ? raw : safeMax;
+  };
+}
+function decorrelatedJitter(baseNs = 100 * NS_PER_MS, maxNs = 30 * NS_PER_SEC) {
+  return (_attempt, _error, prevDelayNs) => {
+    const last = prevDelayNs ?? baseNs;
+    const ceiling = Math.min(maxNs, last * 3);
+    return randomBetween(baseNs, ceiling);
+  };
+}
+function withMaxAttempts(strategy, maxAttempts) {
+  return (attempt, error, prevDelayNs) => {
+    if (attempt >= maxAttempts) return null;
+    return strategy(attempt, error, prevDelayNs);
+  };
+}
+function resolveBackoffPreset(name) {
+  if (name === "constant") return constant(1 * NS_PER_SEC);
+  if (name === "linear") return linear(1 * NS_PER_SEC);
+  if (name === "exponential") return exponential();
+  if (name === "fibonacci") return fibonacci();
+  if (name === "decorrelatedJitter") return decorrelatedJitter();
+  throw new Error(
+    `Unknown backoff preset: "${String(name)}". Use one of: constant, linear, exponential, fibonacci, decorrelatedJitter`
+  );
+}
+var NS_PER_MS, NS_PER_SEC;
+var init_backoff = __esm({
+  "src/base/resilience/backoff.ts"() {
+    "use strict";
+    NS_PER_MS = 1e6;
+    NS_PER_SEC = 1e9;
+  }
+});
+
+// src/base/resilience/timeout.ts
+var timeout_exports = {};
+__export(timeout_exports, {
+  TimeoutError: () => TimeoutError,
+  withTimeout: () => withTimeout
+});
+function withTimeout(source, opts, extraOpts) {
+  const isReactive = isNode(opts);
+  let latestOpts = null;
+  if (!isReactive) {
+    const staticOpts = opts;
+    if (staticOpts.ns === void 0 || typeof staticOpts.ns !== "number" || !Number.isFinite(staticOpts.ns) || staticOpts.ns <= 0) {
+      throw new RangeError("withTimeout: opts.ns must be a positive finite number");
+    }
+    latestOpts = {
+      ns: staticOpts.ns,
+      ...staticOpts.meta != null ? { meta: staticOpts.meta } : {}
+    };
+  } else {
+    const cached2 = opts.cache;
+    if (cached2 !== void 0) {
+      if (cached2.ns === void 0 || typeof cached2.ns !== "number" || !Number.isFinite(cached2.ns) || cached2.ns <= 0) {
+        throw new RangeError(
+          "withTimeout: opts.ns must be a positive finite number on first settle"
+        );
+      }
+      latestOpts = {
+        ns: cached2.ns,
+        ...cached2.meta != null ? { meta: cached2.meta } : {}
+      };
+    }
+  }
+  const callerMeta = extraOpts?.meta;
+  const factoryArgs = isReactive ? { ns: "Node<Partial<TimeoutOptions>>" } : { ns: latestOpts.ns };
+  const timeoutState = (0, import_core4.node)([], {
+    name: "timeoutState",
+    describeKind: "state",
+    initial: { status: "pending" },
+    equals: (a, b) => a === b || a != null && b != null && typeof a === "object" && typeof b === "object" && a.status === b.status && JSON.stringify(a) === JSON.stringify(b)
+  });
+  const out = (0, import_core4.node)(
+    (_data, a) => {
+      let stopped = false;
+      let lastDeadlineNs = 0;
+      const timer = new import_core4.ResettableTimer();
+      let optsUnsub = null;
+      let srcUnsub = null;
+      function emitState(next) {
+        timeoutState.down([[import_core4.DIRTY], [import_core4.DATA, next]]);
+      }
+      function startTimer() {
+        if (stopped) return;
+        if (latestOpts == null || typeof latestOpts.ns !== "number" || !Number.isFinite(latestOpts.ns) || latestOpts.ns <= 0) {
+          return;
+        }
+        const ns = latestOpts.ns;
+        lastDeadlineNs = ns;
+        const startedAt = (0, import_core4.monotonicNs)();
+        const delayMs = ns / NS_PER_MS;
+        emitState({
+          status: "running",
+          startedAt_ns: startedAt,
+          deadline_ns: ns
+        });
+        timer.start(delayMs, () => {
+          if (stopped) return;
+          stopped = true;
+          srcUnsub?.();
+          emitState({
+            status: "errored",
+            firedAt_ns: (0, import_core4.monotonicNs)(),
+            deadline_ns: ns
+          });
+          a.down([[import_core4.ERROR, new TimeoutError(ns)]]);
+        });
+      }
+      function attachSource() {
+        if (srcUnsub != null || stopped) return;
+        srcUnsub = source.subscribe((msgs) => {
+          for (const m of msgs) {
+            if (stopped) return;
+            const t = m[0];
+            if (t === import_core4.DIRTY) a.down([[import_core4.DIRTY]]);
+            else if (t === import_core4.DATA) {
+              startTimer();
+              a.emit(m[1]);
+            } else if (t === import_core4.RESOLVED) a.down([[import_core4.RESOLVED]]);
+            else if (t === import_core4.COMPLETE) {
+              timer.cancel();
+              stopped = true;
+              emitState({
+                status: "completed",
+                settledAt_ns: (0, import_core4.monotonicNs)()
+              });
+              a.down([[import_core4.COMPLETE]]);
+              return;
+            } else if (t === import_core4.ERROR) {
+              timer.cancel();
+              stopped = true;
+              emitState({
+                status: "errored",
+                firedAt_ns: (0, import_core4.monotonicNs)(),
+                deadline_ns: lastDeadlineNs
+              });
+              a.down([m]);
+              return;
+            } else if (t === import_core4.TEARDOWN) {
+              timer.cancel();
+              stopped = true;
+              a.down([m]);
+              return;
+            } else a.down([m]);
+          }
+        });
+        if (latestOpts != null && latestOpts.ns > 0) {
+          startTimer();
+        }
+      }
+      if (isReactive) {
+        const optsNode = opts;
+        optsUnsub = optsNode.subscribe((msgs) => {
+          for (const m of msgs) {
+            if (m[0] !== import_core4.DATA) continue;
+            const next = m[1];
+            if (next == null || typeof next !== "object") continue;
+            const keys = Object.keys(next);
+            if (keys.length === 0) continue;
+            if ("ns" in next) {
+              if (typeof next.ns !== "number" || !Number.isFinite(next.ns) || next.ns <= 0) {
+                if (latestOpts == null) {
+                  stopped = true;
+                  a.down([
+                    [
+                      import_core4.ERROR,
+                      new RangeError(
+                        "withTimeout: opts.ns must be a positive finite number on first settle"
+                      )
+                    ]
+                  ]);
+                  return;
+                }
+                continue;
+              }
+            }
+            const wasNull = latestOpts == null;
+            latestOpts = {
+              ...latestOpts ?? { ns: 0 },
+              ...next
+            };
+            if (wasNull && latestOpts.ns > 0) {
+              attachSource();
+            }
+          }
+        });
+      }
+      if (latestOpts != null) {
+        attachSource();
+      }
+      return () => {
+        stopped = true;
+        timer.cancel();
+        if (srcUnsub) srcUnsub();
+        if (optsUnsub) optsUnsub();
+      };
+    },
+    {
+      ...operatorOpts(),
+      initial: source.cache,
+      meta: { ...callerMeta ?? {}, ...(0, import_core4.factoryTag)("withTimeout", factoryArgs) }
+    }
+  );
+  return { node: out, timeoutState };
+}
+var import_core4, TimeoutError;
+var init_timeout = __esm({
+  "src/base/resilience/timeout.ts"() {
+    "use strict";
+    import_core4 = require("@graphrefly/pure-ts/core");
+    init_internal();
+    init_backoff();
+    TimeoutError = class extends Error {
+      name = "TimeoutError";
+      constructor(ns) {
+        super(`Timed out after ${ns / NS_PER_MS}ms`);
+      }
+    };
+  }
+});
+
+// src/base/sources/index.ts
+var sources_exports = {};
+__export(sources_exports, {
+  awaitSettled: () => awaitSettled,
+  cached: () => cached,
+  defer: () => defer,
+  firstValueFrom: () => firstValueFrom,
+  firstWhere: () => firstWhere,
+  forEach: () => forEach,
+  fromCron: () => fromCron,
+  matchesCron: () => matchesCron,
+  nodeSignal: () => nodeSignal,
+  parseCron: () => parseCron,
+  reactiveCounter: () => reactiveCounter,
+  replay: () => replay,
+  share: () => share,
+  shareReplay: () => shareReplay,
+  toArray: () => toArray
+});
+module.exports = __toCommonJS(sources_exports);
+
+// src/base/sources/async.ts
+var import_core = require("@graphrefly/pure-ts/core");
+var import_extra = require("@graphrefly/pure-ts/extra");
+var import_extra2 = require("@graphrefly/pure-ts/extra");
+function defer(thunk, opts) {
+  const { signal: _sig, ...nodeOpts } = opts ?? {};
+  const sOpts = (0, import_extra.sourceOpts)(nodeOpts);
+  const merged = sOpts.resubscribable === void 0 ? { ...sOpts, resubscribable: true } : sOpts;
+  return (0, import_core.node)((_data, a) => {
+    let unsub;
+    let stopped = false;
+    try {
+      const input = thunk();
+      const src = (0, import_extra2.fromAny)(input, { ...opts, iter: true });
+      unsub = src.subscribe((msgs) => {
+        if (stopped) return;
+        for (const m of msgs) {
+          const t = m[0];
+          if (t === import_core.START) continue;
+          if (t === import_core.DATA) {
+            a.emit(m[1]);
+          } else if (t === import_core.COMPLETE) {
+            stopped = true;
+            a.down([[import_core.COMPLETE]]);
+            break;
+          } else if (t === import_core.ERROR) {
+            stopped = true;
+            a.down([[import_core.ERROR, m[1]]]);
+            break;
+          } else {
+            a.down([m]);
+          }
+        }
+      });
+    } catch (err) {
+      const safe = err === void 0 ? new Error("defer: thunk threw undefined") : err;
+      a.down([[import_core.ERROR, safe]]);
+    }
+    return () => {
+      stopped = true;
+      unsub?.();
+    };
+  }, merged);
+}
+function forEach(source, fn, opts) {
+  const inner = (0, import_core.node)(
+    [source],
+    (data, _actions) => {
+      const batch0 = data[0];
+      if (batch0 != null && batch0.length > 0) {
+        for (const v of batch0) fn(v);
+      }
+    },
+    { describeKind: "effect", ...opts }
+  );
+  return inner.subscribe(() => {
+  });
+}
+function toArray(source, opts) {
+  let cleanup;
+  return (0, import_core.node)(
+    [source],
+    (data, actions, ctx) => {
+      if (cleanup === void 0) {
+        const store = ctx.store;
+        cleanup = {
+          onDeactivation: () => {
+            delete store.buf;
+          }
+        };
+      }
+      if (!ctx.store.buf) ctx.store.buf = [];
+      const buf = ctx.store.buf;
+      const batch0 = data[0];
+      if (batch0 != null && batch0.length > 0) {
+        for (const v of batch0) buf.push(v);
+      }
+      if (ctx.terminalDeps[0] === true) {
+        actions.emit([...buf]);
+        actions.down([[import_core.COMPLETE]]);
+        return cleanup;
+      }
+      if (batch0 == null || batch0.length === 0) {
+        actions.down([[import_core.RESOLVED]]);
+      }
+      return cleanup;
+    },
+    {
+      describeKind: "derived",
+      completeWhenDepsComplete: false,
+      ...opts
+    }
+  );
+}
+function share(source, opts) {
+  return (0, import_core.node)(
+    (_data, a) => source.subscribe((msgs) => {
+      a.down(msgs);
+    }),
+    { ...(0, import_extra.sourceOpts)(opts), initial: source.cache }
+  );
+}
+function replay(source, bufferSize, opts) {
+  if (bufferSize < 1) throw new RangeError("replay expects bufferSize >= 1");
+  return (0, import_core.node)(
+    (_data, a) => source.subscribe((msgs) => {
+      a.down(msgs);
+    }),
+    { ...(0, import_extra.sourceOpts)(opts), initial: source.cache, replayBuffer: bufferSize }
+  );
+}
+function cached(source, opts) {
+  return replay(source, 1, opts);
+}
+var shareReplay = replay;
+
+// src/base/sources/event/cron.ts
+var import_core2 = require("@graphrefly/pure-ts/core");
+function sourceOpts2(opts) {
+  return { describeKind: "producer", ...opts };
+}
+function parseField(field, min, max) {
+  const result = /* @__PURE__ */ new Set();
+  for (const part of field.split(",")) {
+    const [range, stepStr] = part.split("/");
+    const step = stepStr ? Number.parseInt(stepStr, 10) : 1;
+    if (Number.isNaN(step) || step < 1) throw new Error(`Invalid cron step: ${part}`);
+    let start;
+    let end;
+    if (range === "*") {
+      start = min;
+      end = max;
+    } else if (range.includes("-")) {
+      const [a, b] = range.split("-");
+      start = Number.parseInt(a, 10);
+      end = Number.parseInt(b, 10);
+    } else {
+      start = Number.parseInt(range, 10);
+      end = start;
+    }
+    if (Number.isNaN(start) || Number.isNaN(end)) throw new Error(`Invalid cron field: ${field}`);
+    if (start < min || end > max)
+      throw new Error(`Cron field out of range: ${field} (${min}-${max})`);
+    if (start > end) throw new Error(`Invalid cron range: ${start}-${end} in ${field}`);
+    for (let i = start; i <= end; i += step) result.add(i);
+  }
+  return result;
+}
+function parseCron(expr) {
+  const parts = expr.trim().split(/\s+/);
+  if (parts.length !== 5) throw new Error(`Invalid cron: expected 5 fields, got ${parts.length}`);
+  return {
+    minutes: parseField(parts[0], 0, 59),
+    hours: parseField(parts[1], 0, 23),
+    daysOfMonth: parseField(parts[2], 1, 31),
+    months: parseField(parts[3], 1, 12),
+    daysOfWeek: parseField(parts[4], 0, 6)
+  };
+}
+function matchesCron(schedule, date) {
+  return schedule.minutes.has(date.getMinutes()) && schedule.hours.has(date.getHours()) && schedule.daysOfMonth.has(date.getDate()) && schedule.months.has(date.getMonth() + 1) && schedule.daysOfWeek.has(date.getDay());
+}
+function fromCron(expr, opts) {
+  const schedule = parseCron(expr);
+  const { tickMs: tickOpt, output, ...rest } = opts ?? {};
+  const tickMs = tickOpt ?? 6e4;
+  const emitDate = output === "date";
+  return (0, import_core2.node)(
+    (_data, a) => {
+      let lastFiredKey = -1;
+      const check = () => {
+        const now = /* @__PURE__ */ new Date();
+        const key = now.getFullYear() * 1e8 + (now.getMonth() + 1) * 1e6 + now.getDate() * 1e4 + now.getHours() * 100 + now.getMinutes();
+        if (key !== lastFiredKey && matchesCron(schedule, now)) {
+          lastFiredKey = key;
+          a.emit(emitDate ? now : (0, import_core2.wallClockNs)());
+        }
+      };
+      check();
+      const id = setInterval(check, tickMs);
+      return () => clearInterval(id);
+    },
+    { ...sourceOpts2(rest), name: rest.name ?? `cron:${expr}` }
+  );
+}
+
+// src/base/sources/settled.ts
+var import_core5 = require("@graphrefly/pure-ts/core");
+function firstValueFrom(source) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let shouldUnsub = false;
+    let unsub;
+    unsub = source.subscribe((msgs) => {
+      for (const m of msgs) {
+        if (settled) return;
+        if (m[0] === import_core5.DATA) {
+          settled = true;
+          resolve(m[1]);
+          if (unsub) {
+            unsub();
+            unsub = void 0;
+          } else shouldUnsub = true;
+          return;
+        }
+        if (m[0] === import_core5.ERROR) {
+          settled = true;
+          reject(m[1]);
+          if (unsub) {
+            unsub();
+            unsub = void 0;
+          } else shouldUnsub = true;
+          return;
+        }
+        if (m[0] === import_core5.COMPLETE) {
+          settled = true;
+          reject(new Error("completed without DATA"));
+          if (unsub) {
+            unsub();
+            unsub = void 0;
+          } else shouldUnsub = true;
+          return;
+        }
+      }
+    });
+    if (shouldUnsub) {
+      unsub?.();
+      unsub = void 0;
+    }
+  });
+}
+function firstWhere(source, predicate, opts) {
+  let pending;
+  let resolveFn;
+  let rejectFn;
+  let settled = false;
+  let shouldUnsub = false;
+  let unsub;
+  let inInitialSyncPhase = opts?.skipCurrent === true;
+  const settleData = (v) => {
+    if (settled) return;
+    settled = true;
+    if (resolveFn != null) resolveFn(v);
+    else pending = { kind: "data", value: v };
+  };
+  const settleError = (err) => {
+    if (settled) return;
+    settled = true;
+    if (rejectFn != null) rejectFn(err);
+    else pending = { kind: "error", err };
+  };
+  const settleComplete = () => {
+    if (settled) return;
+    settled = true;
+    const err = new Error("completed without matching value");
+    if (rejectFn != null) rejectFn(err);
+    else pending = { kind: "complete" };
+  };
+  const detach = () => {
+    if (unsub) {
+      unsub();
+      unsub = void 0;
+    } else shouldUnsub = true;
+  };
+  const sink = (msgs) => {
+    if (settled) return;
+    for (const m of msgs) {
+      if (settled) return;
+      if (inInitialSyncPhase && m[0] === import_core5.DATA) continue;
+      if (m[0] === import_core5.DATA) {
+        const v = m[1];
+        if (predicate(v)) {
+          settleData(v);
+          detach();
+          return;
+        }
+      }
+      if (m[0] === import_core5.ERROR) {
+        settleError(m[1]);
+        detach();
+        return;
+      }
+      if (m[0] === import_core5.COMPLETE) {
+        settleComplete();
+        detach();
+        return;
+      }
+    }
+  };
+  unsub = source.subscribe(sink);
+  inInitialSyncPhase = false;
+  if (opts?.kick != null && !settled) {
+    try {
+      opts.kick();
+    } catch (err) {
+      settleError(err);
+      detach();
+    }
+  }
+  if (shouldUnsub) {
+    unsub?.();
+    unsub = void 0;
+  }
+  return new Promise((resolve, reject) => {
+    if (pending != null) {
+      if (pending.kind === "data") resolve(pending.value);
+      else if (pending.kind === "error") reject(pending.err);
+      else reject(new Error("completed without matching value"));
+      return;
+    }
+    resolveFn = resolve;
+    rejectFn = reject;
+  });
+}
+var _timeoutOp;
+var _nsPerMs;
+async function awaitSettled(source, opts) {
+  const predicate = opts?.predicate ?? ((v) => v != null);
+  const skipCurrent = opts?.skipCurrent;
+  const kick = opts?.kick;
+  if (opts?.timeoutMs == null || opts.timeoutMs <= 0) {
+    return await firstWhere(source, predicate, { skipCurrent, kick });
+  }
+  if (_timeoutOp === void 0) {
+    const [timeoutMod, backoff] = await Promise.all([
+      Promise.resolve().then(() => (init_timeout(), timeout_exports)),
+      Promise.resolve().then(() => (init_backoff(), backoff_exports))
+    ]);
+    _timeoutOp = timeoutMod.withTimeout;
+    _nsPerMs = backoff.NS_PER_MS;
+  }
+  const guarded = _timeoutOp(source, { ns: opts.timeoutMs * _nsPerMs }).node;
+  return await firstWhere(guarded, predicate, { skipCurrent, kick });
+}
+function nodeSignal(source, opts) {
+  const ctrl = new AbortController();
+  const reason = opts?.reason ?? new Error("cancelled via nodeSignal");
+  let unsub;
+  let shouldUnsub = false;
+  const done = () => {
+    if (unsub) {
+      unsub();
+      unsub = void 0;
+    } else shouldUnsub = true;
+  };
+  unsub = source.subscribe((msgs) => {
+    if (ctrl.signal.aborted) return;
+    for (const m of msgs) {
+      if (m[0] === import_core5.DATA && m[1] === true) {
+        ctrl.abort(reason);
+        done();
+        return;
+      }
+      if (m[0] === import_core5.ERROR) {
+        ctrl.abort(m[1]);
+        done();
+        return;
+      }
+      if (m[0] === import_core5.COMPLETE) {
+        done();
+        return;
+      }
+    }
+  });
+  if (shouldUnsub) {
+    unsub?.();
+    unsub = void 0;
+  }
+  return {
+    signal: ctrl.signal,
+    dispose: () => {
+      if (unsub) {
+        unsub();
+        unsub = void 0;
+      }
+    }
+  };
+}
+function reactiveCounter(cap) {
+  const counter = (0, import_core5.node)([], { initial: 0 });
+  return {
+    node: counter,
+    increment() {
+      const current = counter.cache ?? 0;
+      if (current >= cap) return false;
+      counter.down([[import_core5.DIRTY], [import_core5.DATA, current + 1]]);
+      return true;
+    },
+    get() {
+      return counter.cache ?? 0;
+    },
+    atCap() {
+      return (counter.cache ?? 0) >= cap;
+    }
+  };
+}
+//# sourceMappingURL=index.cjs.map