@graphrefly/graphrefly 0.1.0

package/dist/chunk-VPS7L64N.js

@@ -0,0 +1,4785 @@
+import {
+  bumpVersion,
+  cached,
+  createWatermarkController,
+  empty,
+  escapeRegexChar,
+  firstValueFrom,
+  forEach,
+  fromAny,
+  fromAsyncIter,
+  fromCron,
+  fromEvent,
+  fromFSWatch,
+  fromIter,
+  fromPromise,
+  fromTimer,
+  globToRegExp,
+  logSlice,
+  matchesAnyPattern,
+  matchesCron,
+  never,
+  observeGraph$,
+  observeNode$,
+  of,
+  parseCron,
+  reactiveLog,
+  replay,
+  share,
+  shareReplay,
+  snapshotEqualsVersion,
+  throwError,
+  toArray,
+  toMessages$,
+  toObservable
+} from "./chunk-KWXPDASV.js";
+import {
+  COMPLETE,
+  DATA,
+  DIRTY,
+  ERROR,
+  INVALIDATE,
+  PAUSE,
+  RESOLVED,
+  RESUME,
+  TEARDOWN,
+  __export,
+  __require,
+  batch,
+  derived,
+  dynamicNode,
+  effect,
+  knownMessageTypes,
+  messageTier,
+  monotonicNs,
+  node,
+  producer,
+  state,
+  wallClockNs
+} from "./chunk-5X3LAO3B.js";
+
+// src/extra/index.ts
+var extra_exports = {};
+__export(extra_exports, {
+  CircuitOpenError: () => CircuitOpenError,
+  DictCheckpointAdapter: () => DictCheckpointAdapter,
+  FileCheckpointAdapter: () => FileCheckpointAdapter,
+  MemoryCheckpointAdapter: () => MemoryCheckpointAdapter,
+  NS_PER_MS: () => NS_PER_MS,
+  NS_PER_SEC: () => NS_PER_SEC,
+  SqliteCheckpointAdapter: () => SqliteCheckpointAdapter,
+  audit: () => audit,
+  buffer: () => buffer,
+  bufferCount: () => bufferCount,
+  bufferTime: () => bufferTime,
+  cached: () => cached,
+  catchError: () => catchError,
+  checkpointNodeValue: () => checkpointNodeValue,
+  circuitBreaker: () => circuitBreaker,
+  combine: () => combine,
+  combineLatest: () => combineLatest,
+  concat: () => concat,
+  concatMap: () => concatMap,
+  constant: () => constant,
+  createTransport: () => createTransport,
+  createWatermarkController: () => createWatermarkController,
+  debounce: () => debounce,
+  debounceTime: () => debounceTime,
+  decorrelatedJitter: () => decorrelatedJitter,
+  delay: () => delay,
+  deserializeError: () => deserializeError,
+  distill: () => distill,
+  distinctUntilChanged: () => distinctUntilChanged,
+  elementAt: () => elementAt,
+  empty: () => empty,
+  escapeRegexChar: () => escapeRegexChar,
+  exhaustMap: () => exhaustMap,
+  exponential: () => exponential,
+  fibonacci: () => fibonacci,
+  filter: () => filter,
+  find: () => find,
+  first: () => first,
+  firstValueFrom: () => firstValueFrom,
+  flatMap: () => flatMap,
+  forEach: () => forEach,
+  fromAny: () => fromAny,
+  fromAsyncIter: () => fromAsyncIter,
+  fromCSV: () => fromCSV,
+  fromClickHouseWatch: () => fromClickHouseWatch,
+  fromCron: () => fromCron,
+  fromEvent: () => fromEvent,
+  fromFSWatch: () => fromFSWatch,
+  fromGitHook: () => fromGitHook,
+  fromHTTP: () => fromHTTP,
+  fromIDBRequest: () => fromIDBRequest,
+  fromIDBTransaction: () => fromIDBTransaction,
+  fromIter: () => fromIter,
+  fromKafka: () => fromKafka,
+  fromMCP: () => fromMCP,
+  fromNDJSON: () => fromNDJSON,
+  fromOTel: () => fromOTel,
+  fromPrometheus: () => fromPrometheus,
+  fromPromise: () => fromPromise,
+  fromRedisStream: () => fromRedisStream,
+  fromStatsD: () => fromStatsD,
+  fromSyslog: () => fromSyslog,
+  fromTimer: () => fromTimer,
+  fromWebSocket: () => fromWebSocket,
+  fromWebhook: () => fromWebhook,
+  gate: () => gate,
+  globToRegExp: () => globToRegExp,
+  interval: () => interval,
+  last: () => last,
+  linear: () => linear,
+  logSlice: () => logSlice,
+  map: () => map,
+  matchesAnyPattern: () => matchesAnyPattern,
+  matchesCron: () => matchesCron,
+  merge: () => merge,
+  mergeMap: () => mergeMap,
+  nameToSignal: () => nameToSignal,
+  never: () => never,
+  observeGraph$: () => observeGraph$,
+  observeNode$: () => observeNode$,
+  of: () => of,
+  pairwise: () => pairwise,
+  parseCron: () => parseCron,
+  parsePrometheusText: () => parsePrometheusText,
+  parseStatsD: () => parseStatsD,
+  parseSyslog: () => parseSyslog,
+  pausable: () => pausable,
+  pubsub: () => pubsub,
+  race: () => race,
+  rateLimiter: () => rateLimiter,
+  reactiveIndex: () => reactiveIndex,
+  reactiveList: () => reactiveList,
+  reactiveLog: () => reactiveLog,
+  reactiveMap: () => reactiveMap,
+  reduce: () => reduce,
+  repeat: () => repeat,
+  replay: () => replay,
+  rescue: () => rescue,
+  resolveBackoffPreset: () => resolveBackoffPreset,
+  restoreGraphCheckpoint: () => restoreGraphCheckpoint,
+  restoreGraphCheckpointIndexedDb: () => restoreGraphCheckpointIndexedDb,
+  retry: () => retry,
+  sample: () => sample,
+  saveGraphCheckpoint: () => saveGraphCheckpoint,
+  saveGraphCheckpointIndexedDb: () => saveGraphCheckpointIndexedDb,
+  scan: () => scan,
+  serializeError: () => serializeError,
+  share: () => share,
+  shareReplay: () => shareReplay,
+  signalToName: () => signalToName,
+  skip: () => skip,
+  startWith: () => startWith,
+  switchMap: () => switchMap,
+  take: () => take,
+  takeUntil: () => takeUntil,
+  takeWhile: () => takeWhile,
+  tap: () => tap,
+  throttle: () => throttle,
+  throttleTime: () => throttleTime,
+  throwError: () => throwError,
+  timeout: () => timeout,
+  toArray: () => toArray,
+  toKafka: () => toKafka,
+  toMessages$: () => toMessages$,
+  toObservable: () => toObservable,
+  toRedisStream: () => toRedisStream,
+  toSSE: () => toSSE,
+  toWebSocket: () => toWebSocket,
+  tokenBucket: () => tokenBucket,
+  tokenTracker: () => tokenTracker,
+  verifiable: () => verifiable,
+  window: () => window,
+  windowCount: () => windowCount,
+  windowTime: () => windowTime,
+  withBreaker: () => withBreaker,
+  withLatestFrom: () => withLatestFrom,
+  withMaxAttempts: () => withMaxAttempts,
+  withStatus: () => withStatus,
+  workerBridge: () => workerBridge,
+  workerSelf: () => workerSelf,
+  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/resilience.ts
+function operatorOpts(opts) {
+  return { describeKind: "operator", ...opts };
+}
+function clampNonNegative2(value) {
+  return value < 0 ? 0 : value;
+}
+function msgVal(m) {
+  return m[1];
+}
+function coerceDelayNs(raw) {
+  if (raw === null) return 0;
+  if (typeof raw !== "number" || !Number.isFinite(raw)) {
+    throw new TypeError("backoff strategy must return a finite number or null");
+  }
+  return raw < 0 ? 0 : raw;
+}
+function retry(source, opts) {
+  const count = opts?.count;
+  const backoffOpt = opts?.backoff;
+  const maxRetries = count !== void 0 ? count : backoffOpt === void 0 ? 0 : 2147483647;
+  if (maxRetries < 0) throw new RangeError("retry count must be >= 0");
+  const strategy = backoffOpt === void 0 ? null : typeof backoffOpt === "string" ? resolveBackoffPreset(backoffOpt) : backoffOpt;
+  return producer(
+    (_d, a) => {
+      let attempt = 0;
+      let stopped = false;
+      let prevDelay = null;
+      let unsub;
+      let timer;
+      let timerGen = 0;
+      function cancelTimer() {
+        if (timer !== void 0) {
+          clearTimeout(timer);
+          timer = void 0;
+        }
+      }
+      function disconnectUpstream() {
+        unsub?.();
+        unsub = void 0;
+      }
+      function scheduleRetryOrFinish(err) {
+        if (stopped) return;
+        if (attempt >= maxRetries) {
+          disconnectUpstream();
+          a.down([[ERROR, err]]);
+          return;
+        }
+        const raw = strategy === null ? 0 : strategy(attempt, err, prevDelay);
+        const delayNs = coerceDelayNs(raw === void 0 ? null : raw);
+        prevDelay = delayNs;
+        attempt += 1;
+        timerGen += 1;
+        const gen = timerGen;
+        disconnectUpstream();
+        const delayMs = delayNs > 0 ? delayNs / NS_PER_MS : 1;
+        timer = setTimeout(() => {
+          timer = void 0;
+          if (stopped || gen !== timerGen) return;
+          connect();
+        }, delayMs);
+      }
+      function connect() {
+        cancelTimer();
+        disconnectUpstream();
+        unsub = source.subscribe((msgs) => {
+          for (const m of msgs) {
+            const t = m[0];
+            if (t === DIRTY) a.down([[DIRTY]]);
+            else if (t === DATA) {
+              attempt = 0;
+              prevDelay = null;
+              a.emit(m[1]);
+            } else if (t === RESOLVED) a.down([[RESOLVED]]);
+            else if (t === COMPLETE) {
+              disconnectUpstream();
+              a.down([[COMPLETE]]);
+            } else if (t === ERROR) {
+              scheduleRetryOrFinish(msgVal(m));
+              return;
+            } else a.down([m]);
+          }
+        });
+      }
+      connect();
+      return () => {
+        stopped = true;
+        timerGen += 1;
+        cancelTimer();
+        disconnectUpstream();
+      };
+    },
+    {
+      ...operatorOpts(),
+      initial: source.get()
+    }
+  );
+}
+var CircuitOpenError = class extends Error {
+  name = "CircuitOpenError";
+  constructor() {
+    super("Circuit breaker is open");
+  }
+};
+function circuitBreaker(options) {
+  const threshold = Math.max(1, options?.failureThreshold ?? 5);
+  const baseCooldownNs = clampNonNegative2(options?.cooldownNs ?? 30 * NS_PER_SEC);
+  const cooldownStrategy = options?.cooldown ?? null;
+  const halfOpenMax = Math.max(1, options?.halfOpenMax ?? 1);
+  const now = options?.now ?? monotonicNs;
+  let _state = "closed";
+  let _failureCount = 0;
+  let _openCycle = 0;
+  let _lastOpenedAt = 0;
+  let _lastCooldownNs = baseCooldownNs;
+  let _halfOpenAttempts = 0;
+  function getCooldownNs() {
+    if (!cooldownStrategy) return baseCooldownNs;
+    const delayNs = cooldownStrategy(_openCycle);
+    return delayNs !== null ? delayNs : baseCooldownNs;
+  }
+  function transitionToOpen() {
+    _state = "open";
+    _lastCooldownNs = getCooldownNs();
+    _lastOpenedAt = now();
+    _halfOpenAttempts = 0;
+  }
+  const breaker = {
+    canExecute() {
+      if (_state === "closed") return true;
+      if (_state === "open") {
+        const elapsed = now() - _lastOpenedAt;
+        if (elapsed >= _lastCooldownNs) {
+          _state = "half-open";
+          _halfOpenAttempts = 1;
+          return true;
+        }
+        return false;
+      }
+      if (_halfOpenAttempts < halfOpenMax) {
+        _halfOpenAttempts++;
+        return true;
+      }
+      return false;
+    },
+    recordSuccess() {
+      if (_state === "half-open") {
+        _state = "closed";
+        _failureCount = 0;
+        _openCycle = 0;
+      } else if (_state === "closed") {
+        _failureCount = 0;
+      }
+    },
+    recordFailure(_error) {
+      if (_state === "half-open") {
+        _openCycle++;
+        transitionToOpen();
+        return;
+      }
+      if (_state === "closed") {
+        _failureCount++;
+        if (_failureCount >= threshold) {
+          transitionToOpen();
+        }
+      }
+    },
+    get state() {
+      return _state;
+    },
+    get failureCount() {
+      return _failureCount;
+    },
+    reset() {
+      _state = "closed";
+      _failureCount = 0;
+      _openCycle = 0;
+      _halfOpenAttempts = 0;
+    }
+  };
+  return breaker;
+}
+function withBreaker(breaker, options) {
+  const onOpen = options?.onOpen ?? "skip";
+  return (source) => {
+    const wrapped = node(
+      [],
+      (_deps, a) => {
+        function syncState() {
+          wrapped.meta.breakerState.down([[DATA, breaker.state]]);
+        }
+        const unsub = source.subscribe((msgs) => {
+          for (const m of msgs) {
+            const t = m[0];
+            if (t === DIRTY) a.down([[DIRTY]]);
+            else if (t === DATA) {
+              if (breaker.canExecute()) {
+                syncState();
+                a.emit(m[1]);
+              } else {
+                syncState();
+                if (onOpen === "error") a.down([[ERROR, new CircuitOpenError()]]);
+                else a.down([[RESOLVED]]);
+              }
+            } else if (t === RESOLVED) a.down([[RESOLVED]]);
+            else if (t === COMPLETE) {
+              breaker.recordSuccess();
+              syncState();
+              a.down([[COMPLETE]]);
+            } else if (t === ERROR) {
+              breaker.recordFailure(msgVal(m));
+              syncState();
+              a.down([m]);
+            } else a.down([m]);
+          }
+        });
+        syncState();
+        return unsub;
+      },
+      {
+        ...operatorOpts(),
+        meta: { breakerState: breaker.state },
+        completeWhenDepsComplete: false,
+        initial: source.get()
+      }
+    );
+    return { node: wrapped, breakerState: wrapped.meta.breakerState };
+  };
+}
+function tokenBucket(capacity, refillPerSecond) {
+  if (capacity <= 0) throw new RangeError("capacity must be > 0");
+  if (refillPerSecond < 0) throw new RangeError("refillPerSecond must be >= 0");
+  let tokens = capacity;
+  let updatedAt = monotonicNs();
+  function refill(now) {
+    if (refillPerSecond > 0) {
+      const elapsedNs = now - updatedAt;
+      tokens = Math.min(capacity, tokens + elapsedNs / NS_PER_SEC * refillPerSecond);
+    }
+    updatedAt = now;
+  }
+  return {
+    available() {
+      refill(monotonicNs());
+      return tokens;
+    },
+    tryConsume(cost = 1) {
+      if (cost <= 0) return true;
+      const now = monotonicNs();
+      refill(now);
+      if (tokens >= cost) {
+        tokens -= cost;
+        return true;
+      }
+      return false;
+    }
+  };
+}
+function tokenTracker(capacity, refillPerSecond) {
+  return tokenBucket(capacity, refillPerSecond);
+}
+function rateLimiter(source, maxEvents, windowNs) {
+  if (maxEvents <= 0) throw new RangeError("maxEvents must be > 0");
+  if (windowNs <= 0) throw new RangeError("windowNs must be > 0");
+  return producer(
+    (_d, a) => {
+      const times = [];
+      const pending = [];
+      let timer;
+      let timerGen = 0;
+      function cancelTimer() {
+        if (timer !== void 0) {
+          clearTimeout(timer);
+          timer = void 0;
+        }
+      }
+      function prune(now) {
+        const boundary = now - windowNs;
+        while (times.length > 0 && times[0] <= boundary) times.shift();
+      }
+      function tryEmit() {
+        while (pending.length > 0) {
+          const now = monotonicNs();
+          prune(now);
+          if (times.length < maxEvents) {
+            times.push(now);
+            a.emit(pending.shift());
+          } else {
+            const oldest = times[0];
+            cancelTimer();
+            timerGen += 1;
+            const gen = timerGen;
+            const delayNs = Math.max(0, oldest + windowNs - monotonicNs());
+            timer = setTimeout(() => {
+              timer = void 0;
+              if (gen !== timerGen) return;
+              tryEmit();
+            }, delayNs / NS_PER_MS);
+            return;
+          }
+        }
+      }
+      const unsub = source.subscribe((msgs) => {
+        for (const m of msgs) {
+          const t = m[0];
+          if (t === DIRTY) a.down([[DIRTY]]);
+          else if (t === DATA) {
+            pending.push(m[1]);
+            tryEmit();
+          } else if (t === RESOLVED) a.down([[RESOLVED]]);
+          else if (t === COMPLETE) {
+            timerGen += 1;
+            cancelTimer();
+            pending.length = 0;
+            times.length = 0;
+            a.down([[COMPLETE]]);
+          } else if (t === ERROR) {
+            timerGen += 1;
+            cancelTimer();
+            pending.length = 0;
+            times.length = 0;
+            a.down([m]);
+          } else a.down([m]);
+        }
+      });
+      return () => {
+        timerGen += 1;
+        cancelTimer();
+        unsub();
+      };
+    },
+    {
+      ...operatorOpts(),
+      initial: source.get()
+    }
+  );
+}
+function withStatus(src, options) {
+  const initialStatus = options?.initialStatus ?? "pending";
+  const out = node(
+    [],
+    (_deps, a) => {
+      out.meta.status.down([[DATA, initialStatus]]);
+      out.meta.error.down([[DATA, null]]);
+      const unsub = src.subscribe((msgs) => {
+        for (const m of msgs) {
+          const t = m[0];
+          if (t === DIRTY) a.down([[DIRTY]]);
+          else if (t === DATA) {
+            if (out.meta.status.get() === "errored") {
+              batch(() => {
+                out.meta.error.down([[DATA, null]]);
+                out.meta.status.down([[DATA, "active"]]);
+              });
+            } else {
+              out.meta.status.down([[DATA, "active"]]);
+            }
+            a.emit(m[1]);
+          } else if (t === RESOLVED) a.down([[RESOLVED]]);
+          else if (t === COMPLETE) {
+            out.meta.status.down([[DATA, "completed"]]);
+            a.down([[COMPLETE]]);
+          } else if (t === ERROR) {
+            const err = msgVal(m);
+            batch(() => {
+              out.meta.error.down([[DATA, err]]);
+              out.meta.status.down([[DATA, "errored"]]);
+            });
+            a.down([m]);
+          } else a.down([m]);
+        }
+      });
+      return unsub;
+    },
+    {
+      ...operatorOpts(),
+      meta: { status: initialStatus, error: null },
+      completeWhenDepsComplete: false,
+      resubscribable: true,
+      initial: src.get()
+    }
+  );
+  return {
+    node: out,
+    status: out.meta.status,
+    error: out.meta.error
+  };
+}
+
+// src/extra/adapters.ts
+function sourceOpts(opts) {
+  return { describeKind: "producer", ...opts };
+}
+function fromWebSocket(socketOrRegister, opts) {
+  const { parse, closeOnTeardown = false, ...rest } = opts ?? {};
+  return producer((_d, a) => {
+    let active = true;
+    let cleanup;
+    const runCleanup = () => {
+      const fn = cleanup;
+      cleanup = void 0;
+      fn?.();
+    };
+    const terminate = (message) => {
+      if (!active) return;
+      active = false;
+      a.down([message]);
+      runCleanup();
+    };
+    const emit = (raw, event = raw) => {
+      if (!active) return;
+      try {
+        const payload = raw !== null && typeof raw === "object" && "data" in raw ? raw.data : raw;
+        const parsed = parse ? parse(payload, event) : payload;
+        a.emit(parsed);
+      } catch (err) {
+        terminate([ERROR, err]);
+      }
+    };
+    const error = (err) => {
+      terminate([ERROR, err]);
+    };
+    const complete = () => {
+      terminate([COMPLETE]);
+    };
+    if (typeof socketOrRegister === "function") {
+      try {
+        cleanup = socketOrRegister(emit, error, complete);
+        if (typeof cleanup !== "function") {
+          throw new Error(
+            "fromWebSocket register contract violation: register must return cleanup callable"
+          );
+        }
+      } catch (err) {
+        terminate([ERROR, err]);
+      }
+      return () => {
+        active = false;
+        runCleanup();
+      };
+    }
+    const ws = socketOrRegister;
+    const onMessage = (event) => emit(event, event);
+    const onError = (event) => error(event);
+    const onClose = () => complete();
+    ws.addEventListener("message", onMessage);
+    ws.addEventListener("error", onError);
+    ws.addEventListener("close", onClose);
+    cleanup = () => {
+      ws.removeEventListener("message", onMessage);
+      ws.removeEventListener("error", onError);
+      ws.removeEventListener("close", onClose);
+      if (closeOnTeardown) ws.close();
+    };
+    return () => {
+      active = false;
+      runCleanup();
+    };
+  }, sourceOpts(rest));
+}
+function fromWebhook(register, opts) {
+  return producer((_d, a) => {
+    let active = true;
+    const emit = (payload) => {
+      if (!active) return;
+      a.emit(payload);
+    };
+    const error = (err) => {
+      if (!active) return;
+      active = false;
+      a.down([[ERROR, err]]);
+    };
+    const complete = () => {
+      if (!active) return;
+      active = false;
+      a.down([[COMPLETE]]);
+    };
+    try {
+      const cleanup = register({ emit, error, complete });
+      return () => {
+        active = false;
+        cleanup?.();
+      };
+    } catch (err) {
+      error(err);
+      return () => {
+        active = false;
+      };
+    }
+  }, sourceOpts(opts));
+}
+function fromHTTP(url, opts) {
+  const {
+    method = "GET",
+    headers,
+    body: bodyOpt,
+    transform = (r) => r.json(),
+    timeoutNs = 30 * NS_PER_SEC,
+    signal: externalSignal,
+    ...rest
+  } = opts ?? {};
+  const fetchCount = state(0, { name: `${rest.name ?? "http"}/fetchCount` });
+  const lastUpdated = state(0, { name: `${rest.name ?? "http"}/lastUpdated` });
+  const sourceNode = producer((_d, a) => {
+    let active = true;
+    const abort = new AbortController();
+    if (externalSignal?.aborted) {
+      a.down([[ERROR, externalSignal.reason ?? new Error("Aborted")]]);
+      return () => {
+      };
+    }
+    externalSignal?.addEventListener("abort", () => abort.abort(externalSignal.reason), {
+      once: true
+    });
+    const timeoutId = setTimeout(
+      () => abort.abort(new Error("Request timeout")),
+      Math.ceil(timeoutNs / NS_PER_MS)
+    );
+    const body = bodyOpt !== void 0 ? typeof bodyOpt === "string" ? bodyOpt : JSON.stringify(bodyOpt) : void 0;
+    fetch(url, { method, headers, body, signal: abort.signal }).then(async (res) => {
+      clearTimeout(timeoutId);
+      if (!active) return;
+      if (!res.ok) {
+        throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+      }
+      const data = await transform(res);
+      if (!active) return;
+      batch(() => {
+        fetchCount.down([[DATA, (fetchCount.get() ?? 0) + 1]]);
+        lastUpdated.down([[DATA, wallClockNs()]]);
+        a.emit(data);
+      });
+      a.down([[COMPLETE]]);
+    }).catch((err) => {
+      clearTimeout(timeoutId);
+      if (!active) return;
+      if (err.name === "AbortError") return;
+      a.down([[ERROR, err]]);
+    });
+    return () => {
+      active = false;
+      abort.abort();
+    };
+  }, sourceOpts(rest));
+  const tracked = withStatus(sourceNode);
+  return {
+    ...tracked,
+    fetchCount,
+    lastUpdated
+  };
+}
+function messageTypeLabel(t) {
+  return Symbol.keyFor(t) ?? t.description ?? "message";
+}
+function serializeSseData(value, serialize) {
+  if (typeof value === "string") return value;
+  return serialize(value);
+}
+function sseFrame(event, data) {
+  let out = `event: ${event}
+`;
+  if (data !== void 0) {
+    const lines = data.split(/\r?\n/);
+    for (const line of lines) {
+      out += `data: ${line}
+`;
+    }
+  }
+  return `${out}
+`;
+}
+function toSSE(source, opts) {
+  const {
+    serialize = (value) => {
+      if (value instanceof Error) return value.message;
+      try {
+        return JSON.stringify(value);
+      } catch {
+        return String(value);
+      }
+    },
+    dataEvent = "data",
+    errorEvent = "error",
+    completeEvent = "complete",
+    includeResolved = false,
+    includeDirty = false,
+    keepAliveMs,
+    signal,
+    eventNameResolver = messageTypeLabel
+  } = opts ?? {};
+  const encoder = new TextEncoder();
+  let stop;
+  return new ReadableStream({
+    start(controller) {
+      let closed = false;
+      let keepAlive;
+      let unsub = () => {
+      };
+      const close = () => {
+        if (closed) return;
+        closed = true;
+        if (keepAlive !== void 0) clearInterval(keepAlive);
+        signal?.removeEventListener("abort", onAbort);
+        unsub();
+        controller.close();
+      };
+      stop = close;
+      const write = (event, data) => {
+        if (closed) return;
+        controller.enqueue(encoder.encode(sseFrame(event, data)));
+      };
+      const onAbort = () => {
+        if (closed) return;
+        close();
+      };
+      unsub = source.subscribe((msgs) => {
+        for (const msg of msgs) {
+          const t = msg[0];
+          if (t === DATA) {
+            write(dataEvent, serializeSseData(msg[1], serialize));
+            continue;
+          }
+          if (t === ERROR) {
+            write(errorEvent, serializeSseData(msg[1], serialize));
+            close();
+            return;
+          }
+          if (t === COMPLETE) {
+            write(completeEvent);
+            close();
+            return;
+          }
+          if (!includeResolved && t === RESOLVED) continue;
+          if (!includeDirty && t === DIRTY) continue;
+          write(
+            eventNameResolver(t),
+            msg.length > 1 ? serializeSseData(msg[1], serialize) : void 0
+          );
+        }
+      });
+      if (keepAliveMs !== void 0 && keepAliveMs > 0) {
+        keepAlive = setInterval(() => {
+          if (closed) return;
+          controller.enqueue(encoder.encode(": keepalive\n\n"));
+        }, keepAliveMs);
+      }
+      if (signal?.aborted) onAbort();
+      else signal?.addEventListener("abort", onAbort, { once: true });
+    },
+    cancel() {
+      stop?.();
+    }
+  });
+}
+function toWebSocket(source, socket, opts) {
+  const {
+    serialize = (value) => {
+      if (typeof value === "string" || value instanceof Blob || value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
+        return value;
+      }
+      try {
+        return JSON.stringify(value);
+      } catch {
+        return String(value);
+      }
+    },
+    closeOnComplete = true,
+    closeOnError = true,
+    closeCode,
+    closeReason,
+    onTransportError
+  } = opts ?? {};
+  let closed = false;
+  const toError = (err) => err instanceof Error ? err : new Error(String(err));
+  const reportTransportError = (stage, error, message) => {
+    if (!onTransportError) return;
+    try {
+      onTransportError({ stage, error: toError(error), message });
+    } catch {
+    }
+  };
+  const closeSocket = (message) => {
+    if (closed) return;
+    closed = true;
+    try {
+      socket.close(closeCode, closeReason);
+    } catch (err) {
+      reportTransportError("close", err, message);
+    }
+  };
+  const inner = node([source], () => void 0, {
+    describeKind: "effect",
+    onMessage(msg) {
+      if (msg[0] === DATA) {
+        let serialized;
+        try {
+          serialized = serialize(msg[1]);
+        } catch (err) {
+          reportTransportError("serialize", err, msg);
+          return true;
+        }
+        try {
+          socket.send(serialized === void 0 ? String(msg[1]) : serialized);
+        } catch (err) {
+          reportTransportError("send", err, msg);
+          return true;
+        }
+        return true;
+      }
+      if (msg[0] === COMPLETE && closeOnComplete) {
+        closeSocket(msg);
+        return true;
+      }
+      if (msg[0] === ERROR && closeOnError) {
+        closeSocket(msg);
+        return true;
+      }
+      return false;
+    }
+  });
+  return inner.subscribe(() => {
+  });
+}
+function fromMCP(client, opts) {
+  const { method = "notifications/message", onDisconnect, ...rest } = opts ?? {};
+  return producer((_d, a) => {
+    let active = true;
+    client.setNotificationHandler(method, (notification) => {
+      if (!active) return;
+      a.emit(notification);
+    });
+    if (onDisconnect) {
+      onDisconnect((err) => {
+        if (!active) return;
+        active = false;
+        a.down([[ERROR, err ?? new Error("MCP client disconnected")]]);
+      });
+    }
+    return () => {
+      active = false;
+      client.setNotificationHandler(method, () => {
+      });
+    };
+  }, sourceOpts(rest));
+}
+function fromGitHook(repoPath, opts) {
+  const { pollMs = 5e3, include, exclude, ...rest } = opts ?? {};
+  const includePatterns = include?.map(globToRegExp) ?? [];
+  const excludePatterns = exclude?.map(globToRegExp) ?? [];
+  return producer((_d, a) => {
+    let active = true;
+    let lastSeen;
+    let timer;
+    const { execFileSync } = __require("child_process");
+    const git = (...args) => {
+      try {
+        return execFileSync("git", args, { cwd: repoPath, encoding: "utf-8" }).trim();
+      } catch (err) {
+        if (!active) return "";
+        a.down([[ERROR, err]]);
+        cleanup();
+        return "";
+      }
+    };
+    const cleanup = () => {
+      active = false;
+      if (timer !== void 0) clearTimeout(timer);
+      timer = void 0;
+    };
+    lastSeen = git("rev-parse", "HEAD");
+    if (!active) return () => {
+    };
+    const schedule = () => {
+      if (!active) return;
+      timer = setTimeout(check, pollMs);
+    };
+    const check = () => {
+      if (!active) return;
+      const head = git("rev-parse", "HEAD");
+      if (!active || !head || head === lastSeen) {
+        schedule();
+        return;
+      }
+      let files = git("diff", "--name-only", `${lastSeen}..${head}`).split("\n").filter(Boolean);
+      if (!active) {
+        schedule();
+        return;
+      }
+      if (includePatterns.length > 0) {
+        files = files.filter((f) => matchesAnyPattern(f, includePatterns));
+      }
+      if (excludePatterns.length > 0) {
+        files = files.filter((f) => !matchesAnyPattern(f, excludePatterns));
+      }
+      const message = git("log", "-1", "--format=%s", head);
+      if (!active) {
+        schedule();
+        return;
+      }
+      const author = git("log", "-1", "--format=%an", head);
+      if (!active) {
+        schedule();
+        return;
+      }
+      a.emit({
+        hook: "post-commit",
+        commit: head,
+        files,
+        message,
+        author,
+        timestamp_ns: wallClockNs()
+      });
+      lastSeen = head;
+      schedule();
+    };
+    schedule();
+    return cleanup;
+  }, sourceOpts(rest));
+}
+function fromOTel(register, opts) {
+  let registerCleanup;
+  let active = true;
+  let teardownCount = 0;
+  const teardownOne = () => {
+    teardownCount++;
+    if (teardownCount >= 3 && registerCleanup) {
+      registerCleanup();
+      registerCleanup = void 0;
+    }
+  };
+  const traces = producer(
+    (_d, _a) => () => {
+      active = false;
+      teardownOne();
+    },
+    sourceOpts(opts)
+  );
+  const metrics = producer(
+    (_d, _a) => () => {
+      active = false;
+      teardownOne();
+    },
+    sourceOpts(opts)
+  );
+  const logs = producer(
+    (_d, _a) => () => {
+      active = false;
+      teardownOne();
+    },
+    sourceOpts(opts)
+  );
+  registerCleanup = register({
+    onTraces: (spans) => {
+      if (!active) return;
+      batch(() => {
+        for (const span of spans) traces.down([[DATA, span]]);
+      });
+    },
+    onMetrics: (ms) => {
+      if (!active) return;
+      batch(() => {
+        for (const m of ms) metrics.down([[DATA, m]]);
+      });
+    },
+    onLogs: (ls) => {
+      if (!active) return;
+      batch(() => {
+        for (const l of ls) logs.down([[DATA, l]]);
+      });
+    },
+    onError: (err) => {
+      if (!active) return;
+      active = false;
+      traces.down([[ERROR, err]]);
+      metrics.down([[ERROR, err]]);
+      logs.down([[ERROR, err]]);
+    }
+  }) ?? void 0;
+  return { traces, metrics, logs };
+}
+function fromSyslog(register, opts) {
+  return fromWebhook(register, opts);
+}
+function parseSyslog(raw) {
+  const match = raw.match(/^<(\d{1,3})>\d?\s*(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s*(.*)/s);
+  if (!match) {
+    const nowNs = wallClockNs();
+    return {
+      facility: 1,
+      severity: 6,
+      timestamp: new Date(Math.floor(nowNs / 1e6)).toISOString(),
+      hostname: "-",
+      appName: "-",
+      procId: "-",
+      msgId: "-",
+      message: raw.trim(),
+      timestampNs: nowNs
+    };
+  }
+  const pri = Number(match[1]);
+  return {
+    facility: pri >> 3,
+    severity: pri & 7,
+    timestamp: match[2],
+    hostname: match[3],
+    appName: match[4],
+    procId: match[5],
+    msgId: match[6],
+    message: (match[7] ?? "").trim(),
+    timestampNs: wallClockNs()
+  };
+}
+function fromStatsD(register, opts) {
+  return fromWebhook(register, opts);
+}
+var STATSD_TYPES = {
+  c: "counter",
+  g: "gauge",
+  ms: "timer",
+  h: "histogram",
+  s: "set",
+  d: "distribution"
+};
+function parseStatsD(line) {
+  const parts = line.split("|");
+  const [name, valueStr] = (parts[0] ?? "").split(":");
+  if (!name || valueStr === void 0) {
+    throw new Error(`Invalid StatsD line: ${line}`);
+  }
+  const typeCode = parts[1]?.trim() ?? "c";
+  const type = STATSD_TYPES[typeCode] ?? "counter";
+  const value = type === "set" ? 0 : Number(valueStr);
+  let sampleRate;
+  const tags = {};
+  for (let i = 2; i < parts.length; i++) {
+    const part = parts[i].trim();
+    if (part.startsWith("@")) {
+      sampleRate = Number(part.slice(1));
+    } else if (part.startsWith("#")) {
+      for (const tag of part.slice(1).split(",")) {
+        const [k, v] = tag.split(":");
+        if (k) tags[k] = v ?? "";
+      }
+    }
+  }
+  return { name: name.trim(), value, type, sampleRate, tags, timestampNs: wallClockNs() };
+}
+function fromPrometheus(endpoint, opts) {
+  const {
+    intervalNs = 15 * NS_PER_SEC,
+    headers,
+    timeoutNs = 10 * NS_PER_SEC,
+    signal: externalSignal,
+    ...rest
+  } = opts ?? {};
+  const intervalMs = Math.ceil(intervalNs / NS_PER_MS);
+  return producer((_d, a) => {
+    let active = true;
+    let running = false;
+    let timer;
+    const cleanup = () => {
+      active = false;
+      if (timer !== void 0) {
+        clearInterval(timer);
+        timer = void 0;
+      }
+    };
+    const scrape = async () => {
+      if (!active || running) return;
+      running = true;
+      const abort = new AbortController();
+      const timeoutId = setTimeout(
+        () => abort.abort(new Error("Scrape timeout")),
+        Math.ceil(timeoutNs / NS_PER_MS)
+      );
+      try {
+        const res = await fetch(endpoint, {
+          headers: { Accept: "text/plain", ...headers },
+          signal: abort.signal
+        });
+        clearTimeout(timeoutId);
+        if (!active) return;
+        if (!res.ok) throw new Error(`Prometheus scrape ${res.status}: ${res.statusText}`);
+        const text = await res.text();
+        if (!active) return;
+        const metrics = parsePrometheusText(text);
+        for (const m of metrics) a.emit(m);
+      } catch (err) {
+        clearTimeout(timeoutId);
+        if (!active) return;
+        if (err instanceof Error && err.name === "AbortError") return;
+        cleanup();
+        a.down([[ERROR, err]]);
+      } finally {
+        running = false;
+      }
+    };
+    const onAbort = () => {
+      if (!active) return;
+      cleanup();
+      a.down([[ERROR, externalSignal?.reason ?? new Error("Aborted")]]);
+    };
+    if (externalSignal?.aborted) {
+      onAbort();
+      return () => {
+      };
+    }
+    externalSignal?.addEventListener("abort", onAbort, { once: true });
+    void scrape();
+    timer = setInterval(() => void scrape(), intervalMs);
+    return () => {
+      cleanup();
+      externalSignal?.removeEventListener("abort", onAbort);
+    };
+  }, sourceOpts(rest));
+}
+function parsePrometheusText(text) {
+  const results = [];
+  const types = /* @__PURE__ */ new Map();
+  const helps = /* @__PURE__ */ new Map();
+  for (const rawLine of text.split("\n")) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    if (line.startsWith("# TYPE ")) {
+      const rest = line.slice(7);
+      const spaceIdx = rest.indexOf(" ");
+      if (spaceIdx > 0) {
+        types.set(rest.slice(0, spaceIdx), rest.slice(spaceIdx + 1).trim());
+      }
+      continue;
+    }
+    if (line.startsWith("# HELP ")) {
+      const rest = line.slice(7);
+      const spaceIdx = rest.indexOf(" ");
+      if (spaceIdx > 0) {
+        helps.set(rest.slice(0, spaceIdx), rest.slice(spaceIdx + 1).trim());
+      }
+      continue;
+    }
+    if (line.startsWith("#")) continue;
+    let name;
+    let labels = {};
+    let valueStr;
+    let tsStr;
+    const braceIdx = line.indexOf("{");
+    if (braceIdx >= 0) {
+      name = line.slice(0, braceIdx);
+      const closeBrace = line.indexOf("}", braceIdx);
+      if (closeBrace < 0) continue;
+      const labelStr = line.slice(braceIdx + 1, closeBrace);
+      labels = parsePrometheusLabels(labelStr);
+      const after = line.slice(closeBrace + 1).trim().split(/\s+/);
+      valueStr = after[0] ?? "";
+      tsStr = after[1];
+    } else {
+      const parts = line.split(/\s+/);
+      name = parts[0] ?? "";
+      valueStr = parts[1] ?? "";
+      tsStr = parts[2];
+    }
+    if (!name || !valueStr) continue;
+    const baseName = name.replace(/(_total|_count|_sum|_bucket|_created|_info)$/, "");
+    results.push({
+      name,
+      labels,
+      value: Number(valueStr),
+      timestampMs: tsStr ? Number(tsStr) : void 0,
+      type: types.get(baseName) ?? types.get(name),
+      help: helps.get(baseName) ?? helps.get(name),
+      timestampNs: wallClockNs()
+    });
+  }
+  return results;
+}
+function parsePrometheusLabels(str) {
+  const labels = {};
+  const re = /(\w+)="((?:[^"\\]|\\.)*)"/g;
+  let m = re.exec(str);
+  while (m !== null) {
+    labels[m[1]] = m[2].replace(/\\(.)/g, "$1");
+    m = re.exec(str);
+  }
+  return labels;
+}
+function fromKafka(consumer, topic, opts) {
+  const {
+    fromBeginning = false,
+    deserialize = (buf) => {
+      if (buf === null) return null;
+      try {
+        return JSON.parse(buf.toString());
+      } catch {
+        return buf.toString();
+      }
+    },
+    ...rest
+  } = opts ?? {};
+  return producer((_d, a) => {
+    let active = true;
+    const start = async () => {
+      try {
+        await consumer.subscribe({ topic, fromBeginning });
+        await consumer.run({
+          eachMessage: async ({ topic: t, partition, message: msg }) => {
+            if (!active) return;
+            const headers = {};
+            if (msg.headers) {
+              for (const [k, v] of Object.entries(msg.headers)) {
+                if (v !== void 0) headers[k] = typeof v === "string" ? v : v.toString();
+              }
+            }
+            a.emit({
+              topic: t,
+              partition,
+              key: msg.key?.toString() ?? null,
+              value: deserialize(msg.value),
+              headers,
+              offset: msg.offset,
+              timestamp: msg.timestamp,
+              timestampNs: wallClockNs()
+            });
+          }
+        });
+      } catch (err) {
+        if (active) a.down([[ERROR, err]]);
+      }
+    };
+    void start();
+    return () => {
+      active = false;
+    };
+  }, sourceOpts(rest));
+}
+function toKafka(source, kafkaProducer, topic, opts) {
+  const {
+    serialize = (v) => JSON.stringify(v),
+    keyExtractor,
+    onTransportError,
+    ...rest
+  } = opts ?? {};
+  const inner = node([source], () => void 0, {
+    describeKind: "effect",
+    ...rest,
+    onMessage(msg) {
+      if (msg[0] === DATA) {
+        const value = msg[1];
+        const key = keyExtractor?.(value) ?? null;
+        let serialized;
+        try {
+          serialized = serialize(value);
+        } catch (err) {
+          onTransportError?.({
+            stage: "serialize",
+            error: err instanceof Error ? err : new Error(String(err)),
+            value
+          });
+          return true;
+        }
+        void kafkaProducer.send({
+          topic,
+          messages: [{ key, value: Buffer.from(serialized) }]
+        }).catch((err) => {
+          onTransportError?.({
+            stage: "send",
+            error: err instanceof Error ? err : new Error(String(err)),
+            value
+          });
+        });
+        return true;
+      }
+      return false;
+    }
+  });
+  return inner.subscribe(() => {
+  });
+}
+function fromRedisStream(client, key, opts) {
+  const {
+    blockMs = 5e3,
+    startId = "$",
+    parse = (fields) => {
+      for (let i = 0; i < fields.length; i += 2) {
+        if (fields[i] === "data") {
+          try {
+            return JSON.parse(fields[i + 1]);
+          } catch {
+            return fields[i + 1];
+          }
+        }
+      }
+      const obj = {};
+      for (let i = 0; i < fields.length; i += 2) {
+        obj[fields[i]] = fields[i + 1];
+      }
+      return obj;
+    },
+    ...rest
+  } = opts ?? {};
+  return producer((_d, a) => {
+    let active = true;
+    let lastId = startId;
+    const poll = async () => {
+      while (active) {
+        try {
+          const result = await client.xread("BLOCK", blockMs, "STREAMS", key, lastId);
+          if (!active) return;
+          if (result) {
+            for (const [_streamKey, entries] of result) {
+              for (const [id, fields] of entries) {
+                lastId = id;
+                a.emit({
+                  id,
+                  key,
+                  data: parse(fields),
+                  timestampNs: wallClockNs()
+                });
+              }
+            }
+          }
+        } catch (err) {
+          if (!active) return;
+          a.down([[ERROR, err]]);
+          return;
+        }
+      }
+    };
+    void poll();
+    return () => {
+      active = false;
+    };
+  }, sourceOpts(rest));
+}
+function toRedisStream(source, client, key, opts) {
+  const {
+    serialize = (v) => ["data", JSON.stringify(v)],
+    maxLen,
+    onTransportError,
+    ...rest
+  } = opts ?? {};
+  const inner = node([source], () => void 0, {
+    describeKind: "effect",
+    ...rest,
+    onMessage(msg) {
+      if (msg[0] === DATA) {
+        const value = msg[1];
+        let fields;
+        try {
+          fields = serialize(value);
+        } catch (err) {
+          onTransportError?.({
+            stage: "serialize",
+            error: err instanceof Error ? err : new Error(String(err)),
+            value
+          });
+          return true;
+        }
+        const send = maxLen !== void 0 ? client.xadd(key, "MAXLEN", "~", String(maxLen), "*", ...fields) : client.xadd(key, "*", ...fields);
+        void send.catch((err) => {
+          onTransportError?.({
+            stage: "send",
+            error: err instanceof Error ? err : new Error(String(err)),
+            value
+          });
+        });
+        return true;
+      }
+      return false;
+    }
+  });
+  return inner.subscribe(() => {
+  });
+}
+function fromCSV(source, opts) {
+  const {
+    delimiter = ",",
+    hasHeader = true,
+    columns: explicitColumns,
+    parseLine,
+    ...rest
+  } = opts ?? {};
+  const parse = parseLine ?? ((line) => parseCSVLine(line, delimiter));
+  return producer((_d, a) => {
+    let cancelled = false;
+    const run = async () => {
+      try {
+        let headers = explicitColumns;
+        let buffer2 = "";
+        for await (const chunk of source) {
+          if (cancelled) return;
+          buffer2 += chunk;
+          const lines = buffer2.split(/\r?\n/);
+          buffer2 = lines.pop() ?? "";
+          for (const line of lines) {
+            if (cancelled) return;
+            if (!line.trim()) continue;
+            const values = parse(line);
+            if (!headers && hasHeader) {
+              headers = values;
+              continue;
+            }
+            if (!headers) {
+              headers = values.map((_, i) => `col${i}`);
+            }
+            const row = {};
+            for (let i = 0; i < headers.length; i++) {
+              row[headers[i]] = values[i] ?? "";
+            }
+            a.emit(row);
+          }
+        }
+        if (!cancelled && buffer2.trim()) {
+          const values = parse(buffer2);
+          if (headers) {
+            const row = {};
+            for (let i = 0; i < headers.length; i++) {
+              row[headers[i]] = values[i] ?? "";
+            }
+            a.emit(row);
+          }
+        }
+        if (!cancelled) a.down([[COMPLETE]]);
+      } catch (err) {
+        if (!cancelled) a.down([[ERROR, err]]);
+      }
+    };
+    void run();
+    return () => {
+      cancelled = true;
+    };
+  }, sourceOpts(rest));
+}
+function parseCSVLine(line, delimiter) {
+  const values = [];
+  let current = "";
+  let inQuotes = false;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (inQuotes) {
+      if (ch === '"') {
+        if (line[i + 1] === '"') {
+          current += '"';
+          i++;
+        } else {
+          inQuotes = false;
+        }
+      } else {
+        current += ch;
+      }
+    } else if (ch === '"') {
+      inQuotes = true;
+    } else if (ch === delimiter) {
+      values.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  values.push(current);
+  return values;
+}
+function fromNDJSON(source, opts) {
+  return producer((_d, a) => {
+    let cancelled = false;
+    const run = async () => {
+      try {
+        let buffer2 = "";
+        for await (const chunk of source) {
+          if (cancelled) return;
+          buffer2 += chunk;
+          const lines = buffer2.split(/\r?\n/);
+          buffer2 = lines.pop() ?? "";
+          for (const line of lines) {
+            if (cancelled) return;
+            const trimmed = line.trim();
+            if (!trimmed) continue;
+            a.emit(JSON.parse(trimmed));
+          }
+        }
+        if (!cancelled && buffer2.trim()) {
+          a.emit(JSON.parse(buffer2.trim()));
+        }
+        if (!cancelled) a.down([[COMPLETE]]);
+      } catch (err) {
+        if (!cancelled) a.down([[ERROR, err]]);
+      }
+    };
+    void run();
+    return () => {
+      cancelled = true;
+    };
+  }, sourceOpts(opts));
+}
+function fromClickHouseWatch(client, query, opts) {
+  const {
+    intervalNs = 5 * NS_PER_SEC,
+    format = "JSONEachRow",
+    signal: externalSignal,
+    ...rest
+  } = opts ?? {};
+  const intervalMs = Math.ceil(intervalNs / NS_PER_MS);
+  return producer((_d, a) => {
+    let active = true;
+    let running = false;
+    let timer;
+    const cleanup = () => {
+      active = false;
+      if (timer !== void 0) {
+        clearInterval(timer);
+        timer = void 0;
+      }
+    };
+    const execute = async () => {
+      if (!active || running) return;
+      running = true;
+      try {
+        const result = await client.query({ query, format });
+        if (!active) return;
+        const rows = await result.json();
+        if (!active) return;
+        for (const row of rows) a.emit(row);
+      } catch (err) {
+        if (!active) return;
+        cleanup();
+        a.down([[ERROR, err]]);
+      } finally {
+        running = false;
+      }
+    };
+    const onAbort = () => {
+      if (!active) return;
+      cleanup();
+      a.down([[ERROR, externalSignal?.reason ?? new Error("Aborted")]]);
+    };
+    if (externalSignal?.aborted) {
+      onAbort();
+      return () => {
+      };
+    }
+    externalSignal?.addEventListener("abort", onAbort, { once: true });
+    void execute();
+    timer = setInterval(() => void execute(), intervalMs);
+    return () => {
+      cleanup();
+      externalSignal?.removeEventListener("abort", onAbort);
+    };
+  }, sourceOpts(rest));
+}
+
+// src/extra/checkpoint.ts
+import { randomBytes } from "crypto";
+import { mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "fs";
+import { basename, dirname, join } from "path";
+import { DatabaseSync } from "sqlite";
+function sortJsonValue(value) {
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(sortJsonValue);
+  }
+  const obj = value;
+  const keys = Object.keys(obj).sort();
+  const out = {};
+  for (const k of keys) {
+    out[k] = sortJsonValue(obj[k]);
+  }
+  return out;
+}
+function warnNonJsonValues(data) {
+  for (const [path, node2] of Object.entries(data.nodes)) {
+    const v = node2.value;
+    if (v === void 0 || v === null) continue;
+    if (typeof v === "function" || typeof v === "symbol" || typeof v === "bigint") {
+      console.warn(
+        `checkpoint: node "${path}" has non-JSON-serializable value (${typeof v}); it will be lost on round-trip`
+      );
+    }
+  }
+}
+function stableSnapshotJson(data) {
+  warnNonJsonValues(data);
+  return `${JSON.stringify(sortJsonValue(data), void 0, 0)}
+`;
+}
+var MemoryCheckpointAdapter = class {
+  #data = null;
+  save(data) {
+    this.#data = JSON.parse(JSON.stringify(data));
+  }
+  load() {
+    return this.#data === null ? null : JSON.parse(JSON.stringify(this.#data));
+  }
+};
+var DictCheckpointAdapter = class {
+  #storage;
+  #key;
+  constructor(storage, key = "graphrefly_checkpoint") {
+    this.#storage = storage;
+    this.#key = key;
+  }
+  save(data) {
+    this.#storage[this.#key] = JSON.parse(JSON.stringify(data));
+  }
+  load() {
+    const raw = this.#storage[this.#key];
+    return raw !== null && typeof raw === "object" && !Array.isArray(raw) ? JSON.parse(JSON.stringify(raw)) : null;
+  }
+};
+var FileCheckpointAdapter = class {
+  #path;
+  constructor(path) {
+    this.#path = path;
+  }
+  save(data) {
+    const dir = dirname(this.#path);
+    mkdirSync(dir, { recursive: true });
+    const payload = stableSnapshotJson(data);
+    const base = basename(this.#path);
+    const tmp = join(dir, `.${base}.${randomBytes(8).toString("hex")}.tmp`);
+    try {
+      writeFileSync(tmp, payload, "utf8");
+      renameSync(tmp, this.#path);
+    } catch (e) {
+      try {
+        unlinkSync(tmp);
+      } catch {
+      }
+      throw e;
+    }
+  }
+  load() {
+    try {
+      const text = readFileSync(this.#path, "utf8").trim();
+      if (!text) return null;
+      const data = JSON.parse(text);
+      return data !== null && typeof data === "object" && !Array.isArray(data) ? data : null;
+    } catch {
+      return null;
+    }
+  }
+};
+var SqliteCheckpointAdapter = class {
+  #db;
+  #key;
+  constructor(path, key = "graphrefly_checkpoint") {
+    this.#db = new DatabaseSync(path);
+    this.#key = key;
+    this.#db.exec(
+      `CREATE TABLE IF NOT EXISTS graphrefly_checkpoint (k TEXT PRIMARY KEY, v TEXT NOT NULL)`
+    );
+  }
+  save(data) {
+    const payload = stableSnapshotJson(data).trimEnd();
+    this.#db.prepare(`INSERT OR REPLACE INTO graphrefly_checkpoint (k, v) VALUES (?, ?)`).run(this.#key, payload);
+  }
+  load() {
+    const row = this.#db.prepare(`SELECT v FROM graphrefly_checkpoint WHERE k = ?`).get(this.#key);
+    if (row === void 0 || typeof row.v !== "string" || row.v.trim() === "") return null;
+    const parsed = JSON.parse(row.v);
+    return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  }
+  /** Close the underlying SQLite connection (safe to call more than once). */
+  close() {
+    try {
+      this.#db.close();
+    } catch {
+    }
+  }
+};
+function saveGraphCheckpoint(graph, adapter) {
+  adapter.save(graph.snapshot());
+}
+function restoreGraphCheckpoint(graph, adapter) {
+  const data = adapter.load();
+  if (data === null) return false;
+  graph.restore(data);
+  return true;
+}
+function checkpointNodeValue(n) {
+  return { version: 1, value: n.get() };
+}
+function fromIDBRequest(req) {
+  return producer((_d, a) => {
+    let done = false;
+    const clear = () => {
+      req.onsuccess = null;
+      req.onerror = null;
+    };
+    req.onsuccess = () => {
+      if (done) return;
+      done = true;
+      clear();
+      a.down([[DATA, req.result], [COMPLETE]]);
+    };
+    req.onerror = () => {
+      if (done) return;
+      done = true;
+      clear();
+      a.down([[ERROR, req.error ?? new Error("IndexedDB request failed")]]);
+    };
+    return () => {
+      done = true;
+      clear();
+    };
+  });
+}
+function fromIDBTransaction(tx) {
+  return producer((_d, a) => {
+    let done = false;
+    const clear = () => {
+      tx.oncomplete = null;
+      tx.onerror = null;
+      tx.onabort = null;
+    };
+    tx.oncomplete = () => {
+      if (done) return;
+      done = true;
+      clear();
+      a.down([[DATA, void 0], [COMPLETE]]);
+    };
+    tx.onerror = () => {
+      if (done) return;
+      done = true;
+      clear();
+      a.down([[ERROR, tx.error ?? new Error("IndexedDB transaction failed")]]);
+    };
+    tx.onabort = () => {
+      if (done) return;
+      done = true;
+      clear();
+      a.down([[ERROR, tx.error ?? new Error("IndexedDB transaction aborted")]]);
+    };
+    return () => {
+      done = true;
+      clear();
+    };
+  });
+}
+function openIdbNode(dbName, storeName, version) {
+  return producer((_d, a) => {
+    if (typeof indexedDB === "undefined") {
+      a.down([[ERROR, new TypeError("indexedDB is not available in this environment")]]);
+      return void 0;
+    }
+    const req = indexedDB.open(dbName, version);
+    req.onupgradeneeded = () => {
+      const db = req.result;
+      if (!db.objectStoreNames.contains(storeName)) {
+        db.createObjectStore(storeName);
+      }
+    };
+    const unsub = fromIDBRequest(req).subscribe((msgs) => a.down(msgs));
+    return () => {
+      unsub();
+    };
+  });
+}
+function saveGraphCheckpointIndexedDb(graph, spec) {
+  const key = spec.key ?? "graphrefly_checkpoint";
+  return producer((_d, a) => {
+    let db;
+    let opUnsub;
+    let done = false;
+    const close = () => {
+      if (db === void 0) return;
+      db.close();
+      db = void 0;
+    };
+    const finishWith = (msgs) => {
+      if (done) return;
+      done = true;
+      a.down(msgs);
+      opUnsub?.();
+      opUnsub = void 0;
+      openUnsub();
+      close();
+    };
+    const startWrite = () => {
+      if (db === void 0 || opUnsub !== void 0) return;
+      const tx = db.transaction(spec.storeName, "readwrite");
+      const store = tx.objectStore(spec.storeName);
+      let reqDone = false;
+      let txDone = false;
+      let reqError;
+      let unsubReq;
+      let unsubTx;
+      const maybeFinish = () => {
+        if (reqError !== void 0) {
+          finishWith([[ERROR, reqError]]);
+          return;
+        }
+        if (!reqDone || !txDone) return;
+        finishWith([[DATA, void 0], [COMPLETE]]);
+      };
+      unsubReq = fromIDBRequest(store.put(graph.snapshot(), key)).subscribe((msgs) => {
+        for (const m of msgs) {
+          if (m[0] === ERROR) reqError = m[1];
+          if (m[0] === COMPLETE || m[0] === ERROR) reqDone = true;
+        }
+        maybeFinish();
+      });
+      unsubTx = fromIDBTransaction(tx).subscribe((msgs) => {
+        for (const m of msgs) {
+          if (m[0] === ERROR) {
+            finishWith([[ERROR, m[1]]]);
+            return;
+          }
+          if (m[0] === COMPLETE) txDone = true;
+        }
+        maybeFinish();
+      });
+      opUnsub = () => {
+        unsubReq?.();
+        unsubReq = void 0;
+        unsubTx?.();
+        unsubTx = void 0;
+      };
+    };
+    const openUnsub = openIdbNode(spec.dbName, spec.storeName, spec.version ?? 1).subscribe(
+      (msgs) => {
+        for (const m of msgs) {
+          if (m[0] === DATA) {
+            db = m[1];
+            startWrite();
+            continue;
+          }
+          if (m[0] === ERROR) {
+            finishWith([[ERROR, m[1]]]);
+            return;
+          }
+        }
+      }
+    );
+    return () => {
+      opUnsub?.();
+      opUnsub = void 0;
+      openUnsub();
+      close();
+    };
+  });
+}
+function restoreGraphCheckpointIndexedDb(graph, spec) {
+  const key = spec.key ?? "graphrefly_checkpoint";
+  return producer((_d, a) => {
+    let db;
+    let reqUnsub;
+    let txUnsub;
+    let done = false;
+    let txDone = false;
+    let requestDone = false;
+    let requestValue;
+    let requestError;
+    const close = () => {
+      if (db === void 0) return;
+      db.close();
+      db = void 0;
+    };
+    const finishWith = (msgs) => {
+      if (done) return;
+      done = true;
+      a.down(msgs);
+      reqUnsub?.();
+      reqUnsub = void 0;
+      txUnsub?.();
+      txUnsub = void 0;
+      openUnsub();
+      close();
+    };
+    const maybeEmitResult = () => {
+      if (!requestDone || !txDone) return;
+      if (requestError !== void 0) {
+        finishWith([[ERROR, requestError]]);
+        return;
+      }
+      if (requestValue === void 0 || requestValue === null) {
+        finishWith([[DATA, false], [COMPLETE]]);
+        return;
+      }
+      if (typeof requestValue !== "object" || Array.isArray(requestValue)) {
+        finishWith([[DATA, false], [COMPLETE]]);
+        return;
+      }
+      graph.restore(requestValue);
+      finishWith([[DATA, true], [COMPLETE]]);
+    };
+    const startRead = () => {
+      if (db === void 0 || reqUnsub !== void 0 || txUnsub !== void 0) return;
+      const tx = db.transaction(spec.storeName, "readonly");
+      const store = tx.objectStore(spec.storeName);
+      reqUnsub = fromIDBRequest(store.get(key)).subscribe((msgs) => {
+        for (const m of msgs) {
+          if (m[0] === DATA) requestValue = m[1];
+          if (m[0] === ERROR) requestError = m[1];
+          if (m[0] === COMPLETE || m[0] === ERROR) requestDone = true;
+        }
+        maybeEmitResult();
+      });
+      txUnsub = fromIDBTransaction(tx).subscribe((msgs) => {
+        for (const m of msgs) {
+          if (m[0] === ERROR) {
+            finishWith([[ERROR, m[1]]]);
+            return;
+          }
+          if (m[0] === COMPLETE) txDone = true;
+        }
+        maybeEmitResult();
+      });
+    };
+    const openUnsub = openIdbNode(spec.dbName, spec.storeName, spec.version ?? 1).subscribe(
+      (msgs) => {
+        for (const m of msgs) {
+          if (m[0] === DATA) {
+            db = m[1];
+            startRead();
+            continue;
+          }
+          if (m[0] === ERROR) {
+            finishWith([[ERROR, m[1]]]);
+            return;
+          }
+        }
+      }
+    );
+    return () => {
+      reqUnsub?.();
+      reqUnsub = void 0;
+      txUnsub?.();
+      txUnsub = void 0;
+      openUnsub();
+      close();
+    };
+  });
+}
+
+// src/extra/operators.ts
+function operatorOpts2(opts) {
+  return { describeKind: "operator", ...opts };
+}
+function map(source, project, opts) {
+  return derived([source], ([v]) => project(v), operatorOpts2(opts));
+}
+function filter(source, predicate, opts) {
+  return node(
+    [source],
+    ([v], a) => {
+      if (predicate(v)) return v;
+      a.down([[RESOLVED]]);
+      return void 0;
+    },
+    operatorOpts2(opts)
+  );
+}
+function scan(source, reducer, seed, opts) {
+  let acc = seed;
+  return node(
+    [source],
+    ([v]) => {
+      acc = reducer(acc, v);
+      return acc;
+    },
+    { ...operatorOpts2(opts), initial: seed, resetOnTeardown: true }
+  );
+}
+function reduce(source, reducer, seed, opts) {
+  let acc = seed;
+  let sawData = false;
+  return node(
+    [source],
+    ([v]) => {
+      sawData = true;
+      acc = reducer(acc, v);
+      return void 0;
+    },
+    {
+      ...operatorOpts2(opts),
+      completeWhenDepsComplete: false,
+      onResubscribe: opts?.resubscribable === true ? () => {
+        acc = seed;
+        sawData = false;
+      } : void 0,
+      onMessage(msg, _i, a) {
+        if (msg[0] === COMPLETE) {
+          if (!sawData) acc = seed;
+          a.emit(acc);
+          a.down([[COMPLETE]]);
+          return true;
+        }
+        return false;
+      }
+    }
+  );
+}
+function take(source, count, opts) {
+  if (count <= 0) {
+    return node(
+      [source],
+      (_d, a) => {
+        a.down([[COMPLETE]]);
+        return void 0;
+      },
+      {
+        ...operatorOpts2(opts),
+        completeWhenDepsComplete: false,
+        onMessage(msg, _i, a) {
+          if (msg[0] === COMPLETE) {
+            a.down([[COMPLETE]]);
+          }
+          return true;
+        }
+      }
+    );
+  }
+  let taken = 0;
+  let done = false;
+  return node(
+    [source],
+    ([v]) => {
+      if (done) return void 0;
+      return v;
+    },
+    {
+      ...operatorOpts2(opts),
+      completeWhenDepsComplete: false,
+      onResubscribe: opts?.resubscribable === true ? () => {
+        taken = 0;
+        done = false;
+      } : void 0,
+      onMessage(msg, _i, a) {
+        if (msg[0] === DIRTY) return false;
+        if (done) {
+          return true;
+        }
+        if (msg[0] === DATA) {
+          taken += 1;
+          if (taken >= count) {
+            done = true;
+            a.emit(source.get());
+            a.down([[COMPLETE]]);
+            return true;
+          }
+          return false;
+        }
+        if (msg[0] === RESOLVED) {
+          return false;
+        }
+        if (msg[0] === COMPLETE) {
+          done = true;
+          a.down([[COMPLETE]]);
+          return true;
+        }
+        if (msg[0] === ERROR) {
+          a.down([msg]);
+          return true;
+        }
+        a.down([msg]);
+        return true;
+      }
+    }
+  );
+}
+function skip(source, count, opts) {
+  let skipped = 0;
+  return node([source], () => void 0, {
+    ...operatorOpts2(opts),
+    onMessage(msg, _i, a) {
+      const t = msg[0];
+      if (t === DIRTY) {
+        a.down([[DIRTY]]);
+        return true;
+      }
+      if (t === RESOLVED) {
+        a.down([[RESOLVED]]);
+        return true;
+      }
+      if (t === DATA) {
+        skipped += 1;
+        if (skipped <= count) {
+          a.down([[RESOLVED]]);
+        } else {
+          a.emit(msg[1]);
+        }
+        return true;
+      }
+      return false;
+    }
+  });
+}
+function takeWhile(source, predicate, opts) {
+  let done = false;
+  return node(
+    [source],
+    ([v], a) => {
+      if (done) return void 0;
+      if (!predicate(v)) {
+        done = true;
+        a.down([[COMPLETE]]);
+        return void 0;
+      }
+      return v;
+    },
+    {
+      ...operatorOpts2(opts),
+      completeWhenDepsComplete: false,
+      onMessage(msg, _i, a) {
+        if (done) {
+          if (msg[0] === COMPLETE) {
+            a.down([[COMPLETE]]);
+          }
+          return true;
+        }
+        return false;
+      }
+    }
+  );
+}
+function takeUntil(source, notifier, opts) {
+  const pred = opts?.predicate ?? ((m) => m[0] === DATA);
+  const { predicate: _, ...restOpts } = opts ?? {};
+  let stopped = false;
+  return node(
+    [source, notifier],
+    ([v]) => {
+      if (stopped) return void 0;
+      return v;
+    },
+    {
+      ...operatorOpts2(restOpts),
+      completeWhenDepsComplete: false,
+      onMessage(msg, i, a) {
+        if (stopped) {
+          if (msg[0] === COMPLETE) {
+            a.down([[COMPLETE]]);
+          }
+          return true;
+        }
+        if (i === 1) {
+          if (pred(msg)) {
+            stopped = true;
+            a.down([[COMPLETE]]);
+            return true;
+          }
+          return true;
+        }
+        return false;
+      }
+    }
+  );
+}
+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");
+  let lastVal;
+  let has = false;
+  return node(
+    [source],
+    ([v]) => {
+      lastVal = v;
+      has = true;
+      return void 0;
+    },
+    {
+      ...operatorOpts2(rest),
+      completeWhenDepsComplete: false,
+      onMessage(msg, _i, a) {
+        if (msg[0] === COMPLETE) {
+          if (has) {
+            a.emit(lastVal);
+          } else if (useDefault) {
+            a.emit(defaultValue);
+          }
+          a.down([[COMPLETE]]);
+          return true;
+        }
+        return 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 startWith(source, initial, opts) {
+  let prepended = false;
+  return node(
+    [source],
+    ([v], a) => {
+      if (!prepended) {
+        prepended = true;
+        a.emit(initial);
+      }
+      a.emit(v);
+      return void 0;
+    },
+    operatorOpts2(opts)
+  );
+}
+function tap(source, fnOrObserver, opts) {
+  if (typeof fnOrObserver === "function") {
+    return derived(
+      [source],
+      ([v]) => {
+        fnOrObserver(v);
+        return v;
+      },
+      operatorOpts2(opts)
+    );
+  }
+  const obs = fnOrObserver;
+  return node(
+    [source],
+    ([v]) => {
+      obs.data?.(v);
+      return v;
+    },
+    {
+      ...operatorOpts2(opts),
+      completeWhenDepsComplete: false,
+      onMessage(msg, _i, a) {
+        const t = msg[0];
+        if (t === ERROR) {
+          obs.error?.(msg[1]);
+          a.down([msg]);
+          return true;
+        }
+        if (t === COMPLETE) {
+          obs.complete?.();
+          a.down([msg]);
+          return true;
+        }
+        return false;
+      }
+    }
+  );
+}
+function distinctUntilChanged(source, equals = Object.is, opts) {
+  return node([source], ([v]) => v, {
+    ...operatorOpts2(opts),
+    equals
+  });
+}
+function pairwise(source, opts) {
+  let prev;
+  let hasPrev = false;
+  return node(
+    [source],
+    ([v], a) => {
+      const x = v;
+      if (!hasPrev) {
+        prev = x;
+        hasPrev = true;
+        a.down([[RESOLVED]]);
+        return void 0;
+      }
+      const pair = [prev, x];
+      prev = x;
+      return pair;
+    },
+    operatorOpts2(opts)
+  );
+}
+function combine(...sources) {
+  const deps = [...sources];
+  return node(deps, (vals) => vals, operatorOpts2());
+}
+function withLatestFrom(primary, secondary, opts) {
+  let latestB;
+  let hasB = false;
+  return node([primary, secondary], () => void 0, {
+    ...operatorOpts2(opts),
+    onMessage(msg, i, a) {
+      if (i === 1 && (msg[0] === DATA || msg[0] === RESOLVED)) {
+        latestB = secondary.get();
+        hasB = true;
+        return true;
+      }
+      if (i === 0 && (msg[0] === DATA || msg[0] === RESOLVED)) {
+        if (!hasB) {
+          latestB = secondary.get();
+          hasB = true;
+        }
+        a.emit([primary.get(), latestB]);
+        return true;
+      }
+      if (i === 0 && msg[0] === DIRTY) {
+        a.down([[DIRTY]]);
+        return true;
+      }
+      if (i === 1 && msg[0] === DIRTY) {
+        return true;
+      }
+      if (msg[0] === COMPLETE || msg[0] === ERROR) {
+        a.down([msg]);
+        return true;
+      }
+      a.down([msg]);
+      return true;
+    }
+  });
+}
+function merge(...sources) {
+  if (sources.length === 0) {
+    return producer((_d, a) => {
+      a.down([[COMPLETE]]);
+      return void 0;
+    }, operatorOpts2());
+  }
+  const deps = sources;
+  const n = deps.length;
+  let completed = 0;
+  let dirtyMask = 0n;
+  let anyData = false;
+  return node(deps, () => void 0, {
+    ...operatorOpts2(),
+    completeWhenDepsComplete: false,
+    onMessage(msg, i, a) {
+      const t = msg[0];
+      const bit = 1n << BigInt(i);
+      if (t === DIRTY) {
+        const wasClean = dirtyMask === 0n;
+        dirtyMask |= bit;
+        if (wasClean) {
+          anyData = false;
+          a.down([[DIRTY]]);
+        }
+        return true;
+      }
+      if (t === RESOLVED) {
+        if (dirtyMask & bit) {
+          dirtyMask &= ~bit;
+          if (dirtyMask === 0n && !anyData) {
+            a.down([[RESOLVED]]);
+          }
+        }
+        return true;
+      }
+      if (t === DATA) {
+        dirtyMask &= ~bit;
+        anyData = true;
+        a.emit(msg[1]);
+        return true;
+      }
+      if (t === COMPLETE) {
+        dirtyMask &= ~bit;
+        completed += 1;
+        if (completed >= n) {
+          a.down([[COMPLETE]]);
+        }
+        return true;
+      }
+      if (t === ERROR) {
+        a.down([msg]);
+        return true;
+      }
+      a.down([msg]);
+      return true;
+    }
+  });
+}
+function zip(...sources) {
+  const n = sources.length;
+  if (n === 0) {
+    return node([], () => [], operatorOpts2());
+  }
+  const deps = [...sources];
+  const queues = Array.from({ length: n }, () => []);
+  let dirtyMask = 0n;
+  let anyData = false;
+  let active = n;
+  function tryEmit(a) {
+    while (queues.every((q) => q.length > 0)) {
+      const tuple = queues.map((q) => q.shift());
+      a.emit(tuple);
+    }
+  }
+  return node(deps, () => void 0, {
+    ...operatorOpts2(),
+    completeWhenDepsComplete: false,
+    onMessage(msg, i, a) {
+      const t = msg[0];
+      const bit = 1n << BigInt(i);
+      if (t === DIRTY) {
+        const wasClean = dirtyMask === 0n;
+        dirtyMask |= bit;
+        if (wasClean) {
+          anyData = false;
+          a.down([[DIRTY]]);
+        }
+        return true;
+      }
+      if (t === RESOLVED) {
+        if (dirtyMask & bit) {
+          dirtyMask &= ~bit;
+          if (dirtyMask === 0n) {
+            if (anyData) {
+              tryEmit(a);
+            } else {
+              a.down([[RESOLVED]]);
+            }
+          }
+        }
+        return true;
+      }
+      if (t === DATA) {
+        dirtyMask &= ~bit;
+        queues[i].push(msg[1]);
+        anyData = true;
+        if (dirtyMask === 0n) {
+          tryEmit(a);
+        }
+        return true;
+      }
+      if (t === COMPLETE) {
+        active -= 1;
+        if (active === 0 || queues[i].length === 0) {
+          a.down([[COMPLETE]]);
+        }
+        return true;
+      }
+      if (t === ERROR) {
+        a.down([msg]);
+        return true;
+      }
+      a.down([msg]);
+      return true;
+    }
+  });
+}
+function concat(firstSrc, secondSrc, opts) {
+  let phase = 0;
+  const pending = [];
+  return node([firstSrc, secondSrc], () => void 0, {
+    ...operatorOpts2(opts),
+    completeWhenDepsComplete: false,
+    onMessage(msg, i, a) {
+      const t = msg[0];
+      if (phase === 0 && i === 1) {
+        if (t === DATA) {
+          pending.push(msg[1]);
+        } else if (t === ERROR) {
+          a.down([msg]);
+        }
+        return true;
+      }
+      if (phase === 0 && i === 0) {
+        if (t === COMPLETE) {
+          phase = 1;
+          for (const v of pending) {
+            a.emit(v);
+          }
+          pending.length = 0;
+          return true;
+        }
+        a.down([msg]);
+        return true;
+      }
+      if (phase === 1 && i === 0) {
+        return true;
+      }
+      if (phase === 1 && i === 1) {
+        a.down([msg]);
+        return true;
+      }
+      return true;
+    }
+  });
+}
+function race(...sources) {
+  if (sources.length === 0) {
+    return producer((_d, a) => {
+      a.down([[COMPLETE]]);
+      return void 0;
+    }, operatorOpts2());
+  }
+  if (sources.length === 1) {
+    return node([sources[0]], ([v]) => v, operatorOpts2());
+  }
+  const deps = sources;
+  let winner = null;
+  return node(deps, () => void 0, {
+    ...operatorOpts2(),
+    completeWhenDepsComplete: false,
+    onMessage(msg, i, a) {
+      const t = msg[0];
+      if (winner !== null && i !== winner) {
+        return true;
+      }
+      if (t === DATA && winner === null) {
+        winner = i;
+        a.emit(msg[1]);
+        return true;
+      }
+      if (winner !== null && i === winner) {
+        if (t === DATA) {
+          a.emit(msg[1]);
+          return true;
+        }
+        a.down([msg]);
+        return true;
+      }
+      if (winner === null) {
+        if (t === DIRTY) {
+          a.down([[DIRTY]]);
+          return true;
+        }
+        if (t === RESOLVED) {
+          a.down([[RESOLVED]]);
+          return true;
+        }
+        if (t === COMPLETE || t === ERROR) {
+          a.down([msg]);
+          return true;
+        }
+      }
+      return false;
+    }
+  });
+}
+function forwardInner(inner, a, onInnerComplete) {
+  let unsub;
+  let finished = false;
+  let emitted = false;
+  const finish = () => {
+    if (finished) return;
+    finished = true;
+    onInnerComplete();
+  };
+  unsub = inner.subscribe((msgs) => {
+    let sawComplete = false;
+    let sawError = false;
+    const out = [];
+    for (const m of msgs) {
+      if (m[0] === DATA) emitted = true;
+      if (m[0] === COMPLETE) sawComplete = true;
+      else {
+        if (m[0] === ERROR) sawError = true;
+        out.push(m);
+      }
+    }
+    if (out.length > 0) a.down(out);
+    if (sawError) {
+      unsub?.();
+      unsub = void 0;
+      finish();
+    } else if (sawComplete) {
+      finish();
+    }
+  });
+  if (!emitted && (inner.status === "settled" || inner.status === "resolved")) {
+    a.emit(inner.get());
+  }
+  if (inner.status === "completed" || inner.status === "errored") {
+    finish();
+  }
+  return () => {
+    unsub?.();
+    unsub = void 0;
+  };
+}
+function switchMap(source, project, opts) {
+  let innerUnsub;
+  let sourceDone = false;
+  let attached = false;
+  function clearInner() {
+    innerUnsub?.();
+    innerUnsub = void 0;
+  }
+  function attach(v, a) {
+    attached = true;
+    clearInner();
+    innerUnsub = forwardInner(fromAny(project(v)), a, () => {
+      clearInner();
+      if (sourceDone) a.down([[COMPLETE]]);
+    });
+  }
+  return node(
+    [source],
+    ([v], a) => {
+      if (!attached) attach(v, a);
+      return clearInner;
+    },
+    {
+      ...operatorOpts2(opts),
+      completeWhenDepsComplete: false,
+      onMessage(msg, _i, a) {
+        const t = msg[0];
+        if (t === ERROR) {
+          clearInner();
+          a.down([msg]);
+          return true;
+        }
+        if (t === COMPLETE) {
+          sourceDone = true;
+          if (innerUnsub === void 0) a.down([[COMPLETE]]);
+          return true;
+        }
+        if (t === DIRTY) {
+          a.down([[DIRTY]]);
+          return true;
+        }
+        if (t === RESOLVED) {
+          a.down([[RESOLVED]]);
+          return true;
+        }
+        if (t === DATA) {
+          attach(msg[1], a);
+          return true;
+        }
+        return false;
+      }
+    }
+  );
+}
+function exhaustMap(source, project, opts) {
+  let innerUnsub;
+  let sourceDone = false;
+  let attached = false;
+  function clearInner() {
+    innerUnsub?.();
+    innerUnsub = void 0;
+  }
+  function attach(v, a) {
+    attached = true;
+    innerUnsub = forwardInner(fromAny(project(v)), a, () => {
+      clearInner();
+      if (sourceDone) a.down([[COMPLETE]]);
+    });
+  }
+  return node(
+    [source],
+    ([v], a) => {
+      if (!attached && innerUnsub === void 0) attach(v, a);
+      return clearInner;
+    },
+    {
+      ...operatorOpts2(opts),
+      completeWhenDepsComplete: false,
+      onMessage(msg, _i, a) {
+        const t = msg[0];
+        if (t === ERROR) {
+          clearInner();
+          a.down([msg]);
+          return true;
+        }
+        if (t === COMPLETE) {
+          sourceDone = true;
+          if (innerUnsub === void 0) a.down([[COMPLETE]]);
+          return true;
+        }
+        if (t === DIRTY) {
+          a.down([[DIRTY]]);
+          return true;
+        }
+        if (t === RESOLVED) {
+          a.down([[RESOLVED]]);
+          return true;
+        }
+        if (t === DATA) {
+          if (innerUnsub !== void 0) {
+            a.down([[RESOLVED]]);
+            return true;
+          }
+          attach(msg[1], a);
+          return true;
+        }
+        return false;
+      }
+    }
+  );
+}
+function concatMap(source, project, opts) {
+  const { maxBuffer: maxBuf, ...concatNodeOpts } = opts ?? {};
+  const queue = [];
+  let innerUnsub;
+  let sourceDone = false;
+  let attached = false;
+  function clearInner() {
+    innerUnsub?.();
+    innerUnsub = void 0;
+  }
+  function tryPump(a) {
+    if (innerUnsub !== void 0) return;
+    if (queue.length === 0) {
+      if (sourceDone) a.down([[COMPLETE]]);
+      return;
+    }
+    const v = queue.shift();
+    innerUnsub = forwardInner(fromAny(project(v)), a, () => {
+      clearInner();
+      tryPump(a);
+    });
+  }
+  function enqueue(v, a) {
+    attached = true;
+    if (maxBuf && maxBuf > 0 && queue.length >= maxBuf) queue.shift();
+    queue.push(v);
+    tryPump(a);
+  }
+  return node(
+    [source],
+    ([v], a) => {
+      if (!attached) enqueue(v, a);
+      return clearInner;
+    },
+    {
+      ...operatorOpts2(concatNodeOpts),
+      completeWhenDepsComplete: false,
+      onMessage(msg, _i, a) {
+        const t = msg[0];
+        if (t === ERROR) {
+          clearInner();
+          queue.length = 0;
+          a.down([msg]);
+          return true;
+        }
+        if (t === COMPLETE) {
+          sourceDone = true;
+          tryPump(a);
+          return true;
+        }
+        if (t === DIRTY) {
+          a.down([[DIRTY]]);
+          return true;
+        }
+        if (t === RESOLVED) {
+          a.down([[RESOLVED]]);
+          return true;
+        }
+        if (t === DATA) {
+          enqueue(msg[1], a);
+          return true;
+        }
+        return 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 = [];
+  function tryComplete(a) {
+    if (sourceDone && active === 0 && buffer2.length === 0) a.down([[COMPLETE]]);
+  }
+  function spawn(v, a) {
+    active++;
+    const inner = fromAny(project(v));
+    let stop;
+    const runStop = () => {
+      stop?.();
+      if (stop !== void 0) innerStops.delete(stop);
+      stop = void 0;
+    };
+    stop = inner.subscribe((msgs) => {
+      let sawComplete = false;
+      const out = [];
+      for (const m of msgs) {
+        if (m[0] === COMPLETE) sawComplete = true;
+        else out.push(m);
+      }
+      if (out.length > 0) a.down(out);
+      if (sawComplete) {
+        runStop();
+        active--;
+        drainBuffer(a);
+        tryComplete(a);
+      }
+    });
+    innerStops.add(stop);
+  }
+  function drainBuffer(a) {
+    while (buffer2.length > 0 && active < maxConcurrent) {
+      spawn(buffer2.shift(), a);
+    }
+  }
+  function enqueue(v, a) {
+    if (active < maxConcurrent) {
+      spawn(v, a);
+    } else {
+      buffer2.push(v);
+    }
+  }
+  function clearAll() {
+    for (const u of innerStops) u();
+    innerStops.clear();
+    active = 0;
+    buffer2.length = 0;
+  }
+  let attached = false;
+  return node(
+    [source],
+    ([v], a) => {
+      if (!attached) {
+        attached = true;
+        enqueue(v, a);
+      }
+      return clearAll;
+    },
+    {
+      ...operatorOpts2(mergeNodeOpts),
+      completeWhenDepsComplete: false,
+      onMessage(msg, _i, a) {
+        const t = msg[0];
+        if (t === ERROR) {
+          clearAll();
+          a.down([msg]);
+          return true;
+        }
+        if (t === COMPLETE) {
+          sourceDone = true;
+          tryComplete(a);
+          return true;
+        }
+        if (t === DIRTY) {
+          a.down([[DIRTY]]);
+          return true;
+        }
+        if (t === RESOLVED) {
+          a.down([[RESOLVED]]);
+          return true;
+        }
+        if (t === DATA) {
+          enqueue(msg[1], a);
+          return true;
+        }
+        return false;
+      }
+    }
+  );
+}
+var flatMap = mergeMap;
+function delay(source, ms, opts) {
+  const timers = /* @__PURE__ */ new Set();
+  function clearAll() {
+    for (const id of timers) clearTimeout(id);
+    timers.clear();
+  }
+  return node([source], () => clearAll, {
+    ...operatorOpts2(opts),
+    completeWhenDepsComplete: false,
+    onMessage(msg, _i, a) {
+      const t = msg[0];
+      if (t === DIRTY || t === ERROR || t === COMPLETE || t === PAUSE || t === RESUME) {
+        if (t === COMPLETE) clearAll();
+        a.down([msg]);
+        return true;
+      }
+      if (t === RESOLVED) {
+        a.down([msg]);
+        return true;
+      }
+      if (t === DATA) {
+        const id = setTimeout(() => {
+          timers.delete(id);
+          a.down([msg]);
+        }, ms);
+        timers.add(id);
+        return true;
+      }
+      a.down([msg]);
+      return true;
+    }
+  });
+}
+function debounce(source, ms, opts) {
+  let timer;
+  let pending;
+  function clearTimer() {
+    if (timer !== void 0) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+  }
+  return node([source], () => clearTimer, {
+    ...operatorOpts2(opts),
+    completeWhenDepsComplete: false,
+    onMessage(msg, _i, a) {
+      const t = msg[0];
+      if (t === ERROR || t === PAUSE || t === RESUME) {
+        clearTimer();
+        a.down([msg]);
+        return true;
+      }
+      if (t === COMPLETE) {
+        if (timer !== void 0) {
+          clearTimer();
+          a.emit(pending);
+        }
+        a.down([msg]);
+        return true;
+      }
+      if (t === DIRTY) {
+        a.down([[DIRTY]]);
+        return true;
+      }
+      if (t === DATA) {
+        clearTimer();
+        pending = msg[1];
+        timer = setTimeout(() => {
+          timer = void 0;
+          a.emit(pending);
+        }, ms);
+        return true;
+      }
+      if (t === RESOLVED) {
+        a.down([[RESOLVED]]);
+        return true;
+      }
+      a.down([msg]);
+      return true;
+    }
+  });
+}
+function throttle(source, ms, opts) {
+  const { leading: leadingOpt, trailing: trailingOpt, ...throttleNodeOpts } = opts ?? {};
+  const leading = leadingOpt !== false;
+  const trailing = trailingOpt === true;
+  let timer;
+  const windowNs = ms * NS_PER_MS;
+  let lastEmitNs = -Infinity;
+  let pending;
+  let hasPending = false;
+  function clearTimer() {
+    if (timer !== void 0) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+  }
+  return node(
+    [source],
+    () => {
+      clearTimer();
+      return void 0;
+    },
+    {
+      ...operatorOpts2(throttleNodeOpts),
+      completeWhenDepsComplete: false,
+      onMessage(msg, _i, a) {
+        const t = msg[0];
+        if (t === ERROR || t === COMPLETE || t === PAUSE || t === RESUME) {
+          clearTimer();
+          a.down([msg]);
+          return true;
+        }
+        if (t === DIRTY) {
+          a.down([[DIRTY]]);
+          return true;
+        }
+        if (t === RESOLVED) {
+          a.down([[RESOLVED]]);
+          return true;
+        }
+        if (t === DATA) {
+          const v = msg[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);
+            }
+            return true;
+          }
+          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)
+              );
+            }
+          }
+          return true;
+        }
+        a.down([msg]);
+        return true;
+      }
+    }
+  );
+}
+function sample(source, notifier, opts) {
+  return node([source, notifier], () => void 0, {
+    ...operatorOpts2(opts),
+    completeWhenDepsComplete: false,
+    onMessage(msg, i, a) {
+      const t = msg[0];
+      if (t === ERROR) {
+        a.down([msg]);
+        return true;
+      }
+      if (t === COMPLETE) {
+        a.down([msg]);
+        return true;
+      }
+      if (i === 1 && t === DATA) {
+        a.emit(source.get());
+        return true;
+      }
+      if (i === 1 && t === RESOLVED) {
+        return true;
+      }
+      if (i === 0) {
+        return true;
+      }
+      return false;
+    }
+  });
+}
+function audit(source, ms, opts) {
+  let timer;
+  let latest;
+  let has = false;
+  function clearTimer() {
+    if (timer !== void 0) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+  }
+  return node([source], () => clearTimer, {
+    ...operatorOpts2(opts),
+    completeWhenDepsComplete: false,
+    onMessage(msg, _i, a) {
+      const t = msg[0];
+      if (t === ERROR || t === COMPLETE || t === PAUSE || t === RESUME) {
+        clearTimer();
+        a.down([msg]);
+        return true;
+      }
+      if (t === DIRTY) {
+        a.down([[DIRTY]]);
+        return true;
+      }
+      if (t === RESOLVED) {
+        a.down([[RESOLVED]]);
+        return true;
+      }
+      if (t === DATA) {
+        latest = msg[1];
+        has = true;
+        clearTimer();
+        timer = setTimeout(() => {
+          timer = void 0;
+          if (has) {
+            has = false;
+            a.emit(latest);
+          }
+        }, ms);
+        return true;
+      }
+      a.down([msg]);
+      return true;
+    }
+  });
+}
+function timeout(source, ms, opts) {
+  const { with: withPayload, ...timeoutNodeOpts } = opts ?? {};
+  let timer;
+  const err = withPayload ?? new Error("timeout");
+  function arm(a) {
+    clearTimeout(timer);
+    timer = setTimeout(() => {
+      timer = void 0;
+      a.down([[ERROR, err]]);
+    }, ms);
+  }
+  return node(
+    [source],
+    ([_v], a) => {
+      arm(a);
+      return () => clearTimeout(timer);
+    },
+    {
+      ...operatorOpts2(timeoutNodeOpts),
+      completeWhenDepsComplete: false,
+      onMessage(msg, _i, a) {
+        const t = msg[0];
+        if (t === DATA) {
+          arm(a);
+          a.down([msg]);
+          return true;
+        }
+        if (t === COMPLETE || t === ERROR) {
+          clearTimeout(timer);
+          a.down([msg]);
+          return true;
+        }
+        if (t === DIRTY || t === RESOLVED) {
+          a.down([msg]);
+          return true;
+        }
+        a.down([msg]);
+        return true;
+      }
+    }
+  );
+}
+function buffer(source, notifier, opts) {
+  const buf = [];
+  return node([source, notifier], () => void 0, {
+    ...operatorOpts2(opts),
+    completeWhenDepsComplete: false,
+    onMessage(msg, i, a) {
+      const t = msg[0];
+      if (t === ERROR) {
+        a.down([msg]);
+        return true;
+      }
+      if (t === COMPLETE && i === 0) {
+        if (buf.length > 0) a.emit([...buf]);
+        buf.length = 0;
+        a.down([msg]);
+        return true;
+      }
+      if (t === COMPLETE && i === 1) {
+        a.down([msg]);
+        return true;
+      }
+      if (i === 0 && t === DATA) {
+        buf.push(msg[1]);
+        return true;
+      }
+      if (i === 1 && t === DATA) {
+        if (buf.length > 0) {
+          a.emit([...buf]);
+          buf.length = 0;
+        } else {
+          a.down([[RESOLVED]]);
+        }
+        return true;
+      }
+      if (i === 1 && t === RESOLVED) {
+        return true;
+      }
+      if (i === 0 && (t === DIRTY || t === RESOLVED)) {
+        return true;
+      }
+      return false;
+    }
+  });
+}
+function bufferCount(source, count, opts) {
+  if (count <= 0) throw new RangeError("bufferCount expects count > 0");
+  const buf = [];
+  let started = false;
+  return node(
+    [source],
+    ([v], a) => {
+      if (!started) {
+        started = true;
+        buf.push(v);
+        if (buf.length >= count) {
+          a.emit(buf.splice(0, buf.length));
+        }
+      }
+      return void 0;
+    },
+    {
+      ...operatorOpts2(opts),
+      completeWhenDepsComplete: false,
+      onMessage(msg, _i, a) {
+        const t = msg[0];
+        if (t === ERROR) {
+          a.down([msg]);
+          return true;
+        }
+        if (t === COMPLETE) {
+          if (buf.length > 0) a.emit([...buf]);
+          buf.length = 0;
+          a.down([[COMPLETE]]);
+          return true;
+        }
+        if (t === DIRTY) {
+          a.down([[DIRTY]]);
+          return true;
+        }
+        if (t === RESOLVED) {
+          a.down([[RESOLVED]]);
+          return true;
+        }
+        if (t === DATA) {
+          buf.push(msg[1]);
+          if (buf.length >= count) {
+            a.emit(buf.splice(0, buf.length));
+          }
+          return true;
+        }
+        return false;
+      }
+    }
+  );
+}
+function windowCount(source, count, opts) {
+  if (count <= 0) throw new RangeError("windowCount expects count > 0");
+  let win;
+  let winDown;
+  let n = 0;
+  function openWindow(a) {
+    const s = producer((_d, actions) => {
+      winDown = actions.down.bind(actions);
+      return () => {
+        winDown = void 0;
+      };
+    }, operatorOpts2());
+    win = s;
+    n = 0;
+    a.emit(s);
+  }
+  return node([source], () => void 0, {
+    ...operatorOpts2(opts),
+    completeWhenDepsComplete: false,
+    onMessage(msg, _i, a) {
+      const t = msg[0];
+      if (t === DATA) {
+        if (!win) openWindow(a);
+        winDown?.([[DATA, msg[1]]]);
+        n += 1;
+        if (n >= count) {
+          winDown?.([[COMPLETE]]);
+          win = void 0;
+          winDown = void 0;
+        }
+        return true;
+      }
+      if (t === COMPLETE) {
+        winDown?.([[COMPLETE]]);
+        win = void 0;
+        winDown = void 0;
+        a.down([[COMPLETE]]);
+        return true;
+      }
+      if (t === ERROR) {
+        winDown?.([msg]);
+        win = void 0;
+        winDown = void 0;
+        a.down([msg]);
+        return true;
+      }
+      if (t === DIRTY) {
+        a.down([[DIRTY]]);
+        return true;
+      }
+      if (t === RESOLVED) {
+        a.down([[RESOLVED]]);
+        return true;
+      }
+      return false;
+    }
+  });
+}
+function bufferTime(source, ms, opts) {
+  const buf = [];
+  let iv;
+  return node(
+    [source],
+    (_deps, a) => {
+      iv = setInterval(() => {
+        if (buf.length > 0) {
+          a.emit([...buf]);
+          buf.length = 0;
+        }
+      }, ms);
+      return () => {
+        if (iv !== void 0) clearInterval(iv);
+      };
+    },
+    {
+      ...operatorOpts2(opts),
+      completeWhenDepsComplete: false,
+      onMessage(msg, _i, a) {
+        const t = msg[0];
+        if (t === ERROR) {
+          a.down([msg]);
+          return true;
+        }
+        if (t === COMPLETE) {
+          if (iv !== void 0) clearInterval(iv);
+          if (buf.length > 0) a.emit([...buf]);
+          buf.length = 0;
+          a.down([[COMPLETE]]);
+          return true;
+        }
+        if (t === DIRTY) {
+          a.down([[DIRTY]]);
+          return true;
+        }
+        if (t === RESOLVED) {
+          a.down([[RESOLVED]]);
+          return true;
+        }
+        if (t === DATA) {
+          buf.push(msg[1]);
+          return true;
+        }
+        return false;
+      }
+    }
+  );
+}
+function windowTime(source, ms, opts) {
+  let winDown;
+  let iv;
+  function closeWindow() {
+    winDown?.([[COMPLETE]]);
+    winDown = void 0;
+  }
+  return node(
+    [source],
+    (_deps, a) => {
+      function openWindow() {
+        const s = producer((_d, actions) => {
+          winDown = actions.down.bind(actions);
+          return () => {
+            winDown = void 0;
+          };
+        }, operatorOpts2());
+        a.emit(s);
+      }
+      openWindow();
+      iv = setInterval(() => {
+        closeWindow();
+        openWindow();
+      }, ms);
+      return () => {
+        if (iv !== void 0) clearInterval(iv);
+        closeWindow();
+      };
+    },
+    {
+      ...operatorOpts2(opts),
+      completeWhenDepsComplete: false,
+      onMessage(msg, _i, a) {
+        const t = msg[0];
+        if (t === DATA) {
+          winDown?.([[DATA, msg[1]]]);
+          return true;
+        }
+        if (t === COMPLETE) {
+          if (iv !== void 0) clearInterval(iv);
+          closeWindow();
+          a.down([[COMPLETE]]);
+          return true;
+        }
+        if (t === ERROR) {
+          if (iv !== void 0) clearInterval(iv);
+          winDown?.([msg]);
+          closeWindow();
+          a.down([msg]);
+          return true;
+        }
+        if (t === DIRTY) {
+          a.down([[DIRTY]]);
+          return true;
+        }
+        if (t === RESOLVED) {
+          a.down([[RESOLVED]]);
+          return true;
+        }
+        return false;
+      }
+    }
+  );
+}
+function window(source, notifier, opts) {
+  let win;
+  let winDown;
+  function closeWindow() {
+    winDown?.([[COMPLETE]]);
+    win = void 0;
+    winDown = void 0;
+  }
+  return node([source, notifier], () => void 0, {
+    ...operatorOpts2(opts),
+    completeWhenDepsComplete: false,
+    onMessage(msg, i, a) {
+      const t = msg[0];
+      if (i === 0 && t === DATA) {
+        if (!win) {
+          const s = producer((_d, actions) => {
+            winDown = actions.down.bind(actions);
+            return () => {
+              winDown = void 0;
+            };
+          }, operatorOpts2());
+          win = s;
+          a.emit(s);
+        }
+        winDown?.([[DATA, msg[1]]]);
+        return true;
+      }
+      if (i === 1 && t === DATA) {
+        closeWindow();
+        const s = producer((_d, actions) => {
+          winDown = actions.down.bind(actions);
+          return () => {
+            winDown = void 0;
+          };
+        }, operatorOpts2());
+        win = s;
+        a.emit(s);
+        return true;
+      }
+      if (t === COMPLETE && i === 0) {
+        closeWindow();
+        a.down([[COMPLETE]]);
+        return true;
+      }
+      if (t === COMPLETE && i === 1) {
+        return true;
+      }
+      if (t === ERROR) {
+        winDown?.([msg]);
+        win = void 0;
+        winDown = void 0;
+        a.down([msg]);
+        return true;
+      }
+      if (i === 0 && (t === DIRTY || t === RESOLVED)) {
+        return true;
+      }
+      if (i === 1 && t === RESOLVED) {
+        return true;
+      }
+      return false;
+    }
+  });
+}
+function interval(periodMs, opts) {
+  let n = 0;
+  return producer((_d, a) => {
+    const id = setInterval(() => {
+      a.emit(n);
+      n += 1;
+    }, periodMs);
+    return () => clearInterval(id);
+  }, operatorOpts2(opts));
+}
+function repeat(source, count, opts) {
+  if (count <= 0) throw new RangeError("repeat expects count > 0");
+  return producer((_d, 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?.();
+    };
+  }, operatorOpts2(opts));
+}
+function pausable(source, opts) {
+  let paused = false;
+  const backlog = [];
+  return node([source], () => void 0, {
+    ...operatorOpts2(opts),
+    completeWhenDepsComplete: false,
+    onMessage(msg, _i, a) {
+      const t = msg[0];
+      if (t === PAUSE) {
+        paused = true;
+        a.down([msg]);
+        return true;
+      }
+      if (t === RESUME) {
+        paused = false;
+        a.down([msg]);
+        for (const m of backlog) a.down([m]);
+        backlog.length = 0;
+        return true;
+      }
+      if (paused && (t === DIRTY || t === DATA || t === RESOLVED)) {
+        backlog.push(msg);
+        return true;
+      }
+      a.down([msg]);
+      return true;
+    }
+  });
+}
+function rescue(source, recover, opts) {
+  return node([source], () => void 0, {
+    ...operatorOpts2(opts),
+    completeWhenDepsComplete: false,
+    onMessage(msg, _i, a) {
+      if (msg[0] === ERROR) {
+        try {
+          a.emit(recover(msg[1]));
+        } catch (err) {
+          a.down([[ERROR, err]]);
+        }
+        return true;
+      }
+      a.down([msg]);
+      return true;
+    }
+  });
+}
+function gate(source, control, opts) {
+  return node(
+    [source, control],
+    (_deps, a) => {
+      const v = source.get();
+      const c = control.get();
+      if (!c) {
+        a.down([[RESOLVED]]);
+        return void 0;
+      }
+      return v;
+    },
+    operatorOpts2(opts)
+  );
+}
+var combineLatest = combine;
+var debounceTime = debounce;
+var throttleTime = throttle;
+var catchError = rescue;
+
+// src/extra/reactive-map.ts
+function emptySnapshot() {
+  return { version: 0, value: { map: /* @__PURE__ */ new Map() } };
+}
+function isExpired(e, now) {
+  return e.expiresAt !== void 0 && now >= e.expiresAt;
+}
+function buildMap(store, now) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [k, e] of store) {
+    if (!isExpired(e, now)) out.set(k, e.value);
+  }
+  return out;
+}
+function reactiveMap(options = {}) {
+  const { name, maxSize, defaultTtl, ...nodeOpts } = options;
+  const store = /* @__PURE__ */ new Map();
+  let current = emptySnapshot();
+  const n = state(current, {
+    ...nodeOpts,
+    name,
+    describeKind: "state",
+    equals: snapshotEqualsVersion
+  });
+  function pruneExpiredInternal() {
+    const now = monotonicNs();
+    let removed = false;
+    for (const [k, e] of store) {
+      if (isExpired(e, now)) {
+        store.delete(k);
+        removed = true;
+      }
+    }
+    return removed;
+  }
+  function evictLruWhileOver() {
+    if (maxSize === void 0 || maxSize < 1) return;
+    while (store.size > maxSize) {
+      const first2 = store.keys().next().value;
+      if (first2 === void 0) break;
+      store.delete(first2);
+    }
+  }
+  function pushSnapshot() {
+    pruneExpiredInternal();
+    const now = monotonicNs();
+    const map2 = buildMap(store, now);
+    const nv = n.v;
+    current = bumpVersion(current, { map: map2 }, nv ? { id: nv.id, version: nv.version } : void 0);
+    batch(() => {
+      n.down([[DIRTY]]);
+      n.down([[DATA, current]]);
+    });
+  }
+  function touchLru(key) {
+    const e = store.get(key);
+    if (e === void 0) return;
+    store.delete(key);
+    store.set(key, e);
+  }
+  const bundle = {
+    node: n,
+    get(key) {
+      const now = monotonicNs();
+      const e = store.get(key);
+      if (e === void 0) return void 0;
+      if (isExpired(e, now)) {
+        store.delete(key);
+        pushSnapshot();
+        return void 0;
+      }
+      touchLru(key);
+      return e.value;
+    },
+    set(key, value, setOpts) {
+      pruneExpiredInternal();
+      const ttlSec = setOpts?.ttl ?? defaultTtl;
+      if (ttlSec !== void 0 && ttlSec <= 0) {
+        throw new RangeError(`reactiveMap: ttl must be positive (got ${ttlSec})`);
+      }
+      const expiresAt = ttlSec !== void 0 ? monotonicNs() + ttlSec * 1e9 : void 0;
+      if (store.has(key)) store.delete(key);
+      store.set(key, { value, expiresAt });
+      evictLruWhileOver();
+      pushSnapshot();
+    },
+    delete(key) {
+      if (!store.delete(key)) return;
+      pushSnapshot();
+    },
+    clear() {
+      if (store.size === 0) return;
+      store.clear();
+      pushSnapshot();
+    },
+    has(key) {
+      const now = monotonicNs();
+      const e = store.get(key);
+      if (e === void 0) return false;
+      if (isExpired(e, now)) {
+        store.delete(key);
+        pushSnapshot();
+        return false;
+      }
+      touchLru(key);
+      return true;
+    },
+    get size() {
+      pruneExpiredInternal();
+      return store.size;
+    },
+    pruneExpired() {
+      if (!pruneExpiredInternal()) return;
+      pushSnapshot();
+    }
+  };
+  return bundle;
+}
+
+// src/extra/composite.ts
+function isNodeLike(value) {
+  return typeof value === "object" && value !== null && typeof value.get === "function" && 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) {
+    const verifyStream = switchMap(triggerNode, () => verifyFn(sourceNode.get()));
+    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 keepalive(node2) {
+  node2.subscribe(() => void 0);
+}
+function mapFromSnapshot(snapshot) {
+  if (typeof snapshot === "object" && snapshot !== null && "value" in snapshot && typeof snapshot.value === "object" && snapshot.value !== null && "map" in snapshot.value) {
+    return snapshot.value.map ?? /* @__PURE__ */ new Map();
+  }
+  return /* @__PURE__ */ new Map();
+}
+function asReadonlyMap(store) {
+  return mapFromSnapshot(store.node.get());
+}
+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);
+  const extractionStream = switchMap(sourceNode, (raw) => extractFn(raw, asReadonlyMap(store)));
+  forEach(extractionStream, (extraction) => {
+    applyExtraction(store, extraction);
+  });
+  if (opts.evict) {
+    const evictionKeys = dynamicNode((get) => {
+      const out = [];
+      const snapshot = mapFromSnapshot(get(store.node));
+      for (const [key, mem] of snapshot) {
+        const verdict = opts.evict(key, mem);
+        if (isNodeLike(verdict)) {
+          if (get(verdict) === true) out.push(key);
+          continue;
+        }
+        if (typeof verdict === "boolean") {
+          if (verdict) out.push(key);
+          continue;
+        }
+        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(asReadonlyMap(store))
+    );
+    forEach(consolidationStream, (extraction) => {
+      applyExtraction(store, extraction);
+    });
+  }
+  const compact = derived([store.node, 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;
+      }
+    }
+    return packed;
+  });
+  const size = derived([store.node], ([snapshot]) => mapFromSnapshot(snapshot).size);
+  keepalive(compact);
+  keepalive(size);
+  return { store, compact, size };
+}
+
+// src/extra/pubsub.ts
+var PubSubHubImpl = class {
+  topics = /* @__PURE__ */ new Map();
+  topic(name) {
+    let n = this.topics.get(name);
+    if (n === void 0) {
+      n = state(void 0, { describeKind: "state" });
+      this.topics.set(name, n);
+    }
+    return n;
+  }
+  publish(name, value) {
+    const t = this.topic(name);
+    batch(() => {
+      t.down([[DIRTY]]);
+      t.down([[DATA, value]]);
+    });
+  }
+  removeTopic(name) {
+    const n = this.topics.get(name);
+    if (n === void 0) return false;
+    n.down([[TEARDOWN]]);
+    this.topics.delete(name);
+    return true;
+  }
+};
+function pubsub() {
+  return new PubSubHubImpl();
+}
+
+// src/extra/reactive-index.ts
+function emptySnapshot2() {
+  return { version: 0, value: { rows: [] } };
+}
+function rowKey(row) {
+  return [row.secondary, row.primary];
+}
+function cmpOrd(a, b) {
+  if (a === b) return 0;
+  const ta = typeof a;
+  const tb = typeof b;
+  if (ta === tb && (ta === "number" || ta === "string" || ta === "boolean" || ta === "bigint")) {
+    const ax = a;
+    const bx = b;
+    if (ax < bx) return -1;
+    if (ax > bx) return 1;
+    return 0;
+  }
+  return String(a).localeCompare(String(b));
+}
+function compareKeys(a, b) {
+  let c = cmpOrd(a[0], b[0]);
+  if (c !== 0) return c;
+  c = cmpOrd(a[1], b[1]);
+  return c;
+}
+function bisectLeft(rows, row) {
+  const k = rowKey(row);
+  let lo = 0;
+  let hi = rows.length;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    if (compareKeys(k, rowKey(rows[mid])) > 0) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo;
+}
+function byPrimaryMap(rows) {
+  const m = /* @__PURE__ */ new Map();
+  for (const r of rows) m.set(r.primary, r.value);
+  return m;
+}
+function keepaliveDerived(n) {
+  void n.subscribe(() => {
+  });
+}
+function reactiveIndex(options = {}) {
+  const { name } = options;
+  const buf = [];
+  let current = emptySnapshot2();
+  const ordered = state(current, {
+    name,
+    describeKind: "state",
+    equals: snapshotEqualsVersion
+  });
+  const byPrimary = derived(
+    [ordered],
+    ([s]) => {
+      const rows = s.value.rows;
+      return byPrimaryMap(rows);
+    },
+    { initial: /* @__PURE__ */ new Map(), describeKind: "derived" }
+  );
+  keepaliveDerived(byPrimary);
+  function pushSnapshot() {
+    const ov = ordered.v;
+    current = bumpVersion(
+      current,
+      { rows: [...buf] },
+      ov ? { id: ov.id, version: ov.version } : void 0
+    );
+    batch(() => {
+      ordered.down([[DIRTY]]);
+      ordered.down([[DATA, current]]);
+    });
+  }
+  return {
+    ordered,
+    byPrimary,
+    upsert(primary, secondary, value) {
+      const next = buf.filter((r) => r.primary !== primary);
+      const row = { primary, secondary, value };
+      const pos = bisectLeft(next, row);
+      next.splice(pos, 0, row);
+      buf.length = 0;
+      buf.push(...next);
+      pushSnapshot();
+    },
+    delete(primary) {
+      const next = buf.filter((r) => r.primary !== primary);
+      if (next.length === buf.length) return;
+      buf.length = 0;
+      buf.push(...next);
+      pushSnapshot();
+    },
+    clear() {
+      if (buf.length === 0) return;
+      buf.length = 0;
+      pushSnapshot();
+    }
+  };
+}
+
+// src/extra/reactive-list.ts
+function emptySnapshot3() {
+  return { version: 0, value: { items: [] } };
+}
+function reactiveList(initial, options = {}) {
+  const { name } = options;
+  const buf = initial ? [...initial] : [];
+  let current = buf.length > 0 ? { version: 1, value: { items: [...buf] } } : emptySnapshot3();
+  const items = state(current, {
+    name,
+    describeKind: "state",
+    equals: snapshotEqualsVersion
+  });
+  function pushSnapshot() {
+    const iv = items.v;
+    current = bumpVersion(
+      current,
+      { items: [...buf] },
+      iv ? { id: iv.id, version: iv.version } : void 0
+    );
+    batch(() => {
+      items.down([[DIRTY]]);
+      items.down([[DATA, current]]);
+    });
+  }
+  return {
+    items,
+    append(value) {
+      buf.push(value);
+      pushSnapshot();
+    },
+    insert(index, value) {
+      if (index < 0 || index > buf.length) {
+        throw new RangeError("index out of range");
+      }
+      buf.splice(index, 0, value);
+      pushSnapshot();
+    },
+    pop(index = -1) {
+      if (buf.length === 0) {
+        throw new RangeError("pop from empty list");
+      }
+      const i = index >= 0 ? index : buf.length + index;
+      if (i < 0 || i >= buf.length) {
+        throw new RangeError("index out of range");
+      }
+      const [v] = buf.splice(i, 1);
+      pushSnapshot();
+      return v;
+    },
+    clear() {
+      if (buf.length === 0) return;
+      buf.length = 0;
+      pushSnapshot();
+    }
+  };
+}
+
+// src/extra/worker/protocol.ts
+var signalToNameMap = /* @__PURE__ */ new Map([
+  [INVALIDATE, "INVALIDATE"],
+  [PAUSE, "PAUSE"],
+  [RESUME, "RESUME"],
+  [TEARDOWN, "TEARDOWN"],
+  [COMPLETE, "COMPLETE"],
+  [ERROR, "ERROR"]
+]);
+var nameToSignalMap = /* @__PURE__ */ new Map([
+  ["INVALIDATE", INVALIDATE],
+  ["PAUSE", PAUSE],
+  ["RESUME", RESUME],
+  ["TEARDOWN", TEARDOWN],
+  ["COMPLETE", COMPLETE],
+  ["ERROR", ERROR]
+]);
+function signalToName(s) {
+  const known = signalToNameMap.get(s);
+  if (known) return known;
+  const key = Symbol.keyFor(s);
+  return key ?? "UNKNOWN";
+}
+function nameToSignal(name) {
+  const known = nameToSignalMap.get(name);
+  if (known) return known;
+  if (name && name !== "UNKNOWN") return Symbol.for(name);
+  return void 0;
+}
+function serializeError(err) {
+  if (err instanceof Error) {
+    return { message: err.message, name: err.name, stack: err.stack };
+  }
+  return { message: String(err), name: "Error" };
+}
+function deserializeError(payload) {
+  const err = new Error(payload.message);
+  err.name = payload.name;
+  if (payload.stack) err.stack = payload.stack;
+  return err;
+}
+
+// src/extra/worker/transport.ts
+function createTransport(target) {
+  if (typeof MessagePort !== "undefined" && target instanceof MessagePort) {
+    return {
+      post(data, transfer) {
+        target.postMessage(data, transfer ?? []);
+      },
+      listen(handler) {
+        const h = (e) => handler(e.data);
+        target.addEventListener("message", h);
+        target.start();
+        return () => target.removeEventListener("message", h);
+      },
+      terminate() {
+        target.close();
+      }
+    };
+  }
+  if (typeof SharedWorker !== "undefined" && target instanceof SharedWorker) {
+    return createTransport(target.port);
+  }
+  if (typeof Worker !== "undefined" && target instanceof Worker) {
+    return {
+      post(data, transfer) {
+        target.postMessage(data, transfer ?? []);
+      },
+      listen(handler) {
+        const h = (e) => handler(e.data);
+        target.addEventListener("message", h);
+        return () => target.removeEventListener("message", h);
+      },
+      terminate() {
+        target.terminate();
+      }
+    };
+  }
+  if (typeof BroadcastChannel !== "undefined" && target instanceof BroadcastChannel) {
+    return {
+      post(data, transfer) {
+        if (transfer && transfer.length > 0) {
+          console.warn(
+            "[graphrefly] WorkerTransport: BroadcastChannel does not support Transferable objects. The transfer argument is ignored and objects will be cloned instead."
+          );
+        }
+        target.postMessage(data);
+      },
+      listen(handler) {
+        const h = (e) => handler(e.data);
+        target.addEventListener("message", h);
+        return () => target.removeEventListener("message", h);
+      },
+      terminate() {
+        target.close();
+      }
+    };
+  }
+  if (typeof ServiceWorker !== "undefined" && target instanceof ServiceWorker) {
+    return {
+      post(data, transfer) {
+        target.postMessage(data, transfer ?? []);
+      },
+      listen(handler) {
+        const h = (e) => {
+          if (e.source === target) handler(e.data);
+        };
+        navigator.serviceWorker.addEventListener("message", h);
+        return () => navigator.serviceWorker.removeEventListener("message", h);
+      }
+    };
+  }
+  throw new Error(
+    "createTransport: unsupported target type. Expected Worker, SharedWorker, ServiceWorker, BroadcastChannel, or MessagePort."
+  );
+}
+
+// src/extra/worker/bridge.ts
+function isTransport(t) {
+  return typeof t === "object" && t !== null && typeof t.post === "function" && typeof t.listen === "function";
+}
+function workerBridge(target, opts) {
+  const transport = isTransport(target) ? target : createTransport(target);
+  const bridgeName = opts.name ?? "workerBridge";
+  const exposeEntries = Object.entries(opts.expose ?? {});
+  const importNames = opts.import ?? [];
+  const transferFns = opts.transfer ?? {};
+  const statusNode = state("connecting", {
+    name: `${bridgeName}::meta::status`
+  });
+  const errorNode = state(null, {
+    name: `${bridgeName}::meta::error`
+  });
+  const proxyNodes = /* @__PURE__ */ new Map();
+  const lastSeenImportVersions = /* @__PURE__ */ new Map();
+  for (const name of importNames) {
+    const proxy = state(void 0, { name: `${bridgeName}::${name}` });
+    proxyNodes.set(name, proxy);
+  }
+  const lastSent = /* @__PURE__ */ new Map();
+  let effectUnsub;
+  if (exposeEntries.length > 0) {
+    const exposedNodes = exposeEntries.map(([, n]) => n);
+    const aggregated = derived(
+      exposedNodes,
+      () => {
+        const updates = {};
+        for (const [name, n] of exposeEntries) {
+          const v = n.get();
+          if (v !== lastSent.get(name)) {
+            updates[name] = v;
+            lastSent.set(name, v);
+          }
+        }
+        return updates;
+      },
+      { equals: () => false, name: `${bridgeName}::aggregated` }
+    );
+    const effectNode = effect([aggregated], () => {
+      const updates = aggregated.get();
+      if (Object.keys(updates).length === 0) return;
+      const transferList = [];
+      for (const name of Object.keys(updates)) {
+        const fn = transferFns[name];
+        if (fn) transferList.push(...fn(updates[name]));
+      }
+      let versions;
+      for (const [name, n] of exposeEntries) {
+        if (name in updates && n.v != null) {
+          if (versions == null) versions = {};
+          versions[name] = n.v.version;
+        }
+      }
+      const msg = { t: "b", u: updates, ...versions ? { v: versions } : {} };
+      try {
+        transport.post(msg, transferList.length > 0 ? transferList : void 0);
+      } catch (err) {
+        errorNode.down([[DATA, err instanceof Error ? err : new Error(String(err))]]);
+      }
+    });
+    effectUnsub = effectNode.subscribe(() => {
+    });
+  }
+  let destroyed = false;
+  const unlisten = transport.listen((data) => {
+    if (destroyed) return;
+    const msg = data;
+    switch (msg.t) {
+      // Worker ready — set proxy nodes with initial values
+      case "r": {
+        if (handshakeTimer !== void 0) clearTimeout(handshakeTimer);
+        batch(() => {
+          for (const [name, value] of Object.entries(msg.stores)) {
+            const proxy = proxyNodes.get(name);
+            if (proxy) proxy.down([[DATA, value]]);
+          }
+        });
+        statusNode.down([[DATA, "connected"]]);
+        const initValues = {};
+        for (const [name, n] of exposeEntries) {
+          initValues[name] = n.get();
+          lastSent.set(name, initValues[name]);
+        }
+        transport.post({ t: "i", stores: initValues });
+        break;
+      }
+      // Single value update from worker
+      case "v": {
+        const proxy = proxyNodes.get(msg.s);
+        if (proxy) proxy.down([[DATA, msg.d]]);
+        break;
+      }
+      // Batch value update from worker
+      case "b": {
+        batch(() => {
+          for (const [name, value] of Object.entries(msg.u)) {
+            const incomingVersion = msg.v?.[name];
+            if (incomingVersion != null) {
+              const lastSeen = lastSeenImportVersions.get(name);
+              if (lastSeen != null && incomingVersion <= lastSeen) continue;
+              lastSeenImportVersions.set(name, incomingVersion);
+            }
+            const proxy = proxyNodes.get(name);
+            if (proxy) proxy.down([[DATA, value]]);
+          }
+        });
+        break;
+      }
+      // Error from worker node
+      case "e": {
+        const proxy = proxyNodes.get(msg.s);
+        if (proxy) proxy.down([[ERROR, deserializeError(msg.err)]]);
+        break;
+      }
+      // Lifecycle signal from worker
+      case "s": {
+        const sig = nameToSignal(msg.sig);
+        if (!sig) break;
+        const targets = msg.s === "*" ? [...proxyNodes.values()] : proxyNodes.has(msg.s) ? [proxyNodes.get(msg.s)] : [];
+        for (const proxy of targets) {
+          proxy.down(msg.d === void 0 ? [[sig]] : [[sig, msg.d]]);
+        }
+        break;
+      }
+    }
+  });
+  const exposeUnsubs = [];
+  for (const [name, n] of exposeEntries) {
+    const unsub = n.subscribe(((msgs) => {
+      if (destroyed) return;
+      for (const m of msgs) {
+        const type = m[0];
+        if (type === DATA) continue;
+        if (knownMessageTypes.includes(type) && messageTier(type) < 2) continue;
+        if (type === ERROR) {
+          transport.post({
+            t: "e",
+            s: name,
+            err: serializeError(m[1])
+          });
+        } else {
+          transport.post({
+            t: "s",
+            s: name,
+            sig: signalToName(type),
+            d: m.length > 1 ? m[1] : void 0
+          });
+        }
+      }
+    }));
+    exposeUnsubs.push(unsub);
+  }
+  let handshakeTimer;
+  if (opts.timeoutMs != null && opts.timeoutMs > 0) {
+    handshakeTimer = setTimeout(() => {
+      if (statusNode.get() === "connecting") {
+        errorNode.down([[DATA, new Error("Worker bridge handshake timeout")]]);
+        destroy();
+      }
+    }, opts.timeoutMs);
+  }
+  function destroy() {
+    if (destroyed) return;
+    destroyed = true;
+    if (handshakeTimer !== void 0) clearTimeout(handshakeTimer);
+    transport.post({
+      t: "s",
+      s: "*",
+      sig: signalToName(TEARDOWN)
+    });
+    if (effectUnsub) effectUnsub();
+    for (const unsub of exposeUnsubs) unsub();
+    exposeUnsubs.length = 0;
+    unlisten();
+    statusNode.down([[DATA, "closed"]]);
+    lastSent.clear();
+    lastSeenImportVersions.clear();
+    proxyNodes.clear();
+  }
+  const result = {
+    meta: { status: statusNode, error: errorNode },
+    destroy
+  };
+  for (const [name, proxy] of proxyNodes) {
+    result[name] = proxy;
+  }
+  return result;
+}
+
+// src/extra/worker/self.ts
+function isTransport2(t) {
+  return typeof t === "object" && t !== null && typeof t.post === "function" && typeof t.listen === "function";
+}
+function workerSelf(target, opts) {
+  const transport = isTransport2(target) ? target : createTransport(target);
+  const importNames = opts.import ?? [];
+  const transferFns = opts.transfer ?? {};
+  const proxyNodes = /* @__PURE__ */ new Map();
+  const lastSeenImportVersions = /* @__PURE__ */ new Map();
+  const importedObj = {};
+  for (const name of importNames) {
+    const s = state(void 0, { name: `worker::${name}` });
+    proxyNodes.set(name, s);
+    importedObj[name] = s;
+  }
+  const exposedNodes = opts.expose(importedObj);
+  const exposeEntries = Object.entries(exposedNodes);
+  const lastSent = /* @__PURE__ */ new Map();
+  let effectUnsub;
+  let destroyed = false;
+  if (exposeEntries.length > 0) {
+    const nodes = exposeEntries.map(([, n]) => n);
+    const aggregated = derived(
+      nodes,
+      () => {
+        const updates = {};
+        for (const [name, n] of exposeEntries) {
+          const v = n.get();
+          if (v !== lastSent.get(name)) {
+            updates[name] = v;
+            lastSent.set(name, v);
+          }
+        }
+        return updates;
+      },
+      { equals: () => false, name: "workerSelf::aggregated" }
+    );
+    const effectNode = effect([aggregated], () => {
+      if (destroyed) return;
+      const updates = aggregated.get();
+      if (Object.keys(updates).length === 0) return;
+      const transferList = [];
+      for (const name of Object.keys(updates)) {
+        const fn = transferFns[name];
+        if (fn) transferList.push(...fn(updates[name]));
+      }
+      let versions;
+      for (const [name, n] of exposeEntries) {
+        if (name in updates && n.v != null) {
+          if (versions == null) versions = {};
+          versions[name] = n.v.version;
+        }
+      }
+      const msg = { t: "b", u: updates, ...versions ? { v: versions } : {} };
+      try {
+        transport.post(msg, transferList.length > 0 ? transferList : void 0);
+      } catch (_err) {
+      }
+    });
+    effectUnsub = effectNode.subscribe(() => {
+    });
+  }
+  const exposeUnsubs = [];
+  for (const [name, n] of exposeEntries) {
+    const unsub = n.subscribe(((msgs) => {
+      if (destroyed) return;
+      for (const m of msgs) {
+        const type = m[0];
+        if (type === DATA) continue;
+        if (knownMessageTypes.includes(type) && messageTier(type) < 2) continue;
+        if (type === ERROR) {
+          transport.post({
+            t: "e",
+            s: name,
+            err: serializeError(m[1])
+          });
+        } else {
+          transport.post({
+            t: "s",
+            s: name,
+            sig: signalToName(type),
+            d: m.length > 1 ? m[1] : void 0
+          });
+        }
+      }
+    }));
+    exposeUnsubs.push(unsub);
+  }
+  const unlisten = transport.listen((data) => {
+    if (destroyed) return;
+    const msg = data;
+    switch (msg.t) {
+      // Init from main — set proxy node values
+      case "i": {
+        batch(() => {
+          for (const [name, value] of Object.entries(msg.stores)) {
+            const proxy = proxyNodes.get(name);
+            if (proxy) proxy.down([[DATA, value]]);
+          }
+        });
+        break;
+      }
+      // Single value update from main
+      case "v": {
+        const proxy = proxyNodes.get(msg.s);
+        if (proxy) proxy.down([[DATA, msg.d]]);
+        break;
+      }
+      // Batch value update from main
+      case "b": {
+        batch(() => {
+          for (const [name, value] of Object.entries(msg.u)) {
+            const incomingVersion = msg.v?.[name];
+            if (incomingVersion != null) {
+              const lastSeen = lastSeenImportVersions.get(name);
+              if (lastSeen != null && incomingVersion <= lastSeen) continue;
+              lastSeenImportVersions.set(name, incomingVersion);
+            }
+            const proxy = proxyNodes.get(name);
+            if (proxy) proxy.down([[DATA, value]]);
+          }
+        });
+        break;
+      }
+      // Error from main node
+      case "e": {
+        const proxy = proxyNodes.get(msg.s);
+        if (proxy) proxy.down([[ERROR, deserializeError(msg.err)]]);
+        break;
+      }
+      // Lifecycle signal from main
+      case "s": {
+        const sig = nameToSignal(msg.sig);
+        if (!sig) break;
+        if (sig === TEARDOWN && msg.s === "*") {
+          destroy();
+          return;
+        }
+        const targets = msg.s === "*" ? [...proxyNodes.values()] : proxyNodes.has(msg.s) ? [proxyNodes.get(msg.s)] : [];
+        for (const proxy of targets) {
+          proxy.down(msg.d === void 0 ? [[sig]] : [[sig, msg.d]]);
+        }
+        break;
+      }
+    }
+  });
+  const readyValues = {};
+  for (const [name, n] of exposeEntries) {
+    readyValues[name] = n.get();
+    lastSent.set(name, readyValues[name]);
+  }
+  transport.post({ t: "r", stores: readyValues });
+  function destroy() {
+    if (destroyed) return;
+    destroyed = true;
+    if (effectUnsub) effectUnsub();
+    for (const unsub of exposeUnsubs) unsub();
+    exposeUnsubs.length = 0;
+    unlisten();
+    transport.terminate?.();
+    lastSent.clear();
+    lastSeenImportVersions.clear();
+    proxyNodes.clear();
+  }
+  return { destroy };
+}
+
+export {
+  NS_PER_MS,
+  NS_PER_SEC,
+  constant,
+  linear,
+  exponential,
+  fibonacci,
+  decorrelatedJitter,
+  withMaxAttempts,
+  resolveBackoffPreset,
+  retry,
+  CircuitOpenError,
+  circuitBreaker,
+  withBreaker,
+  tokenBucket,
+  tokenTracker,
+  rateLimiter,
+  withStatus,
+  fromWebSocket,
+  fromWebhook,
+  fromHTTP,
+  toSSE,
+  toWebSocket,
+  fromMCP,
+  fromGitHook,
+  fromOTel,
+  fromSyslog,
+  parseSyslog,
+  fromStatsD,
+  parseStatsD,
+  fromPrometheus,
+  parsePrometheusText,
+  fromKafka,
+  toKafka,
+  fromRedisStream,
+  toRedisStream,
+  fromCSV,
+  fromNDJSON,
+  fromClickHouseWatch,
+  MemoryCheckpointAdapter,
+  DictCheckpointAdapter,
+  FileCheckpointAdapter,
+  SqliteCheckpointAdapter,
+  saveGraphCheckpoint,
+  restoreGraphCheckpoint,
+  checkpointNodeValue,
+  fromIDBRequest,
+  fromIDBTransaction,
+  saveGraphCheckpointIndexedDb,
+  restoreGraphCheckpointIndexedDb,
+  map,
+  filter,
+  scan,
+  reduce,
+  take,
+  skip,
+  takeWhile,
+  takeUntil,
+  first,
+  last,
+  find,
+  elementAt,
+  startWith,
+  tap,
+  distinctUntilChanged,
+  pairwise,
+  combine,
+  withLatestFrom,
+  merge,
+  zip,
+  concat,
+  race,
+  switchMap,
+  exhaustMap,
+  concatMap,
+  mergeMap,
+  flatMap,
+  delay,
+  debounce,
+  throttle,
+  sample,
+  audit,
+  timeout,
+  buffer,
+  bufferCount,
+  windowCount,
+  bufferTime,
+  windowTime,
+  window,
+  interval,
+  repeat,
+  pausable,
+  rescue,
+  gate,
+  combineLatest,
+  debounceTime,
+  throttleTime,
+  catchError,
+  reactiveMap,
+  verifiable,
+  distill,
+  pubsub,
+  reactiveIndex,
+  reactiveList,
+  signalToName,
+  nameToSignal,
+  serializeError,
+  deserializeError,
+  createTransport,
+  workerBridge,
+  workerSelf,
+  extra_exports
+};
+//# sourceMappingURL=chunk-VPS7L64N.js.map