@graphrefly/graphrefly 0.26.0 → 0.27.0

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

@@ -1,9 +1,76 @@
 import {
-  NativeLogBackend,
   createWatermarkController,
-  reactiveLog,
   toObservable
-} from "./chunk-RB6QPHJ7.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,
@@ -57,7 +124,6 @@ import {
   PAUSE,
   RESOLVED,
   RESUME,
-  START,
   TEARDOWN,
   __export,
   __require
@@ -249,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 };
@@ -406,1392 +379,57 @@ function externalBundle(register, channels, opts) {
       (_a) => {
         activatedCount++;
         return () => {
-          teardownCount++;
-          if (activatedCount > 0 && teardownCount >= activatedCount && teardownCount >= channels.length) {
-            finishCleanup();
-          }
-        };
-      },
-      sourceOpts({ ...chOpts, name })
-    );
-    nodes[ch] = n;
-    channelNodes.push(n);
-  }
-  const bundle = {};
-  for (const ch of channels) {
-    bundle[ch] = (value) => {
-      if (!active) return;
-      nodes[ch].down([[DATA, value]]);
-    };
-  }
-  bundle.error = (err) => {
-    if (!active) return;
-    active = false;
-    batch(() => {
-      for (const n of channelNodes) n.down([[ERROR, err]]);
-    });
-    finishCleanup();
-  };
-  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();
-        }
-      }
-    });
-    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]]);
+          teardownCount++;
+          if (activatedCount > 0 && teardownCount >= activatedCount && teardownCount >= channels.length) {
+            finishCleanup();
           }
-        } else if (m[0] === COMPLETE) {
-          a.down([[COMPLETE]]);
+        };
+      },
+      sourceOpts({ ...chOpts, name })
+    );
+    nodes[ch] = n;
+    channelNodes.push(n);
+  }
+  const bundle = {};
+  for (const ch of channels) {
+    bundle[ch] = (value) => {
+      if (!active) return;
+      nodes[ch].down([[DATA, value]]);
+    };
+  }
+  bundle.error = (err) => {
+    if (!active) return;
+    active = false;
+    batch(() => {
+      for (const n of channelNodes) n.down([[ERROR, err]]);
+    });
+    finishCleanup();
+  };
+  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 {
         }
       }
     });
-    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 {
@@ -2207,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) {
@@ -2300,7 +938,7 @@ function retry(source, opts) {
       };
     },
     {
-      ...operatorOpts2(),
+      ...operatorOpts(),
       initial: source.cache
     }
   );
@@ -2390,7 +1028,7 @@ function retrySource(factory, opts) {
       };
     },
     {
-      ...operatorOpts2(),
+      ...operatorOpts(),
       initial: opts?.initial
     }
   );
@@ -2403,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;
@@ -2517,7 +1155,7 @@ function withBreaker(breaker, options) {
         return unsub;
       },
       {
-        ...operatorOpts2(),
+        ...operatorOpts(),
         meta: { breakerState: breaker.state },
         completeWhenDepsComplete: false,
         initial: source.cache
@@ -2635,7 +1273,7 @@ function rateLimiter(source, opts) {
       };
     },
     {
-      ...operatorOpts2(),
+      ...operatorOpts(),
       initial: source.cache
     }
   );
@@ -2682,7 +1320,7 @@ function withStatus(src, options) {
       return unsub;
     },
     {
-      ...operatorOpts2(),
+      ...operatorOpts(),
       meta: { status: initialStatus, error: null },
       completeWhenDepsComplete: false,
       resubscribable: true,
@@ -2751,7 +1389,7 @@ function fallback(source, fb) {
       };
     },
     {
-      ...operatorOpts2(),
+      ...operatorOpts(),
       initial: source.cache
     }
   );
@@ -2806,7 +1444,7 @@ function timeout(source, timeoutNs) {
       };
     },
     {
-      ...operatorOpts2(),
+      ...operatorOpts(),
       initial: source.cache
     }
   );
@@ -5036,468 +3674,106 @@ function cascadingCache(tiers, opts) {
       if (result !== void 0 && result !== null) {
         nd.down([[DATA, result]]);
         promote(key, result, tierIndex);
-        return;
-      }
-    }
-  }
-  function evictIfNeeded() {
-    if (!policy || maxSize <= 0) return;
-    while (policy.size() >= maxSize) {
-      const victims = policy.evict(1);
-      if (victims.length === 0) break;
-      for (const key of victims) {
-        const nd = entries.get(key);
-        if (nd) {
-          const value = nd.cache;
-          if (nd.status !== "sentinel" && tiers.length > 0) {
-            const lastIndex = tiers.length - 1;
-            try {
-              fireAndForget(tiers[lastIndex].save(key, value));
-            } catch {
-            }
-            for (let j = 0; j < lastIndex; j++) {
-              try {
-                const clearFn = tiers[j].clear;
-                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() {
+        return;
+      }
     }
-  };
-}
-
-// 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 }]]);
+  function evictIfNeeded() {
+    if (!policy || maxSize <= 0) return;
+    while (policy.size() >= maxSize) {
+      const victims = policy.evict(1);
+      if (victims.length === 0) break;
+      for (const key of victims) {
+        const nd = entries.get(key);
+        if (nd) {
+          const value = nd.cache;
+          if (nd.status !== "sentinel" && tiers.length > 0) {
+            const lastIndex = tiers.length - 1;
+            try {
+              fireAndForget(tiers[lastIndex].save(key, value));
+            } catch {
+            }
+            for (let j = 0; j < lastIndex; j++) {
+              try {
+                const clearFn = tiers[j].clear;
+                if (clearFn) fireAndForget(clearFn.call(tiers[j], key));
+              } catch {
+              }
+            }
           }
+          nd.down([[TEARDOWN]]);
         }
-      });
-    });
-  }
-  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]);
+        entries.delete(key);
+      }
     }
-  });
-  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);
-        }
+  }
+  return {
+    load(key) {
+      const existing = entries.get(key);
+      if (existing) {
+        policy?.touch(key);
+        return existing;
       }
-      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);
+      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
@@ -5793,134 +4069,6 @@ 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]]);
-    });
-  }
-  function wrapMutation(op) {
-    const prev = backend.version;
-    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() {
-    }
-  };
-}
-
 // src/extra/sources-fs.ts
 import { existsSync, watch } from "node:fs";
 import { resolve as resolvePath } from "node:path";
@@ -6846,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,
@@ -6970,16 +5063,10 @@ export {
   fromKysely,
   lru,
   cascadingCache,
-  NativeMapBackend,
-  reactiveMap,
-  verifiable,
-  distill,
   NativePubSubBackend,
   pubsub,
   NativeIndexBackend,
   reactiveIndex,
-  NativeListBackend,
-  reactiveList,
   fromFSWatch,
   memoryStorage,
   dictStorage,
@@ -6997,4 +5084,4 @@ export {
   workerSelf,
   extra_exports
 };
-//# sourceMappingURL=chunk-AMCG74RZ.js.map
+//# sourceMappingURL=chunk-BQ6RQQFF.js.map