@graphrefly/graphrefly 0.27.0 → 0.29.0

package/dist/chunk-BQ6RQQFF.js

@@ -1,5087 +0,0 @@
-import {
-  createWatermarkController,
-  toObservable
-} from "./chunk-OFVJBJXR.js";
-import {
-  NS_PER_MS,
-  NS_PER_SEC,
-  audit,
-  buffer,
-  bufferCount,
-  bufferTime,
-  catchError,
-  combine,
-  combineLatest,
-  concat,
-  concatMap,
-  constant,
-  debounce,
-  debounceTime,
-  decorrelatedJitter,
-  delay,
-  distill,
-  distinctUntilChanged,
-  elementAt,
-  exhaustMap,
-  exponential,
-  fibonacci,
-  filter,
-  find,
-  first,
-  flatMap,
-  interval,
-  last,
-  linear,
-  map,
-  merge,
-  mergeMap,
-  pairwise,
-  pausable,
-  race,
-  reduce,
-  repeat,
-  rescue,
-  resolveBackoffPreset,
-  sample,
-  scan,
-  skip,
-  switchMap,
-  take,
-  takeUntil,
-  takeWhile,
-  tap,
-  throttle,
-  throttleTime,
-  valve,
-  verifiable,
-  window,
-  windowCount,
-  windowTime,
-  withLatestFrom,
-  withMaxAttempts,
-  zip
-} from "./chunk-RNHBMHKA.js";
-import {
-  NativeListBackend,
-  NativeMapBackend,
-  reactiveList,
-  reactiveMap
-} from "./chunk-WKNUIZOY.js";
-import {
-  NativeLogBackend,
-  reactiveLog
-} from "./chunk-J2VBW3DZ.js";
-import {
-  cached,
-  empty,
-  escapeRegexChar,
-  firstValueFrom,
-  firstWhere,
-  forEach,
-  fromAny,
-  fromAsyncIter,
-  fromCron,
-  fromEvent,
-  fromIter,
-  fromPromise,
-  fromRaf,
-  fromTimer,
-  globToRegExp,
-  keepalive,
-  matchesAnyPattern,
-  matchesCron,
-  never,
-  of,
-  parseCron,
-  reactiveCounter,
-  replay,
-  share,
-  shareReplay,
-  throwError,
-  toArray
-} from "./chunk-BVZYTZ5H.js";
-import {
-  ResettableTimer,
-  RingBuffer
-} from "./chunk-7TAQJHQV.js";
-import {
-  batch,
-  defaultConfig,
-  derived,
-  effect,
-  monotonicNs,
-  node,
-  producer,
-  state,
-  wallClockNs
-} from "./chunk-PHOUUNK7.js";
-import {
-  COMPLETE,
-  DATA,
-  DIRTY,
-  ERROR,
-  INVALIDATE,
-  PAUSE,
-  RESOLVED,
-  RESUME,
-  TEARDOWN,
-  __export,
-  __require
-} from "./chunk-SX52TAR4.js";
-
-// src/extra/index.ts
-var extra_exports = {};
-__export(extra_exports, {
-  CircuitOpenError: () => CircuitOpenError,
-  NS_PER_MS: () => NS_PER_MS,
-  NS_PER_SEC: () => NS_PER_SEC,
-  NativeIndexBackend: () => NativeIndexBackend,
-  NativeListBackend: () => NativeListBackend,
-  NativeLogBackend: () => NativeLogBackend,
-  NativeMapBackend: () => NativeMapBackend,
-  NativePubSubBackend: () => NativePubSubBackend,
-  RateLimiterOverflowError: () => RateLimiterOverflowError,
-  ResettableTimer: () => ResettableTimer,
-  TimeoutError: () => TimeoutError,
-  audit: () => audit,
-  buffer: () => buffer,
-  bufferCount: () => bufferCount,
-  bufferTime: () => bufferTime,
-  cached: () => cached,
-  cascadingCache: () => cascadingCache,
-  catchError: () => catchError,
-  checkpointToRedis: () => checkpointToRedis,
-  checkpointToS3: () => checkpointToS3,
-  circuitBreaker: () => circuitBreaker,
-  combine: () => combine,
-  combineLatest: () => combineLatest,
-  concat: () => concat,
-  concatMap: () => concatMap,
-  constant: () => constant,
-  createTransport: () => createTransport,
-  createWatermarkController: () => createWatermarkController,
-  csvRows: () => csvRows,
-  debounce: () => debounce,
-  debounceTime: () => debounceTime,
-  decorrelatedJitter: () => decorrelatedJitter,
-  delay: () => delay,
-  deserializeError: () => deserializeError,
-  dictStorage: () => dictStorage,
-  distill: () => distill,
-  distinctUntilChanged: () => distinctUntilChanged,
-  elementAt: () => elementAt,
-  empty: () => empty,
-  escapeRegexChar: () => escapeRegexChar,
-  exhaustMap: () => exhaustMap,
-  exponential: () => exponential,
-  externalBundle: () => externalBundle,
-  externalProducer: () => externalProducer,
-  fallback: () => fallback,
-  fibonacci: () => fibonacci,
-  fileStorage: () => fileStorage,
-  filter: () => filter,
-  find: () => find,
-  first: () => first,
-  firstValueFrom: () => firstValueFrom,
-  firstWhere: () => firstWhere,
-  flatMap: () => flatMap,
-  forEach: () => forEach,
-  fromAny: () => fromAny,
-  fromAsyncIter: () => fromAsyncIter,
-  fromCSV: () => fromCSV,
-  fromClickHouseWatch: () => fromClickHouseWatch,
-  fromCron: () => fromCron,
-  fromDrizzle: () => fromDrizzle,
-  fromEvent: () => fromEvent,
-  fromFSWatch: () => fromFSWatch,
-  fromGitHook: () => fromGitHook,
-  fromHTTP: () => fromHTTP,
-  fromHTTPPoll: () => fromHTTPPoll,
-  fromHTTPStream: () => fromHTTPStream,
-  fromIDBRequest: () => fromIDBRequest,
-  fromIDBTransaction: () => fromIDBTransaction,
-  fromIter: () => fromIter,
-  fromKafka: () => fromKafka,
-  fromKysely: () => fromKysely,
-  fromMCP: () => fromMCP,
-  fromNATS: () => fromNATS,
-  fromNDJSON: () => fromNDJSON,
-  fromOTel: () => fromOTel,
-  fromPrisma: () => fromPrisma,
-  fromPrometheus: () => fromPrometheus,
-  fromPromise: () => fromPromise,
-  fromPulsar: () => fromPulsar,
-  fromRabbitMQ: () => fromRabbitMQ,
-  fromRaf: () => fromRaf,
-  fromRedisStream: () => fromRedisStream,
-  fromSSE: () => fromSSE,
-  fromSqlite: () => fromSqlite,
-  fromSqliteCursor: () => fromSqliteCursor,
-  fromStatsD: () => fromStatsD,
-  fromSyslog: () => fromSyslog,
-  fromTimer: () => fromTimer,
-  fromWebSocket: () => fromWebSocket,
-  fromWebSocketReconnect: () => fromWebSocketReconnect,
-  fromWebhook: () => fromWebhook,
-  globToRegExp: () => globToRegExp,
-  indexedDbStorage: () => indexedDbStorage,
-  interval: () => interval,
-  keepalive: () => keepalive,
-  last: () => last,
-  linear: () => linear,
-  lru: () => lru,
-  map: () => map,
-  matchesAnyPattern: () => matchesAnyPattern,
-  matchesCron: () => matchesCron,
-  memoryStorage: () => memoryStorage,
-  merge: () => merge,
-  mergeMap: () => mergeMap,
-  nameToSignal: () => nameToSignal,
-  ndjsonRows: () => ndjsonRows,
-  never: () => never,
-  of: () => of,
-  pairwise: () => pairwise,
-  parseCron: () => parseCron,
-  parsePrometheusText: () => parsePrometheusText,
-  parseStatsD: () => parseStatsD,
-  parseSyslog: () => parseSyslog,
-  pausable: () => pausable,
-  pubsub: () => pubsub,
-  race: () => race,
-  rateLimiter: () => rateLimiter,
-  reactiveCounter: () => reactiveCounter,
-  reactiveIndex: () => reactiveIndex,
-  reactiveList: () => reactiveList,
-  reactiveLog: () => reactiveLog,
-  reactiveMap: () => reactiveMap,
-  reactiveSink: () => reactiveSink,
-  reduce: () => reduce,
-  repeat: () => repeat,
-  replay: () => replay,
-  rescue: () => rescue,
-  resolveBackoffPreset: () => resolveBackoffPreset,
-  retry: () => retry,
-  retrySource: () => retrySource,
-  sample: () => sample,
-  scan: () => scan,
-  serializeError: () => serializeError,
-  share: () => share,
-  shareReplay: () => shareReplay,
-  signalToName: () => signalToName,
-  skip: () => skip,
-  sqliteStorage: () => sqliteStorage,
-  switchMap: () => switchMap,
-  take: () => take,
-  takeUntil: () => takeUntil,
-  takeWhile: () => takeWhile,
-  tap: () => tap,
-  throttle: () => throttle,
-  throttleTime: () => throttleTime,
-  throwError: () => throwError,
-  timeout: () => timeout,
-  toArray: () => toArray,
-  toCSV: () => toCSV,
-  toClickHouse: () => toClickHouse,
-  toFile: () => toFile,
-  toHTTP: () => toHTTP,
-  toKafka: () => toKafka,
-  toLoki: () => toLoki,
-  toMongo: () => toMongo,
-  toNATS: () => toNATS,
-  toObservable: () => toObservable,
-  toPostgres: () => toPostgres,
-  toPulsar: () => toPulsar,
-  toRabbitMQ: () => toRabbitMQ,
-  toReadableStream: () => toReadableStream,
-  toRedisStream: () => toRedisStream,
-  toS3: () => toS3,
-  toSSE: () => toSSE,
-  toSSEBytes: () => toSSEBytes,
-  toSqlite: () => toSqlite,
-  toTempo: () => toTempo,
-  toWebSocket: () => toWebSocket,
-  tokenBucket: () => tokenBucket,
-  valve: () => valve,
-  verifiable: () => verifiable,
-  window: () => window,
-  windowCount: () => windowCount,
-  windowTime: () => windowTime,
-  withBreaker: () => withBreaker,
-  withLatestFrom: () => withLatestFrom,
-  withMaxAttempts: () => withMaxAttempts,
-  withStatus: () => withStatus,
-  workerBridge: () => workerBridge,
-  workerSelf: () => workerSelf,
-  zip: () => zip
-});
-
-// src/extra/external-register.ts
-function sourceOpts(opts) {
-  return { describeKind: "producer", ...opts };
-}
-function externalProducer(register, opts) {
-  return producer((a) => {
-    let active = true;
-    const triad = {
-      emit(value) {
-        if (!active) return;
-        a.emit(value);
-      },
-      error(err) {
-        if (!active) return;
-        active = false;
-        a.down([[ERROR, err]]);
-      },
-      complete() {
-        if (!active) return;
-        active = false;
-        a.down([[COMPLETE]]);
-      }
-    };
-    let cleanup;
-    try {
-      const ret = register(triad);
-      cleanup = typeof ret === "function" ? ret : void 0;
-    } catch (err) {
-      triad.error(err);
-      return () => {
-        active = false;
-      };
-    }
-    return () => {
-      active = false;
-      try {
-        cleanup?.();
-      } catch {
-      }
-    };
-  }, sourceOpts(opts));
-}
-function externalBundle(register, channels, opts) {
-  let active = true;
-  let cleanup;
-  let activatedCount = 0;
-  let teardownCount = 0;
-  const nodes = {};
-  const channelNodes = [];
-  const finishCleanup = () => {
-    const fn = cleanup;
-    cleanup = void 0;
-    try {
-      fn?.();
-    } catch {
-    }
-  };
-  for (const ch of channels) {
-    const name = opts?.name ? `${opts.name}::${ch}` : ch;
-    const chOpts = opts?.channelOpts?.[ch];
-    const n = producer(
-      (_a) => {
-        activatedCount++;
-        return () => {
-          teardownCount++;
-          if (activatedCount > 0 && teardownCount >= activatedCount && teardownCount >= channels.length) {
-            finishCleanup();
-          }
-        };
-      },
-      sourceOpts({ ...chOpts, name })
-    );
-    nodes[ch] = n;
-    channelNodes.push(n);
-  }
-  const bundle = {};
-  for (const ch of channels) {
-    bundle[ch] = (value) => {
-      if (!active) return;
-      nodes[ch].down([[DATA, value]]);
-    };
-  }
-  bundle.error = (err) => {
-    if (!active) return;
-    active = false;
-    batch(() => {
-      for (const n of channelNodes) n.down([[ERROR, err]]);
-    });
-    finishCleanup();
-  };
-  bundle.complete = () => {
-    if (!active) return;
-    active = false;
-    batch(() => {
-      for (const n of channelNodes) n.down([[COMPLETE]]);
-    });
-    finishCleanup();
-  };
-  const ret = register(bundle);
-  cleanup = typeof ret === "function" ? ret : void 0;
-  const dispose = () => {
-    if (!active) return;
-    active = false;
-    batch(() => {
-      for (const n of channelNodes) {
-        try {
-          n.down([[COMPLETE]]);
-        } catch {
-        }
-      }
-    });
-    finishCleanup();
-  };
-  return Object.assign(nodes, { dispose });
-}
-
-// src/extra/reactive-sink.ts
-var BackpressureBuffer = class {
-  ring;
-  arr;
-  constructor(cap) {
-    if (cap === Number.POSITIVE_INFINITY || cap <= 0) {
-      this.arr = [];
-      this.ring = null;
-    } else {
-      this.ring = new RingBuffer(cap);
-      this.arr = null;
-    }
-  }
-  get length() {
-    return this.ring != null ? this.ring.size : this.arr.length;
-  }
-  push(item) {
-    if (this.ring != null) this.ring.push(item);
-    else this.arr.push(item);
-  }
-  /** Drop-oldest — O(1) in bounded mode. Returns undefined when empty. */
-  shift() {
-    if (this.ring != null) return this.ring.shift();
-    return this.arr.shift();
-  }
-  /** Full drain — returns contents, resets to empty. */
-  drain() {
-    if (this.ring != null) {
-      const out2 = this.ring.toArray();
-      this.ring.clear();
-      return out2;
-    }
-    const out = this.arr;
-    this.arr = [];
-    return out;
-  }
-};
-function coerceError(err) {
-  return err instanceof Error ? err : new Error(String(err));
-}
-function resolveBackoff(backoff) {
-  if (backoff === void 0) return null;
-  if (typeof backoff === "string") return resolveBackoffPreset(backoff);
-  return backoff;
-}
-function reactiveSink(source, config) {
-  const {
-    name,
-    onTransportError,
-    retry: retry2,
-    backpressure,
-    batchSize = Number.POSITIVE_INFINITY,
-    flushIntervalMs = 0,
-    serialize,
-    stopOn,
-    onUpstreamMessage,
-    onDispose,
-    send,
-    sendBatch,
-    ctx: ctxValue
-  } = config;
-  if (!send && !sendBatch) {
-    throw new Error("reactiveSink: `send` or `sendBatch` must be provided");
-  }
-  const ctx = ctxValue;
-  const maxAttempts = Math.max(1, retry2?.maxAttempts ?? 1);
-  const backoffStrategy = resolveBackoff(
-    retry2?.backoff ?? (maxAttempts > 1 ? "exponential" : void 0)
-  );
-  const shouldRetry = retry2?.shouldRetry ?? (() => true);
-  const useBuffering = sendBatch !== void 0 || batchSize < Number.POSITIVE_INFINITY || flushIntervalMs > 0;
-  const nameFor = (suffix) => name ? `${name}::${suffix}` : void 0;
-  const sent = state(void 0, {
-    equals: () => false,
-    name: nameFor("sent")
-  });
-  const failed = state(null, { name: nameFor("failed") });
-  const inFlightCountNode = state(0, { name: nameFor("inFlight") });
-  const errorsNode = state(null, { name: nameFor("errors") });
-  const bufferedNode = useBuffering ? state(0, { name: nameFor("buffered") }) : void 0;
-  const pausedNode = backpressure ? state(false, { name: nameFor("paused") }) : void 0;
-  let inFlightCount = 0;
-  const bumpInFlight = (delta) => {
-    inFlightCount += delta;
-    inFlightCountNode.down([[DATA, inFlightCount]]);
-  };
-  const reportError = (err) => {
-    try {
-      onTransportError?.(err);
-    } catch {
-    }
-    try {
-      errorsNode.down([[DATA, err]]);
-    } catch {
-    }
-  };
-  const inFlightPromises = /* @__PURE__ */ new Set();
-  const trackPromise = (p) => {
-    inFlightPromises.add(p);
-    const done = () => inFlightPromises.delete(p);
-    p.then(done, done);
-  };
-  const scheduleRetry = (runAgain, attempt, error) => {
-    const raw = backoffStrategy ? backoffStrategy(attempt - 1, error, null) : 0;
-    const delayNs = raw === null || raw === void 0 ? 0 : typeof raw === "number" && raw > 0 ? raw : 0;
-    const delayMs = Math.max(1, Math.ceil(delayNs / NS_PER_MS));
-    return new Promise((resolve) => {
-      setTimeout(() => resolve(runAgain()), delayMs);
-    });
-  };
-  const isThenable2 = (v) => v != null && typeof v === "object" && typeof v.then === "function";
-  const performSend = (value) => {
-    let payload;
-    try {
-      payload = serialize ? serialize(value) : value;
-    } catch (rawErr) {
-      const error = coerceError(rawErr);
-      reportError({ stage: "serialize", error, value });
-      failed.down([[DATA, { value, error, attempts: 0 }]]);
-      return Promise.resolve();
-    }
-    let attempt = 0;
-    const onError = (rawErr) => {
-      bumpInFlight(-1);
-      const error = coerceError(rawErr);
-      reportError({ stage: "send", error, value, attempt });
-      const more = attempt < maxAttempts && shouldRetry(error, attempt);
-      if (!more) {
-        failed.down([[DATA, { value, error, attempts: attempt }]]);
-        return void 0;
-      }
-      return scheduleRetry(run, attempt, error);
-    };
-    const onSuccess = () => {
-      bumpInFlight(-1);
-      sent.down([[DATA, value]]);
-    };
-    function run() {
-      attempt += 1;
-      bumpInFlight(1);
-      let result;
-      try {
-        result = send(payload, ctx);
-      } catch (rawErr) {
-        return onError(rawErr) ?? Promise.resolve();
-      }
-      if (isThenable2(result)) {
-        return result.then(onSuccess, (rawErr) => onError(rawErr));
-      }
-      onSuccess();
-      return Promise.resolve();
-    }
-    return run();
-  };
-  const maxBuf = backpressure?.maxBuffer ?? Number.POSITIVE_INFINITY;
-  const buffer2 = new BackpressureBuffer(maxBuf);
-  let flushTimer;
-  let disposed = false;
-  const updateBuffered = () => {
-    bufferedNode?.down([[DATA, buffer2.length]]);
-  };
-  const markPaused = (paused) => {
-    if (!pausedNode) return;
-    pausedNode.down([[DATA, paused]]);
-  };
-  const bpStrategy = backpressure?.strategy ?? "drop-oldest";
-  const pushWithBackpressure = (value, payload) => {
-    const entry = { value, payload };
-    if (buffer2.length < maxBuf) {
-      buffer2.push(entry);
-      updateBuffered();
-      return true;
-    }
-    if (bpStrategy === "drop-oldest") {
-      const dropped = buffer2.shift();
-      buffer2.push(entry);
-      updateBuffered();
-      markPaused(true);
-      failed.down([
-        [
-          DATA,
-          {
-            value: dropped.value,
-            error: new Error("backpressure: buffer overflow \u2014 dropped oldest"),
-            attempts: 0
-          }
-        ]
-      ]);
-      return true;
-    }
-    if (bpStrategy === "drop-newest") {
-      markPaused(true);
-      failed.down([
-        [
-          DATA,
-          {
-            value,
-            error: new Error("backpressure: buffer overflow \u2014 dropped newest"),
-            attempts: 0
-          }
-        ]
-      ]);
-      return false;
-    }
-    const err = new Error("backpressure: buffer overflow");
-    reportError({ stage: "send", error: err, value });
-    failed.down([[DATA, { value, error: err, attempts: 0 }]]);
-    markPaused(true);
-    return false;
-  };
-  const performBufferedBatchFlush = (chunk) => {
-    let attempt = 0;
-    const payloads = chunk.map((e) => e.payload);
-    const onError = (rawErr) => {
-      bumpInFlight(-1);
-      const error = coerceError(rawErr);
-      reportError({ stage: "send", error, value: chunk.map((e) => e.value), attempt });
-      const more = attempt < maxAttempts && shouldRetry(error, attempt);
-      if (!more) {
-        for (const { value: v } of chunk) {
-          failed.down([[DATA, { value: v, error, attempts: attempt }]]);
-        }
-        return void 0;
-      }
-      return scheduleRetry(run, attempt, error);
-    };
-    const onSuccess = () => {
-      bumpInFlight(-1);
-      for (const { value: v } of chunk) sent.down([[DATA, v]]);
-    };
-    function run() {
-      attempt += 1;
-      bumpInFlight(1);
-      let result;
-      try {
-        result = sendBatch(payloads, ctx);
-      } catch (rawErr) {
-        return onError(rawErr) ?? Promise.resolve();
-      }
-      if (isThenable2(result)) {
-        return result.then(onSuccess, (rawErr) => onError(rawErr));
-      }
-      onSuccess();
-      return Promise.resolve();
-    }
-    return run();
-  };
-  const performBufferedPerRecordFlush = async (chunk) => {
-    for (const entry of chunk) {
-      await performPreSerializedSend(entry.value, entry.payload);
-    }
-  };
-  const performPreSerializedSend = (value, payload) => {
-    let attempt = 0;
-    const onError = (rawErr) => {
-      bumpInFlight(-1);
-      const error = coerceError(rawErr);
-      reportError({ stage: "send", error, value, attempt });
-      const more = attempt < maxAttempts && shouldRetry(error, attempt);
-      if (!more) {
-        failed.down([[DATA, { value, error, attempts: attempt }]]);
-        return void 0;
-      }
-      return scheduleRetry(run, attempt, error);
-    };
-    const onSuccess = () => {
-      bumpInFlight(-1);
-      sent.down([[DATA, value]]);
-    };
-    function run() {
-      attempt += 1;
-      bumpInFlight(1);
-      let result;
-      try {
-        result = send(payload, ctx);
-      } catch (rawErr) {
-        return onError(rawErr) ?? Promise.resolve();
-      }
-      if (isThenable2(result)) {
-        return result.then(onSuccess, (rawErr) => onError(rawErr));
-      }
-      onSuccess();
-      return Promise.resolve();
-    }
-    return run();
-  };
-  const doFlush = () => {
-    if (disposed || buffer2.length === 0) return Promise.resolve();
-    const chunk = buffer2.drain();
-    updateBuffered();
-    markPaused(false);
-    if (sendBatch !== void 0) {
-      const p2 = performBufferedBatchFlush(chunk);
-      trackPromise(p2);
-      return p2;
-    }
-    const p = performBufferedPerRecordFlush(chunk);
-    trackPromise(p);
-    return p;
-  };
-  const scheduleFlush = () => {
-    if (flushTimer !== void 0 || disposed) return;
-    if (flushIntervalMs <= 0) return;
-    flushTimer = setTimeout(() => {
-      flushTimer = void 0;
-      void doFlush();
-    }, flushIntervalMs);
-  };
-  const unsub = source.subscribe((msgs) => {
-    for (const msg of msgs) {
-      const type = msg[0];
-      if (type !== DATA) {
-        try {
-          onUpstreamMessage?.(msg);
-        } catch {
-        }
-      }
-      if (type === DATA) {
-        const value = msg[1];
-        if (useBuffering) {
-          let payload;
-          if (serialize) {
-            try {
-              payload = serialize(value);
-            } catch (rawErr) {
-              const error = coerceError(rawErr);
-              reportError({ stage: "serialize", error, value });
-              failed.down([[DATA, { value, error, attempts: 0 }]]);
-              continue;
-            }
-          } else {
-            payload = value;
-          }
-          const admitted = pushWithBackpressure(value, payload);
-          if (!admitted) continue;
-          if (buffer2.length >= batchSize) void doFlush();
-          else scheduleFlush();
-        } else {
-          const p = performSend(value);
-          trackPromise(p);
-        }
-      } else if (defaultConfig.messageTier(type) >= 3) {
-        if (useBuffering) {
-          if (flushTimer !== void 0) {
-            clearTimeout(flushTimer);
-            flushTimer = void 0;
-          }
-          void doFlush();
-        }
-      }
-    }
-  });
-  let stopUnsub;
-  if (stopOn) {
-    let firstBatchSeen = false;
-    stopUnsub = stopOn.subscribe((msgs) => {
-      if (!firstBatchSeen) {
-        firstBatchSeen = true;
-        return;
-      }
-      if (msgs.length > 0 && !teardownRequested) dispose();
-    });
-  }
-  let teardownRequested = false;
-  const dispose = () => {
-    if (teardownRequested) return;
-    teardownRequested = true;
-    if (flushTimer !== void 0) {
-      clearTimeout(flushTimer);
-      flushTimer = void 0;
-    }
-    if (useBuffering) void doFlush();
-    disposed = true;
-    stopUnsub?.();
-    unsub();
-    const tearDown = (n) => {
-      try {
-        n.down([[TEARDOWN]]);
-      } catch {
-      }
-    };
-    tearDown(errorsNode);
-    tearDown(failed);
-    tearDown(sent);
-    tearDown(inFlightCountNode);
-    if (bufferedNode) tearDown(bufferedNode);
-    if (pausedNode) tearDown(pausedNode);
-    try {
-      onDispose?.();
-    } catch {
-    }
-  };
-  const handle = {
-    dispose,
-    sent,
-    failed,
-    inFlight: inFlightCountNode,
-    errors: errorsNode
-  };
-  if (useBuffering) {
-    handle.buffered = bufferedNode;
-    handle.flush = async () => {
-      if (disposed) return;
-      await doFlush();
-      await Promise.all(inFlightPromises);
-    };
-  }
-  if (pausedNode) handle.paused = pausedNode;
-  void COMPLETE;
-  void ERROR;
-  return handle;
-}
-
-// src/extra/resilience.ts
-function operatorOpts(opts) {
-  return { describeKind: "derived", ...opts };
-}
-function clampNonNegative(value) {
-  return value < 0 ? 0 : value;
-}
-function msgVal(m) {
-  return m[1];
-}
-function coerceDelayNs(raw) {
-  if (typeof raw !== "number" || !Number.isFinite(raw)) {
-    throw new TypeError("backoff strategy must return a finite number");
-  }
-  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(
-    (a) => {
-      let attempt = 0;
-      let stopped = false;
-      let prevDelay = null;
-      let unsub;
-      const timer = new ResettableTimer();
-      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);
-        if (raw === null || raw === void 0) {
-          disconnectUpstream();
-          a.down([[ERROR, err]]);
-          return;
-        }
-        let delayNs;
-        try {
-          delayNs = coerceDelayNs(raw);
-        } catch {
-          disconnectUpstream();
-          a.down([[ERROR, err]]);
-          return;
-        }
-        prevDelay = delayNs;
-        attempt += 1;
-        disconnectUpstream();
-        const delayMs = delayNs > 0 ? delayNs / NS_PER_MS : 1;
-        timer.start(delayMs, () => {
-          if (stopped) return;
-          connect();
-        });
-      }
-      function connect() {
-        timer.cancel();
-        disconnectUpstream();
-        unsub = source.subscribe((msgs) => {
-          if (stopped) return;
-          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;
-        timer.cancel();
-        disconnectUpstream();
-      };
-    },
-    {
-      ...operatorOpts(),
-      initial: source.cache
-    }
-  );
-}
-function retrySource(factory, 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(
-    (a) => {
-      let attempt = 0;
-      let stopped = false;
-      let prevDelay = null;
-      let unsub;
-      const timer = new ResettableTimer();
-      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);
-        if (raw === null || raw === void 0) {
-          disconnectUpstream();
-          a.down([[ERROR, err]]);
-          return;
-        }
-        let delayNs;
-        try {
-          delayNs = coerceDelayNs(raw);
-        } catch {
-          disconnectUpstream();
-          a.down([[ERROR, err]]);
-          return;
-        }
-        prevDelay = delayNs;
-        attempt += 1;
-        disconnectUpstream();
-        const delayMs = delayNs > 0 ? delayNs / NS_PER_MS : 1;
-        timer.start(delayMs, () => {
-          if (stopped) return;
-          connect();
-        });
-      }
-      function connect() {
-        timer.cancel();
-        disconnectUpstream();
-        let src;
-        try {
-          src = factory();
-        } catch (err) {
-          scheduleRetryOrFinish(err);
-          return;
-        }
-        unsub = src.subscribe((msgs) => {
-          if (stopped) return;
-          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;
-        timer.cancel();
-        disconnectUpstream();
-      };
-    },
-    {
-      ...operatorOpts(),
-      initial: opts?.initial
-    }
-  );
-}
-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 = clampNonNegative(options?.cooldownNs ?? 30 * NS_PER_SEC);
-  const cooldownStrategy = options?.cooldown ?? null;
-  const halfOpenMax = Math.max(1, options?.halfOpenMax ?? 1);
-  const now = options?.now ?? monotonicNs;
-  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.cache
-      }
-    );
-    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;
-    }
-  };
-}
-var RateLimiterOverflowError = class extends Error {
-  name = "RateLimiterOverflowError";
-  constructor(maxBuffer) {
-    super(`rateLimiter buffer overflow (maxBuffer=${maxBuffer})`);
-  }
-};
-function rateLimiter(source, opts) {
-  const { maxEvents, windowNs } = opts;
-  if (maxEvents <= 0) throw new RangeError("maxEvents must be > 0");
-  if (windowNs <= 0) throw new RangeError("windowNs must be > 0");
-  const maxBuffer = opts.maxBuffer;
-  if (maxBuffer !== void 0 && maxBuffer < 1) throw new RangeError("maxBuffer must be >= 1");
-  const onOverflow = opts.onOverflow ?? "drop-newest";
-  const refillPerSec = maxEvents * NS_PER_SEC / windowNs;
-  return producer(
-    (a) => {
-      const bucket = tokenBucket(maxEvents, refillPerSec);
-      const pending = [];
-      const timer = new ResettableTimer();
-      let terminated = false;
-      const tokenTimeNs = NS_PER_SEC / refillPerSec;
-      function tryEmit() {
-        while (pending.length > 0) {
-          if (bucket.tryConsume(1)) {
-            a.emit(pending.shift());
-          } else {
-            timer.start(Math.max(1, tokenTimeNs / NS_PER_MS), tryEmit);
-            return;
-          }
-        }
-      }
-      const unsub = source.subscribe((msgs) => {
-        for (const m of msgs) {
-          if (terminated) return;
-          const t = m[0];
-          if (t === DIRTY) a.down([[DIRTY]]);
-          else if (t === DATA) {
-            if (maxBuffer !== void 0 && pending.length >= maxBuffer) {
-              if (onOverflow === "drop-newest") {
-              } else if (onOverflow === "drop-oldest") {
-                pending.shift();
-                pending.push(m[1]);
-              } else {
-                terminated = true;
-                timer.cancel();
-                pending.length = 0;
-                a.down([[ERROR, new RateLimiterOverflowError(maxBuffer)]]);
-                return;
-              }
-            } else {
-              pending.push(m[1]);
-            }
-            tryEmit();
-          } else if (t === RESOLVED) a.down([[RESOLVED]]);
-          else if (t === COMPLETE) {
-            terminated = true;
-            timer.cancel();
-            pending.length = 0;
-            a.down([[COMPLETE]]);
-          } else if (t === ERROR) {
-            terminated = true;
-            timer.cancel();
-            pending.length = 0;
-            a.down([m]);
-          } else if (t === TEARDOWN) {
-            terminated = true;
-            timer.cancel();
-            pending.length = 0;
-            a.down([m]);
-            return;
-          } else a.down([m]);
-        }
-      });
-      return () => {
-        terminated = true;
-        timer.cancel();
-        unsub();
-      };
-    },
-    {
-      ...operatorOpts(),
-      initial: source.cache
-    }
-  );
-}
-function withStatus(src, options) {
-  const initialStatus = options?.initialStatus ?? "pending";
-  const out = node(
-    [],
-    (_deps, a) => {
-      let currentStatus = initialStatus;
-      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 (currentStatus === "errored") {
-              batch(() => {
-                out.meta.error.down([[DATA, null]]);
-                out.meta.status.down([[DATA, "active"]]);
-              });
-            } else {
-              out.meta.status.down([[DATA, "active"]]);
-            }
-            currentStatus = "active";
-            a.emit(m[1]);
-          } else if (t === RESOLVED) a.down([[RESOLVED]]);
-          else if (t === COMPLETE) {
-            out.meta.status.down([[DATA, "completed"]]);
-            currentStatus = "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"]]);
-            });
-            currentStatus = "errored";
-            a.down([m]);
-          } else a.down([m]);
-        }
-      });
-      return unsub;
-    },
-    {
-      ...operatorOpts(),
-      meta: { status: initialStatus, error: null },
-      completeWhenDepsComplete: false,
-      resubscribable: true,
-      initial: src.cache
-    }
-  );
-  return {
-    node: out,
-    status: out.meta.status,
-    error: out.meta.error
-  };
-}
-var TimeoutError = class extends Error {
-  name = "TimeoutError";
-  constructor(ns) {
-    super(`Timed out after ${ns / NS_PER_MS}ms`);
-  }
-};
-function isNode(x) {
-  return x != null && typeof x === "object" && "cache" in x && typeof x.subscribe === "function";
-}
-function isThenable(x) {
-  return x != null && typeof x.then === "function";
-}
-function isAsyncIterable(x) {
-  return x != null && typeof x === "object" && typeof x[Symbol.asyncIterator] === "function";
-}
-function fallback(source, fb) {
-  return producer(
-    (a) => {
-      let fallbackUnsub;
-      let sourceUnsub;
-      function switchToFallback() {
-        sourceUnsub?.();
-        sourceUnsub = void 0;
-        if (isNode(fb) || isThenable(fb) || isAsyncIterable(fb)) {
-          const fbNode = fromAny(fb);
-          fallbackUnsub = fbNode.subscribe((fMsgs) => {
-            a.down(fMsgs);
-          });
-        } else {
-          a.emit(fb);
-          a.down([[COMPLETE]]);
-        }
-      }
-      sourceUnsub = source.subscribe((msgs) => {
-        for (const m of msgs) {
-          const t = m[0];
-          if (t === DIRTY) a.down([[DIRTY]]);
-          else if (t === DATA) a.emit(m[1]);
-          else if (t === RESOLVED) a.down([[RESOLVED]]);
-          else if (t === COMPLETE) a.down([[COMPLETE]]);
-          else if (t === ERROR) {
-            switchToFallback();
-            return;
-          } else if (t === TEARDOWN) {
-            fallbackUnsub?.();
-            a.down([m]);
-            return;
-          } else a.down([m]);
-        }
-      });
-      return () => {
-        sourceUnsub?.();
-        fallbackUnsub?.();
-      };
-    },
-    {
-      ...operatorOpts(),
-      initial: source.cache
-    }
-  );
-}
-function timeout(source, timeoutNs) {
-  if (timeoutNs <= 0) throw new RangeError("timeoutNs must be > 0");
-  return producer(
-    (a) => {
-      let stopped = false;
-      const timer = new ResettableTimer();
-      function startTimer() {
-        const delayMs = timeoutNs / NS_PER_MS;
-        timer.start(delayMs, () => {
-          if (stopped) return;
-          stopped = true;
-          unsub();
-          a.down([[ERROR, new TimeoutError(timeoutNs)]]);
-        });
-      }
-      const unsub = source.subscribe((msgs) => {
-        for (const m of msgs) {
-          if (stopped) return;
-          const t = m[0];
-          if (t === DIRTY) a.down([[DIRTY]]);
-          else if (t === DATA) {
-            startTimer();
-            a.emit(m[1]);
-          } else if (t === RESOLVED) a.down([[RESOLVED]]);
-          else if (t === COMPLETE) {
-            timer.cancel();
-            stopped = true;
-            a.down([[COMPLETE]]);
-            return;
-          } else if (t === ERROR) {
-            timer.cancel();
-            stopped = true;
-            a.down([m]);
-            return;
-          } else if (t === TEARDOWN) {
-            timer.cancel();
-            stopped = true;
-            a.down([m]);
-            return;
-          } else a.down([m]);
-        }
-      });
-      startTimer();
-      return () => {
-        stopped = true;
-        timer.cancel();
-        unsub();
-      };
-    },
-    {
-      ...operatorOpts(),
-      initial: source.cache
-    }
-  );
-}
-
-// src/extra/adapters.ts
-function sourceOpts2(opts) {
-  return { describeKind: "producer", ...opts };
-}
-function fromWebSocket(socketOrRegister, opts) {
-  const { parse, closeOnTeardown = false, ...rest } = opts ?? {};
-  return producer((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();
-    };
-  }, sourceOpts2(rest));
-}
-function fromWebhook(register, opts) {
-  return externalProducer(register, opts);
-}
-function fromHTTP(url, opts) {
-  const {
-    method = "GET",
-    headers,
-    body: bodyOpt,
-    transform = (r) => r.json(),
-    timeoutNs = 30 * NS_PER_SEC,
-    signal: externalSignal,
-    completeAfterFetch = false,
-    refetchOnSubscribe = false,
-    ...rest
-  } = opts ?? {};
-  const fetchCount = state(0, { name: `${rest.name ?? "http"}/fetchCount` });
-  const lastUpdated = state(0, { name: `${rest.name ?? "http"}/lastUpdated` });
-  const fetched = state(false, { name: `${rest.name ?? "http"}/fetched` });
-  let fetchCountLocal = 0;
-  const body = bodyOpt !== void 0 ? typeof bodyOpt === "string" ? bodyOpt : JSON.stringify(bodyOpt) : void 0;
-  const runFetch = (a) => {
-    const abort = new AbortController();
-    let active = true;
-    if (externalSignal?.aborted) {
-      active = false;
-      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)
-    );
-    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(() => {
-        fetchCountLocal += 1;
-        fetchCount.down([[DATA, fetchCountLocal]]);
-        lastUpdated.down([[DATA, wallClockNs()]]);
-        fetched.down([[DATA, true]]);
-        a.emit(data);
-      });
-      if (completeAfterFetch) a.down([[COMPLETE]]);
-    }).catch((err) => {
-      clearTimeout(timeoutId);
-      if (!active) return;
-      if (err && err.name === "AbortError") return;
-      a.down([[ERROR, err]]);
-    });
-    return () => {
-      active = false;
-      abort.abort();
-    };
-  };
-  const sourceNode = producer(
-    (a) => runFetch({
-      emit: (v) => a.emit(v),
-      down: (msgs) => a.down(msgs)
-    }),
-    {
-      ...sourceOpts2(rest),
-      // `resubscribable: true` when refetchOnSubscribe — each new activation
-      // (subscribe after full deactivation) re-runs the producer fn → fresh
-      // fetch. Default (cache-once) stays non-resubscribable: producer runs
-      // once on first activation, cached DATA replays to late subscribers.
-      resubscribable: refetchOnSubscribe
-    }
-  );
-  const tracked = withStatus(sourceNode);
-  return {
-    ...tracked,
-    fetchCount,
-    lastUpdated,
-    fetched
-  };
-}
-function toHTTP(source, url, opts) {
-  const {
-    method = "POST",
-    headers = { "Content-Type": "application/json" },
-    serialize = (v) => JSON.stringify(v),
-    timeoutNs,
-    batchFormat = "json-array",
-    batchSize,
-    flushIntervalMs,
-    retry: retry2,
-    onTransportError
-  } = opts ?? {};
-  const sendOne = async (body) => {
-    const controller = timeoutNs !== void 0 ? new AbortController() : void 0;
-    let timeoutId;
-    if (controller && timeoutNs !== void 0) {
-      timeoutId = setTimeout(
-        () => controller.abort(new Error("Request timeout")),
-        Math.ceil(timeoutNs / NS_PER_MS)
-      );
-    }
-    try {
-      const res = await fetch(url, {
-        method,
-        headers,
-        body,
-        signal: controller?.signal
-      });
-      const drain = async () => {
-        try {
-          await res.arrayBuffer?.();
-        } catch {
-        }
-      };
-      if (!res.ok) {
-        await drain();
-        throw new Error(`HTTP ${res.status}: ${res.statusText}`);
-      }
-      await drain();
-    } finally {
-      if (timeoutId !== void 0) clearTimeout(timeoutId);
-    }
-  };
-  const buffered = batchSize !== void 0 || flushIntervalMs !== void 0;
-  if (buffered) {
-    return reactiveSink(source, {
-      onTransportError,
-      retry: retry2,
-      batchSize,
-      flushIntervalMs,
-      sendBatch: async (chunk) => {
-        let body;
-        if (batchFormat === "ndjson") {
-          body = chunk.map((v) => {
-            const s = serialize(v);
-            return typeof s === "string" ? s : new TextDecoder().decode(s);
-          }).join("\n");
-        } else {
-          body = JSON.stringify(chunk);
-        }
-        await sendOne(body);
-      }
-    });
-  }
-  return reactiveSink(source, {
-    onTransportError,
-    retry: retry2,
-    serialize,
-    send: async (payload) => {
-      await sendOne(payload);
-    }
-  });
-}
-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 (defaultConfig.isLocalOnly(t)) {
-            if (t === DIRTY && includeDirty) {
-            } else continue;
-          }
-          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;
-          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 toSSEBytes(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();
-  return producer((a) => {
-    let active = true;
-    let keepAlive;
-    const emitFrame = (event, data) => {
-      if (!active) return;
-      a.emit(encoder.encode(sseFrame(event, data)));
-    };
-    const onAbort = () => {
-      if (!active) return;
-      active = false;
-      a.down([[COMPLETE]]);
-    };
-    const unsub = source.subscribe((msgs) => {
-      if (!active) return;
-      for (const msg of msgs) {
-        const t = msg[0];
-        if (defaultConfig.isLocalOnly(t)) {
-          if (t === DIRTY && includeDirty) {
-          } else continue;
-        }
-        if (t === DATA) {
-          emitFrame(dataEvent, serializeSseData(msg[1], serialize));
-          continue;
-        }
-        if (t === ERROR) {
-          emitFrame(errorEvent, serializeSseData(msg[1], serialize));
-          active = false;
-          a.down([[COMPLETE]]);
-          return;
-        }
-        if (t === COMPLETE) {
-          emitFrame(completeEvent);
-          active = false;
-          a.down([[COMPLETE]]);
-          return;
-        }
-        if (!includeResolved && t === RESOLVED) continue;
-        emitFrame(
-          eventNameResolver(t),
-          msg.length > 1 ? serializeSseData(msg[1], serialize) : void 0
-        );
-      }
-    });
-    if (keepAliveMs !== void 0 && keepAliveMs > 0) {
-      keepAlive = setInterval(() => {
-        if (!active) return;
-        a.emit(encoder.encode(": keepalive\n\n"));
-      }, keepAliveMs);
-    }
-    if (signal?.aborted) onAbort();
-    else signal?.addEventListener("abort", onAbort, { once: true });
-    return () => {
-      active = false;
-      if (keepAlive !== void 0) clearInterval(keepAlive);
-      signal?.removeEventListener("abort", onAbort);
-      unsub();
-    };
-  });
-}
-function toReadableStream(bytes) {
-  let unsub;
-  let closed = false;
-  return new ReadableStream({
-    start(controller) {
-      unsub = bytes.subscribe((msgs) => {
-        for (const m of msgs) {
-          const t = m[0];
-          if (closed) return;
-          if (t === DATA) {
-            try {
-              controller.enqueue(m[1]);
-            } catch {
-              closed = true;
-              unsub?.();
-            }
-          } else if (t === ERROR) {
-            closed = true;
-            try {
-              controller.error(m[1]);
-            } catch {
-            }
-            return;
-          } else if (t === COMPLETE) {
-            closed = true;
-            try {
-              controller.close();
-            } catch {
-            }
-            return;
-          }
-        }
-      });
-    },
-    cancel() {
-      closed = true;
-      unsub?.();
-    }
-  });
-}
-function fromSSE(source, opts) {
-  const { parse = (raw) => raw, ...rest } = opts ?? {};
-  return producer((a) => {
-    let active = true;
-    const decoder = new TextDecoder();
-    let buffer2 = "";
-    let currentEvent = "message";
-    let currentData = [];
-    let currentId;
-    let currentRetry;
-    const flushEvent = () => {
-      if (currentData.length === 0 && currentEvent === "message" && currentId === void 0) {
-        currentData = [];
-        return;
-      }
-      const raw = currentData.join("\n");
-      a.emit({
-        event: currentEvent,
-        data: parse(raw),
-        id: currentId,
-        retry: currentRetry
-      });
-      currentEvent = "message";
-      currentData = [];
-      currentId = void 0;
-      currentRetry = void 0;
-    };
-    const processLine = (line) => {
-      if (line === "") {
-        flushEvent();
-        return;
-      }
-      if (line.startsWith(":")) return;
-      const colon = line.indexOf(":");
-      const field = colon < 0 ? line : line.slice(0, colon);
-      let value = colon < 0 ? "" : line.slice(colon + 1);
-      if (value.startsWith(" ")) value = value.slice(1);
-      switch (field) {
-        case "event":
-          currentEvent = value;
-          break;
-        case "data":
-          currentData.push(value);
-          break;
-        case "id":
-          if (!value.includes("\0")) currentId = value;
-          break;
-        case "retry": {
-          const n = Number(value);
-          if (Number.isFinite(n)) currentRetry = n;
-          break;
-        }
-      }
-    };
-    const processChunk = (chunk, done) => {
-      if (!active) return;
-      buffer2 += decoder.decode(chunk, { stream: !done });
-      const parts = buffer2.split(/\r?\n/);
-      buffer2 = parts.pop() ?? "";
-      for (const line of parts) processLine(line);
-    };
-    let reader;
-    let iter;
-    const run = async () => {
-      try {
-        const resp = source;
-        const stream = source instanceof ReadableStream ? source : resp && typeof resp === "object" && resp.body instanceof ReadableStream ? resp.body : null;
-        if (stream) {
-          reader = stream.getReader();
-          while (active) {
-            const { value, done } = await reader.read();
-            if (done) break;
-            processChunk(value, false);
-          }
-          processChunk(new Uint8Array(), true);
-        } else {
-          const asyncIter = source;
-          iter = asyncIter[Symbol.asyncIterator]();
-          while (active) {
-            const step = await iter.next();
-            if (step.done) break;
-            processChunk(step.value, false);
-          }
-          processChunk(new Uint8Array(), true);
-        }
-        if (buffer2.trim()) {
-          for (const line of buffer2.split(/\r?\n/)) processLine(line);
-          flushEvent();
-        }
-        if (active) a.down([[COMPLETE]]);
-      } catch (err) {
-        if (active) a.down([[ERROR, err]]);
-      }
-    };
-    void run();
-    return () => {
-      active = false;
-      if (reader) {
-        void reader.cancel().catch(() => {
-        });
-      }
-      if (iter && typeof iter.return === "function") {
-        void Promise.resolve(iter.return()).catch(() => void 0);
-      }
-    };
-  }, sourceOpts2(rest));
-}
-function fromHTTPStream(url, opts) {
-  const { method = "GET", headers, body: bodyOpt, signal: externalSignal, ...rest } = opts ?? {};
-  return producer((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 body = bodyOpt !== void 0 ? typeof bodyOpt === "string" ? bodyOpt : JSON.stringify(bodyOpt) : void 0;
-    const run = async () => {
-      try {
-        const res = await fetch(url, { method, headers, body, signal: abort.signal });
-        if (!active) return;
-        if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`);
-        if (!res.body) throw new Error("HTTP response has no body");
-        const reader = res.body.getReader();
-        while (active) {
-          const { value, done } = await reader.read();
-          if (done) break;
-          if (value) a.emit(value);
-        }
-        if (active) a.down([[COMPLETE]]);
-      } catch (err) {
-        if (!active) return;
-        if (err && err.name === "AbortError") return;
-        a.down([[ERROR, err]]);
-      }
-    };
-    void run();
-    return () => {
-      active = false;
-      abort.abort();
-    };
-  }, sourceOpts2(rest));
-}
-function fromHTTPPoll(url, opts) {
-  const { intervalMs = 5e3, ...httpOpts } = opts ?? {};
-  return switchMap(
-    fromTimer(intervalMs, { period: intervalMs }),
-    () => fromHTTP(url, { ...httpOpts, completeAfterFetch: true }).node
-  );
-}
-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,
-    retry: retry2,
-    backpressure,
-    stopOn
-  } = opts ?? {};
-  let socketClosed = false;
-  const closeSocket = (trigger) => {
-    if (socketClosed) return;
-    socketClosed = true;
-    try {
-      socket.close(closeCode, closeReason);
-    } catch (err) {
-      const error = err instanceof Error ? err : new Error(String(err));
-      try {
-        onTransportError?.({ stage: "close", error, value: void 0, message: trigger });
-      } catch {
-      }
-    }
-  };
-  let externalCloseHandler = null;
-  const removeExternalCloseHandler = () => {
-    if (externalCloseHandler) {
-      try {
-        socket.removeEventListener("close", externalCloseHandler);
-      } catch {
-      }
-      externalCloseHandler = null;
-    }
-  };
-  const handle = reactiveSink(source, {
-    onTransportError,
-    serialize: (value) => {
-      const s = serialize(value);
-      if (s === void 0) {
-        throw new Error("serialize returned undefined");
-      }
-      return s;
-    },
-    retry: retry2,
-    backpressure,
-    stopOn,
-    onDispose: removeExternalCloseHandler,
-    send: (payload) => {
-      socket.send(payload);
-    },
-    onUpstreamMessage: (msg) => {
-      if (msg[0] === COMPLETE && closeOnComplete) closeSocket(msg);
-      else if (msg[0] === ERROR && closeOnError) closeSocket(msg);
-    }
-  });
-  externalCloseHandler = () => {
-    socketClosed = true;
-    handle.dispose();
-  };
-  socket.addEventListener("close", externalCloseHandler);
-  return handle;
-}
-function fromWebSocketReconnect(factory, opts) {
-  const {
-    parse,
-    maxRetries,
-    backoff = "exponential",
-    closeOnTeardown = true,
-    ...rest
-  } = opts ?? {};
-  return retrySource(
-    () => fromWebSocket(factory(), {
-      parse,
-      closeOnTeardown,
-      ...rest
-    }),
-    { count: maxRetries, backoff }
-  );
-}
-function fromMCP(client, opts) {
-  const { method = "notifications/message", onDisconnect, ...rest } = opts ?? {};
-  return externalProducer(({ emit, error }) => {
-    client.setNotificationHandler(method, (notification) => emit(notification));
-    onDisconnect?.((err) => error(err ?? new Error("MCP client disconnected")));
-    return () => client.setNotificationHandler(method, () => {
-    });
-  }, rest);
-}
-function fromGitHook(repoPath, opts) {
-  const { pollMs = 5e3, include, exclude, maxConsecutiveErrors = 1 } = opts ?? {};
-  const includePatterns = include?.map(globToRegExp) ?? [];
-  const excludePatterns = exclude?.map(globToRegExp) ?? [];
-  const { execFileSync } = __require("child_process");
-  const gitQuery = (args) => execFileSync("git", args, { cwd: repoPath, encoding: "utf-8" }).trim();
-  let lastSeen;
-  let consecutiveErrors = 0;
-  return switchMap(
-    fromTimer(0, { period: pollMs }),
-    () => producer((a) => {
-      try {
-        const head = gitQuery(["rev-parse", "HEAD"]);
-        if (!head) {
-          consecutiveErrors = 0;
-          return () => {
-          };
-        }
-        if (lastSeen === void 0) {
-          lastSeen = head;
-          consecutiveErrors = 0;
-          return () => {
-          };
-        }
-        if (head === lastSeen) {
-          consecutiveErrors = 0;
-          return () => {
-          };
-        }
-        let files = gitQuery(["diff", "--name-only", `${lastSeen}..${head}`]).split("\n").filter(Boolean);
-        if (includePatterns.length > 0) {
-          files = files.filter((f) => matchesAnyPattern(f, includePatterns));
-        }
-        if (excludePatterns.length > 0) {
-          files = files.filter((f) => !matchesAnyPattern(f, excludePatterns));
-        }
-        const message = gitQuery(["log", "-1", "--format=%s", head]);
-        const author = gitQuery(["log", "-1", "--format=%an", head]);
-        a.emit({
-          hook: "post-commit",
-          commit: head,
-          files,
-          message,
-          author,
-          timestamp_ns: wallClockNs()
-        });
-        lastSeen = head;
-        consecutiveErrors = 0;
-      } catch (err) {
-        consecutiveErrors += 1;
-        if (consecutiveErrors >= maxConsecutiveErrors) {
-          a.down([[ERROR, err]]);
-        }
-      }
-      return () => {
-      };
-    })
-  );
-}
-function fromOTel(register, opts) {
-  const nodes = externalBundle(
-    ({ traces, metrics, logs, error }) => {
-      return register({
-        onTraces: (spans) => {
-          batch(() => {
-            for (const s of spans) traces(s);
-          });
-        },
-        onMetrics: (ms) => {
-          batch(() => {
-            for (const m of ms) metrics(m);
-          });
-        },
-        onLogs: (ls) => {
-          batch(() => {
-            for (const l of ls) logs(l);
-          });
-        },
-        onError: error
-      }) ?? void 0;
-    },
-    ["traces", "metrics", "logs"],
-    opts?.name ? { name: opts.name } : void 0
-  );
-  return nodes;
-}
-function fromSyslog(register, opts) {
-  return externalProducer(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 externalProducer(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,
-    maxConsecutiveErrors = 1
-  } = opts ?? {};
-  const intervalMs = Math.ceil(intervalNs / NS_PER_MS);
-  let consecutiveErrors = 0;
-  return switchMap(
-    fromTimer(0, { period: intervalMs, signal: externalSignal }),
-    () => producer((a) => {
-      let active = true;
-      const abort = new AbortController();
-      const timeoutId = setTimeout(
-        () => abort.abort(new Error("Scrape timeout")),
-        Math.ceil(timeoutNs / NS_PER_MS)
-      );
-      const run = async () => {
-        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);
-          consecutiveErrors = 0;
-          a.down([[COMPLETE]]);
-        } catch (err) {
-          clearTimeout(timeoutId);
-          if (!active) return;
-          if (err instanceof Error && err.name === "AbortError") return;
-          consecutiveErrors += 1;
-          if (consecutiveErrors >= maxConsecutiveErrors) {
-            a.down([[ERROR, err]]);
-          }
-        }
-      };
-      void run();
-      return () => {
-        active = false;
-        clearTimeout(timeoutId);
-        abort.abort();
-      };
-    })
-  );
-}
-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((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;
-    };
-  }, sourceOpts2(rest));
-}
-function toKafka(source, kafkaProducer, topic, opts) {
-  const { serialize = (v) => JSON.stringify(v), keyExtractor, onTransportError } = opts ?? {};
-  return reactiveSink(source, {
-    onTransportError,
-    send: async (value) => {
-      const key = keyExtractor?.(value) ?? null;
-      const serialized = serialize(value);
-      await kafkaProducer.send({
-        topic,
-        messages: [{ key, value: Buffer.from(serialized) }]
-      });
-    }
-  });
-}
-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((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;
-    };
-  }, sourceOpts2(rest));
-}
-function toRedisStream(source, client, key, opts) {
-  const {
-    serialize = (v) => ["data", JSON.stringify(v)],
-    maxLen,
-    onTransportError
-  } = opts ?? {};
-  return reactiveSink(source, {
-    onTransportError,
-    send: async (value) => {
-      const fields = serialize(value);
-      await (maxLen !== void 0 ? client.xadd(key, "MAXLEN", "~", String(maxLen), "*", ...fields) : client.xadd(key, "*", ...fields));
-    }
-  });
-}
-function fromCSV(source, opts) {
-  const {
-    delimiter = ",",
-    hasHeader = true,
-    columns: explicitColumns,
-    parseLine,
-    ...rest
-  } = opts ?? {};
-  const parse = parseLine ?? ((line) => parseCSVLine(line, delimiter));
-  return producer((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;
-    };
-  }, sourceOpts2(rest));
-}
-function csvRows(source, opts) {
-  const {
-    delimiter = ",",
-    hasHeader = true,
-    columns: explicitColumns,
-    parseLine,
-    ...rest
-  } = opts ?? {};
-  const parse = parseLine ?? ((line) => parseCSVLine(line, delimiter));
-  return node(
-    [source],
-    (data, a, ctx) => {
-      const batch0 = data[0];
-      if (batch0 == null || batch0.length === 0) return;
-      const s = ctx.store;
-      if (typeof s.buffer !== "string") s.buffer = "";
-      if (s.headers === void 0 && explicitColumns) s.headers = explicitColumns.slice();
-      for (const chunkRaw of batch0) {
-        s.buffer = s.buffer + chunkRaw;
-        const lines = s.buffer.split(/\r?\n/);
-        s.buffer = lines.pop() ?? "";
-        for (const line of lines) {
-          if (!line.trim()) continue;
-          const values = parse(line);
-          if (!s.headers && hasHeader) {
-            s.headers = values;
-            continue;
-          }
-          if (!s.headers) s.headers = values.map((_, i) => `col${i}`);
-          const row = {};
-          for (let i = 0; i < s.headers.length; i++) row[s.headers[i]] = values[i] ?? "";
-          a.emit(row);
-        }
-      }
-    },
-    { describeKind: "derived", ...rest }
-  );
-}
-function ndjsonRows(source, opts) {
-  return node(
-    [source],
-    (data, a, ctx) => {
-      const batch0 = data[0];
-      if (batch0 == null || batch0.length === 0) return;
-      const s = ctx.store;
-      if (typeof s.buffer !== "string") s.buffer = "";
-      for (const chunkRaw of batch0) {
-        s.buffer = s.buffer + chunkRaw;
-        const lines = s.buffer.split(/\r?\n/);
-        s.buffer = lines.pop() ?? "";
-        for (const line of lines) {
-          if (!line.trim()) continue;
-          try {
-            a.emit(JSON.parse(line));
-          } catch (err) {
-            a.down([[ERROR, err]]);
-            return;
-          }
-        }
-      }
-    },
-    { describeKind: "derived", ...opts ?? {} }
-  );
-}
-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((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;
-    };
-  }, sourceOpts2(opts));
-}
-function fromClickHouseWatch(client, query, opts) {
-  const {
-    intervalNs = 5 * NS_PER_SEC,
-    format = "JSONEachRow",
-    signal: externalSignal,
-    maxConsecutiveErrors = 1
-  } = opts ?? {};
-  const intervalMs = Math.ceil(intervalNs / NS_PER_MS);
-  let consecutiveErrors = 0;
-  return switchMap(
-    fromTimer(0, { period: intervalMs, signal: externalSignal }),
-    () => producer((a) => {
-      let active = true;
-      const run = async () => {
-        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);
-          consecutiveErrors = 0;
-          a.down([[COMPLETE]]);
-        } catch (err) {
-          if (!active) return;
-          consecutiveErrors += 1;
-          if (consecutiveErrors >= maxConsecutiveErrors) {
-            a.down([[ERROR, err]]);
-          }
-        }
-      };
-      void run();
-      return () => {
-        active = false;
-      };
-    })
-  );
-}
-function fromPulsar(consumer, opts) {
-  const {
-    autoAck = true,
-    deserialize = (buf) => {
-      try {
-        return JSON.parse(buf.toString());
-      } catch {
-        return buf.toString();
-      }
-    },
-    onAckError,
-    ...rest
-  } = opts ?? {};
-  const reportAckError = (err) => {
-    if (!onAckError) return;
-    try {
-      onAckError(err instanceof Error ? err : new Error(String(err)));
-    } catch {
-    }
-  };
-  return producer((a) => {
-    let active = true;
-    const loop = async () => {
-      while (active) {
-        try {
-          const rawMsg = await consumer.receive();
-          if (!active) return;
-          const structured = {
-            topic: rawMsg.getTopicName(),
-            messageId: rawMsg.getMessageId().toString(),
-            key: rawMsg.getPartitionKey(),
-            value: deserialize(rawMsg.getData()),
-            properties: rawMsg.getProperties(),
-            publishTime: rawMsg.getPublishTimestamp(),
-            eventTime: rawMsg.getEventTimestamp(),
-            timestampNs: wallClockNs()
-          };
-          if (autoAck) {
-            a.emit(structured);
-            void consumer.acknowledge(rawMsg).catch(reportAckError);
-          } else {
-            let settled = false;
-            const envelope = {
-              value: structured,
-              ack() {
-                if (settled) return;
-                settled = true;
-                void consumer.acknowledge(rawMsg).catch(reportAckError);
-              },
-              nack(_opts) {
-                if (settled) return;
-                settled = true;
-                const anyConsumer = consumer;
-                try {
-                  const result = anyConsumer.negativeAcknowledge?.(rawMsg);
-                  if (result && typeof result.then === "function") {
-                    void result.catch(reportAckError);
-                  }
-                } catch (err) {
-                  reportAckError(err);
-                }
-              }
-            };
-            a.emit(envelope);
-          }
-        } catch (err) {
-          if (active) a.down([[ERROR, err]]);
-          return;
-        }
-      }
-    };
-    void loop();
-    return () => {
-      active = false;
-    };
-  }, sourceOpts2(rest));
-}
-function toPulsar(source, pulsarProducer, opts) {
-  const {
-    serialize = (v) => Buffer.from(JSON.stringify(v)),
-    keyExtractor,
-    propertiesExtractor,
-    onTransportError
-  } = opts ?? {};
-  return reactiveSink(source, {
-    onTransportError,
-    send: async (value) => {
-      await pulsarProducer.send({
-        data: serialize(value),
-        partitionKey: keyExtractor?.(value),
-        properties: propertiesExtractor?.(value)
-      });
-    }
-  });
-}
-function fromNATS(client, subject, opts) {
-  const decoder = new TextDecoder();
-  const {
-    queue,
-    deserialize = (data) => {
-      const text = decoder.decode(data);
-      try {
-        return JSON.parse(text);
-      } catch {
-        return text;
-      }
-    },
-    ...rest
-  } = opts ?? {};
-  return producer((a) => {
-    let active = true;
-    const sub = client.subscribe(subject, queue ? { queue } : void 0);
-    const loop = async () => {
-      try {
-        for await (const msg of sub) {
-          if (!active) return;
-          const headers = {};
-          if (msg.headers) {
-            for (const k of msg.headers.keys()) {
-              headers[k] = msg.headers.get(k);
-            }
-          }
-          a.emit({
-            subject: msg.subject,
-            data: deserialize(msg.data),
-            headers,
-            reply: msg.reply,
-            sid: msg.sid,
-            timestampNs: wallClockNs()
-          });
-        }
-        if (active) a.down([[COMPLETE]]);
-      } catch (err) {
-        if (active) a.down([[ERROR, err]]);
-      }
-    };
-    void loop();
-    return () => {
-      active = false;
-    };
-  }, sourceOpts2(rest));
-}
-function toNATS(source, client, subject, opts) {
-  const encoder = new TextEncoder();
-  const { serialize = (v) => encoder.encode(JSON.stringify(v)), onTransportError } = opts ?? {};
-  return reactiveSink(source, {
-    onTransportError,
-    send: (value) => {
-      client.publish(subject, serialize(value));
-    }
-  });
-}
-function fromRabbitMQ(channel, queue, opts) {
-  const {
-    autoAck = true,
-    deserialize = (buf) => {
-      try {
-        return JSON.parse(buf.toString());
-      } catch {
-        return buf.toString();
-      }
-    },
-    onAckError,
-    ...rest
-  } = opts ?? {};
-  const reportAckError = (err) => {
-    if (!onAckError) return;
-    try {
-      onAckError(err instanceof Error ? err : new Error(String(err)));
-    } catch {
-    }
-  };
-  return producer((a) => {
-    let active = true;
-    let consumerTag;
-    const start = async () => {
-      try {
-        const result = await channel.consume(
-          queue,
-          (rawMsg) => {
-            if (!active) return;
-            if (rawMsg === null) {
-              if (active) a.down([[ERROR, new Error("Consumer cancelled by broker")]]);
-              return;
-            }
-            const structured = {
-              queue,
-              routingKey: rawMsg.fields.routingKey,
-              exchange: rawMsg.fields.exchange,
-              content: deserialize(rawMsg.content),
-              properties: rawMsg.properties,
-              deliveryTag: rawMsg.fields.deliveryTag,
-              redelivered: rawMsg.fields.redelivered,
-              timestampNs: wallClockNs()
-            };
-            if (autoAck) {
-              a.emit(structured);
-              try {
-                channel.ack(rawMsg);
-              } catch (err) {
-                reportAckError(err);
-              }
-            } else {
-              let settled = false;
-              const channelWithNack = channel;
-              const envelope = {
-                value: structured,
-                ack() {
-                  if (settled) return;
-                  settled = true;
-                  try {
-                    channel.ack(rawMsg);
-                  } catch (err) {
-                    reportAckError(err);
-                  }
-                },
-                nack(nackOpts) {
-                  if (settled) return;
-                  settled = true;
-                  const requeue = nackOpts?.requeue;
-                  if (!channelWithNack.nack) {
-                    reportAckError(
-                      new Error("RabbitMQ channel does not expose `nack`; cannot negative-ack")
-                    );
-                    return;
-                  }
-                  try {
-                    channelWithNack.nack(rawMsg, false, requeue);
-                  } catch (err) {
-                    reportAckError(err);
-                  }
-                }
-              };
-              a.emit(envelope);
-            }
-          },
-          { noAck: false }
-        );
-        consumerTag = result.consumerTag;
-      } catch (err) {
-        if (active) a.down([[ERROR, err]]);
-      }
-    };
-    void start();
-    return () => {
-      active = false;
-      if (consumerTag !== void 0) {
-        void channel.cancel(consumerTag);
-      }
-    };
-  }, sourceOpts2(rest));
-}
-function toRabbitMQ(source, channel, exchange, opts) {
-  const {
-    serialize = (v) => Buffer.from(JSON.stringify(v)),
-    routingKeyExtractor = () => "",
-    onTransportError
-  } = opts ?? {};
-  return reactiveSink(source, {
-    onTransportError,
-    send: (value) => {
-      const routingKey = routingKeyExtractor(value);
-      const content = serialize(value);
-      channel.publish(exchange, routingKey, content);
-    }
-  });
-}
-function toFile(source, writer, opts) {
-  const {
-    serialize = (v) => `${JSON.stringify(v)}
-`,
-    flushIntervalMs = 0,
-    batchSize = Number.POSITIVE_INFINITY,
-    onTransportError,
-    mode: _mode
-  } = opts ?? {};
-  const buffered = flushIntervalMs > 0 || batchSize < Number.POSITIVE_INFINITY;
-  const handle = buffered ? reactiveSink(source, {
-    onTransportError,
-    batchSize,
-    flushIntervalMs,
-    serialize,
-    sendBatch: (chunk) => {
-      writer.write(chunk.join(""));
-    }
-  }) : reactiveSink(source, {
-    onTransportError,
-    serialize,
-    send: (line) => {
-      writer.write(line);
-    }
-  });
-  const originalDispose = handle.dispose;
-  handle.dispose = () => {
-    originalDispose();
-    try {
-      writer.end();
-    } catch {
-    }
-  };
-  return handle;
-}
-function escapeCSVField(value, delimiter) {
-  if (value.includes(delimiter) || value.includes('"') || value.includes("\n")) {
-    return `"${value.replace(/"/g, '""')}"`;
-  }
-  return value;
-}
-function toCSV(source, writer, opts) {
-  const {
-    columns,
-    delimiter = ",",
-    writeHeader = true,
-    cellExtractor = (row, col) => String(row[col] ?? ""),
-    flushIntervalMs = 0,
-    batchSize = Number.POSITIVE_INFINITY,
-    onTransportError,
-    ...rest
-  } = opts;
-  let headerWritten = false;
-  const serializeRow = (row) => {
-    if (!headerWritten && writeHeader) {
-      headerWritten = true;
-      const header = columns.map((c) => escapeCSVField(c, delimiter)).join(delimiter);
-      const data = columns.map((c) => escapeCSVField(cellExtractor(row, c), delimiter)).join(delimiter);
-      return `${header}
-${data}
-`;
-    }
-    return `${columns.map((c) => escapeCSVField(cellExtractor(row, c), delimiter)).join(delimiter)}
-`;
-  };
-  return toFile(source, writer, {
-    serialize: serializeRow,
-    flushIntervalMs,
-    batchSize,
-    onTransportError,
-    ...rest
-  });
-}
-function toClickHouse(source, client, table, opts) {
-  const {
-    batchSize = 1e3,
-    flushIntervalMs = 5e3,
-    format = "JSONEachRow",
-    transform = (v) => v,
-    onTransportError
-  } = opts ?? {};
-  return reactiveSink(source, {
-    onTransportError,
-    batchSize,
-    flushIntervalMs,
-    serialize: transform,
-    sendBatch: async (batch2) => {
-      await client.insert({ table, values: batch2, format });
-    }
-  });
-}
-function toS3(source, client, bucket, opts) {
-  const {
-    format = "ndjson",
-    keyGenerator = (seq2, timestampNs) => {
-      const ms = Math.floor(timestampNs / 1e6);
-      const ts = new Date(ms).toISOString().replace(/[:.]/g, "-");
-      return `data/${ts}-${seq2}.${format === "ndjson" ? "ndjson" : "json"}`;
-    },
-    batchSize = 1e3,
-    flushIntervalMs = 1e4,
-    transform = (v) => v,
-    onTransportError
-  } = opts ?? {};
-  const contentType = format === "ndjson" ? "application/x-ndjson" : "application/json";
-  let seq = 0;
-  return reactiveSink(source, {
-    onTransportError,
-    batchSize,
-    flushIntervalMs,
-    serialize: transform,
-    sendBatch: async (batch2) => {
-      seq += 1;
-      const body = format === "ndjson" ? `${batch2.map((v) => JSON.stringify(v)).join("\n")}
-` : JSON.stringify(batch2);
-      const key = keyGenerator(seq, wallClockNs());
-      await client.putObject({ Bucket: bucket, Key: key, Body: body, ContentType: contentType });
-    }
-  });
-}
-function toPostgres(source, client, table, opts) {
-  const {
-    toSQL = (v, t) => ({
-      sql: `INSERT INTO "${t.replace(/"/g, '""')}" (data) VALUES ($1)`,
-      params: [JSON.stringify(v)]
-    }),
-    onTransportError
-  } = opts ?? {};
-  return reactiveSink(source, {
-    onTransportError,
-    serialize: (value) => toSQL(value, table),
-    send: async (q) => {
-      const query = q;
-      await client.query(query.sql, query.params);
-    }
-  });
-}
-function toMongo(source, collection, opts) {
-  const { toDocument = (v) => v, onTransportError } = opts ?? {};
-  return reactiveSink(source, {
-    onTransportError,
-    serialize: toDocument,
-    send: async (doc) => {
-      await collection.insertOne(doc);
-    }
-  });
-}
-function toLoki(source, client, opts) {
-  const {
-    labels = {},
-    toLine = (v) => JSON.stringify(v),
-    toLabels,
-    onTransportError
-  } = opts ?? {};
-  return reactiveSink(source, {
-    onTransportError,
-    serialize: (value) => ({
-      line: toLine(value),
-      labels: toLabels ? { ...labels, ...toLabels(value) } : labels
-    }),
-    send: async (payload) => {
-      const { line, labels: streamLabels } = payload;
-      const ts = `${wallClockNs()}`;
-      await client.push({ streams: [{ stream: streamLabels, values: [[ts, line]] }] });
-    }
-  });
-}
-function toTempo(source, client, opts) {
-  const { toResourceSpans = (v) => [v], onTransportError } = opts ?? {};
-  return reactiveSink(source, {
-    onTransportError,
-    serialize: toResourceSpans,
-    send: async (spans) => {
-      await client.push({ resourceSpans: spans });
-    }
-  });
-}
-function checkpointToS3(graph, client, bucket, opts) {
-  const { prefix = "checkpoints/", debounceMs = 500, compactEvery = 10, onError } = opts ?? {};
-  const tier = {
-    debounceMs,
-    compactEvery,
-    save(_key, data) {
-      const ms = Math.floor(wallClockNs() / 1e6);
-      const s3Key = `${prefix}${graph.name}/checkpoint-${ms}.json`;
-      let body;
-      try {
-        body = JSON.stringify(data);
-      } catch (err) {
-        onError?.(err);
-        return;
-      }
-      void client.putObject({
-        Bucket: bucket,
-        Key: s3Key,
-        Body: body,
-        ContentType: "application/json"
-      }).catch((err) => onError?.(err));
-    },
-    load() {
-      return null;
-    }
-  };
-  return graph.attachStorage([tier], { onError: (err) => onError?.(err) });
-}
-function checkpointToRedis(graph, client, opts) {
-  const {
-    prefix = "graphrefly:checkpoint:",
-    debounceMs = 500,
-    compactEvery = 10,
-    onError
-  } = opts ?? {};
-  const redisKey = `${prefix}${graph.name}`;
-  const tier = {
-    debounceMs,
-    compactEvery,
-    save(_key, data) {
-      let body;
-      try {
-        body = JSON.stringify(data);
-      } catch (err) {
-        onError?.(err);
-        return;
-      }
-      void client.set(redisKey, body).catch((err) => onError?.(err));
-    },
-    async load() {
-      const raw = await client.get(redisKey);
-      if (raw == null) return null;
-      try {
-        return JSON.parse(raw);
-      } catch {
-        return null;
-      }
-    }
-  };
-  return graph.attachStorage([tier], { onError: (err) => onError?.(err) });
-}
-function fromSqlite(db, query, opts) {
-  const { mapRow = (r) => r, params, ...rest } = opts ?? {};
-  return producer(
-    (a) => {
-      try {
-        const rows = db.query(query, params);
-        const mapped = rows.map(mapRow);
-        a.emit(mapped);
-        a.down([[COMPLETE]]);
-      } catch (err) {
-        a.down([[ERROR, err instanceof Error ? err : new Error(String(err))]]);
-      }
-      return void 0;
-    },
-    { describeKind: "producer", completeWhenDepsComplete: false, ...rest }
-  );
-}
-function fromSqliteCursor(db, query, opts) {
-  const { mapRow = (r) => r, params, ...rest } = opts ?? {};
-  return producer(
-    (a) => {
-      try {
-        const it = db.iterate(query, params);
-        batch(() => {
-          for (const row of it) a.emit(mapRow(row));
-          a.down([[COMPLETE]]);
-        });
-      } catch (err) {
-        a.down([[ERROR, err instanceof Error ? err : new Error(String(err))]]);
-      }
-      return void 0;
-    },
-    { describeKind: "producer", completeWhenDepsComplete: false, ...rest }
-  );
-}
-function toSqlite(source, db, table, opts) {
-  if (table.includes("\0") || table.length === 0) {
-    throw new Error(`toSqlite: invalid table name: ${JSON.stringify(table)}`);
-  }
-  const {
-    toSQL = (v, t) => ({
-      sql: `INSERT INTO "${t.replace(/"/g, '""')}" (data) VALUES (?)`,
-      params: [JSON.stringify(v)]
-    }),
-    onTransportError,
-    batchInsert = false,
-    maxBatchSize = 1e3,
-    flushIntervalMs = 0
-  } = opts ?? {};
-  const serialize = (value) => toSQL(value, table);
-  if (!batchInsert) {
-    return reactiveSink(source, {
-      onTransportError,
-      serialize,
-      send: (q) => {
-        const query = q;
-        db.query(query.sql, query.params);
-      }
-    });
-  }
-  const errorsNode = state(null);
-  const sentNode = state(void 0, { equals: () => false });
-  const failedNode = state(null);
-  const inFlightNode = state(0);
-  const bufferedNode = state(0);
-  const reportError = (err) => {
-    try {
-      onTransportError?.(err);
-    } catch {
-    }
-    try {
-      errorsNode.down([[DATA, err]]);
-    } catch {
-    }
-  };
-  let pending = [];
-  let flushing = false;
-  let timer;
-  let disposed = false;
-  const updateBuffered = () => bufferedNode.down([[DATA, pending.length]]);
-  const safeEmitSent = (v) => {
-    if (disposed) return;
-    sentNode.down([[DATA, v]]);
-  };
-  const safeEmitFailed = (f) => {
-    if (disposed) return;
-    failedNode.down([[DATA, f]]);
-  };
-  const safeSetInFlight = (n) => {
-    if (disposed) return;
-    inFlightNode.down([[DATA, n]]);
-  };
-  const safeReportError = (err) => {
-    if (disposed) return;
-    reportError(err);
-  };
-  const flushTransaction = () => {
-    if (pending.length === 0 || flushing) return;
-    flushing = true;
-    safeSetInFlight(1);
-    try {
-      db.query("BEGIN", []);
-    } catch (err) {
-      flushing = false;
-      safeSetInFlight(0);
-      safeReportError({
-        stage: "send",
-        error: err instanceof Error ? err : new Error(String(err)),
-        value: void 0
-      });
-      return;
-    }
-    const chunk = pending;
-    pending = [];
-    updateBuffered();
-    let firstError;
-    let committedCount = 0;
-    for (const entry of chunk) {
-      try {
-        db.query(entry.query.sql, entry.query.params);
-        committedCount += 1;
-      } catch (err) {
-        firstError = err instanceof Error ? err : new Error(String(err));
-        break;
-      }
-    }
-    if (firstError) {
-      try {
-        db.query("ROLLBACK", []);
-      } catch {
-      }
-      safeReportError({ stage: "send", error: firstError, value: void 0 });
-      for (const entry of chunk) {
-        safeEmitFailed({ value: entry.value, error: firstError, attempts: 1 });
-      }
-    } else {
-      try {
-        db.query("COMMIT", []);
-        for (const entry of chunk) safeEmitSent(entry.value);
-      } catch (err) {
-        const error = err instanceof Error ? err : new Error(String(err));
-        safeReportError({ stage: "send", error, value: void 0 });
-        for (let i = 0; i < committedCount; i++) {
-          safeEmitFailed({ value: chunk[i].value, error, attempts: 1 });
-        }
-      }
-    }
-    flushing = false;
-    safeSetInFlight(0);
-  };
-  const scheduleFlush = () => {
-    if (flushIntervalMs > 0 && timer === void 0 && !disposed) {
-      timer = setTimeout(() => {
-        timer = void 0;
-        flushTransaction();
-      }, flushIntervalMs);
-    }
-  };
-  const unsub = source.subscribe((msgs) => {
-    for (const msg of msgs) {
-      const t = msg[0];
-      if (t === DATA) {
-        const value = msg[1];
-        let query;
-        try {
-          query = serialize(value);
-        } catch (err) {
-          const error = err instanceof Error ? err : new Error(String(err));
-          reportError({ stage: "serialize", error, value });
-          failedNode.down([[DATA, { value, error, attempts: 0 }]]);
-          continue;
-        }
-        pending.push({ value, query });
-        updateBuffered();
-        if (pending.length >= maxBatchSize) flushTransaction();
-        else scheduleFlush();
-      } else if (defaultConfig.messageTier(t) >= 3) {
-        flushTransaction();
-      }
-    }
-  });
-  const dispose = () => {
-    if (disposed) return;
-    if (timer !== void 0) {
-      clearTimeout(timer);
-      timer = void 0;
-    }
-    flushTransaction();
-    disposed = true;
-    unsub();
-    for (const n of [errorsNode, sentNode, failedNode, inFlightNode, bufferedNode]) {
-      try {
-        n.down([[TEARDOWN]]);
-      } catch {
-      }
-    }
-  };
-  return {
-    dispose,
-    sent: sentNode,
-    failed: failedNode,
-    inFlight: inFlightNode,
-    errors: errorsNode,
-    buffered: bufferedNode,
-    flush: async () => {
-      if (!disposed) flushTransaction();
-    }
-  };
-}
-function fromPrisma(model, opts) {
-  const { args, mapRow = (r) => r, ...rest } = opts ?? {};
-  return producer(
-    (a) => {
-      let active = true;
-      void model.findMany(args).then((rows) => {
-        if (!active) return;
-        a.emit(rows.map(mapRow));
-        a.down([[COMPLETE]]);
-      }).catch((err) => {
-        if (!active) return;
-        try {
-          a.down([[ERROR, err instanceof Error ? err : new Error(String(err))]]);
-        } catch {
-        }
-      });
-      return () => {
-        active = false;
-      };
-    },
-    { ...rest, describeKind: "producer", completeWhenDepsComplete: false }
-  );
-}
-function fromDrizzle(query, opts) {
-  const { mapRow = (r) => r, ...rest } = opts ?? {};
-  return producer(
-    (a) => {
-      let active = true;
-      void query.execute().then((rows) => {
-        if (!active) return;
-        a.emit(rows.map(mapRow));
-        a.down([[COMPLETE]]);
-      }).catch((err) => {
-        if (!active) return;
-        try {
-          a.down([[ERROR, err instanceof Error ? err : new Error(String(err))]]);
-        } catch {
-        }
-      });
-      return () => {
-        active = false;
-      };
-    },
-    { ...rest, describeKind: "producer", completeWhenDepsComplete: false }
-  );
-}
-function fromKysely(query, opts) {
-  const { mapRow = (r) => r, ...rest } = opts ?? {};
-  return producer(
-    (a) => {
-      let active = true;
-      void query.execute().then((rows) => {
-        if (!active) return;
-        a.emit(rows.map(mapRow));
-        a.down([[COMPLETE]]);
-      }).catch((err) => {
-        if (!active) return;
-        try {
-          a.down([[ERROR, err instanceof Error ? err : new Error(String(err))]]);
-        } catch {
-        }
-      });
-      return () => {
-        active = false;
-      };
-    },
-    { ...rest, describeKind: "producer", completeWhenDepsComplete: false }
-  );
-}
-
-// src/extra/cascading-cache.ts
-function lru() {
-  const map2 = /* @__PURE__ */ new Map();
-  let head = null;
-  let tail = null;
-  function unlink(n) {
-    if (n.prev) n.prev.next = n.next;
-    else head = n.next;
-    if (n.next) n.next.prev = n.prev;
-    else tail = n.prev;
-    n.prev = null;
-    n.next = null;
-  }
-  function pushFront(n) {
-    n.next = head;
-    n.prev = null;
-    if (head) head.prev = n;
-    head = n;
-    if (tail === null) tail = n;
-  }
-  return {
-    insert(key) {
-      if (map2.has(key)) {
-        this.touch(key);
-        return;
-      }
-      const n = { key, prev: null, next: null };
-      map2.set(key, n);
-      pushFront(n);
-    },
-    touch(key) {
-      const n = map2.get(key);
-      if (!n) return;
-      unlink(n);
-      pushFront(n);
-    },
-    delete(key) {
-      const n = map2.get(key);
-      if (!n) return;
-      unlink(n);
-      map2.delete(key);
-    },
-    evict(count) {
-      const victims = [];
-      for (let i = 0; i < count && tail !== null; i++) {
-        const n = tail;
-        victims.push(n.key);
-        unlink(n);
-        map2.delete(n.key);
-      }
-      return victims;
-    },
-    size() {
-      return map2.size;
-    }
-  };
-}
-function isPromiseLike(v) {
-  return v != null && typeof v.then === "function";
-}
-function fireAndForget(result) {
-  if (isPromiseLike(result)) {
-    result.catch(() => {
-    });
-  }
-}
-function cascadingCache(tiers, opts) {
-  const entries = /* @__PURE__ */ new Map();
-  const maxSize = opts?.maxSize ?? 0;
-  const policy = maxSize > 0 ? opts?.eviction ?? lru() : null;
-  const writeThrough = opts?.writeThrough ?? false;
-  function promote(key, value, hitTierIndex) {
-    for (let i = 0; i < hitTierIndex; i++) {
-      try {
-        fireAndForget(tiers[i].save(key, value));
-      } catch {
-      }
-    }
-  }
-  function cascade(key, nd, startTier = 0) {
-    for (let tierIndex = startTier; tierIndex < tiers.length; tierIndex++) {
-      let result;
-      try {
-        result = tiers[tierIndex].load(key);
-      } catch {
-        continue;
-      }
-      if (isPromiseLike(result)) {
-        const captured = tierIndex;
-        result.then(
-          (val) => {
-            if (val !== void 0 && val !== null) {
-              nd.down([[DATA, val]]);
-              promote(key, val, captured);
-            } else {
-              cascade(key, nd, captured + 1);
-            }
-          },
-          () => {
-            cascade(key, nd, captured + 1);
-          }
-        );
-        return;
-      }
-      if (result !== void 0 && result !== null) {
-        nd.down([[DATA, result]]);
-        promote(key, result, tierIndex);
-        return;
-      }
-    }
-  }
-  function evictIfNeeded() {
-    if (!policy || maxSize <= 0) return;
-    while (policy.size() >= maxSize) {
-      const victims = policy.evict(1);
-      if (victims.length === 0) break;
-      for (const key of victims) {
-        const nd = entries.get(key);
-        if (nd) {
-          const value = nd.cache;
-          if (nd.status !== "sentinel" && tiers.length > 0) {
-            const lastIndex = tiers.length - 1;
-            try {
-              fireAndForget(tiers[lastIndex].save(key, value));
-            } catch {
-            }
-            for (let j = 0; j < lastIndex; j++) {
-              try {
-                const clearFn = tiers[j].clear;
-                if (clearFn) fireAndForget(clearFn.call(tiers[j], key));
-              } catch {
-              }
-            }
-          }
-          nd.down([[TEARDOWN]]);
-        }
-        entries.delete(key);
-      }
-    }
-  }
-  return {
-    load(key) {
-      const existing = entries.get(key);
-      if (existing) {
-        policy?.touch(key);
-        return existing;
-      }
-      if (policy && maxSize > 0 && policy.size() >= maxSize) {
-        evictIfNeeded();
-      }
-      const nd = state(void 0);
-      entries.set(key, nd);
-      policy?.insert(key);
-      cascade(key, nd);
-      return nd;
-    },
-    save(key, value) {
-      if (writeThrough) {
-        for (const tier of tiers) {
-          try {
-            fireAndForget(tier.save(key, value));
-          } catch {
-          }
-        }
-      } else if (tiers[0]) {
-        try {
-          fireAndForget(tiers[0].save(key, value));
-        } catch {
-        }
-      }
-      const existing = entries.get(key);
-      if (existing) {
-        existing.down([[DATA, value]]);
-        policy?.touch(key);
-      } else {
-        if (policy && maxSize > 0 && policy.size() >= maxSize) {
-          evictIfNeeded();
-        }
-        const nd = state(value);
-        entries.set(key, nd);
-        policy?.insert(key);
-      }
-    },
-    invalidate(key) {
-      const existing = entries.get(key);
-      if (existing) cascade(key, existing);
-    },
-    delete(key) {
-      policy?.delete(key);
-      const nd = entries.get(key);
-      if (nd) nd.down([[TEARDOWN]]);
-      entries.delete(key);
-      for (const tier of tiers) {
-        try {
-          const clearFn = tier.clear;
-          if (clearFn) fireAndForget(clearFn.call(tier, key));
-        } catch {
-        }
-      }
-    },
-    has(key) {
-      return entries.has(key);
-    },
-    get size() {
-      return entries.size;
-    }
-  };
-}
-
-// src/extra/pubsub.ts
-var NativePubSubBackend = class {
-  _version = 0;
-  _topics = /* @__PURE__ */ new Set();
-  get version() {
-    return this._version;
-  }
-  get topicCount() {
-    return this._topics.size;
-  }
-  hasTopic(name) {
-    return this._topics.has(name);
-  }
-  topicNames() {
-    return this._topics.values();
-  }
-  createTopic(name) {
-    if (this._topics.has(name)) return false;
-    this._topics.add(name);
-    this._version += 1;
-    return true;
-  }
-  removeTopic(name) {
-    const had = this._topics.delete(name);
-    if (had) this._version += 1;
-    return had;
-  }
-};
-function pubsub(options = {}) {
-  const { backend: userBackend } = options;
-  const backend = userBackend ?? new NativePubSubBackend();
-  const nodes = /* @__PURE__ */ new Map();
-  function ensureTopic(name) {
-    let n = nodes.get(name);
-    if (n === void 0) {
-      n = node({ describeKind: "state" });
-      nodes.set(name, n);
-      backend.createTopic(name);
-    }
-    return n;
-  }
-  return {
-    topic(name) {
-      return ensureTopic(name);
-    },
-    publish(name, value) {
-      ensureTopic(name).emit(value);
-    },
-    publishMany(entries) {
-      batch(() => {
-        for (const [name, value] of entries) {
-          ensureTopic(name).emit(value);
-        }
-      });
-    },
-    removeTopic(name) {
-      const n = nodes.get(name);
-      if (n === void 0) return false;
-      nodes.delete(name);
-      backend.removeTopic(name);
-      n.down([[TEARDOWN]]);
-      return true;
-    },
-    has(name) {
-      return backend.hasTopic(name);
-    },
-    get size() {
-      return backend.topicCount;
-    },
-    topicNames() {
-      return backend.topicNames();
-    }
-  };
-}
-
-// src/extra/reactive-index.ts
-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) {
-  const c = cmpOrd(a[0], b[0]);
-  if (c !== 0) return c;
-  return cmpOrd(a[1], b[1]);
-}
-function rowKey(row) {
-  return [row.secondary, row.primary];
-}
-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;
-}
-var NativeIndexBackend = class {
-  _version = 0;
-  _buf = [];
-  _byPrimary = /* @__PURE__ */ new Map();
-  get version() {
-    return this._version;
-  }
-  get size() {
-    return this._buf.length;
-  }
-  has(primary) {
-    return this._byPrimary.has(primary);
-  }
-  get(primary) {
-    return this._byPrimary.get(primary)?.value;
-  }
-  upsert(primary, secondary, value, opts) {
-    const existing = this._byPrimary.get(primary);
-    const row = { primary, secondary, value };
-    if (existing !== void 0 && opts?.equals?.(existing, row)) {
-      return false;
-    }
-    if (existing !== void 0) {
-      const oldPos = bisectLeft(this._buf, existing);
-      this._buf.splice(oldPos, 1);
-    }
-    const newPos = bisectLeft(this._buf, row);
-    this._buf.splice(newPos, 0, row);
-    this._byPrimary.set(primary, row);
-    this._version += 1;
-    return existing === void 0;
-  }
-  upsertMany(rows, opts) {
-    let changed = 0;
-    try {
-      for (const r of rows) {
-        const existing = this._byPrimary.get(r.primary);
-        const row = {
-          primary: r.primary,
-          secondary: r.secondary,
-          value: r.value
-        };
-        if (existing !== void 0 && opts?.equals?.(existing, row)) {
-          continue;
-        }
-        if (existing !== void 0) {
-          const oldPos = bisectLeft(this._buf, existing);
-          this._buf.splice(oldPos, 1);
-        }
-        const newPos = bisectLeft(this._buf, row);
-        this._buf.splice(newPos, 0, row);
-        this._byPrimary.set(r.primary, row);
-        changed += 1;
-      }
-    } finally {
-      if (changed > 0) this._version += 1;
-    }
-    return changed;
-  }
-  delete(primary) {
-    const existing = this._byPrimary.get(primary);
-    if (existing === void 0) return false;
-    const pos = bisectLeft(this._buf, existing);
-    this._buf.splice(pos, 1);
-    this._byPrimary.delete(primary);
-    this._version += 1;
-    return true;
-  }
-  deleteMany(primaries) {
-    let removed = 0;
-    try {
-      for (const primary of primaries) {
-        const existing = this._byPrimary.get(primary);
-        if (existing === void 0) continue;
-        const pos = bisectLeft(this._buf, existing);
-        this._buf.splice(pos, 1);
-        this._byPrimary.delete(primary);
-        removed += 1;
-      }
-    } finally {
-      if (removed > 0) this._version += 1;
-    }
-    return removed;
-  }
-  clear() {
-    const n = this._buf.length;
-    if (n === 0) return 0;
-    this._buf.length = 0;
-    this._byPrimary.clear();
-    this._version += 1;
-    return n;
-  }
-  toArray() {
-    return [...this._buf];
-  }
-  toPrimaryMap() {
-    const m = /* @__PURE__ */ new Map();
-    for (const r of this._buf) m.set(r.primary, r.value);
-    return m;
-  }
-};
-function keepaliveDerived(n) {
-  return n.subscribe(() => {
-  });
-}
-function reactiveIndex(options = {}) {
-  const { name, versioning, equals: defaultEquals, backend: userBackend } = options;
-  const backend = userBackend ?? new NativeIndexBackend();
-  function withDefaultEquals(opts) {
-    if (opts?.equals !== void 0) return opts;
-    if (defaultEquals === void 0) return opts;
-    return { ...opts, equals: defaultEquals };
-  }
-  const ordered = state([], {
-    name,
-    describeKind: "state",
-    equals: (a, b) => a === b,
-    ...versioning != null ? { versioning } : {}
-  });
-  const byPrimary = derived(
-    [ordered],
-    ([s]) => {
-      const rows = s;
-      const m = /* @__PURE__ */ new Map();
-      for (const r of rows) m.set(r.primary, r.value);
-      return m;
-    },
-    { initial: backend.toPrimaryMap(), describeKind: "derived" }
-  );
-  const disposeByPrimaryKeepalive = keepaliveDerived(byPrimary);
-  let disposed = false;
-  function pushSnapshot() {
-    const snapshot = backend.toArray();
-    batch(() => {
-      ordered.down([[DIRTY]]);
-      ordered.down([[DATA, snapshot]]);
-    });
-  }
-  function wrapMutation(op) {
-    const prev = backend.version;
-    try {
-      return op();
-    } finally {
-      if (backend.version !== prev) pushSnapshot();
-    }
-  }
-  return {
-    ordered,
-    byPrimary,
-    has(primary) {
-      return backend.has(primary);
-    },
-    get(primary) {
-      return backend.get(primary);
-    },
-    get size() {
-      return backend.size;
-    },
-    upsert(primary, secondary, value, opts) {
-      return wrapMutation(() => backend.upsert(primary, secondary, value, withDefaultEquals(opts)));
-    },
-    upsertMany(rows, opts) {
-      const list = [...rows];
-      if (list.length === 0) return;
-      wrapMutation(() => backend.upsertMany(list, withDefaultEquals(opts)));
-    },
-    delete(primary) {
-      wrapMutation(() => backend.delete(primary));
-    },
-    deleteMany(primaries) {
-      const list = [...primaries];
-      if (list.length === 0) return;
-      wrapMutation(() => backend.deleteMany(list));
-    },
-    clear() {
-      wrapMutation(() => backend.clear());
-    },
-    dispose() {
-      if (disposed) return;
-      disposed = true;
-      disposeByPrimaryKeepalive();
-    }
-  };
-}
-
-// src/extra/sources-fs.ts
-import { existsSync, watch } from "node:fs";
-import { resolve as resolvePath } from "node:path";
-function sourceOpts3(opts) {
-  return { describeKind: "producer", ...opts };
-}
-function fromFSWatch(paths, opts) {
-  const list = Array.isArray(paths) ? paths : [paths];
-  if (list.length === 0) {
-    throw new RangeError("fromFSWatch expects at least one path");
-  }
-  const { recursive = true, debounce: debounce2 = 100, include, exclude, ...rest } = opts ?? {};
-  const includePatterns = include?.map(globToRegExp) ?? [];
-  const excludePatterns = (exclude ?? ["**/node_modules/**", "**/.git/**", "**/dist/**"]).map(
-    globToRegExp
-  );
-  return producer((a) => {
-    const pending = /* @__PURE__ */ new Map();
-    const watchers = [];
-    let stopped = false;
-    let terminalEmitted = false;
-    let generation = 0;
-    const closeWatchers = () => {
-      for (const watcher of watchers.splice(0)) watcher.close();
-    };
-    const emitError = (err) => {
-      if (terminalEmitted) return;
-      terminalEmitted = true;
-      stopped = true;
-      if (timer !== void 0) clearTimeout(timer);
-      timer = void 0;
-      pending.clear();
-      closeWatchers();
-      a.down([[ERROR, err]]);
-    };
-    let timer;
-    const flush = (token) => {
-      timer = void 0;
-      if (stopped || terminalEmitted) return;
-      if (pending.size === 0) return;
-      const batchMessages = [];
-      for (const evt of pending.values()) batchMessages.push([DATA, evt]);
-      pending.clear();
-      if (stopped || terminalEmitted || token !== generation) return;
-      a.down(batchMessages);
-    };
-    try {
-      for (const basePath of list) {
-        const watcher = watch(
-          basePath,
-          { recursive },
-          (eventType, fileName) => {
-            if (stopped || terminalEmitted) return;
-            if (fileName == null) return;
-            const rel = String(fileName).replaceAll("\\", "/");
-            const abs = resolvePath(basePath, String(fileName));
-            const normalized = abs.replaceAll("\\", "/");
-            const root = resolvePath(basePath).replaceAll("\\", "/");
-            const relForMatch = rel.startsWith("./") ? rel.slice(2) : rel;
-            const included = includePatterns.length === 0 || matchesAnyPattern(normalized, includePatterns) || matchesAnyPattern(relForMatch, includePatterns);
-            if (!included) return;
-            const excluded = matchesAnyPattern(normalized, excludePatterns) || matchesAnyPattern(relForMatch, excludePatterns);
-            if (excluded) return;
-            let kind = "change";
-            if (eventType === "rename") {
-              try {
-                kind = existsSync(normalized) ? "create" : "delete";
-              } catch {
-                kind = "rename";
-              }
-            }
-            pending.set(normalized, {
-              type: kind,
-              path: normalized,
-              root,
-              relative_path: relForMatch,
-              timestamp_ns: wallClockNs()
-            });
-            if (timer !== void 0) clearTimeout(timer);
-            const token = generation;
-            timer = setTimeout(() => flush(token), debounce2);
-          }
-        );
-        watcher.on("error", (err) => emitError(err));
-        watchers.push(watcher);
-      }
-    } catch (err) {
-      emitError(err);
-    }
-    return () => {
-      stopped = true;
-      generation += 1;
-      if (timer !== void 0) clearTimeout(timer);
-      timer = void 0;
-      closeWatchers();
-      pending.clear();
-    };
-  }, sourceOpts3(rest));
-}
-
-// src/extra/storage.ts
-import { randomBytes } from "node:crypto";
-import {
-  mkdirSync,
-  readdirSync,
-  readFileSync,
-  renameSync,
-  unlinkSync,
-  writeFileSync
-} from "node:fs";
-import { basename, dirname, join } from "node:path";
-import { DatabaseSync } from "node:sqlite";
-function sortJsonValue(value) {
-  if (value === null || typeof value !== "object") return value;
-  if (Array.isArray(value)) return value.map(sortJsonValue);
-  const obj = value;
-  const keys = Object.keys(obj).sort();
-  const out = {};
-  for (const k of keys) out[k] = sortJsonValue(obj[k]);
-  return out;
-}
-function stableJsonString(data) {
-  return JSON.stringify(sortJsonValue(data), void 0, 0);
-}
-function memoryStorage() {
-  const data = /* @__PURE__ */ new Map();
-  return {
-    save(key, record) {
-      data.set(key, JSON.parse(JSON.stringify(record)));
-    },
-    load(key) {
-      const v = data.get(key);
-      return v === void 0 ? null : JSON.parse(JSON.stringify(v));
-    },
-    clear(key) {
-      data.delete(key);
-    },
-    list() {
-      return [...data.keys()].sort();
-    }
-  };
-}
-function dictStorage(storage) {
-  return {
-    save(key, record) {
-      storage[key] = JSON.parse(JSON.stringify(record));
-    },
-    load(key) {
-      const raw = storage[key];
-      return raw === void 0 ? null : JSON.parse(JSON.stringify(raw));
-    },
-    clear(key) {
-      delete storage[key];
-    },
-    list() {
-      return Object.keys(storage).sort();
-    }
-  };
-}
-function fileStorage(dir) {
-  const encoder = new TextEncoder();
-  const decoder = new TextDecoder("utf-8", { fatal: true });
-  const pathFor = (key) => {
-    let out = "";
-    for (const ch of key) {
-      if (ch.length === 1 && /[a-zA-Z0-9_-]/.test(ch)) {
-        out += ch;
-        continue;
-      }
-      for (const byte of encoder.encode(ch)) {
-        out += `%${byte.toString(16).padStart(2, "0")}`;
-      }
-    }
-    return join(dir, `${out}.json`);
-  };
-  const keyFromFilename = (filename) => {
-    if (!filename.endsWith(".json")) return null;
-    const stem = filename.slice(0, -".json".length);
-    const bytes = [];
-    const encodeAscii = (s) => {
-      for (let i2 = 0; i2 < s.length; i2++) bytes.push(s.charCodeAt(i2));
-    };
-    let i = 0;
-    while (i < stem.length) {
-      const ch = stem[i];
-      if (ch === "%" && i + 2 < stem.length) {
-        const hex = stem.slice(i + 1, i + 3);
-        if (/^[0-9a-f]{2}$/i.test(hex)) {
-          bytes.push(Number.parseInt(hex, 16));
-          i += 3;
-          continue;
-        }
-      }
-      encodeAscii(ch);
-      i += 1;
-    }
-    try {
-      return decoder.decode(new Uint8Array(bytes));
-    } catch {
-      return null;
-    }
-  };
-  return {
-    save(key, record) {
-      mkdirSync(dir, { recursive: true });
-      const filePath = pathFor(key);
-      const payload = `${stableJsonString(record)}
-`;
-      const base = basename(filePath);
-      const d = dirname(filePath);
-      const tmp = join(d, `.${base}.${randomBytes(8).toString("hex")}.tmp`);
-      try {
-        writeFileSync(tmp, payload, "utf8");
-        renameSync(tmp, filePath);
-      } catch (e) {
-        try {
-          unlinkSync(tmp);
-        } catch {
-        }
-        throw e;
-      }
-    },
-    load(key) {
-      try {
-        const text = readFileSync(pathFor(key), "utf8").trim();
-        if (!text) return null;
-        return JSON.parse(text);
-      } catch {
-        return null;
-      }
-    },
-    clear(key) {
-      try {
-        unlinkSync(pathFor(key));
-      } catch (e) {
-        if (e.code !== "ENOENT") throw e;
-      }
-    },
-    list() {
-      try {
-        const entries = readdirSync(dir);
-        const keys = [];
-        for (const entry of entries) {
-          if (entry.startsWith(".")) continue;
-          const k = keyFromFilename(entry);
-          if (k !== null) keys.push(k);
-        }
-        return keys.sort();
-      } catch (e) {
-        if (e.code === "ENOENT") return [];
-        throw e;
-      }
-    }
-  };
-}
-function sqliteStorage(path) {
-  const db = new DatabaseSync(path);
-  db.exec(`CREATE TABLE IF NOT EXISTS graphrefly_checkpoint (k TEXT PRIMARY KEY, v TEXT NOT NULL)`);
-  return {
-    save(key, record) {
-      const payload = stableJsonString(record);
-      db.prepare(`INSERT OR REPLACE INTO graphrefly_checkpoint (k, v) VALUES (?, ?)`).run(
-        key,
-        payload
-      );
-    },
-    load(key) {
-      const row = db.prepare(`SELECT v FROM graphrefly_checkpoint WHERE k = ?`).get(key);
-      if (row === void 0 || typeof row.v !== "string" || row.v.trim() === "") return null;
-      return JSON.parse(row.v);
-    },
-    clear(key) {
-      db.prepare(`DELETE FROM graphrefly_checkpoint WHERE k = ?`).run(key);
-    },
-    list() {
-      const rows = db.prepare(`SELECT k FROM graphrefly_checkpoint ORDER BY k`).all();
-      return rows.map((r) => r.k);
-    },
-    close() {
-      try {
-        db.close();
-      } catch {
-      }
-    }
-  };
-}
-function fromIDBRequest(req) {
-  return producer((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((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 openIdb(dbName, storeName, version) {
-  return new Promise((resolve, reject) => {
-    if (typeof indexedDB === "undefined") {
-      reject(new TypeError("indexedDB is not available in this environment"));
-      return;
-    }
-    const req = indexedDB.open(dbName, version);
-    req.onupgradeneeded = () => {
-      const db = req.result;
-      if (!db.objectStoreNames.contains(storeName)) {
-        db.createObjectStore(storeName);
-      }
-    };
-    req.onsuccess = () => resolve(req.result);
-    req.onerror = () => reject(req.error ?? new Error("IndexedDB open failed"));
-  });
-}
-function idbOp(dbName, storeName, version, mode, op) {
-  return openIdb(dbName, storeName, version).then(
-    (db) => new Promise((resolve, reject) => {
-      const tx = db.transaction(storeName, mode);
-      const store = tx.objectStore(storeName);
-      const req = op(store);
-      let reqResult;
-      let reqDone = false;
-      let txDone = false;
-      const finish = () => {
-        if (!reqDone || !txDone) return;
-        db.close();
-        resolve(reqResult);
-      };
-      req.onsuccess = () => {
-        reqResult = req.result;
-        reqDone = true;
-        finish();
-      };
-      req.onerror = () => {
-        db.close();
-        reject(req.error ?? new Error("IndexedDB request failed"));
-      };
-      tx.oncomplete = () => {
-        txDone = true;
-        if (!reqDone) {
-          db.close();
-          reject(new Error("IndexedDB transaction completed without request result"));
-          return;
-        }
-        finish();
-      };
-      tx.onerror = () => {
-        db.close();
-        reject(tx.error ?? new Error("IndexedDB transaction failed"));
-      };
-      tx.onabort = () => {
-        db.close();
-        reject(tx.error ?? new Error("IndexedDB transaction aborted"));
-      };
-    })
-  );
-}
-function indexedDbStorage(spec) {
-  const { dbName, storeName } = spec;
-  const version = spec.version ?? 1;
-  const recordKey = spec.key ?? "graphrefly_checkpoint";
-  return {
-    async save(_key, record) {
-      await idbOp(
-        dbName,
-        storeName,
-        version,
-        "readwrite",
-        (store) => store.put(record, recordKey)
-      );
-    },
-    async load(_key) {
-      const raw = await idbOp(
-        dbName,
-        storeName,
-        version,
-        "readonly",
-        (store) => store.get(recordKey)
-      );
-      if (raw === void 0 || raw === null) return null;
-      if (typeof raw !== "object" || Array.isArray(raw)) return null;
-      return raw;
-    },
-    async clear(_key) {
-      await idbOp(dbName, storeName, version, "readwrite", (store) => store.delete(recordKey));
-    }
-  };
-}
-
-// 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);
-  }
-  let effectUnsub;
-  if (exposeEntries.length > 0) {
-    const exposedNodes = exposeEntries.map(([, n]) => n);
-    const aggregated = node(
-      exposedNodes,
-      (data, a) => {
-        const updates = {};
-        for (let i = 0; i < exposeEntries.length; i++) {
-          const [name] = exposeEntries[i];
-          const batch0 = data[i];
-          if (batch0 != null && batch0.length > 0) {
-            updates[name] = batch0.at(-1);
-          }
-        }
-        if (Object.keys(updates).length === 0) return;
-        a.emit(updates);
-      },
-      // Each `updates` object is a fresh allocation, so default reference
-      // equality correctly propagates every aggregation wave — no
-      // `equals: () => false` override needed.
-      { name: `${bridgeName}::aggregated` }
-    );
-    const effectNode = effect([aggregated], (data) => {
-      const updates = data[0];
-      if (updates == null || 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.
-      // The handshake deadline auto-cancels via the reactive race
-      // (`statusNode → "connected"` wins) — no explicit clearTimeout.
-      case "r": {
-        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.cache;
-        }
-        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 (defaultConfig.isLocalOnly(type)) 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 handshakeUnsub;
-  if (opts.timeoutMs != null && opts.timeoutMs > 0) {
-    const deadline$ = fromTimer(opts.timeoutMs);
-    const ready$ = filter(statusNode, (s) => s === "connected");
-    const race$ = first(
-      merge(
-        map(deadline$, () => "timeout"),
-        map(ready$, () => "ready")
-      )
-    );
-    handshakeUnsub = race$.subscribe((msgs) => {
-      for (const m of msgs) {
-        if (m[0] === DATA && m[1] === "timeout") {
-          errorNode.down([[DATA, new Error("Worker bridge handshake timeout")]]);
-          destroy();
-        }
-      }
-    });
-  }
-  function destroy() {
-    if (destroyed) return;
-    destroyed = true;
-    handshakeUnsub?.();
-    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"]]);
-    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);
-  let effectUnsub;
-  let destroyed = false;
-  if (exposeEntries.length > 0) {
-    const nodes = exposeEntries.map(([, n]) => n);
-    const aggregated = node(
-      nodes,
-      (data, a) => {
-        const updates = {};
-        for (let i = 0; i < exposeEntries.length; i++) {
-          const [name] = exposeEntries[i];
-          const batch0 = data[i];
-          if (batch0 != null && batch0.length > 0) {
-            updates[name] = batch0.at(-1);
-          }
-        }
-        if (Object.keys(updates).length === 0) return;
-        a.emit(updates);
-      },
-      // Fresh `updates` object per wave → default reference equality is
-      // correct; no `equals: () => false` override needed.
-      { name: "workerSelf::aggregated" }
-    );
-    const effectNode = effect([aggregated], (data) => {
-      if (destroyed) return;
-      const updates = data[0];
-      if (updates == null || 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 (defaultConfig.isLocalOnly(type)) 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.cache;
-  }
-  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?.();
-    lastSeenImportVersions.clear();
-    proxyNodes.clear();
-  }
-  return { destroy };
-}
-
-export {
-  externalProducer,
-  externalBundle,
-  reactiveSink,
-  retry,
-  retrySource,
-  CircuitOpenError,
-  circuitBreaker,
-  withBreaker,
-  tokenBucket,
-  RateLimiterOverflowError,
-  rateLimiter,
-  withStatus,
-  TimeoutError,
-  fallback,
-  timeout,
-  fromWebSocket,
-  fromWebhook,
-  fromHTTP,
-  toHTTP,
-  toSSE,
-  toSSEBytes,
-  toReadableStream,
-  fromSSE,
-  fromHTTPStream,
-  fromHTTPPoll,
-  toWebSocket,
-  fromWebSocketReconnect,
-  fromMCP,
-  fromGitHook,
-  fromOTel,
-  fromSyslog,
-  parseSyslog,
-  fromStatsD,
-  parseStatsD,
-  fromPrometheus,
-  parsePrometheusText,
-  fromKafka,
-  toKafka,
-  fromRedisStream,
-  toRedisStream,
-  fromCSV,
-  csvRows,
-  ndjsonRows,
-  fromNDJSON,
-  fromClickHouseWatch,
-  fromPulsar,
-  toPulsar,
-  fromNATS,
-  toNATS,
-  fromRabbitMQ,
-  toRabbitMQ,
-  toFile,
-  toCSV,
-  toClickHouse,
-  toS3,
-  toPostgres,
-  toMongo,
-  toLoki,
-  toTempo,
-  checkpointToS3,
-  checkpointToRedis,
-  fromSqlite,
-  fromSqliteCursor,
-  toSqlite,
-  fromPrisma,
-  fromDrizzle,
-  fromKysely,
-  lru,
-  cascadingCache,
-  NativePubSubBackend,
-  pubsub,
-  NativeIndexBackend,
-  reactiveIndex,
-  fromFSWatch,
-  memoryStorage,
-  dictStorage,
-  fileStorage,
-  sqliteStorage,
-  fromIDBRequest,
-  fromIDBTransaction,
-  indexedDbStorage,
-  signalToName,
-  nameToSignal,
-  serializeError,
-  deserializeError,
-  createTransport,
-  workerBridge,
-  workerSelf,
-  extra_exports
-};
-//# sourceMappingURL=chunk-BQ6RQQFF.js.map