@graphrefly/graphrefly 0.25.0 → 0.27.0

package/dist/{chunk-IAHGTNOZ.js → chunk-BQ6RQQFF.js}

@@ -1,9 +1,76 @@
 import {
-  NativeLogBackend,
   createWatermarkController,
-  reactiveLog,
   toObservable
-} from "./chunk-PY4XCDLR.js";
+} from "./chunk-OFVJBJXR.js";
+import {
+  NS_PER_MS,
+  NS_PER_SEC,
+  audit,
+  buffer,
+  bufferCount,
+  bufferTime,
+  catchError,
+  combine,
+  combineLatest,
+  concat,
+  concatMap,
+  constant,
+  debounce,
+  debounceTime,
+  decorrelatedJitter,
+  delay,
+  distill,
+  distinctUntilChanged,
+  elementAt,
+  exhaustMap,
+  exponential,
+  fibonacci,
+  filter,
+  find,
+  first,
+  flatMap,
+  interval,
+  last,
+  linear,
+  map,
+  merge,
+  mergeMap,
+  pairwise,
+  pausable,
+  race,
+  reduce,
+  repeat,
+  rescue,
+  resolveBackoffPreset,
+  sample,
+  scan,
+  skip,
+  switchMap,
+  take,
+  takeUntil,
+  takeWhile,
+  tap,
+  throttle,
+  throttleTime,
+  valve,
+  verifiable,
+  window,
+  windowCount,
+  windowTime,
+  withLatestFrom,
+  withMaxAttempts,
+  zip
+} from "./chunk-RNHBMHKA.js";
+import {
+  NativeListBackend,
+  NativeMapBackend,
+  reactiveList,
+  reactiveMap
+} from "./chunk-WKNUIZOY.js";
+import {
+  NativeLogBackend,
+  reactiveLog
+} from "./chunk-J2VBW3DZ.js";
 import {
   cached,
   empty,
@@ -15,7 +82,6 @@ import {
   fromAsyncIter,
   fromCron,
   fromEvent,
-  fromFSWatch,
   fromIter,
   fromPromise,
   fromRaf,
@@ -33,11 +99,22 @@ import {
   shareReplay,
   throwError,
   toArray
-} from "./chunk-L2GLW2U7.js";
+} from "./chunk-BVZYTZ5H.js";
 import {
   ResettableTimer,
   RingBuffer
 } from "./chunk-7TAQJHQV.js";
+import {
+  batch,
+  defaultConfig,
+  derived,
+  effect,
+  monotonicNs,
+  node,
+  producer,
+  state,
+  wallClockNs
+} from "./chunk-PHOUUNK7.js";
 import {
   COMPLETE,
   DATA,
@@ -47,20 +124,10 @@ import {
   PAUSE,
   RESOLVED,
   RESUME,
-  START,
   TEARDOWN,
   __export,
-  __require,
-  batch,
-  defaultConfig,
-  derived,
-  effect,
-  monotonicNs,
-  node,
-  producer,
-  state,
-  wallClockNs
-} from "./chunk-5DJTTKX3.js";
+  __require
+} from "./chunk-SX52TAR4.js";
 
 // src/extra/index.ts
 var extra_exports = {};
@@ -248,99 +315,6 @@ __export(extra_exports, {
   zip: () => zip
 });
 
-// src/extra/backoff.ts
-var NS_PER_MS = 1e6;
-var NS_PER_SEC = 1e9;
-function clampNonNegative(value) {
-  return value < 0 ? 0 : value;
-}
-function applyJitter(delay2, jitter) {
-  if (jitter === "none") return delay2;
-  if (jitter === "full") return Math.random() * delay2;
-  return delay2 / 2 + Math.random() * (delay2 / 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 delay2;
-    if (baseNs === 0) {
-      delay2 = 0;
-    } else if (factor === 1) {
-      delay2 = 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;
-      }
-      delay2 = baseNs * growth;
-      if (delay2 > maxDelayNs) delay2 = maxDelayNs;
-    }
-    return applyJitter(delay2, 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 last2 = prevDelayNs ?? baseNs;
-    const ceiling = Math.min(maxNs, last2 * 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`
-  );
-}
-
 // src/extra/external-register.ts
 function sourceOpts(opts) {
   return { describeKind: "producer", ...opts };
@@ -434,1363 +408,28 @@ function externalBundle(register, channels, opts) {
   bundle.complete = () => {
     if (!active) return;
     active = false;
-    batch(() => {
-      for (const n of channelNodes) n.down([[COMPLETE]]);
-    });
-    finishCleanup();
-  };
-  const ret = register(bundle);
-  cleanup = typeof ret === "function" ? ret : void 0;
-  const dispose = () => {
-    if (!active) return;
-    active = false;
-    batch(() => {
-      for (const n of channelNodes) {
-        try {
-          n.down([[COMPLETE]]);
-        } catch {
-        }
-      }
-    });
-    finishCleanup();
-  };
-  return Object.assign(nodes, { dispose });
-}
-
-// src/extra/operators.ts
-function operatorOpts(opts) {
-  return { describeKind: "derived", ...opts };
-}
-function map(source, project, opts) {
-  return node(
-    [source],
-    (data, a) => {
-      const batch0 = data[0];
-      if (batch0 == null || batch0.length === 0) {
-        a.down([[RESOLVED]]);
-        return;
-      }
-      for (const v of batch0) {
-        a.emit(project(v));
-      }
-    },
-    operatorOpts(opts)
-  );
-}
-function filter(source, predicate, opts) {
-  return node(
-    [source],
-    (data, a) => {
-      const batch0 = data[0];
-      if (batch0 == null || batch0.length === 0) {
-        a.down([[RESOLVED]]);
-        return;
-      }
-      let emitted = false;
-      for (const v of batch0) {
-        if (predicate(v)) {
-          a.emit(v);
-          emitted = true;
-        }
-      }
-      if (!emitted) a.down([[RESOLVED]]);
-    },
-    operatorOpts(opts)
-  );
-}
-function scan(source, reducer, seed, opts) {
-  return node(
-    [source],
-    (data, a, ctx) => {
-      if (!("acc" in ctx.store)) ctx.store.acc = seed;
-      const batch0 = data[0];
-      if (batch0 == null || batch0.length === 0) {
-        a.down([[RESOLVED]]);
-        return;
-      }
-      for (const v of batch0) {
-        ctx.store.acc = reducer(ctx.store.acc, v);
-        a.emit(ctx.store.acc);
-      }
-    },
-    { ...operatorOpts(opts), initial: seed, resetOnTeardown: true }
-  );
-}
-function reduce(source, reducer, seed, opts) {
-  return node(
-    [source],
-    (data, a, ctx) => {
-      if (!("acc" in ctx.store)) ctx.store.acc = seed;
-      if (ctx.terminalDeps[0] === true) {
-        a.emit(ctx.store.acc);
-        a.down([[COMPLETE]]);
-        return;
-      }
-      const batch0 = data[0];
-      if (batch0 == null || batch0.length === 0) {
-        a.down([[RESOLVED]]);
-        return;
-      }
-      for (const v of batch0) {
-        ctx.store.acc = reducer(ctx.store.acc, v);
-      }
-    },
-    {
-      ...operatorOpts(opts),
-      completeWhenDepsComplete: false
-    }
-  );
-}
-function take(source, count, opts) {
-  if (count <= 0) {
-    return node(
-      [source],
-      (_d, a, ctx) => {
-        if (ctx.store.completed) return;
-        ctx.store.completed = true;
-        a.down([[COMPLETE]]);
-      },
-      {
-        ...operatorOpts(opts),
-        completeWhenDepsComplete: false
-      }
-    );
-  }
-  return node(
-    [source],
-    (data, a, ctx) => {
-      if (!("taken" in ctx.store)) ctx.store.taken = 0;
-      if (ctx.store.done) {
-        a.down([[RESOLVED]]);
-        return;
-      }
-      if (ctx.terminalDeps[0] === true) {
-        ctx.store.done = true;
-        a.down([[COMPLETE]]);
-        return;
-      }
-      const batch0 = data[0];
-      if (batch0 == null || batch0.length === 0) {
-        a.down([[RESOLVED]]);
-        return;
-      }
-      for (const v of batch0) {
-        ctx.store.taken++;
-        a.emit(v);
-        if (ctx.store.taken >= count) {
-          ctx.store.done = true;
-          a.down([[COMPLETE]]);
-          return;
-        }
-      }
-    },
-    {
-      ...operatorOpts(opts),
-      completeWhenDepsComplete: false
-    }
-  );
-}
-function skip(source, count, opts) {
-  return node(
-    [source],
-    (data, a, ctx) => {
-      if (!("skipped" in ctx.store)) ctx.store.skipped = 0;
-      const batch0 = data[0];
-      if (batch0 == null || batch0.length === 0) {
-        a.down([[RESOLVED]]);
-        return;
-      }
-      let emitted = false;
-      for (const v of batch0) {
-        ctx.store.skipped++;
-        if (ctx.store.skipped <= count) {
-        } else {
-          a.emit(v);
-          emitted = true;
-        }
-      }
-      if (!emitted) a.down([[RESOLVED]]);
-    },
-    operatorOpts(opts)
-  );
-}
-function takeWhile(source, predicate, opts) {
-  return node(
-    [source],
-    (data, a, ctx) => {
-      if (ctx.store.done) {
-        a.down([[RESOLVED]]);
-        return;
-      }
-      const batch0 = data[0];
-      if (batch0 == null || batch0.length === 0) {
-        a.down([[RESOLVED]]);
-        return;
-      }
-      for (const v of batch0) {
-        if (!predicate(v)) {
-          ctx.store.done = true;
-          a.down([[COMPLETE]]);
-          return;
-        }
-        a.emit(v);
-      }
-    },
-    {
-      ...operatorOpts(opts),
-      completeWhenDepsComplete: false
-    }
-  );
-}
-function takeUntil(source, notifier, opts) {
-  const pred = opts?.predicate ?? ((m) => m[0] === DATA);
-  const { predicate: _, ...restOpts } = opts ?? {};
-  return producer(
-    (a) => {
-      let stopped = false;
-      const srcUnsub = source.subscribe((msgs) => {
-        if (stopped) return;
-        for (const m of msgs) {
-          if (stopped) return;
-          if (m[0] === DATA) a.emit(m[1]);
-          else if (m[0] === COMPLETE || m[0] === ERROR) {
-            stopped = true;
-            a.down([m]);
-          }
-        }
-      });
-      const notUnsub = notifier.subscribe((msgs) => {
-        if (stopped) return;
-        for (const m of msgs) {
-          if (stopped) return;
-          if (pred(m)) {
-            stopped = true;
-            a.down([[COMPLETE]]);
-            return;
-          }
-        }
-      });
-      return () => {
-        srcUnsub();
-        notUnsub();
-      };
-    },
-    operatorOpts(restOpts)
-  );
-}
-function first(source, opts) {
-  return take(source, 1, opts);
-}
-function last(source, options) {
-  const { defaultValue, ...rest } = options ?? {};
-  const useDefault = options != null && Object.hasOwn(options, "defaultValue");
-  return node(
-    [source],
-    (data, a, ctx) => {
-      if (ctx.terminalDeps[0] === true) {
-        if (ctx.store.has) {
-          a.emit(ctx.store.latest);
-        } else if (useDefault) {
-          a.emit(defaultValue);
-        }
-        a.down([[COMPLETE]]);
-        return;
-      }
-      const batch0 = data[0];
-      if (batch0 == null || batch0.length === 0) {
-        a.down([[RESOLVED]]);
-        return;
-      }
-      ctx.store.latest = batch0.at(-1);
-      ctx.store.has = true;
-    },
-    {
-      ...operatorOpts(rest),
-      completeWhenDepsComplete: false
-    }
-  );
-}
-function find(source, predicate, opts) {
-  return take(filter(source, predicate, opts), 1, opts);
-}
-function elementAt(source, index, opts) {
-  return take(skip(source, index, opts), 1, opts);
-}
-function tap(source, fnOrObserver, opts) {
-  if (typeof fnOrObserver === "function") {
-    return node(
-      [source],
-      (data, a) => {
-        const batch0 = data[0];
-        if (batch0 == null || batch0.length === 0) {
-          a.down([[RESOLVED]]);
-          return;
-        }
-        for (const v of batch0) {
-          fnOrObserver(v);
-          a.emit(v);
-        }
-      },
-      operatorOpts(opts)
-    );
-  }
-  const obs = fnOrObserver;
-  return node(
-    [source],
-    (data, a, ctx) => {
-      if (ctx.terminalDeps[0] !== void 0) {
-        if (ctx.terminalDeps[0] === true) {
-          obs.complete?.();
-          a.down([[COMPLETE]]);
-        } else {
-          obs.error?.(ctx.terminalDeps[0]);
-          a.down([[ERROR, ctx.terminalDeps[0]]]);
-        }
-        return;
-      }
-      const batch0 = data[0];
-      if (batch0 == null || batch0.length === 0) {
-        a.down([[RESOLVED]]);
-        return;
-      }
-      for (const v of batch0) {
-        obs.data?.(v);
-        a.emit(v);
-      }
-    },
-    {
-      ...operatorOpts(opts),
-      completeWhenDepsComplete: false
-    }
-  );
-}
-function distinctUntilChanged(source, equals = Object.is, opts) {
-  return node(
-    [source],
-    (data, a, ctx) => {
-      const batch0 = data[0];
-      if (batch0 == null || batch0.length === 0) {
-        a.down([[RESOLVED]]);
-        return;
-      }
-      let emitted = false;
-      for (const val of batch0) {
-        if (ctx.store.hasPrev && equals(ctx.store.prev, val)) {
-        } else {
-          ctx.store.prev = val;
-          ctx.store.hasPrev = true;
-          a.emit(val);
-          emitted = true;
-        }
-      }
-      if (!emitted) a.down([[RESOLVED]]);
-    },
-    operatorOpts(opts)
-  );
-}
-function pairwise(source, opts) {
-  return node(
-    [source],
-    (data, a, ctx) => {
-      const batch0 = data[0];
-      if (batch0 == null || batch0.length === 0) {
-        a.down([[RESOLVED]]);
-        return;
-      }
-      let emitted = false;
-      for (const x of batch0) {
-        if (!ctx.store.hasPrev) {
-          ctx.store.prev = x;
-          ctx.store.hasPrev = true;
-        } else {
-          const pair = [ctx.store.prev, x];
-          ctx.store.prev = x;
-          a.emit(pair);
-          emitted = true;
-        }
-      }
-      if (!emitted) a.down([[RESOLVED]]);
-    },
-    operatorOpts(opts)
-  );
-}
-function combine(...sources) {
-  const deps = [...sources];
-  return derived(deps, (vals) => vals, {
-    ...operatorOpts(),
-    equals: (a, b) => {
-      if (a.length !== b.length) return false;
-      for (let i = 0; i < a.length; i++) {
-        if (!Object.is(a[i], b[i])) return false;
-      }
-      return true;
-    }
-  });
-}
-function withLatestFrom(primary, secondary, opts) {
-  return node(
-    [primary, secondary],
-    (data, a, ctx) => {
-      const batch0 = data[0];
-      const batch1 = data[1];
-      const secondaryVal = batch1 != null && batch1.length > 0 ? batch1.at(-1) : ctx.prevData[1];
-      if (batch0 != null && batch0.length > 0) {
-        if (!(batch1 != null && batch1.length > 0) && ctx.prevData[1] === void 0) {
-          a.down([[RESOLVED]]);
-          return;
-        }
-        for (const v of batch0) {
-          a.emit([v, secondaryVal]);
-        }
-      } else {
-        a.down([[RESOLVED]]);
-      }
-    },
-    operatorOpts(opts)
-  );
-}
-function merge(...sources) {
-  if (sources.length === 0) {
-    return producer((a) => {
-      a.down([[COMPLETE]]);
-    }, operatorOpts());
-  }
-  return producer((a) => {
-    const n = sources.length;
-    let completed = 0;
-    const unsubs = [];
-    for (const src of sources) {
-      const u = src.subscribe((msgs) => {
-        for (const m of msgs) {
-          if (m[0] === DATA) {
-            a.emit(m[1]);
-          } else if (m[0] === COMPLETE) {
-            completed += 1;
-            if (completed >= n) {
-              a.down([[COMPLETE]]);
-            }
-          } else if (m[0] === ERROR) {
-            a.down([m]);
-          }
-        }
-      });
-      unsubs.push(u);
-    }
-    return () => {
-      for (const u of unsubs) u();
-    };
-  }, operatorOpts());
-}
-function zip(...sources) {
-  const n = sources.length;
-  if (n === 0) {
-    return producer((a) => {
-      a.emit([]);
-      a.down([[COMPLETE]]);
-    }, operatorOpts());
-  }
-  return producer((a) => {
-    const queues = Array.from({ length: n }, () => []);
-    let active = n;
-    function tryEmit() {
-      while (queues.every((q) => q.length > 0)) {
-        const tuple = queues.map((q) => q.shift());
-        a.emit(tuple);
-      }
-    }
-    const unsubs = [];
-    for (let i = 0; i < n; i++) {
-      const idx = i;
-      const u = sources[i].subscribe((msgs) => {
-        for (const m of msgs) {
-          if (m[0] === DATA) {
-            queues[idx].push(m[1]);
-            tryEmit();
-          } else if (m[0] === COMPLETE) {
-            active -= 1;
-            if (active === 0 || queues[idx].length === 0) {
-              a.down([[COMPLETE]]);
-            }
-          } else if (m[0] === ERROR) {
-            a.down([m]);
-          }
-        }
-      });
-      unsubs.push(u);
-    }
-    return () => {
-      for (const u of unsubs) u();
-    };
-  }, operatorOpts());
-}
-function concat(firstSrc, secondSrc, opts) {
-  return producer((a) => {
-    let phase = 0;
-    const pending = [];
-    let firstUnsub;
-    let secondUnsub;
-    secondUnsub = secondSrc.subscribe((msgs) => {
-      for (const m of msgs) {
-        if (phase === 0) {
-          if (m[0] === DATA) pending.push(m[1]);
-          else if (m[0] === ERROR) a.down([m]);
-        } else {
-          if (m[0] === DATA) a.emit(m[1]);
-          else if (m[0] === COMPLETE || m[0] === ERROR) a.down([m]);
-        }
-      }
-    });
-    firstUnsub = firstSrc.subscribe((msgs) => {
-      for (const m of msgs) {
-        if (phase === 0) {
-          if (m[0] === DATA) {
-            a.emit(m[1]);
-          } else if (m[0] === COMPLETE) {
-            phase = 1;
-            for (const v of pending) {
-              a.emit(v);
-            }
-            pending.length = 0;
-          } else if (m[0] === ERROR) {
-            a.down([m]);
-          }
-        }
-      }
-    });
-    return () => {
-      firstUnsub?.();
-      secondUnsub?.();
-    };
-  }, operatorOpts(opts));
-}
-function race(...sources) {
-  if (sources.length === 0) {
-    return producer((a) => {
-      a.down([[COMPLETE]]);
-    }, operatorOpts());
-  }
-  if (sources.length === 1) {
-    return node(
-      [sources[0]],
-      (data, a) => {
-        const batch0 = data[0];
-        if (batch0 == null || batch0.length === 0) {
-          a.down([[RESOLVED]]);
-          return;
-        }
-        for (const v of batch0) a.emit(v);
-      },
-      operatorOpts()
-    );
-  }
-  return producer((a) => {
-    let winner = null;
-    const unsubs = [];
-    for (let i = 0; i < sources.length; i++) {
-      const idx = i;
-      const u = sources[i].subscribe((msgs) => {
-        for (const m of msgs) {
-          if (winner !== null && idx !== winner) return;
-          if (m[0] === DATA) {
-            if (winner === null) winner = idx;
-            a.emit(m[1]);
-          } else if (m[0] === COMPLETE || m[0] === ERROR) {
-            if (winner === null || idx === winner) {
-              a.down([m]);
-            }
-          }
-        }
-      });
-      unsubs.push(u);
-    }
-    return () => {
-      for (const u of unsubs) u();
-    };
-  }, operatorOpts());
-}
-function forwardInner(inner, a, onInnerComplete) {
-  let unsub;
-  let finished = false;
-  const finish = () => {
-    if (finished) return;
-    finished = true;
-    onInnerComplete();
-  };
-  unsub = inner.subscribe((msgs) => {
-    let sawComplete = false;
-    let sawError = false;
-    for (const m of msgs) {
-      if (m[0] === START) continue;
-      if (m[0] === DATA) {
-        a.emit(m[1]);
-      } else if (m[0] === COMPLETE) {
-        sawComplete = true;
-      } else if (m[0] === ERROR) {
-        sawError = true;
-        a.down([m]);
-      } else if (m[0] === DIRTY || m[0] === RESOLVED) {
-        a.down([m]);
-      }
-    }
-    if (sawError) {
-      unsub?.();
-      unsub = void 0;
-      finish();
-    } else if (sawComplete) {
-      finish();
-    }
-  });
-  return () => {
-    unsub?.();
-    unsub = void 0;
-  };
-}
-function switchMap(source, project, opts) {
-  let innerUnsub;
-  let sourceDone = false;
-  function clearInner() {
-    innerUnsub?.();
-    innerUnsub = void 0;
-  }
-  return node(
-    [source],
-    (data, a, ctx) => {
-      if (ctx.terminalDeps[0] != null && ctx.terminalDeps[0] !== true) {
-        clearInner();
-        return;
-      }
-      if (ctx.terminalDeps[0] === true) {
-        sourceDone = true;
-        if (!innerUnsub) a.down([[COMPLETE]]);
-        return;
-      }
-      const batch0 = data[0];
-      if (batch0 == null || batch0.length === 0) return;
-      clearInner();
-      innerUnsub = forwardInner(fromAny(project(batch0[batch0.length - 1])), a, () => {
-        clearInner();
-        if (sourceDone) a.down([[COMPLETE]]);
-      });
-      return {
-        deactivation: () => {
-          clearInner();
-          sourceDone = false;
-        }
-      };
-    },
-    { ...operatorOpts(opts), completeWhenDepsComplete: false }
-  );
-}
-function exhaustMap(source, project, opts) {
-  let innerUnsub;
-  let sourceDone = false;
-  function clearInner() {
-    innerUnsub?.();
-    innerUnsub = void 0;
-  }
-  return node(
-    [source],
-    (data, a, ctx) => {
-      if (ctx.terminalDeps[0] != null && ctx.terminalDeps[0] !== true) {
-        clearInner();
-        return;
-      }
-      if (ctx.terminalDeps[0] === true) {
-        sourceDone = true;
-        if (!innerUnsub) a.down([[COMPLETE]]);
-        return;
-      }
-      const batch0 = data[0];
-      if (batch0 == null || batch0.length === 0) return;
-      if (innerUnsub === void 0) {
-        innerUnsub = forwardInner(fromAny(project(batch0[0])), a, () => {
-          clearInner();
-          if (sourceDone) a.down([[COMPLETE]]);
-        });
-      } else {
-        a.down([[RESOLVED]]);
-      }
-      return {
-        deactivation: () => {
-          clearInner();
-          sourceDone = false;
-        }
-      };
-    },
-    { ...operatorOpts(opts), completeWhenDepsComplete: false }
-  );
-}
-function concatMap(source, project, opts) {
-  const { maxBuffer: maxBuf, ...concatNodeOpts } = opts ?? {};
-  const queue = [];
-  let innerUnsub;
-  let sourceDone = false;
-  let actions;
-  function clearInner() {
-    innerUnsub?.();
-    innerUnsub = void 0;
-  }
-  function tryPump() {
-    if (!actions || innerUnsub !== void 0) return;
-    if (queue.length === 0) {
-      if (sourceDone) actions.down([[COMPLETE]]);
-      return;
-    }
-    const v = queue.shift();
-    innerUnsub = forwardInner(fromAny(project(v)), actions, () => {
-      clearInner();
-      tryPump();
-    });
-  }
-  function enqueue(v) {
-    if (maxBuf && maxBuf > 0 && queue.length >= maxBuf) queue.shift();
-    queue.push(v);
-    tryPump();
-  }
-  return node(
-    [source],
-    (data, a, ctx) => {
-      actions = a;
-      if (ctx.terminalDeps[0] != null && ctx.terminalDeps[0] !== true) {
-        clearInner();
-        queue.length = 0;
-        return;
-      }
-      if (ctx.terminalDeps[0] === true) {
-        sourceDone = true;
-        tryPump();
-        return;
-      }
-      const batch0 = data[0];
-      if (batch0 == null || batch0.length === 0) return;
-      for (const v of batch0) {
-        enqueue(v);
-      }
-      return {
-        deactivation: () => {
-          clearInner();
-          queue.length = 0;
-          sourceDone = false;
-        }
-      };
-    },
-    { ...operatorOpts(concatNodeOpts), completeWhenDepsComplete: false }
-  );
-}
-function mergeMap(source, project, opts) {
-  const { concurrent: concurrentOpt, ...mergeNodeOpts } = opts ?? {};
-  const maxConcurrent = concurrentOpt != null && concurrentOpt > 0 ? concurrentOpt : Number.POSITIVE_INFINITY;
-  let active = 0;
-  let sourceDone = false;
-  const innerStops = /* @__PURE__ */ new Set();
-  const buffer2 = [];
-  let actions;
-  function tryComplete() {
-    if (sourceDone && active === 0 && buffer2.length === 0 && actions) {
-      actions.down([[COMPLETE]]);
-    }
-  }
-  function spawn(v) {
-    if (!actions) return;
-    active++;
-    let stop;
-    stop = forwardInner(fromAny(project(v)), actions, () => {
-      if (stop) innerStops.delete(stop);
-      active--;
-      drainBuffer();
-      tryComplete();
-    });
-    innerStops.add(stop);
-  }
-  function drainBuffer() {
-    while (buffer2.length > 0 && active < maxConcurrent) {
-      spawn(buffer2.shift());
-    }
-  }
-  function enqueue(v) {
-    if (active < maxConcurrent) spawn(v);
-    else buffer2.push(v);
-  }
-  function clearAll() {
-    for (const u of innerStops) u();
-    innerStops.clear();
-    active = 0;
-    buffer2.length = 0;
-  }
-  return node(
-    [source],
-    (data, a, ctx) => {
-      actions = a;
-      if (ctx.terminalDeps[0] != null && ctx.terminalDeps[0] !== true) {
-        clearAll();
-        return;
-      }
-      if (ctx.terminalDeps[0] === true) {
-        sourceDone = true;
-        tryComplete();
-        return;
-      }
-      const batch0 = data[0];
-      if (batch0 == null || batch0.length === 0) return;
-      for (const v of batch0) {
-        enqueue(v);
-      }
-      return {
-        deactivation: () => {
-          clearAll();
-          sourceDone = false;
-        }
-      };
-    },
-    { ...operatorOpts(mergeNodeOpts), completeWhenDepsComplete: false }
-  );
-}
-var flatMap = mergeMap;
-function delay(source, ms, opts) {
-  return producer((a) => {
-    const timers = /* @__PURE__ */ new Set();
-    function clearAll() {
-      for (const id of timers) clearTimeout(id);
-      timers.clear();
-    }
-    const srcUnsub = source.subscribe((msgs) => {
-      for (const m of msgs) {
-        if (m[0] === DATA) {
-          const id = setTimeout(() => {
-            timers.delete(id);
-            a.emit(m[1]);
-          }, ms);
-          timers.add(id);
-        } else if (m[0] === COMPLETE) {
-          const id = setTimeout(() => {
-            timers.delete(id);
-            a.down([[COMPLETE]]);
-          }, ms);
-          timers.add(id);
-        } else if (m[0] === ERROR) {
-          clearAll();
-          a.down([m]);
-        }
-      }
-    });
-    return () => {
-      srcUnsub();
-      clearAll();
-    };
-  }, operatorOpts(opts));
-}
-function debounce(source, ms, opts) {
-  return producer((a) => {
-    let timer;
-    let pending;
-    function clearTimer() {
-      if (timer !== void 0) {
-        clearTimeout(timer);
-        timer = void 0;
-      }
-    }
-    const srcUnsub = source.subscribe((msgs) => {
-      for (const m of msgs) {
-        if (m[0] === DATA) {
-          clearTimer();
-          pending = m[1];
-          timer = setTimeout(() => {
-            timer = void 0;
-            a.emit(pending);
-          }, ms);
-        } else if (m[0] === COMPLETE) {
-          if (timer !== void 0) {
-            clearTimer();
-            a.emit(pending);
-          }
-          a.down([[COMPLETE]]);
-        } else if (m[0] === ERROR) {
-          clearTimer();
-          a.down([m]);
-        }
-      }
-    });
-    return () => {
-      srcUnsub();
-      clearTimer();
-    };
-  }, operatorOpts(opts));
-}
-function throttle(source, ms, opts) {
-  const { leading: leadingOpt, trailing: trailingOpt, ...throttleNodeOpts } = opts ?? {};
-  const leading = leadingOpt !== false;
-  const trailing = trailingOpt === true;
-  const windowNs = ms * NS_PER_MS;
-  return producer((a) => {
-    let timer;
-    let lastEmitNs = -Infinity;
-    let pending;
-    let hasPending = false;
-    function clearTimer() {
-      if (timer !== void 0) {
-        clearTimeout(timer);
-        timer = void 0;
-      }
-    }
-    const srcUnsub = source.subscribe((msgs) => {
-      for (const m of msgs) {
-        if (m[0] === DATA) {
-          const v = m[1];
-          const nowNs = monotonicNs();
-          if (leading && nowNs - lastEmitNs >= windowNs) {
-            lastEmitNs = nowNs;
-            a.emit(v);
-            clearTimer();
-            if (trailing) {
-              timer = setTimeout(() => {
-                timer = void 0;
-                if (hasPending) {
-                  lastEmitNs = monotonicNs();
-                  a.emit(pending);
-                  hasPending = false;
-                }
-              }, ms);
-            }
-          } else if (trailing) {
-            pending = v;
-            hasPending = true;
-            if (timer === void 0) {
-              const elapsedMs = (nowNs - lastEmitNs) / NS_PER_MS;
-              timer = setTimeout(
-                () => {
-                  timer = void 0;
-                  if (hasPending) {
-                    lastEmitNs = monotonicNs();
-                    a.emit(pending);
-                    hasPending = false;
-                  }
-                },
-                Math.max(0, ms - elapsedMs)
-              );
-            }
-          }
-        } else if (m[0] === COMPLETE || m[0] === ERROR) {
-          clearTimer();
-          a.down([m]);
-        }
-      }
-    });
-    return () => {
-      srcUnsub();
-      clearTimer();
-    };
-  }, operatorOpts(throttleNodeOpts));
-}
-function sample(source, notifier, opts) {
-  return producer((a) => {
-    let lastSourceValue;
-    let terminated = false;
-    let sourceCompleted = false;
-    const srcUnsub = source.subscribe((msgs) => {
-      if (terminated) return;
-      for (const m of msgs) {
-        if (terminated) return;
-        if (m[0] === DATA) {
-          lastSourceValue = { v: m[1] };
-        } else if (m[0] === ERROR) {
-          terminated = true;
-          a.down([m]);
-        } else if (m[0] === COMPLETE) {
-          sourceCompleted = true;
-          lastSourceValue = void 0;
-        }
-      }
-    });
-    const notUnsub = notifier.subscribe((msgs) => {
-      if (terminated) return;
-      for (const m of msgs) {
-        if (terminated) return;
-        if (m[0] === DATA) {
-          if (lastSourceValue !== void 0 && !sourceCompleted) {
-            a.emit(lastSourceValue.v);
-          }
-        } else if (m[0] === ERROR) {
-          terminated = true;
-          a.down([m]);
-        } else if (m[0] === COMPLETE) {
-          terminated = true;
-          a.down([[COMPLETE]]);
-        }
-      }
-    });
-    return () => {
-      srcUnsub();
-      notUnsub();
-    };
-  }, operatorOpts(opts));
-}
-function audit(source, ms, opts) {
-  return producer((a) => {
-    let timer;
-    let latest;
-    let has = false;
-    function clearTimer() {
-      if (timer !== void 0) {
-        clearTimeout(timer);
-        timer = void 0;
-      }
-    }
-    const srcUnsub = source.subscribe((msgs) => {
-      for (const m of msgs) {
-        if (m[0] === DATA) {
-          latest = m[1];
-          has = true;
-          clearTimer();
-          timer = setTimeout(() => {
-            timer = void 0;
-            if (has) {
-              has = false;
-              a.emit(latest);
-            }
-          }, ms);
-        } else if (m[0] === COMPLETE || m[0] === ERROR) {
-          clearTimer();
-          a.down([m]);
-        }
-      }
-    });
-    return () => {
-      srcUnsub();
-      clearTimer();
-    };
-  }, operatorOpts(opts));
-}
-function buffer(source, notifier, opts) {
-  return producer((a) => {
-    const buf = [];
-    const srcUnsub = source.subscribe((msgs) => {
-      for (const m of msgs) {
-        if (m[0] === DATA) {
-          buf.push(m[1]);
-        } else if (m[0] === COMPLETE) {
-          if (buf.length > 0) a.emit([...buf]);
-          buf.length = 0;
-          a.down([[COMPLETE]]);
-        } else if (m[0] === ERROR) {
-          a.down([m]);
-        }
-      }
-    });
-    const notUnsub = notifier.subscribe((msgs) => {
-      for (const m of msgs) {
-        if (m[0] === DATA) {
-          if (buf.length > 0) {
-            a.emit([...buf]);
-            buf.length = 0;
-          }
-        } else if (m[0] === COMPLETE) {
-          a.down([[COMPLETE]]);
-        } else if (m[0] === ERROR) {
-          a.down([m]);
-        }
-      }
-    });
-    return () => {
-      srcUnsub();
-      notUnsub();
-      buf.length = 0;
-    };
-  }, operatorOpts(opts));
-}
-function bufferCount(source, count, opts) {
-  if (count <= 0) throw new RangeError("bufferCount expects count > 0");
-  return producer((a) => {
-    const buf = [];
-    const srcUnsub = source.subscribe((msgs) => {
-      for (const m of msgs) {
-        if (m[0] === DATA) {
-          buf.push(m[1]);
-          if (buf.length >= count) {
-            a.emit(buf.splice(0, buf.length));
-          }
-        } else if (m[0] === COMPLETE) {
-          if (buf.length > 0) a.emit([...buf]);
-          buf.length = 0;
-          a.down([[COMPLETE]]);
-        } else if (m[0] === ERROR) {
-          a.down([m]);
-        }
-      }
-    });
-    return () => {
-      srcUnsub();
-      buf.length = 0;
-    };
-  }, operatorOpts(opts));
-}
-function windowCount(source, count, opts) {
-  if (count <= 0) throw new RangeError("windowCount expects count > 0");
-  return producer((a) => {
-    let winDown;
-    let n = 0;
-    function openWindow() {
-      const s = producer((actions) => {
-        winDown = actions.down.bind(actions);
-        return () => {
-          winDown = void 0;
-        };
-      }, operatorOpts());
-      n = 0;
-      a.emit(s);
-    }
-    const srcUnsub = source.subscribe((msgs) => {
-      for (const m of msgs) {
-        if (m[0] === DATA) {
-          if (!winDown) openWindow();
-          winDown?.([[DATA, m[1]]]);
-          n += 1;
-          if (n >= count) {
-            winDown?.([[COMPLETE]]);
-            winDown = void 0;
-          }
-        } else if (m[0] === COMPLETE) {
-          winDown?.([[COMPLETE]]);
-          winDown = void 0;
-          a.down([[COMPLETE]]);
-        } else if (m[0] === ERROR) {
-          winDown?.([m]);
-          winDown = void 0;
-          a.down([m]);
-        }
-      }
-    });
-    return () => {
-      srcUnsub();
-      winDown?.([[COMPLETE]]);
-      winDown = void 0;
-    };
-  }, operatorOpts(opts));
-}
-function bufferTime(source, ms, opts) {
-  return producer((a) => {
-    const buf = [];
-    const iv = setInterval(() => {
-      if (buf.length > 0) {
-        a.emit([...buf]);
-        buf.length = 0;
-      }
-    }, ms);
-    const srcUnsub = source.subscribe((msgs) => {
-      for (const m of msgs) {
-        if (m[0] === DATA) {
-          buf.push(m[1]);
-        } else if (m[0] === COMPLETE) {
-          clearInterval(iv);
-          if (buf.length > 0) a.emit([...buf]);
-          buf.length = 0;
-          a.down([[COMPLETE]]);
-        } else if (m[0] === ERROR) {
-          clearInterval(iv);
-          a.down([m]);
-        }
-      }
-    });
-    return () => {
-      srcUnsub();
-      clearInterval(iv);
-      buf.length = 0;
-    };
-  }, operatorOpts(opts));
-}
-function windowTime(source, ms, opts) {
-  return producer((a) => {
-    let winDown;
-    function closeWindow() {
-      winDown?.([[COMPLETE]]);
-      winDown = void 0;
-    }
-    function openWindow() {
-      const s = producer((actions) => {
-        winDown = actions.down.bind(actions);
-        return () => {
-          winDown = void 0;
-        };
-      }, operatorOpts());
-      a.emit(s);
-    }
-    openWindow();
-    const iv = setInterval(() => {
-      closeWindow();
-      openWindow();
-    }, ms);
-    const srcUnsub = source.subscribe((msgs) => {
-      for (const m of msgs) {
-        if (m[0] === DATA) {
-          winDown?.([[DATA, m[1]]]);
-        } else if (m[0] === COMPLETE) {
-          clearInterval(iv);
-          closeWindow();
-          a.down([[COMPLETE]]);
-        } else if (m[0] === ERROR) {
-          clearInterval(iv);
-          winDown?.([m]);
-          closeWindow();
-          a.down([m]);
-        }
-      }
-    });
-    return () => {
-      srcUnsub();
-      clearInterval(iv);
-      closeWindow();
-    };
-  }, operatorOpts(opts));
-}
-function window(source, notifier, opts) {
-  return producer((a) => {
-    let winDown;
-    function closeWindow() {
-      winDown?.([[COMPLETE]]);
-      winDown = void 0;
-    }
-    function openWindow() {
-      const s = producer((actions) => {
-        winDown = actions.down.bind(actions);
-        return () => {
-          winDown = void 0;
-        };
-      }, operatorOpts());
-      a.emit(s);
-    }
-    const srcUnsub = source.subscribe((msgs) => {
-      for (const m of msgs) {
-        if (m[0] === DATA) {
-          if (!winDown) openWindow();
-          winDown?.([[DATA, m[1]]]);
-        } else if (m[0] === COMPLETE) {
-          closeWindow();
-          a.down([[COMPLETE]]);
-        } else if (m[0] === ERROR) {
-          winDown?.([m]);
-          winDown = void 0;
-          a.down([m]);
-        }
-      }
-    });
-    const notUnsub = notifier.subscribe((msgs) => {
-      for (const m of msgs) {
-        if (m[0] === DATA) {
-          closeWindow();
-          openWindow();
-        }
-      }
+    batch(() => {
+      for (const n of channelNodes) n.down([[COMPLETE]]);
     });
-    return () => {
-      srcUnsub();
-      notUnsub();
-      closeWindow();
-    };
-  }, operatorOpts(opts));
-}
-function interval(periodMs, opts) {
-  return producer((a, ctx) => {
-    if (!("n" in ctx.store)) ctx.store.n = 0;
-    const id = setInterval(() => {
-      a.emit(ctx.store.n);
-      ctx.store.n = ctx.store.n + 1;
-    }, periodMs);
-    return () => clearInterval(id);
-  }, operatorOpts(opts));
-}
-function repeat(source, count, opts) {
-  if (count <= 0) throw new RangeError("repeat expects count > 0");
-  return producer((a) => {
-    let remaining = count;
-    let innerU;
-    const start = () => {
-      innerU?.();
-      innerU = source.subscribe((msgs) => {
-        let completed = false;
-        const fwd = [];
-        for (const m of msgs) {
-          if (m[0] === COMPLETE) completed = true;
-          else fwd.push(m);
-        }
-        if (fwd.length > 0) a.down(fwd);
-        if (completed) {
-          innerU?.();
-          innerU = void 0;
-          remaining -= 1;
-          if (remaining > 0) start();
-          else a.down([[COMPLETE]]);
-        }
-      });
-    };
-    start();
-    return () => {
-      innerU?.();
-    };
-  }, operatorOpts(opts));
-}
-function pausable(source, opts) {
-  return node(
-    [source],
-    (data, a) => {
-      const batch0 = data[0];
-      if (batch0 == null || batch0.length === 0) {
-        a.down([[RESOLVED]]);
-        return;
-      }
-      for (const v of batch0) a.emit(v);
-    },
-    operatorOpts(opts)
-  );
-}
-function rescue(source, recover, opts) {
-  return producer((a) => {
-    const srcUnsub = source.subscribe((msgs) => {
-      for (const m of msgs) {
-        if (m[0] === DATA) {
-          a.emit(m[1]);
-        } else if (m[0] === ERROR) {
-          try {
-            a.emit(recover(m[1]));
-          } catch (recoverErr) {
-            a.down([[ERROR, recoverErr]]);
-          }
-        } else if (m[0] === COMPLETE) {
-          a.down([[COMPLETE]]);
+    finishCleanup();
+  };
+  const ret = register(bundle);
+  cleanup = typeof ret === "function" ? ret : void 0;
+  const dispose = () => {
+    if (!active) return;
+    active = false;
+    batch(() => {
+      for (const n of channelNodes) {
+        try {
+          n.down([[COMPLETE]]);
+        } catch {
         }
       }
     });
-    return () => {
-      srcUnsub();
-    };
-  }, operatorOpts(opts));
-}
-function valve(source, control, opts) {
-  return node(
-    [source, control],
-    (data, a, ctx) => {
-      const batch1 = data[1];
-      const controlValue = batch1 != null && batch1.length > 0 ? batch1.at(-1) : ctx.prevData[1];
-      if (!controlValue) {
-        a.down([[RESOLVED]]);
-        return;
-      }
-      const batch0 = data[0];
-      if (batch0 != null && batch0.length > 0) {
-        for (const v of batch0) a.emit(v);
-        return;
-      }
-      if (batch1 != null && batch1.length > 0 && ctx.prevData[0] !== void 0) {
-        a.emit(ctx.prevData[0]);
-        return;
-      }
-      a.down([[RESOLVED]]);
-    },
-    operatorOpts(opts)
-  );
+    finishCleanup();
+  };
+  return Object.assign(nodes, { dispose });
 }
-var combineLatest = combine;
-var debounceTime = debounce;
-var throttleTime = throttle;
-var catchError = rescue;
 
 // src/extra/reactive-sink.ts
 var BackpressureBuffer = class {
@@ -2206,10 +845,10 @@ function reactiveSink(source, config) {
 }
 
 // src/extra/resilience.ts
-function operatorOpts2(opts) {
+function operatorOpts(opts) {
   return { describeKind: "derived", ...opts };
 }
-function clampNonNegative2(value) {
+function clampNonNegative(value) {
   return value < 0 ? 0 : value;
 }
 function msgVal(m) {
@@ -2299,7 +938,7 @@ function retry(source, opts) {
       };
     },
     {
-      ...operatorOpts2(),
+      ...operatorOpts(),
       initial: source.cache
     }
   );
@@ -2389,7 +1028,7 @@ function retrySource(factory, opts) {
       };
     },
     {
-      ...operatorOpts2(),
+      ...operatorOpts(),
       initial: opts?.initial
     }
   );
@@ -2402,7 +1041,7 @@ var CircuitOpenError = class extends Error {
 };
 function circuitBreaker(options) {
   const threshold = Math.max(1, options?.failureThreshold ?? 5);
-  const baseCooldownNs = clampNonNegative2(options?.cooldownNs ?? 30 * NS_PER_SEC);
+  const baseCooldownNs = clampNonNegative(options?.cooldownNs ?? 30 * NS_PER_SEC);
   const cooldownStrategy = options?.cooldown ?? null;
   const halfOpenMax = Math.max(1, options?.halfOpenMax ?? 1);
   const now = options?.now ?? monotonicNs;
@@ -2516,7 +1155,7 @@ function withBreaker(breaker, options) {
         return unsub;
       },
       {
-        ...operatorOpts2(),
+        ...operatorOpts(),
         meta: { breakerState: breaker.state },
         completeWhenDepsComplete: false,
         initial: source.cache
@@ -2634,7 +1273,7 @@ function rateLimiter(source, opts) {
       };
     },
     {
-      ...operatorOpts2(),
+      ...operatorOpts(),
       initial: source.cache
     }
   );
@@ -2681,7 +1320,7 @@ function withStatus(src, options) {
       return unsub;
     },
     {
-      ...operatorOpts2(),
+      ...operatorOpts(),
       meta: { status: initialStatus, error: null },
       completeWhenDepsComplete: false,
       resubscribable: true,
@@ -2750,7 +1389,7 @@ function fallback(source, fb) {
       };
     },
     {
-      ...operatorOpts2(),
+      ...operatorOpts(),
       initial: source.cache
     }
   );
@@ -2805,7 +1444,7 @@ function timeout(source, timeoutNs) {
       };
     },
     {
-      ...operatorOpts2(),
+      ...operatorOpts(),
       initial: source.cache
     }
   );
@@ -5060,443 +3699,81 @@ function cascadingCache(tiers, opts) {
                 if (clearFn) fireAndForget(clearFn.call(tiers[j], key));
               } catch {
               }
-            }
-          }
-          nd.down([[TEARDOWN]]);
-        }
-        entries.delete(key);
-      }
-    }
-  }
-  return {
-    load(key) {
-      const existing = entries.get(key);
-      if (existing) {
-        policy?.touch(key);
-        return existing;
-      }
-      if (policy && maxSize > 0 && policy.size() >= maxSize) {
-        evictIfNeeded();
-      }
-      const nd = state(void 0);
-      entries.set(key, nd);
-      policy?.insert(key);
-      cascade(key, nd);
-      return nd;
-    },
-    save(key, value) {
-      if (writeThrough) {
-        for (const tier of tiers) {
-          try {
-            fireAndForget(tier.save(key, value));
-          } catch {
-          }
-        }
-      } else if (tiers[0]) {
-        try {
-          fireAndForget(tiers[0].save(key, value));
-        } catch {
-        }
-      }
-      const existing = entries.get(key);
-      if (existing) {
-        existing.down([[DATA, value]]);
-        policy?.touch(key);
-      } else {
-        if (policy && maxSize > 0 && policy.size() >= maxSize) {
-          evictIfNeeded();
-        }
-        const nd = state(value);
-        entries.set(key, nd);
-        policy?.insert(key);
-      }
-    },
-    invalidate(key) {
-      const existing = entries.get(key);
-      if (existing) cascade(key, existing);
-    },
-    delete(key) {
-      policy?.delete(key);
-      const nd = entries.get(key);
-      if (nd) nd.down([[TEARDOWN]]);
-      entries.delete(key);
-      for (const tier of tiers) {
-        try {
-          const clearFn = tier.clear;
-          if (clearFn) fireAndForget(clearFn.call(tier, key));
-        } catch {
-        }
-      }
-    },
-    has(key) {
-      return entries.has(key);
-    },
-    get size() {
-      return entries.size;
-    }
-  };
-}
-
-// src/extra/reactive-map.ts
-var NativeMapBackend = class {
-  _version = 0;
-  _store = /* @__PURE__ */ new Map();
-  _maxSize;
-  _defaultTtl;
-  constructor(options = {}) {
-    const { maxSize, defaultTtl } = options;
-    if (maxSize !== void 0 && maxSize < 1) {
-      throw new RangeError("maxSize must be >= 1");
-    }
-    if (defaultTtl !== void 0 && defaultTtl <= 0) {
-      throw new RangeError("defaultTtl must be positive");
-    }
-    this._maxSize = maxSize;
-    this._defaultTtl = defaultTtl;
-  }
-  get version() {
-    return this._version;
-  }
-  get size() {
-    return this._store.size;
-  }
-  has(key) {
-    const e = this._store.get(key);
-    if (e === void 0) return false;
-    if (this._isExpired(e)) {
-      this._store.delete(key);
-      this._version += 1;
-      return false;
-    }
-    this._touchLru(key, e);
-    return true;
-  }
-  get(key) {
-    const e = this._store.get(key);
-    if (e === void 0) return void 0;
-    if (this._isExpired(e)) {
-      this._store.delete(key);
-      this._version += 1;
-      return void 0;
-    }
-    this._touchLru(key, e);
-    return e.value;
-  }
-  set(key, value, ttl) {
-    const expiresAt = this._resolveExpiresAt(ttl);
-    if (this._store.has(key)) this._store.delete(key);
-    this._store.set(key, { value, expiresAt });
-    this._evictLruWhileOver();
-    this._version += 1;
-  }
-  setMany(entries, ttl) {
-    const expiresAt = this._resolveExpiresAt(ttl);
-    let count = 0;
-    try {
-      for (const [key, value] of entries) {
-        if (this._store.has(key)) this._store.delete(key);
-        this._store.set(key, { value, expiresAt });
-        count += 1;
-      }
-    } finally {
-      if (count > 0) {
-        this._evictLruWhileOver();
-        this._version += 1;
-      }
-    }
-  }
-  delete(key) {
-    const had = this._store.delete(key);
-    if (had) this._version += 1;
-    return had;
-  }
-  deleteMany(keys) {
-    let removed = 0;
-    try {
-      for (const k of keys) {
-        if (this._store.delete(k)) removed += 1;
-      }
-    } finally {
-      if (removed > 0) this._version += 1;
-    }
-    return removed;
-  }
-  clear() {
-    const n = this._store.size;
-    if (n === 0) return 0;
-    this._store.clear();
-    this._version += 1;
-    return n;
-  }
-  pruneExpired() {
-    const now = monotonicNs();
-    let removed = 0;
-    for (const [k, e] of this._store) {
-      if (this._isExpired(e, now)) {
-        this._store.delete(k);
-        removed += 1;
-      }
-    }
-    if (removed > 0) this._version += 1;
-    return removed;
-  }
-  toMap() {
-    const now = monotonicNs();
-    const out = /* @__PURE__ */ new Map();
-    for (const [k, e] of this._store) {
-      if (!this._isExpired(e, now)) out.set(k, e.value);
-    }
-    return out;
-  }
-  _resolveExpiresAt(ttl) {
-    const effectiveTtl = ttl ?? this._defaultTtl;
-    if (effectiveTtl === void 0) return void 0;
-    if (!Number.isFinite(effectiveTtl) || effectiveTtl <= 0) {
-      throw new RangeError(
-        `MapBackend: ttl must be a positive finite number (got ${effectiveTtl})`
-      );
-    }
-    return monotonicNs() + effectiveTtl * 1e9;
-  }
-  _isExpired(e, now) {
-    if (e.expiresAt === void 0) return false;
-    return (now ?? monotonicNs()) >= e.expiresAt;
-  }
-  _touchLru(key, entry) {
-    this._store.delete(key);
-    this._store.set(key, entry);
-  }
-  _evictLruWhileOver() {
-    if (this._maxSize === void 0) return;
-    while (this._store.size > this._maxSize) {
-      const first2 = this._store.keys().next().value;
-      if (first2 === void 0) break;
-      this._store.delete(first2);
-    }
-  }
-};
-function reactiveMap(options = {}) {
-  const { name, maxSize, defaultTtl, versioning, backend: userBackend } = options;
-  const backend = userBackend ?? new NativeMapBackend({ maxSize, defaultTtl });
-  const n = state(backend.toMap(), {
-    name,
-    describeKind: "state",
-    equals: (a, b) => a === b,
-    ...versioning != null ? { versioning } : {}
-  });
-  function pushSnapshot() {
-    const map2 = backend.toMap();
-    batch(() => {
-      n.down([[DIRTY]]);
-      n.down([[DATA, map2]]);
-    });
-  }
-  function wrapMutation(op) {
-    const prev = backend.version;
-    try {
-      return op();
-    } finally {
-      if (backend.version !== prev) pushSnapshot();
-    }
-  }
-  return {
-    entries: n,
-    has(key) {
-      return wrapMutation(() => backend.has(key));
-    },
-    get(key) {
-      return wrapMutation(() => backend.get(key));
-    },
-    set(key, value, opts) {
-      wrapMutation(() => backend.set(key, value, opts?.ttl));
-    },
-    setMany(entries, opts) {
-      wrapMutation(() => backend.setMany(entries, opts?.ttl));
-    },
-    delete(key) {
-      wrapMutation(() => backend.delete(key));
-    },
-    deleteMany(keys) {
-      wrapMutation(() => backend.deleteMany(keys));
-    },
-    clear() {
-      wrapMutation(() => backend.clear());
-    },
-    pruneExpired() {
-      wrapMutation(() => backend.pruneExpired());
-    },
-    /**
-     * Current raw entry count — O(1), **pure read**. May include
-     * not-yet-pruned expired entries on TTL maps until the next mutation
-     * or an explicit `pruneExpired()` / `has` / `get` triggers a prune.
-     *
-     * Previously this getter ran `pruneExpired()` inline and emitted a
-     * snapshot as a side effect — that violated spec §5.8 "no
-     * side-effectful reads" and created a re-entrancy hazard when a
-     * subscriber to `entries` read `.size` from its own callback. D2(a).
-     *
-     * For a live count that excludes expired entries, call
-     * `bundle.pruneExpired()` first.
-     */
-    get size() {
-      return backend.size;
-    },
-    dispose() {
-    }
-  };
-}
-
-// src/extra/composite.ts
-function isNodeLike(value) {
-  return typeof value === "object" && value !== null && "cache" in value && typeof value.subscribe === "function";
-}
-function verifiable(source, verifyFn, opts) {
-  const sourceNode = fromAny(source);
-  const hasSourceVersioning = sourceNode.v != null;
-  const verified = state(opts?.initialVerified ?? null, {
-    ...hasSourceVersioning ? { meta: { sourceVersion: null } } : {}
-  });
-  const hasTrigger = opts?.trigger !== void 0 && opts.trigger !== null;
-  let triggerNode = null;
-  if (hasTrigger && opts?.autoVerify) {
-    triggerNode = merge(fromAny(opts.trigger), sourceNode);
-  } else if (hasTrigger) {
-    triggerNode = fromAny(opts.trigger);
-  } else if (opts?.autoVerify) {
-    triggerNode = sourceNode;
-  }
-  if (triggerNode !== null) {
-    let verifyStream;
-    if (triggerNode === sourceNode) {
-      verifyStream = switchMap(sourceNode, (src) => verifyFn(src));
-    } else {
-      let latestSource = sourceNode.cache;
-      sourceNode.subscribe((msgs) => {
-        for (const m of msgs) {
-          if (m[0] === DATA) latestSource = m[1];
-        }
-      });
-      verifyStream = switchMap(triggerNode, () => verifyFn(latestSource));
-    }
-    forEach(verifyStream, (value) => {
-      batch(() => {
-        verified.down([[DATA, value]]);
-        if (hasSourceVersioning) {
-          const sv = sourceNode.v;
-          if (sv != null) {
-            verified.meta.sourceVersion.down([[DATA, { id: sv.id, version: sv.version }]]);
-          }
-        }
-      });
-    });
-  }
-  return { node: sourceNode, verified, trigger: triggerNode };
-}
-function keepalive2(node2) {
-  node2.subscribe(() => void 0);
-}
-function mapFromSnapshot(snapshot) {
-  if (snapshot instanceof Map) return snapshot;
-  return /* @__PURE__ */ new Map();
-}
-function applyExtraction(store, extraction) {
-  if (!Array.isArray(extraction.upsert)) {
-    throw new TypeError("distill extraction requires upsert: Array<{ key, value }>");
-  }
-  batch(() => {
-    for (const { key, value } of extraction.upsert) {
-      store.set(key, value);
-    }
-    for (const key of extraction.remove ?? []) {
-      store.delete(key);
-    }
-  });
-}
-function distill(source, extractFn, opts) {
-  const sourceNode = fromAny(source);
-  const store = reactiveMap(opts.mapOptions ?? {});
-  const budget = opts.budget ?? 2e3;
-  const hasContext = opts.context !== void 0 && opts.context !== null;
-  const contextNode = hasContext ? fromAny(opts.context) : state(null);
-  let latestStore = mapFromSnapshot(store.entries.cache);
-  store.entries.subscribe((msgs) => {
-    for (const m of msgs) {
-      if (m[0] === DATA) latestStore = mapFromSnapshot(m[1]);
-    }
-  });
-  const extractionStream = switchMap(sourceNode, (raw) => extractFn(raw, latestStore));
-  forEach(extractionStream, (extraction) => {
-    applyExtraction(store, extraction);
-  });
-  if (opts.evict) {
-    const verdictUnsubs = /* @__PURE__ */ new Map();
-    const evictionKeys = derived([store.entries], ([snapshot]) => {
-      const out = [];
-      const entries = mapFromSnapshot(snapshot);
-      for (const key of verdictUnsubs.keys()) {
-        if (!entries.has(key)) {
-          verdictUnsubs.get(key)();
-          verdictUnsubs.delete(key);
+            }
+          }
+          nd.down([[TEARDOWN]]);
         }
+        entries.delete(key);
       }
-      for (const [key, mem] of entries) {
-        const verdict = opts.evict(key, mem);
-        if (isNodeLike(verdict)) {
-          if (!verdictUnsubs.has(key)) {
-            const unsub = forEach(verdict, (val) => {
-              if (val === true && store.has(key)) {
-                store.delete(key);
-              }
-            });
-            verdictUnsubs.set(key, unsub);
+    }
+  }
+  return {
+    load(key) {
+      const existing = entries.get(key);
+      if (existing) {
+        policy?.touch(key);
+        return existing;
+      }
+      if (policy && maxSize > 0 && policy.size() >= maxSize) {
+        evictIfNeeded();
+      }
+      const nd = state(void 0);
+      entries.set(key, nd);
+      policy?.insert(key);
+      cascade(key, nd);
+      return nd;
+    },
+    save(key, value) {
+      if (writeThrough) {
+        for (const tier of tiers) {
+          try {
+            fireAndForget(tier.save(key, value));
+          } catch {
           }
-          continue;
         }
-        if (typeof verdict === "boolean") {
-          if (verdict) out.push(key);
-          continue;
+      } else if (tiers[0]) {
+        try {
+          fireAndForget(tiers[0].save(key, value));
+        } catch {
         }
-        throw new TypeError("distill evict() must return boolean or Node<boolean>");
       }
-      return out;
-    });
-    forEach(evictionKeys, (keys) => {
-      for (const key of keys) store.delete(key);
-    });
-  }
-  const hasConsolidateTrigger = opts.consolidateTrigger !== void 0 && opts.consolidateTrigger !== null;
-  if (opts.consolidate && hasConsolidateTrigger) {
-    const consolidateTriggerNode = fromAny(opts.consolidateTrigger);
-    const consolidationStream = switchMap(
-      consolidateTriggerNode,
-      () => opts.consolidate(latestStore)
-    );
-    forEach(consolidationStream, (extraction) => {
-      applyExtraction(store, extraction);
-    });
-  }
-  const compact = derived([store.entries, contextNode], ([snapshot, context]) => {
-    const entries = [...mapFromSnapshot(snapshot).entries()].map(([key, value]) => ({
-      key,
-      value,
-      score: opts.score(value, context),
-      cost: opts.cost(value)
-    }));
-    entries.sort((a, b) => b.score - a.score);
-    const packed = [];
-    let remaining = budget;
-    for (const item of entries) {
-      if (item.cost <= remaining) {
-        packed.push({ key: item.key, value: item.value, score: item.score });
-        remaining -= item.cost;
+      const existing = entries.get(key);
+      if (existing) {
+        existing.down([[DATA, value]]);
+        policy?.touch(key);
+      } else {
+        if (policy && maxSize > 0 && policy.size() >= maxSize) {
+          evictIfNeeded();
+        }
+        const nd = state(value);
+        entries.set(key, nd);
+        policy?.insert(key);
+      }
+    },
+    invalidate(key) {
+      const existing = entries.get(key);
+      if (existing) cascade(key, existing);
+    },
+    delete(key) {
+      policy?.delete(key);
+      const nd = entries.get(key);
+      if (nd) nd.down([[TEARDOWN]]);
+      entries.delete(key);
+      for (const tier of tiers) {
+        try {
+          const clearFn = tier.clear;
+          if (clearFn) fireAndForget(clearFn.call(tier, key));
+        } catch {
+        }
       }
+    },
+    has(key) {
+      return entries.has(key);
+    },
+    get size() {
+      return entries.size;
     }
-    return packed;
-  });
-  const size = derived([store.entries], ([snapshot]) => mapFromSnapshot(snapshot).size);
-  keepalive2(compact);
-  keepalive2(size);
-  return { store, compact, size };
+  };
 }
 
 // src/extra/pubsub.ts
@@ -5792,139 +4069,118 @@ function reactiveIndex(options = {}) {
   };
 }
 
-// src/extra/reactive-list.ts
-var NativeListBackend = class {
-  _version = 0;
-  _buf;
-  constructor(initial) {
-    this._buf = initial ? [...initial] : [];
-  }
-  get version() {
-    return this._version;
-  }
-  get size() {
-    return this._buf.length;
-  }
-  at(index) {
-    if (!Number.isInteger(index)) return void 0;
-    const i = index >= 0 ? index : this._buf.length + index;
-    if (i < 0 || i >= this._buf.length) return void 0;
-    return this._buf[i];
-  }
-  append(value) {
-    this._buf.push(value);
-    this._version += 1;
-  }
-  appendMany(values) {
-    if (values.length === 0) return;
-    const oldLen = this._buf.length;
-    this._buf.length = oldLen + values.length;
-    for (let i = 0; i < values.length; i++) {
-      this._buf[oldLen + i] = values[i];
-    }
-    this._version += 1;
-  }
-  insert(index, value) {
-    if (!Number.isInteger(index) || index < 0 || index > this._buf.length) {
-      throw new RangeError(`insert: index ${index} out of range [0, ${this._buf.length}]`);
-    }
-    this._buf.splice(index, 0, value);
-    this._version += 1;
-  }
-  insertMany(index, values) {
-    if (!Number.isInteger(index) || index < 0 || index > this._buf.length) {
-      throw new RangeError(`insertMany: index ${index} out of range [0, ${this._buf.length}]`);
-    }
-    if (values.length === 0) return;
-    this._buf.splice(index, 0, ...values);
-    this._version += 1;
-  }
-  pop(index) {
-    if (this._buf.length === 0) {
-      throw new RangeError("pop from empty list");
-    }
-    if (!Number.isInteger(index)) {
-      throw new RangeError(`pop: index ${index} must be an integer`);
-    }
-    const i = index >= 0 ? index : this._buf.length + index;
-    if (i < 0 || i >= this._buf.length) {
-      throw new RangeError(`pop: index ${index} out of range`);
-    }
-    const [v] = this._buf.splice(i, 1);
-    this._version += 1;
-    return v;
-  }
-  clear() {
-    const n = this._buf.length;
-    if (n === 0) return 0;
-    this._buf.length = 0;
-    this._version += 1;
-    return n;
-  }
-  toArray() {
-    return [...this._buf];
-  }
-};
-function reactiveList(initial, options = {}) {
-  const { name, versioning, backend: userBackend } = options;
-  const backend = userBackend ?? new NativeListBackend(initial);
-  const items = state(backend.toArray(), {
-    name,
-    describeKind: "state",
-    equals: (a, b) => a === b,
-    ...versioning != null ? { versioning } : {}
-  });
-  function pushSnapshot() {
-    const snapshot = backend.toArray();
-    batch(() => {
-      items.down([[DIRTY]]);
-      items.down([[DATA, snapshot]]);
-    });
+// src/extra/sources-fs.ts
+import { existsSync, watch } from "node:fs";
+import { resolve as resolvePath } from "node:path";
+function sourceOpts3(opts) {
+  return { describeKind: "producer", ...opts };
+}
+function fromFSWatch(paths, opts) {
+  const list = Array.isArray(paths) ? paths : [paths];
+  if (list.length === 0) {
+    throw new RangeError("fromFSWatch expects at least one path");
   }
-  function wrapMutation(op) {
-    const prev = backend.version;
+  const { recursive = true, debounce: debounce2 = 100, include, exclude, ...rest } = opts ?? {};
+  const includePatterns = include?.map(globToRegExp) ?? [];
+  const excludePatterns = (exclude ?? ["**/node_modules/**", "**/.git/**", "**/dist/**"]).map(
+    globToRegExp
+  );
+  return producer((a) => {
+    const pending = /* @__PURE__ */ new Map();
+    const watchers = [];
+    let stopped = false;
+    let terminalEmitted = false;
+    let generation = 0;
+    const closeWatchers = () => {
+      for (const watcher of watchers.splice(0)) watcher.close();
+    };
+    const emitError = (err) => {
+      if (terminalEmitted) return;
+      terminalEmitted = true;
+      stopped = true;
+      if (timer !== void 0) clearTimeout(timer);
+      timer = void 0;
+      pending.clear();
+      closeWatchers();
+      a.down([[ERROR, err]]);
+    };
+    let timer;
+    const flush = (token) => {
+      timer = void 0;
+      if (stopped || terminalEmitted) return;
+      if (pending.size === 0) return;
+      const batchMessages = [];
+      for (const evt of pending.values()) batchMessages.push([DATA, evt]);
+      pending.clear();
+      if (stopped || terminalEmitted || token !== generation) return;
+      a.down(batchMessages);
+    };
     try {
-      return op();
-    } finally {
-      if (backend.version !== prev) pushSnapshot();
-    }
-  }
-  return {
-    items,
-    get size() {
-      return backend.size;
-    },
-    at(index) {
-      return backend.at(index);
-    },
-    append(value) {
-      wrapMutation(() => backend.append(value));
-    },
-    appendMany(values) {
-      wrapMutation(() => backend.appendMany(values));
-    },
-    insert(index, value) {
-      wrapMutation(() => backend.insert(index, value));
-    },
-    insertMany(index, values) {
-      wrapMutation(() => backend.insertMany(index, values));
-    },
-    pop(index = -1) {
-      return wrapMutation(() => backend.pop(index));
-    },
-    clear() {
-      wrapMutation(() => backend.clear());
-    },
-    dispose() {
+      for (const basePath of list) {
+        const watcher = watch(
+          basePath,
+          { recursive },
+          (eventType, fileName) => {
+            if (stopped || terminalEmitted) return;
+            if (fileName == null) return;
+            const rel = String(fileName).replaceAll("\\", "/");
+            const abs = resolvePath(basePath, String(fileName));
+            const normalized = abs.replaceAll("\\", "/");
+            const root = resolvePath(basePath).replaceAll("\\", "/");
+            const relForMatch = rel.startsWith("./") ? rel.slice(2) : rel;
+            const included = includePatterns.length === 0 || matchesAnyPattern(normalized, includePatterns) || matchesAnyPattern(relForMatch, includePatterns);
+            if (!included) return;
+            const excluded = matchesAnyPattern(normalized, excludePatterns) || matchesAnyPattern(relForMatch, excludePatterns);
+            if (excluded) return;
+            let kind = "change";
+            if (eventType === "rename") {
+              try {
+                kind = existsSync(normalized) ? "create" : "delete";
+              } catch {
+                kind = "rename";
+              }
+            }
+            pending.set(normalized, {
+              type: kind,
+              path: normalized,
+              root,
+              relative_path: relForMatch,
+              timestamp_ns: wallClockNs()
+            });
+            if (timer !== void 0) clearTimeout(timer);
+            const token = generation;
+            timer = setTimeout(() => flush(token), debounce2);
+          }
+        );
+        watcher.on("error", (err) => emitError(err));
+        watchers.push(watcher);
+      }
+    } catch (err) {
+      emitError(err);
     }
-  };
+    return () => {
+      stopped = true;
+      generation += 1;
+      if (timer !== void 0) clearTimeout(timer);
+      timer = void 0;
+      closeWatchers();
+      pending.clear();
+    };
+  }, sourceOpts3(rest));
 }
 
 // src/extra/storage.ts
-import { randomBytes } from "crypto";
-import { mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "fs";
-import { basename, dirname, join } from "path";
-import { DatabaseSync } from "sqlite";
+import { randomBytes } from "node:crypto";
+import {
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync
+} from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
 function sortJsonValue(value) {
   if (value === null || typeof value !== "object") return value;
   if (Array.isArray(value)) return value.map(sortJsonValue);
@@ -5949,6 +4205,9 @@ function memoryStorage() {
     },
     clear(key) {
       data.delete(key);
+    },
+    list() {
+      return [...data.keys()].sort();
     }
   };
 }
@@ -5963,16 +4222,54 @@ function dictStorage(storage) {
     },
     clear(key) {
       delete storage[key];
+    },
+    list() {
+      return Object.keys(storage).sort();
     }
   };
 }
 function fileStorage(dir) {
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder("utf-8", { fatal: true });
   const pathFor = (key) => {
-    const safe = key.replace(
-      /[^a-zA-Z0-9_-]/g,
-      (c) => `%${c.charCodeAt(0).toString(16).padStart(2, "0")}`
-    );
-    return join(dir, `${safe}.json`);
+    let out = "";
+    for (const ch of key) {
+      if (ch.length === 1 && /[a-zA-Z0-9_-]/.test(ch)) {
+        out += ch;
+        continue;
+      }
+      for (const byte of encoder.encode(ch)) {
+        out += `%${byte.toString(16).padStart(2, "0")}`;
+      }
+    }
+    return join(dir, `${out}.json`);
+  };
+  const keyFromFilename = (filename) => {
+    if (!filename.endsWith(".json")) return null;
+    const stem = filename.slice(0, -".json".length);
+    const bytes = [];
+    const encodeAscii = (s) => {
+      for (let i2 = 0; i2 < s.length; i2++) bytes.push(s.charCodeAt(i2));
+    };
+    let i = 0;
+    while (i < stem.length) {
+      const ch = stem[i];
+      if (ch === "%" && i + 2 < stem.length) {
+        const hex = stem.slice(i + 1, i + 3);
+        if (/^[0-9a-f]{2}$/i.test(hex)) {
+          bytes.push(Number.parseInt(hex, 16));
+          i += 3;
+          continue;
+        }
+      }
+      encodeAscii(ch);
+      i += 1;
+    }
+    try {
+      return decoder.decode(new Uint8Array(bytes));
+    } catch {
+      return null;
+    }
   };
   return {
     save(key, record) {
@@ -6009,6 +4306,21 @@ function fileStorage(dir) {
       } catch (e) {
         if (e.code !== "ENOENT") throw e;
       }
+    },
+    list() {
+      try {
+        const entries = readdirSync(dir);
+        const keys = [];
+        for (const entry of entries) {
+          if (entry.startsWith(".")) continue;
+          const k = keyFromFilename(entry);
+          if (k !== null) keys.push(k);
+        }
+        return keys.sort();
+      } catch (e) {
+        if (e.code === "ENOENT") return [];
+        throw e;
+      }
     }
   };
 }
@@ -6031,6 +4343,10 @@ function sqliteStorage(path) {
     clear(key) {
       db.prepare(`DELETE FROM graphrefly_checkpoint WHERE k = ?`).run(key);
     },
+    list() {
+      const rows = db.prepare(`SELECT k FROM graphrefly_checkpoint ORDER BY k`).all();
+      return rows.map((r) => r.k);
+    },
     close() {
       try {
         db.close();
@@ -6678,63 +4994,8 @@ function workerSelf(target, opts) {
 }
 
 export {
-  NS_PER_MS,
-  NS_PER_SEC,
-  constant,
-  linear,
-  exponential,
-  fibonacci,
-  decorrelatedJitter,
-  withMaxAttempts,
-  resolveBackoffPreset,
   externalProducer,
   externalBundle,
-  map,
-  filter,
-  scan,
-  reduce,
-  take,
-  skip,
-  takeWhile,
-  takeUntil,
-  first,
-  last,
-  find,
-  elementAt,
-  tap,
-  distinctUntilChanged,
-  pairwise,
-  combine,
-  withLatestFrom,
-  merge,
-  zip,
-  concat,
-  race,
-  switchMap,
-  exhaustMap,
-  concatMap,
-  mergeMap,
-  flatMap,
-  delay,
-  debounce,
-  throttle,
-  sample,
-  audit,
-  buffer,
-  bufferCount,
-  windowCount,
-  bufferTime,
-  windowTime,
-  window,
-  interval,
-  repeat,
-  pausable,
-  rescue,
-  valve,
-  combineLatest,
-  debounceTime,
-  throttleTime,
-  catchError,
   reactiveSink,
   retry,
   retrySource,
@@ -6802,16 +5063,11 @@ export {
   fromKysely,
   lru,
   cascadingCache,
-  NativeMapBackend,
-  reactiveMap,
-  verifiable,
-  distill,
   NativePubSubBackend,
   pubsub,
   NativeIndexBackend,
   reactiveIndex,
-  NativeListBackend,
-  reactiveList,
+  fromFSWatch,
   memoryStorage,
   dictStorage,
   fileStorage,
@@ -6828,4 +5084,4 @@ export {
   workerSelf,
   extra_exports
 };
-//# sourceMappingURL=chunk-IAHGTNOZ.js.map
+//# sourceMappingURL=chunk-BQ6RQQFF.js.map