@graphrefly/graphrefly 0.5.0 → 0.7.0

package/dist/extra/index.cjs

@@ -27,11 +27,14 @@ __export(extra_exports, {
   NS_PER_MS: () => NS_PER_MS,
   NS_PER_SEC: () => NS_PER_SEC,
   SqliteCheckpointAdapter: () => SqliteCheckpointAdapter,
+  TimeoutError: () => TimeoutError,
   audit: () => audit,
   buffer: () => buffer,
   bufferCount: () => bufferCount,
   bufferTime: () => bufferTime,
+  cache: () => cache,
   cached: () => cached,
+  cascadingCache: () => cascadingCache,
   catchError: () => catchError,
   checkpointNodeValue: () => checkpointNodeValue,
   checkpointToRedis: () => checkpointToRedis,
@@ -56,6 +59,7 @@ __export(extra_exports, {
   escapeRegexChar: () => escapeRegexChar,
   exhaustMap: () => exhaustMap,
   exponential: () => exponential,
+  fallback: () => fallback,
   fibonacci: () => fibonacci,
   filter: () => filter,
   find: () => find,
@@ -68,6 +72,7 @@ __export(extra_exports, {
   fromCSV: () => fromCSV,
   fromClickHouseWatch: () => fromClickHouseWatch,
   fromCron: () => fromCron,
+  fromDrizzle: () => fromDrizzle,
   fromEvent: () => fromEvent,
   fromFSWatch: () => fromFSWatch,
   fromGitHook: () => fromGitHook,
@@ -76,15 +81,18 @@ __export(extra_exports, {
   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,
   fromRedisStream: () => fromRedisStream,
+  fromSqlite: () => fromSqlite,
   fromStatsD: () => fromStatsD,
   fromSyslog: () => fromSyslog,
   fromTimer: () => fromTimer,
@@ -96,6 +104,7 @@ __export(extra_exports, {
   last: () => last,
   linear: () => linear,
   logSlice: () => logSlice,
+  lru: () => lru,
   map: () => map,
   matchesAnyPattern: () => matchesAnyPattern,
   matchesCron: () => matchesCron,
@@ -145,6 +154,7 @@ __export(extra_exports, {
   throttle: () => throttle,
   throttleTime: () => throttleTime,
   throwError: () => throwError,
+  tieredStorage: () => tieredStorage,
   timeout: () => timeout,
   toArray: () => toArray,
   toCSV: () => toCSV,
@@ -162,6 +172,7 @@ __export(extra_exports, {
   toRedisStream: () => toRedisStream,
   toS3: () => toS3,
   toSSE: () => toSSE,
+  toSqlite: () => toSqlite,
   toTempo: () => toTempo,
   toWebSocket: () => toWebSocket,
   tokenBucket: () => tokenBucket,
@@ -328,10 +339,14 @@ function partitionForBatch(messages) {
   }
   return { immediate, deferred, terminal };
 }
-function emitWithBatch(emit, messages, phase = 2) {
+function emitWithBatch(emit, messages, phase = 2, options) {
   if (messages.length === 0) {
     return;
   }
+  if (options?.strategy === "sequential") {
+    _emitSequential(emit, messages, phase);
+    return;
+  }
   const queue = phase === 3 ? pendingPhase3 : pendingPhase2;
   if (messages.length === 1) {
     const t = messages[0][0];
@@ -372,6 +387,29 @@ function emitWithBatch(emit, messages, phase = 2) {
     }
   }
 }
+function _emitSequential(emit, messages, phase = 2) {
+  const dataQueue = phase === 3 ? pendingPhase3 : pendingPhase2;
+  for (const msg of messages) {
+    const tier = messageTier(msg[0]);
+    if (tier === 2) {
+      if (isBatching()) {
+        const m = msg;
+        dataQueue.push(() => emit([m]));
+      } else {
+        emit([msg]);
+      }
+    } else if (tier >= 3) {
+      if (isBatching()) {
+        const m = msg;
+        pendingPhase3.push(() => emit([m]));
+      } else {
+        emit([msg]);
+      }
+    } else {
+      emit([msg]);
+    }
+  }
+}
 
 // src/core/clock.ts
 function monotonicNs() {
@@ -570,6 +608,7 @@ var NodeImpl = class {
   _producerStarted = false;
   _connecting = false;
   _manualEmitUsed = false;
+  _hasEmittedData = false;
   _sinkCount = 0;
   _singleDepSinkCount = 0;
   // --- Object/collection state ---
@@ -856,6 +895,7 @@ var NodeImpl = class {
         this._cleanup = void 0;
         cleanupFn?.();
         this._cached = void 0;
+        this._hasEmittedData = false;
         this._lastDepValues = void 0;
       }
       this._status = statusAfterMessage(this._status, m);
@@ -865,6 +905,7 @@ var NodeImpl = class {
       if (t === TEARDOWN) {
         if (this._opts.resetOnTeardown) {
           this._cached = void 0;
+          this._hasEmittedData = false;
         }
         const teardownCleanup = this._cleanup;
         this._cleanup = void 0;
@@ -895,7 +936,16 @@ var NodeImpl = class {
   }
   _emitAutoValue(value) {
     const wasDirty = this._status === "dirty";
-    const unchanged = this._equals(this._cached, value);
+    let unchanged;
+    try {
+      unchanged = this._hasEmittedData && this._equals(this._cached, value);
+    } catch (eqErr) {
+      const eqMsg = eqErr instanceof Error ? eqErr.message : String(eqErr);
+      const wrapped = new Error(`Node "${this.name}": equals threw: ${eqMsg}`, { cause: eqErr });
+      this._downInternal([[ERROR, wrapped]]);
+      return;
+    }
+    this._hasEmittedData = true;
     if (unchanged) {
       this._downInternal(wasDirty ? [[RESOLVED]] : [[DIRTY], [RESOLVED]]);
       return;
@@ -942,7 +992,9 @@ var NodeImpl = class {
       if (out === void 0) return;
       this._emitAutoValue(out);
     } catch (err) {
-      this._downInternal([[ERROR, err]]);
+      const errMsg = err instanceof Error ? err.message : String(err);
+      const wrapped = new Error(`Node "${this.name}": fn threw: ${errMsg}`, { cause: err });
+      this._downInternal([[ERROR, wrapped]]);
     }
   }
   _onDepDirty(index) {
@@ -977,7 +1029,11 @@ var NodeImpl = class {
         try {
           if (this._onMessage(msg, index, this._actions)) continue;
         } catch (err) {
-          this._downInternal([[ERROR, err]]);
+          const errMsg = err instanceof Error ? err.message : String(err);
+          const wrapped = new Error(`Node "${this.name}": onMessage threw: ${errMsg}`, {
+            cause: err
+          });
+          this._downInternal([[ERROR, wrapped]]);
           return;
         }
       }
@@ -1192,6 +1248,34 @@ function resolveBackoffPreset(name) {
   );
 }
 
+// src/core/timer.ts
+var ResettableTimer = class {
+  _timer;
+  _gen = 0;
+  /** Schedule callback after delayMs. Cancels any pending timer. */
+  start(delayMs, callback) {
+    this.cancel();
+    this._gen += 1;
+    const gen = this._gen;
+    this._timer = setTimeout(() => {
+      this._timer = void 0;
+      if (gen !== this._gen) return;
+      callback();
+    }, delayMs);
+  }
+  /** Cancel the pending timer (if any). */
+  cancel() {
+    if (this._timer !== void 0) {
+      clearTimeout(this._timer);
+      this._timer = void 0;
+    }
+  }
+  /** Whether a timer is currently pending. */
+  get pending() {
+    return this._timer !== void 0;
+  }
+};
+
 // src/extra/resilience.ts
 function operatorOpts(opts) {
   return { describeKind: "operator", ...opts };
@@ -1221,14 +1305,7 @@ function retry(source, opts) {
       let stopped = false;
       let prevDelay = null;
       let unsub;
-      let timer;
-      let timerGen = 0;
-      function cancelTimer() {
-        if (timer !== void 0) {
-          clearTimeout(timer);
-          timer = void 0;
-        }
-      }
+      const timer = new ResettableTimer();
       function disconnectUpstream() {
         unsub?.();
         unsub = void 0;
@@ -1244,20 +1321,18 @@ function retry(source, opts) {
         const delayNs = coerceDelayNs(raw === void 0 ? null : raw);
         prevDelay = delayNs;
         attempt += 1;
-        timerGen += 1;
-        const gen = timerGen;
         disconnectUpstream();
         const delayMs = delayNs > 0 ? delayNs / NS_PER_MS : 1;
-        timer = setTimeout(() => {
-          timer = void 0;
-          if (stopped || gen !== timerGen) return;
+        timer.start(delayMs, () => {
+          if (stopped) return;
           connect();
-        }, delayMs);
+        });
       }
       function connect() {
-        cancelTimer();
+        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]]);
@@ -1279,8 +1354,7 @@ function retry(source, opts) {
       connect();
       return () => {
         stopped = true;
-        timerGen += 1;
-        cancelTimer();
+        timer.cancel();
         disconnectUpstream();
       };
     },
@@ -1460,14 +1534,7 @@ function rateLimiter(source, maxEvents, windowNs) {
     (_d, a) => {
       const times = [];
       const pending = [];
-      let timer;
-      let timerGen = 0;
-      function cancelTimer() {
-        if (timer !== void 0) {
-          clearTimeout(timer);
-          timer = void 0;
-        }
-      }
+      const timer = new ResettableTimer();
       function prune(now) {
         const boundary = now - windowNs;
         while (times.length > 0 && times[0] <= boundary) times.shift();
@@ -1481,15 +1548,10 @@ function rateLimiter(source, maxEvents, windowNs) {
             a.emit(pending.shift());
           } else {
             const oldest = times[0];
-            cancelTimer();
-            timerGen += 1;
-            const gen = timerGen;
             const delayNs = Math.max(0, oldest + windowNs - monotonicNs());
-            timer = setTimeout(() => {
-              timer = void 0;
-              if (gen !== timerGen) return;
+            timer.start(delayNs / NS_PER_MS, () => {
               tryEmit();
-            }, delayNs / NS_PER_MS);
+            });
             return;
           }
         }
@@ -1503,14 +1565,12 @@ function rateLimiter(source, maxEvents, windowNs) {
             tryEmit();
           } else if (t === RESOLVED) a.down([[RESOLVED]]);
           else if (t === COMPLETE) {
-            timerGen += 1;
-            cancelTimer();
+            timer.cancel();
             pending.length = 0;
             times.length = 0;
             a.down([[COMPLETE]]);
           } else if (t === ERROR) {
-            timerGen += 1;
-            cancelTimer();
+            timer.cancel();
             pending.length = 0;
             times.length = 0;
             a.down([m]);
@@ -1518,8 +1578,7 @@ function rateLimiter(source, maxEvents, windowNs) {
         }
       });
       return () => {
-        timerGen += 1;
-        cancelTimer();
+        timer.cancel();
         unsub();
       };
     },
@@ -1580,6 +1639,147 @@ function withStatus(src, options) {
     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.subscribe === "function" && typeof x.get === "function";
+}
+function fallback(source, fb) {
+  return producer(
+    (_d, a) => {
+      let fallbackUnsub;
+      let sourceUnsub;
+      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) {
+            sourceUnsub?.();
+            if (isNode(fb)) {
+              fallbackUnsub = fb.subscribe((fMsgs) => {
+                a.down(fMsgs);
+              });
+              const cur = fb.get();
+              if (cur !== void 0) a.down([[DATA, cur]]);
+            } else {
+              a.emit(fb);
+              a.down([[COMPLETE]]);
+            }
+            return;
+          } else if (t === TEARDOWN) {
+            fallbackUnsub?.();
+            a.down([m]);
+            return;
+          } else a.down([m]);
+        }
+      });
+      return () => {
+        sourceUnsub?.();
+        fallbackUnsub?.();
+      };
+    },
+    {
+      ...operatorOpts(),
+      initial: source.get()
+    }
+  );
+}
+function timeout(source, timeoutNs) {
+  if (timeoutNs <= 0) throw new RangeError("timeoutNs must be > 0");
+  return producer(
+    (_d, 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.get()
+    }
+  );
+}
+function cache(source, ttlNs) {
+  if (ttlNs <= 0) throw new RangeError("ttlNs must be > 0");
+  let cachedValue;
+  let cachedAt = 0;
+  let hasCached = false;
+  return producer(
+    (_d, a) => {
+      if (hasCached && monotonicNs() - cachedAt < ttlNs) {
+        a.down([[DATA, cachedValue]]);
+      }
+      const unsub = source.subscribe((msgs) => {
+        for (const m of msgs) {
+          const t = m[0];
+          if (t === DATA) {
+            cachedValue = m[1];
+            cachedAt = monotonicNs();
+            hasCached = true;
+            a.emit(cachedValue);
+          } else if (t === DIRTY) a.down([[DIRTY]]);
+          else if (t === RESOLVED) a.down([[RESOLVED]]);
+          else if (t === COMPLETE) a.down([[COMPLETE]]);
+          else if (t === ERROR) a.down([m]);
+          else a.down([m]);
+        }
+      });
+      return unsub;
+    },
+    {
+      ...operatorOpts(),
+      resubscribable: true,
+      initial: source.get()
+    }
+  );
+}
 
 // src/extra/sources.ts
 var import_node_fs = require("fs");
@@ -1937,11 +2137,11 @@ function fromAsyncIter(iterable, opts) {
     };
   }, sourceOpts(rest));
 }
-function isNode(x) {
+function isNode2(x) {
   return x != null && typeof x.subscribe === "function" && typeof x.get === "function";
 }
 function fromAny(input, opts) {
-  if (isNode(input)) {
+  if (isNode2(input)) {
     return input;
   }
   if (isThenable(input)) {
@@ -2073,6 +2273,17 @@ function firstValueFrom(source) {
 var shareReplay = replay;
 
 // src/extra/adapters.ts
+function createSinkErrorHandler(userHandler) {
+  const errorsNode = state(null);
+  const handler = (err) => {
+    userHandler?.(err);
+    try {
+      errorsNode.down([[DATA, err]]);
+    } catch {
+    }
+  };
+  return { errorsNode, handler };
+}
 function sourceOpts2(opts) {
   return { describeKind: "producer", ...opts };
 }
@@ -2375,7 +2586,7 @@ function toWebSocket(source, socket, opts) {
   };
   const inner = node([source], () => void 0, {
     describeKind: "effect",
-    onMessage(msg) {
+    onMessage(msg, _depIndex, _actions) {
       if (msg[0] === DATA) {
         let serialized;
         try {
@@ -2823,10 +3034,11 @@ function toKafka(source, kafkaProducer, topic, opts) {
     onTransportError,
     ...rest
   } = opts ?? {};
+  const { errorsNode, handler } = createSinkErrorHandler(onTransportError);
   const inner = node([source], () => void 0, {
     describeKind: "effect",
     ...rest,
-    onMessage(msg) {
+    onMessage(msg, _depIndex, _actions) {
       if (msg[0] === DATA) {
         const value = msg[1];
         const key = keyExtractor?.(value) ?? null;
@@ -2834,7 +3046,7 @@ function toKafka(source, kafkaProducer, topic, opts) {
         try {
           serialized = serialize(value);
         } catch (err) {
-          onTransportError?.({
+          handler({
             stage: "serialize",
             error: err instanceof Error ? err : new Error(String(err)),
             value
@@ -2845,7 +3057,7 @@ function toKafka(source, kafkaProducer, topic, opts) {
           topic,
           messages: [{ key, value: Buffer.from(serialized) }]
         }).catch((err) => {
-          onTransportError?.({
+          handler({
             stage: "send",
             error: err instanceof Error ? err : new Error(String(err)),
             value
@@ -2856,8 +3068,15 @@ function toKafka(source, kafkaProducer, topic, opts) {
       return false;
     }
   });
-  return inner.subscribe(() => {
+  const unsub = inner.subscribe(() => {
   });
+  return {
+    dispose: () => {
+      unsub();
+      errorsNode.down([[TEARDOWN]]);
+    },
+    errors: errorsNode
+  };
 }
 function fromRedisStream(client, key, opts) {
   const {
@@ -2922,17 +3141,18 @@ function toRedisStream(source, client, key, opts) {
     onTransportError,
     ...rest
   } = opts ?? {};
+  const { errorsNode, handler } = createSinkErrorHandler(onTransportError);
   const inner = node([source], () => void 0, {
     describeKind: "effect",
     ...rest,
-    onMessage(msg) {
+    onMessage(msg, _depIndex, _actions) {
       if (msg[0] === DATA) {
         const value = msg[1];
         let fields;
         try {
           fields = serialize(value);
         } catch (err) {
-          onTransportError?.({
+          handler({
             stage: "serialize",
             error: err instanceof Error ? err : new Error(String(err)),
             value
@@ -2941,7 +3161,7 @@ function toRedisStream(source, client, key, opts) {
         }
         const send = maxLen !== void 0 ? client.xadd(key, "MAXLEN", "~", String(maxLen), "*", ...fields) : client.xadd(key, "*", ...fields);
         void send.catch((err) => {
-          onTransportError?.({
+          handler({
             stage: "send",
             error: err instanceof Error ? err : new Error(String(err)),
             value
@@ -2952,8 +3172,15 @@ function toRedisStream(source, client, key, opts) {
       return false;
     }
   });
-  return inner.subscribe(() => {
+  const unsub = inner.subscribe(() => {
   });
+  return {
+    dispose: () => {
+      unsub();
+      errorsNode.down([[TEARDOWN]]);
+    },
+    errors: errorsNode
+  };
 }
 function fromCSV(source, opts) {
   const {
@@ -3180,17 +3407,18 @@ function toPulsar(source, pulsarProducer, opts) {
     onTransportError,
     ...rest
   } = opts ?? {};
+  const { errorsNode, handler } = createSinkErrorHandler(onTransportError);
   const inner = node([source], () => void 0, {
     describeKind: "effect",
     ...rest,
-    onMessage(msg) {
+    onMessage(msg, _depIndex, _actions) {
       if (msg[0] === DATA) {
         const value = msg[1];
         let data;
         try {
           data = serialize(value);
         } catch (err) {
-          onTransportError?.({
+          handler({
             stage: "serialize",
             error: err instanceof Error ? err : new Error(String(err)),
             value
@@ -3202,7 +3430,7 @@ function toPulsar(source, pulsarProducer, opts) {
           partitionKey: keyExtractor?.(value),
           properties: propertiesExtractor?.(value)
         }).catch((err) => {
-          onTransportError?.({
+          handler({
             stage: "send",
             error: err instanceof Error ? err : new Error(String(err)),
             value
@@ -3213,8 +3441,15 @@ function toPulsar(source, pulsarProducer, opts) {
       return false;
     }
   });
-  return inner.subscribe(() => {
+  const unsub = inner.subscribe(() => {
   });
+  return {
+    dispose: () => {
+      unsub();
+      errorsNode.down([[TEARDOWN]]);
+    },
+    errors: errorsNode
+  };
 }
 function fromNATS(client, subject, opts) {
   const decoder = new TextDecoder();
@@ -3270,17 +3505,18 @@ function toNATS(source, client, subject, opts) {
     onTransportError,
     ...rest
   } = opts ?? {};
+  const { errorsNode, handler } = createSinkErrorHandler(onTransportError);
   const inner = node([source], () => void 0, {
     describeKind: "effect",
     ...rest,
-    onMessage(msg) {
+    onMessage(msg, _depIndex, _actions) {
       if (msg[0] === DATA) {
         const value = msg[1];
         let data;
         try {
           data = serialize(value);
         } catch (err) {
-          onTransportError?.({
+          handler({
             stage: "serialize",
             error: err instanceof Error ? err : new Error(String(err)),
             value
@@ -3290,7 +3526,7 @@ function toNATS(source, client, subject, opts) {
         try {
           client.publish(subject, data);
         } catch (err) {
-          onTransportError?.({
+          handler({
             stage: "send",
             error: err instanceof Error ? err : new Error(String(err)),
             value
@@ -3301,8 +3537,15 @@ function toNATS(source, client, subject, opts) {
       return false;
     }
   });
-  return inner.subscribe(() => {
+  const unsub = inner.subscribe(() => {
   });
+  return {
+    dispose: () => {
+      unsub();
+      errorsNode.down([[TEARDOWN]]);
+    },
+    errors: errorsNode
+  };
 }
 function fromRabbitMQ(channel, queue, opts) {
   const {
@@ -3364,17 +3607,18 @@ function toRabbitMQ(source, channel, exchange, opts) {
     onTransportError,
     ...rest
   } = opts ?? {};
+  const { errorsNode, handler } = createSinkErrorHandler(onTransportError);
   const inner = node([source], () => void 0, {
     describeKind: "effect",
     ...rest,
-    onMessage(msg) {
+    onMessage(msg, _depIndex, _actions) {
       if (msg[0] === DATA) {
         const value = msg[1];
         let routingKey;
         try {
           routingKey = routingKeyExtractor(value);
         } catch (err) {
-          onTransportError?.({
+          handler({
             stage: "routing_key",
             error: err instanceof Error ? err : new Error(String(err)),
             value
@@ -3385,7 +3629,7 @@ function toRabbitMQ(source, channel, exchange, opts) {
         try {
           content = serialize(value);
         } catch (err) {
-          onTransportError?.({
+          handler({
             stage: "serialize",
             error: err instanceof Error ? err : new Error(String(err)),
             value
@@ -3395,7 +3639,7 @@ function toRabbitMQ(source, channel, exchange, opts) {
         try {
           channel.publish(exchange, routingKey, content);
         } catch (err) {
-          onTransportError?.({
+          handler({
             stage: "send",
             error: err instanceof Error ? err : new Error(String(err)),
             value
@@ -3406,8 +3650,15 @@ function toRabbitMQ(source, channel, exchange, opts) {
       return false;
     }
   });
-  return inner.subscribe(() => {
+  const unsub = inner.subscribe(() => {
   });
+  return {
+    dispose: () => {
+      unsub();
+      errorsNode.down([[TEARDOWN]]);
+    },
+    errors: errorsNode
+  };
 }
 function toFile(source, writer, opts) {
   const {
@@ -3419,8 +3670,10 @@ function toFile(source, writer, opts) {
     mode: _mode,
     ...rest
   } = opts ?? {};
+  const { errorsNode, handler } = createSinkErrorHandler(onTransportError);
   let buffer2 = [];
   let timer;
+  let disposed = false;
   const doFlush = () => {
     if (buffer2.length === 0) return;
     const chunk = buffer2.join("");
@@ -3428,7 +3681,7 @@ function toFile(source, writer, opts) {
     try {
       writer.write(chunk);
     } catch (err) {
-      onTransportError?.({
+      handler({
         stage: "send",
         error: err instanceof Error ? err : new Error(String(err)),
         value: chunk
@@ -3436,7 +3689,7 @@ function toFile(source, writer, opts) {
     }
   };
   const scheduleFlush = () => {
-    if (flushIntervalMs > 0 && timer === void 0) {
+    if (flushIntervalMs > 0 && timer === void 0 && !disposed) {
       timer = setTimeout(() => {
         timer = void 0;
         doFlush();
@@ -3447,14 +3700,14 @@ function toFile(source, writer, opts) {
   const inner = node([source], () => void 0, {
     describeKind: "effect",
     ...rest,
-    onMessage(msg) {
+    onMessage(msg, _depIndex, _actions) {
       if (msg[0] === DATA) {
         const value = msg[1];
         let line;
         try {
           line = serialize(value);
         } catch (err) {
-          onTransportError?.({
+          handler({
             stage: "serialize",
             error: err instanceof Error ? err : new Error(String(err)),
             value
@@ -3469,7 +3722,7 @@ function toFile(source, writer, opts) {
           try {
             writer.write(line);
           } catch (err) {
-            onTransportError?.({
+            handler({
               stage: "send",
               error: err instanceof Error ? err : new Error(String(err)),
               value
@@ -3478,7 +3731,7 @@ function toFile(source, writer, opts) {
         }
         return true;
       }
-      if (msg[0] === COMPLETE || msg[0] === TEARDOWN) {
+      if (messageTier(msg[0]) >= 3) {
         doFlush();
       }
       return false;
@@ -3487,18 +3740,25 @@ function toFile(source, writer, opts) {
   const unsub = inner.subscribe(() => {
   });
   const dispose = () => {
+    if (disposed) return;
+    disposed = true;
     if (timer !== void 0) {
       clearTimeout(timer);
       timer = void 0;
     }
     doFlush();
-    writer.end();
+    try {
+      writer.end();
+    } catch {
+    }
     unsub();
+    errorsNode.down([[TEARDOWN]]);
   };
   return {
     dispose,
+    errors: errorsNode,
     flush: async () => {
-      doFlush();
+      if (!disposed) doFlush();
     }
   };
 }
@@ -3549,25 +3809,29 @@ function toClickHouse(source, client, table, opts) {
     onTransportError,
     ...rest
   } = opts ?? {};
+  const { errorsNode, handler } = createSinkErrorHandler(onTransportError);
   let buffer2 = [];
   let timer;
-  let lastFlush = Promise.resolve();
+  let disposed = false;
+  const inFlight = /* @__PURE__ */ new Set();
   const doFlush = () => {
     if (buffer2.length === 0) return Promise.resolve();
     const batch2 = buffer2;
     buffer2 = [];
     try {
       const p = client.insert({ table, values: batch2, format }).catch((err) => {
-        onTransportError?.({
+        handler({
           stage: "send",
           error: err instanceof Error ? err : new Error(String(err)),
           value: batch2
         });
+      }).finally(() => {
+        inFlight.delete(p);
       });
-      lastFlush = p;
+      inFlight.add(p);
       return p;
     } catch (err) {
-      onTransportError?.({
+      handler({
         stage: "send",
         error: err instanceof Error ? err : new Error(String(err)),
         value: batch2
@@ -3576,7 +3840,7 @@ function toClickHouse(source, client, table, opts) {
     }
   };
   const scheduleFlush = () => {
-    if (timer === void 0) {
+    if (timer === void 0 && !disposed) {
       timer = setTimeout(() => {
         timer = void 0;
         doFlush();
@@ -3586,13 +3850,13 @@ function toClickHouse(source, client, table, opts) {
   const inner = node([source], () => void 0, {
     describeKind: "effect",
     ...rest,
-    onMessage(msg) {
+    onMessage(msg, _depIndex, _actions) {
       if (msg[0] === DATA) {
         const value = msg[1];
         try {
           buffer2.push(transform(value));
         } catch (err) {
-          onTransportError?.({
+          handler({
             stage: "serialize",
             error: err instanceof Error ? err : new Error(String(err)),
             value
@@ -3603,7 +3867,7 @@ function toClickHouse(source, client, table, opts) {
         else scheduleFlush();
         return true;
       }
-      if (msg[0] === COMPLETE || msg[0] === TEARDOWN) {
+      if (messageTier(msg[0]) >= 3) {
         doFlush();
       }
       return false;
@@ -3612,16 +3876,24 @@ function toClickHouse(source, client, table, opts) {
   const unsub = inner.subscribe(() => {
   });
   const dispose = () => {
+    if (disposed) return;
+    disposed = true;
     if (timer !== void 0) {
       clearTimeout(timer);
       timer = void 0;
     }
     doFlush();
     unsub();
+    errorsNode.down([[TEARDOWN]]);
   };
   return {
     dispose,
-    flush: () => doFlush().then(() => lastFlush)
+    errors: errorsNode,
+    flush: () => {
+      const p = disposed ? Promise.resolve() : doFlush();
+      return p.then(() => Promise.all(inFlight)).then(() => {
+      });
+    }
   };
 }
 function toS3(source, client, bucket, opts) {
@@ -3638,10 +3910,12 @@ function toS3(source, client, bucket, opts) {
     onTransportError,
     ...rest
   } = opts ?? {};
+  const { errorsNode, handler } = createSinkErrorHandler(onTransportError);
   let buffer2 = [];
   let timer;
   let seq = 0;
-  let lastFlush = Promise.resolve();
+  let disposed = false;
+  const inFlight = /* @__PURE__ */ new Set();
   const doFlush = () => {
     if (buffer2.length === 0) return Promise.resolve();
     const batch2 = buffer2;
@@ -3654,16 +3928,18 @@ function toS3(source, client, bucket, opts) {
     try {
       const p = client.putObject({ Bucket: bucket, Key: key, Body: body, ContentType: contentType }).then(() => {
       }).catch((err) => {
-        onTransportError?.({
+        handler({
           stage: "send",
           error: err instanceof Error ? err : new Error(String(err)),
           value: batch2
         });
+      }).finally(() => {
+        inFlight.delete(p);
       });
-      lastFlush = p;
+      inFlight.add(p);
       return p;
     } catch (err) {
-      onTransportError?.({
+      handler({
         stage: "send",
         error: err instanceof Error ? err : new Error(String(err)),
         value: batch2
@@ -3672,7 +3948,7 @@ function toS3(source, client, bucket, opts) {
     }
   };
   const scheduleFlush = () => {
-    if (timer === void 0) {
+    if (timer === void 0 && !disposed) {
       timer = setTimeout(() => {
         timer = void 0;
         doFlush();
@@ -3682,13 +3958,13 @@ function toS3(source, client, bucket, opts) {
   const inner = node([source], () => void 0, {
     describeKind: "effect",
     ...rest,
-    onMessage(msg) {
+    onMessage(msg, _depIndex, _actions) {
       if (msg[0] === DATA) {
         const value = msg[1];
         try {
           buffer2.push(transform(value));
         } catch (err) {
-          onTransportError?.({
+          handler({
             stage: "serialize",
             error: err instanceof Error ? err : new Error(String(err)),
             value
@@ -3699,7 +3975,7 @@ function toS3(source, client, bucket, opts) {
         else scheduleFlush();
         return true;
       }
-      if (msg[0] === COMPLETE || msg[0] === TEARDOWN) {
+      if (messageTier(msg[0]) >= 3) {
         doFlush();
       }
       return false;
@@ -3708,16 +3984,24 @@ function toS3(source, client, bucket, opts) {
   const unsub = inner.subscribe(() => {
   });
   const dispose = () => {
+    if (disposed) return;
+    disposed = true;
     if (timer !== void 0) {
       clearTimeout(timer);
       timer = void 0;
     }
     doFlush();
     unsub();
+    errorsNode.down([[TEARDOWN]]);
   };
   return {
     dispose,
-    flush: () => doFlush().then(() => lastFlush)
+    errors: errorsNode,
+    flush: () => {
+      const p = disposed ? Promise.resolve() : doFlush();
+      return p.then(() => Promise.all(inFlight)).then(() => {
+      });
+    }
   };
 }
 function toPostgres(source, client, table, opts) {
@@ -3729,17 +4013,18 @@ function toPostgres(source, client, table, opts) {
     onTransportError,
     ...rest
   } = opts ?? {};
+  const { errorsNode, handler } = createSinkErrorHandler(onTransportError);
   const inner = node([source], () => void 0, {
     describeKind: "effect",
     ...rest,
-    onMessage(msg) {
+    onMessage(msg, _depIndex, _actions) {
       if (msg[0] === DATA) {
         const value = msg[1];
         let query;
         try {
           query = toSQL(value, table);
         } catch (err) {
-          onTransportError?.({
+          handler({
             stage: "serialize",
             error: err instanceof Error ? err : new Error(String(err)),
             value
@@ -3747,7 +4032,7 @@ function toPostgres(source, client, table, opts) {
           return true;
         }
         void client.query(query.sql, query.params).catch((err) => {
-          onTransportError?.({
+          handler({
             stage: "send",
             error: err instanceof Error ? err : new Error(String(err)),
             value
@@ -3758,22 +4043,30 @@ function toPostgres(source, client, table, opts) {
       return false;
     }
   });
-  return inner.subscribe(() => {
+  const unsub = inner.subscribe(() => {
   });
+  return {
+    dispose: () => {
+      unsub();
+      errorsNode.down([[TEARDOWN]]);
+    },
+    errors: errorsNode
+  };
 }
 function toMongo(source, collection, opts) {
   const { toDocument = (v) => v, onTransportError, ...rest } = opts ?? {};
+  const { errorsNode, handler } = createSinkErrorHandler(onTransportError);
   const inner = node([source], () => void 0, {
     describeKind: "effect",
     ...rest,
-    onMessage(msg) {
+    onMessage(msg, _depIndex, _actions) {
       if (msg[0] === DATA) {
         const value = msg[1];
         let doc;
         try {
           doc = toDocument(value);
         } catch (err) {
-          onTransportError?.({
+          handler({
             stage: "serialize",
             error: err instanceof Error ? err : new Error(String(err)),
             value
@@ -3781,7 +4074,7 @@ function toMongo(source, collection, opts) {
           return true;
         }
         void collection.insertOne(doc).catch((err) => {
-          onTransportError?.({
+          handler({
             stage: "send",
             error: err instanceof Error ? err : new Error(String(err)),
             value
@@ -3792,8 +4085,15 @@ function toMongo(source, collection, opts) {
       return false;
     }
   });
-  return inner.subscribe(() => {
+  const unsub = inner.subscribe(() => {
   });
+  return {
+    dispose: () => {
+      unsub();
+      errorsNode.down([[TEARDOWN]]);
+    },
+    errors: errorsNode
+  };
 }
 function toLoki(source, client, opts) {
   const {
@@ -3803,17 +4103,18 @@ function toLoki(source, client, opts) {
     onTransportError,
     ...rest
   } = opts ?? {};
+  const { errorsNode, handler } = createSinkErrorHandler(onTransportError);
   const inner = node([source], () => void 0, {
     describeKind: "effect",
     ...rest,
-    onMessage(msg) {
+    onMessage(msg, _depIndex, _actions) {
       if (msg[0] === DATA) {
         const value = msg[1];
         let line;
         try {
           line = toLine(value);
         } catch (err) {
-          onTransportError?.({
+          handler({
             stage: "serialize",
             error: err instanceof Error ? err : new Error(String(err)),
             value
@@ -3824,7 +4125,7 @@ function toLoki(source, client, opts) {
         try {
           streamLabels = toLabels ? { ...labels, ...toLabels(value) } : labels;
         } catch (err) {
-          onTransportError?.({
+          handler({
             stage: "serialize",
             error: err instanceof Error ? err : new Error(String(err)),
             value
@@ -3833,7 +4134,7 @@ function toLoki(source, client, opts) {
         }
         const ts = `${wallClockNs()}`;
         void client.push({ streams: [{ stream: streamLabels, values: [[ts, line]] }] }).catch((err) => {
-          onTransportError?.({
+          handler({
             stage: "send",
             error: err instanceof Error ? err : new Error(String(err)),
             value
@@ -3844,22 +4145,30 @@ function toLoki(source, client, opts) {
       return false;
     }
   });
-  return inner.subscribe(() => {
+  const unsub = inner.subscribe(() => {
   });
+  return {
+    dispose: () => {
+      unsub();
+      errorsNode.down([[TEARDOWN]]);
+    },
+    errors: errorsNode
+  };
 }
 function toTempo(source, client, opts) {
   const { toResourceSpans = (v) => [v], onTransportError, ...rest } = opts ?? {};
+  const { errorsNode, handler } = createSinkErrorHandler(onTransportError);
   const inner = node([source], () => void 0, {
     describeKind: "effect",
     ...rest,
-    onMessage(msg) {
+    onMessage(msg, _depIndex, _actions) {
       if (msg[0] === DATA) {
         const value = msg[1];
         let spans;
         try {
           spans = toResourceSpans(value);
         } catch (err) {
-          onTransportError?.({
+          handler({
             stage: "serialize",
             error: err instanceof Error ? err : new Error(String(err)),
             value
@@ -3867,7 +4176,7 @@ function toTempo(source, client, opts) {
           return true;
         }
         void client.push({ resourceSpans: spans }).catch((err) => {
-          onTransportError?.({
+          handler({
             stage: "send",
             error: err instanceof Error ? err : new Error(String(err)),
             value
@@ -3878,15 +4187,22 @@ function toTempo(source, client, opts) {
       return false;
     }
   });
-  return inner.subscribe(() => {
+  const unsub = inner.subscribe(() => {
   });
+  return {
+    dispose: () => {
+      unsub();
+      errorsNode.down([[TEARDOWN]]);
+    },
+    errors: errorsNode
+  };
 }
 function checkpointToS3(graph, client, bucket, opts) {
   const { prefix = "checkpoints/", debounceMs, compactEvery, onError } = opts ?? {};
   const adapter = {
-    save(data) {
+    save(_key, data) {
       const ms = Math.floor(wallClockNs() / 1e6);
-      const key = `${prefix}${graph.name}/checkpoint-${ms}.json`;
+      const s3Key = `${prefix}${graph.name}/checkpoint-${ms}.json`;
       let body;
       try {
         body = JSON.stringify(data);
@@ -3896,7 +4212,7 @@ function checkpointToS3(graph, client, bucket, opts) {
       }
       void client.putObject({
         Bucket: bucket,
-        Key: key,
+        Key: s3Key,
         Body: body,
         ContentType: "application/json"
       }).catch((err) => onError?.(err));
@@ -3906,9 +4222,9 @@ function checkpointToS3(graph, client, bucket, opts) {
 }
 function checkpointToRedis(graph, client, opts) {
   const { prefix = "graphrefly:checkpoint:", debounceMs, compactEvery, onError } = opts ?? {};
-  const key = `${prefix}${graph.name}`;
+  const redisKey = `${prefix}${graph.name}`;
   const adapter = {
-    save(data) {
+    save(_key, data) {
       let body;
       try {
         body = JSON.stringify(data);
@@ -3916,11 +4232,250 @@ function checkpointToRedis(graph, client, opts) {
         onError?.(err);
         return;
       }
-      void client.set(key, body).catch((err) => onError?.(err));
+      void client.set(redisKey, body).catch((err) => onError?.(err));
     }
   };
   return graph.autoCheckpoint(adapter, { debounceMs, compactEvery, onError });
 }
+function fromSqlite(db, query, opts) {
+  const { mapRow = (r) => r, params, ...rest } = opts ?? {};
+  return producer(
+    (_d, a) => {
+      let mapped;
+      try {
+        const rows = db.query(query, params);
+        mapped = rows.map(mapRow);
+      } catch (err) {
+        a.down([[ERROR, err instanceof Error ? err : new Error(String(err))]]);
+        return void 0;
+      }
+      batch(() => {
+        for (const item of mapped) {
+          a.down([[DATA, item]]);
+        }
+        a.down([[COMPLETE]]);
+      });
+      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,
+    ...rest
+  } = opts ?? {};
+  const { errorsNode, handler } = createSinkErrorHandler(onTransportError);
+  const pendingInserts = [];
+  let flushing = false;
+  let disposed = false;
+  let timer;
+  function flushTransaction() {
+    if (pendingInserts.length === 0 || flushing) return;
+    flushing = true;
+    try {
+      db.query("BEGIN", []);
+    } catch (err) {
+      flushing = false;
+      handler({
+        stage: "send",
+        error: err instanceof Error ? err : new Error(String(err)),
+        value: void 0
+      });
+      return;
+    }
+    const batch2 = pendingInserts.splice(0);
+    let firstError;
+    for (const q of batch2) {
+      try {
+        db.query(q.sql, q.params);
+      } catch (err) {
+        firstError = err instanceof Error ? err : new Error(String(err));
+        break;
+      }
+    }
+    if (firstError) {
+      try {
+        db.query("ROLLBACK", []);
+      } catch {
+      }
+      handler({ stage: "send", error: firstError, value: void 0 });
+    } else {
+      try {
+        db.query("COMMIT", []);
+      } catch (err) {
+        handler({
+          stage: "send",
+          error: err instanceof Error ? err : new Error(String(err)),
+          value: void 0
+        });
+      }
+    }
+    flushing = false;
+  }
+  const scheduleFlush = () => {
+    if (batchInsert && flushIntervalMs > 0 && timer === void 0 && !disposed) {
+      timer = setTimeout(() => {
+        timer = void 0;
+        flushTransaction();
+      }, flushIntervalMs);
+    }
+  };
+  const inner = node([source], () => void 0, {
+    describeKind: "effect",
+    ...rest,
+    onMessage(msg, _depIndex, _actions) {
+      if (msg[0] === DATA) {
+        const value = msg[1];
+        let query;
+        try {
+          query = toSQL(value, table);
+        } catch (err) {
+          handler({
+            stage: "serialize",
+            error: err instanceof Error ? err : new Error(String(err)),
+            value
+          });
+          return true;
+        }
+        if (batchInsert) {
+          pendingInserts.push(query);
+          if (pendingInserts.length >= maxBatchSize) flushTransaction();
+          else scheduleFlush();
+        } else {
+          try {
+            db.query(query.sql, query.params);
+          } catch (err) {
+            handler({
+              stage: "send",
+              error: err instanceof Error ? err : new Error(String(err)),
+              value
+            });
+          }
+        }
+        return true;
+      }
+      if (batchInsert && messageTier(msg[0]) >= 3) {
+        flushTransaction();
+      }
+      return false;
+    }
+  });
+  const unsub = inner.subscribe(() => {
+  });
+  const dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    if (timer !== void 0) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+    if (batchInsert) flushTransaction();
+    unsub();
+    errorsNode.down([[TEARDOWN]]);
+  };
+  return {
+    dispose,
+    errors: errorsNode,
+    flush: batchInsert ? async () => {
+      if (!disposed) flushTransaction();
+    } : void 0
+  };
+}
+function fromPrisma(model, opts) {
+  const { args, mapRow = (r) => r, ...rest } = opts ?? {};
+  return producer(
+    (_d, a) => {
+      let active = true;
+      void model.findMany(args).then((rows) => {
+        if (!active) return;
+        const mapped = rows.map(mapRow);
+        batch(() => {
+          for (const item of mapped) {
+            a.emit(item);
+          }
+        });
+        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(
+    (_d, a) => {
+      let active = true;
+      void query.execute().then((rows) => {
+        if (!active) return;
+        const mapped = rows.map(mapRow);
+        batch(() => {
+          for (const item of mapped) {
+            a.emit(item);
+          }
+        });
+        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(
+    (_d, a) => {
+      let active = true;
+      void query.execute().then((rows) => {
+        if (!active) return;
+        const mapped = rows.map(mapRow);
+        batch(() => {
+          for (const item of mapped) {
+            a.emit(item);
+          }
+        });
+        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/backpressure.ts
 var nextLockId = 0;
@@ -3966,6 +4521,205 @@ function createWatermarkController(sendUp, opts) {
   };
 }
 
+// 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 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++) {
+      const tier = tiers[i];
+      if (tier.save) tier.save(key, value);
+    }
+  }
+  function cascade(key, nd) {
+    for (let tierIndex = 0; tierIndex < tiers.length; tierIndex++) {
+      let result;
+      try {
+        result = tiers[tierIndex].load(key);
+      } catch {
+        continue;
+      }
+      if (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.get();
+          if (value !== void 0) {
+            for (let i = tiers.length - 1; i >= 0; i--) {
+              if (tiers[i].save) {
+                tiers[i].save(key, value);
+                for (let j = 0; j < i; j++) {
+                  if (tiers[j].clear) tiers[j].clear(key);
+                }
+                break;
+              }
+            }
+          }
+          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);
+      if (policy) {
+        policy.insert(key);
+      }
+      cascade(key, nd);
+      return nd;
+    },
+    save(key, value) {
+      if (writeThrough) {
+        for (const tier of tiers) {
+          if (tier.save) tier.save(key, value);
+        }
+      } else if (tiers[0]?.save) {
+        tiers[0].save(key, value);
+      }
+      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);
+        if (policy) {
+          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) {
+        if (tier.clear) tier.clear(key);
+      }
+    },
+    has(key) {
+      return entries.has(key);
+    },
+    get size() {
+      return entries.size;
+    }
+  };
+}
+function adapterToTier(adapter) {
+  return {
+    load: (key) => adapter.load(key),
+    save: (key, value) => adapter.save(key, value),
+    clear: (key) => adapter.clear(key)
+  };
+}
+function tieredStorage(adapters, opts) {
+  const inner = cascadingCache(adapters.map(adapterToTier), {
+    maxSize: opts?.maxSize,
+    eviction: opts?.eviction,
+    writeThrough: true
+  });
+  return {
+    load: (key) => inner.load(key),
+    save: (key, value) => inner.save(key, value),
+    invalidate: (key) => inner.invalidate(key),
+    delete: (key) => inner.delete(key),
+    has: (key) => inner.has(key),
+    get size() {
+      return inner.size;
+    },
+    cache: inner
+  };
+}
+
 // src/extra/checkpoint.ts
 var import_node_crypto2 = require("crypto");
 var import_node_fs2 = require("fs");
@@ -3986,60 +4740,61 @@ function sortJsonValue(value) {
   }
   return out;
 }
-function warnNonJsonValues(data) {
-  for (const [path, node2] of Object.entries(data.nodes)) {
-    const v = node2.value;
-    if (v === void 0 || v === null) continue;
-    if (typeof v === "function" || typeof v === "symbol" || typeof v === "bigint") {
-      console.warn(
-        `checkpoint: node "${path}" has non-JSON-serializable value (${typeof v}); it will be lost on round-trip`
-      );
-    }
-  }
-}
-function stableSnapshotJson(data) {
-  warnNonJsonValues(data);
+function stableJsonString(data) {
   return `${JSON.stringify(sortJsonValue(data), void 0, 0)}
 `;
 }
 var MemoryCheckpointAdapter = class {
-  #data = null;
-  save(data) {
-    this.#data = JSON.parse(JSON.stringify(data));
+  #data = /* @__PURE__ */ new Map();
+  save(key, data) {
+    this.#data.set(key, JSON.parse(JSON.stringify(data)));
+  }
+  load(key) {
+    const v = this.#data.get(key);
+    return v === void 0 ? null : JSON.parse(JSON.stringify(v));
   }
-  load() {
-    return this.#data === null ? null : JSON.parse(JSON.stringify(this.#data));
+  clear(key) {
+    this.#data.delete(key);
   }
 };
 var DictCheckpointAdapter = class {
   #storage;
-  #key;
-  constructor(storage, key = "graphrefly_checkpoint") {
+  constructor(storage) {
     this.#storage = storage;
-    this.#key = key;
   }
-  save(data) {
-    this.#storage[this.#key] = JSON.parse(JSON.stringify(data));
+  save(key, data) {
+    this.#storage[key] = JSON.parse(JSON.stringify(data));
   }
-  load() {
-    const raw = this.#storage[this.#key];
-    return raw !== null && typeof raw === "object" && !Array.isArray(raw) ? JSON.parse(JSON.stringify(raw)) : null;
+  load(key) {
+    const raw = this.#storage[key];
+    return raw === void 0 ? null : JSON.parse(JSON.stringify(raw));
+  }
+  clear(key) {
+    delete this.#storage[key];
   }
 };
 var FileCheckpointAdapter = class {
-  #path;
-  constructor(path) {
-    this.#path = path;
-  }
-  save(data) {
-    const dir = (0, import_node_path2.dirname)(this.#path);
-    (0, import_node_fs2.mkdirSync)(dir, { recursive: true });
-    const payload = stableSnapshotJson(data);
-    const base = (0, import_node_path2.basename)(this.#path);
+  #dir;
+  constructor(dir) {
+    this.#dir = dir;
+  }
+  #pathFor(key) {
+    const safeName = key.replace(
+      /[^a-zA-Z0-9_-]/g,
+      (c) => `%${c.charCodeAt(0).toString(16).padStart(2, "0")}`
+    );
+    return (0, import_node_path2.join)(this.#dir, `${safeName}.json`);
+  }
+  save(key, data) {
+    (0, import_node_fs2.mkdirSync)(this.#dir, { recursive: true });
+    const filePath = this.#pathFor(key);
+    const payload = stableJsonString(data);
+    const base = (0, import_node_path2.basename)(filePath);
+    const dir = (0, import_node_path2.dirname)(filePath);
     const tmp = (0, import_node_path2.join)(dir, `.${base}.${(0, import_node_crypto2.randomBytes)(8).toString("hex")}.tmp`);
     try {
       (0, import_node_fs2.writeFileSync)(tmp, payload, "utf8");
-      (0, import_node_fs2.renameSync)(tmp, this.#path);
+      (0, import_node_fs2.renameSync)(tmp, filePath);
     } catch (e) {
       try {
         (0, import_node_fs2.unlinkSync)(tmp);
@@ -4048,36 +4803,42 @@ var FileCheckpointAdapter = class {
       throw e;
     }
   }
-  load() {
+  load(key) {
     try {
-      const text = (0, import_node_fs2.readFileSync)(this.#path, "utf8").trim();
+      const text = (0, import_node_fs2.readFileSync)(this.#pathFor(key), "utf8").trim();
       if (!text) return null;
-      const data = JSON.parse(text);
-      return data !== null && typeof data === "object" && !Array.isArray(data) ? data : null;
+      return JSON.parse(text);
     } catch {
       return null;
     }
   }
+  clear(key) {
+    try {
+      (0, import_node_fs2.unlinkSync)(this.#pathFor(key));
+    } catch (e) {
+      if (e.code !== "ENOENT") throw e;
+    }
+  }
 };
 var SqliteCheckpointAdapter = class {
   #db;
-  #key;
-  constructor(path, key = "graphrefly_checkpoint") {
+  constructor(path) {
     this.#db = new import_node_sqlite.DatabaseSync(path);
-    this.#key = key;
     this.#db.exec(
       `CREATE TABLE IF NOT EXISTS graphrefly_checkpoint (k TEXT PRIMARY KEY, v TEXT NOT NULL)`
     );
   }
-  save(data) {
-    const payload = stableSnapshotJson(data).trimEnd();
-    this.#db.prepare(`INSERT OR REPLACE INTO graphrefly_checkpoint (k, v) VALUES (?, ?)`).run(this.#key, payload);
+  save(key, data) {
+    const payload = stableJsonString(data).trimEnd();
+    this.#db.prepare(`INSERT OR REPLACE INTO graphrefly_checkpoint (k, v) VALUES (?, ?)`).run(key, payload);
   }
-  load() {
-    const row = this.#db.prepare(`SELECT v FROM graphrefly_checkpoint WHERE k = ?`).get(this.#key);
+  load(key) {
+    const row = this.#db.prepare(`SELECT v FROM graphrefly_checkpoint WHERE k = ?`).get(key);
     if (row === void 0 || typeof row.v !== "string" || row.v.trim() === "") return null;
-    const parsed = JSON.parse(row.v);
-    return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+    return JSON.parse(row.v);
+  }
+  clear(key) {
+    this.#db.prepare(`DELETE FROM graphrefly_checkpoint WHERE k = ?`).run(key);
   }
   /** Close the underlying SQLite connection (safe to call more than once). */
   close() {
@@ -4088,10 +4849,10 @@ var SqliteCheckpointAdapter = class {
   }
 };
 function saveGraphCheckpoint(graph, adapter) {
-  adapter.save(graph.snapshot());
+  adapter.save(graph.name, graph.snapshot());
 }
 function restoreGraphCheckpoint(graph, adapter) {
-  const data = adapter.load();
+  const data = adapter.load(graph.name);
   if (data === null) return false;
   graph.restore(data);
   return true;
@@ -5956,48 +6717,6 @@ function audit(source, ms, opts) {
     }
   });
 }
-function timeout(source, ms, opts) {
-  const { with: withPayload, ...timeoutNodeOpts } = opts ?? {};
-  let timer;
-  const err = withPayload ?? new Error("timeout");
-  function arm(a) {
-    clearTimeout(timer);
-    timer = setTimeout(() => {
-      timer = void 0;
-      a.down([[ERROR, err]]);
-    }, ms);
-  }
-  return node(
-    [source],
-    ([_v], a) => {
-      arm(a);
-      return () => clearTimeout(timer);
-    },
-    {
-      ...operatorOpts3(timeoutNodeOpts),
-      completeWhenDepsComplete: false,
-      onMessage(msg, _i, a) {
-        const t = msg[0];
-        if (t === DATA) {
-          arm(a);
-          a.down([msg]);
-          return true;
-        }
-        if (t === COMPLETE || t === ERROR) {
-          clearTimeout(timer);
-          a.down([msg]);
-          return true;
-        }
-        if (t === DIRTY || t === RESOLVED) {
-          a.down([msg]);
-          return true;
-        }
-        a.down([msg]);
-        return true;
-      }
-    }
-  );
-}
 function buffer(source, notifier, opts) {
   const buf = [];
   return node([source, notifier], () => void 0, {
@@ -7554,11 +8273,14 @@ function workerSelf(target, opts) {
   NS_PER_MS,
   NS_PER_SEC,
   SqliteCheckpointAdapter,
+  TimeoutError,
   audit,
   buffer,
   bufferCount,
   bufferTime,
+  cache,
   cached,
+  cascadingCache,
   catchError,
   checkpointNodeValue,
   checkpointToRedis,
@@ -7583,6 +8305,7 @@ function workerSelf(target, opts) {
   escapeRegexChar,
   exhaustMap,
   exponential,
+  fallback,
   fibonacci,
   filter,
   find,
@@ -7595,6 +8318,7 @@ function workerSelf(target, opts) {
   fromCSV,
   fromClickHouseWatch,
   fromCron,
+  fromDrizzle,
   fromEvent,
   fromFSWatch,
   fromGitHook,
@@ -7603,15 +8327,18 @@ function workerSelf(target, opts) {
   fromIDBTransaction,
   fromIter,
   fromKafka,
+  fromKysely,
   fromMCP,
   fromNATS,
   fromNDJSON,
   fromOTel,
+  fromPrisma,
   fromPrometheus,
   fromPromise,
   fromPulsar,
   fromRabbitMQ,
   fromRedisStream,
+  fromSqlite,
   fromStatsD,
   fromSyslog,
   fromTimer,
@@ -7623,6 +8350,7 @@ function workerSelf(target, opts) {
   last,
   linear,
   logSlice,
+  lru,
   map,
   matchesAnyPattern,
   matchesCron,
@@ -7672,6 +8400,7 @@ function workerSelf(target, opts) {
   throttle,
   throttleTime,
   throwError,
+  tieredStorage,
   timeout,
   toArray,
   toCSV,
@@ -7689,6 +8418,7 @@ function workerSelf(target, opts) {
   toRedisStream,
   toS3,
   toSSE,
+  toSqlite,
   toTempo,
   toWebSocket,
   tokenBucket,