@graphrefly/graphrefly 0.5.0 → 0.7.0

package/dist/{chunk-ZERWUCGK.js → chunk-ONLYF6GA.js}

@@ -32,7 +32,10 @@ import {
   toArray,
   toMessages$,
   toObservable
-} from "./chunk-KWXPDASV.js";
+} from "./chunk-PEBORXRA.js";
+import {
+  ResettableTimer
+} from "./chunk-WZ2Z2CRV.js";
 import {
   COMPLETE,
   DATA,
@@ -56,7 +59,7 @@ import {
   producer,
   state,
   wallClockNs
-} from "./chunk-5X3LAO3B.js";
+} from "./chunk-3EVXOI5C.js";
 
 // src/extra/index.ts
 var extra_exports = {};
@@ -68,11 +71,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,
@@ -97,6 +103,7 @@ __export(extra_exports, {
   escapeRegexChar: () => escapeRegexChar,
   exhaustMap: () => exhaustMap,
   exponential: () => exponential,
+  fallback: () => fallback,
   fibonacci: () => fibonacci,
   filter: () => filter,
   find: () => find,
@@ -109,6 +116,7 @@ __export(extra_exports, {
   fromCSV: () => fromCSV,
   fromClickHouseWatch: () => fromClickHouseWatch,
   fromCron: () => fromCron,
+  fromDrizzle: () => fromDrizzle,
   fromEvent: () => fromEvent,
   fromFSWatch: () => fromFSWatch,
   fromGitHook: () => fromGitHook,
@@ -117,15 +125,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,
@@ -137,6 +148,7 @@ __export(extra_exports, {
   last: () => last,
   linear: () => linear,
   logSlice: () => logSlice,
+  lru: () => lru,
   map: () => map,
   matchesAnyPattern: () => matchesAnyPattern,
   matchesCron: () => matchesCron,
@@ -186,6 +198,7 @@ __export(extra_exports, {
   throttle: () => throttle,
   throttleTime: () => throttleTime,
   throwError: () => throwError,
+  tieredStorage: () => tieredStorage,
   timeout: () => timeout,
   toArray: () => toArray,
   toCSV: () => toCSV,
@@ -203,6 +216,7 @@ __export(extra_exports, {
   toRedisStream: () => toRedisStream,
   toS3: () => toS3,
   toSSE: () => toSSE,
+  toSqlite: () => toSqlite,
   toTempo: () => toTempo,
   toWebSocket: () => toWebSocket,
   tokenBucket: () => tokenBucket,
@@ -342,14 +356,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;
@@ -365,20 +372,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]]);
@@ -400,8 +405,7 @@ function retry(source, opts) {
       connect();
       return () => {
         stopped = true;
-        timerGen += 1;
-        cancelTimer();
+        timer.cancel();
         disconnectUpstream();
       };
     },
@@ -581,14 +585,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();
@@ -602,15 +599,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;
           }
         }
@@ -624,14 +616,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]);
@@ -639,8 +629,7 @@ function rateLimiter(source, maxEvents, windowNs) {
         }
       });
       return () => {
-        timerGen += 1;
-        cancelTimer();
+        timer.cancel();
         unsub();
       };
     },
@@ -701,8 +690,160 @@ 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/adapters.ts
+function createSinkErrorHandler(userHandler) {
+  const errorsNode = state(null);
+  const handler = (err) => {
+    userHandler?.(err);
+    try {
+      errorsNode.down([[DATA, err]]);
+    } catch {
+    }
+  };
+  return { errorsNode, handler };
+}
 function sourceOpts(opts) {
   return { describeKind: "producer", ...opts };
 }
@@ -1005,7 +1146,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 {
@@ -1453,10 +1594,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;
@@ -1464,7 +1606,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
@@ -1475,7 +1617,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
@@ -1486,8 +1628,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 {
@@ -1552,17 +1701,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
@@ -1571,7 +1721,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
@@ -1582,8 +1732,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 {
@@ -1810,17 +1967,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
@@ -1832,7 +1990,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
@@ -1843,8 +2001,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();
@@ -1900,17 +2065,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
@@ -1920,7 +2086,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
@@ -1931,8 +2097,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 {
@@ -1994,17 +2167,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
@@ -2015,7 +2189,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
@@ -2025,7 +2199,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
@@ -2036,8 +2210,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 {
@@ -2049,8 +2230,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("");
@@ -2058,7 +2241,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
@@ -2066,7 +2249,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();
@@ -2077,14 +2260,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
@@ -2099,7 +2282,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
@@ -2108,7 +2291,7 @@ function toFile(source, writer, opts) {
         }
         return true;
       }
-      if (msg[0] === COMPLETE || msg[0] === TEARDOWN) {
+      if (messageTier(msg[0]) >= 3) {
         doFlush();
       }
       return false;
@@ -2117,18 +2300,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();
     }
   };
 }
@@ -2179,25 +2369,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
@@ -2206,7 +2400,7 @@ function toClickHouse(source, client, table, opts) {
     }
   };
   const scheduleFlush = () => {
-    if (timer === void 0) {
+    if (timer === void 0 && !disposed) {
       timer = setTimeout(() => {
         timer = void 0;
         doFlush();
@@ -2216,13 +2410,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
@@ -2233,7 +2427,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;
@@ -2242,16 +2436,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) {
@@ -2268,10 +2470,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;
@@ -2284,16 +2488,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
@@ -2302,7 +2508,7 @@ function toS3(source, client, bucket, opts) {
     }
   };
   const scheduleFlush = () => {
-    if (timer === void 0) {
+    if (timer === void 0 && !disposed) {
       timer = setTimeout(() => {
         timer = void 0;
         doFlush();
@@ -2312,13 +2518,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
@@ -2329,7 +2535,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;
@@ -2338,16 +2544,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) {
@@ -2359,17 +2573,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
@@ -2377,7 +2592,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
@@ -2388,22 +2603,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
@@ -2411,7 +2634,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
@@ -2422,8 +2645,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 {
@@ -2433,17 +2663,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
@@ -2454,7 +2685,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
@@ -2463,7 +2694,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
@@ -2474,22 +2705,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
@@ -2497,7 +2736,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
@@ -2508,15 +2747,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);
@@ -2526,7 +2772,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));
@@ -2536,9 +2782,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);
@@ -2546,11 +2792,449 @@ 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/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
 import { randomBytes } from "crypto";
@@ -2572,60 +3256,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(key) {
+    const raw = this.#storage[key];
+    return raw === void 0 ? null : JSON.parse(JSON.stringify(raw));
   }
-  load() {
-    const raw = this.#storage[this.#key];
-    return raw !== null && typeof raw === "object" && !Array.isArray(raw) ? JSON.parse(JSON.stringify(raw)) : null;
+  clear(key) {
+    delete this.#storage[key];
   }
 };
 var FileCheckpointAdapter = class {
-  #path;
-  constructor(path) {
-    this.#path = 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 join(this.#dir, `${safeName}.json`);
   }
-  save(data) {
-    const dir = dirname(this.#path);
-    mkdirSync(dir, { recursive: true });
-    const payload = stableSnapshotJson(data);
-    const base = basename(this.#path);
+  save(key, data) {
+    mkdirSync(this.#dir, { recursive: true });
+    const filePath = this.#pathFor(key);
+    const payload = stableJsonString(data);
+    const base = basename(filePath);
+    const dir = dirname(filePath);
     const tmp = join(dir, `.${base}.${randomBytes(8).toString("hex")}.tmp`);
     try {
       writeFileSync(tmp, payload, "utf8");
-      renameSync(tmp, this.#path);
+      renameSync(tmp, filePath);
     } catch (e) {
       try {
         unlinkSync(tmp);
@@ -2634,36 +3319,42 @@ var FileCheckpointAdapter = class {
       throw e;
     }
   }
-  load() {
+  load(key) {
     try {
-      const text = readFileSync(this.#path, "utf8").trim();
+      const text = 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 {
+      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 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() {
@@ -2674,10 +3365,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;
@@ -4083,48 +4774,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);
-    },
-    {
-      ...operatorOpts2(timeoutNodeOpts),
-      completeWhenDepsComplete: false,
-      onMessage(msg, _i, a) {
-        const t = msg[0];
-        if (t === DATA) {
-          arm(a);
-          a.down([msg]);
-          return true;
-        }
-        if (t === COMPLETE || t === ERROR) {
-          clearTimeout(timer);
-          a.down([msg]);
-          return true;
-        }
-        if (t === DIRTY || t === RESOLVED) {
-          a.down([msg]);
-          return true;
-        }
-        a.down([msg]);
-        return true;
-      }
-    }
-  );
-}
 function buffer(source, notifier, opts) {
   const buf = [];
   return node([source, notifier], () => void 0, {
@@ -5494,6 +6143,10 @@ export {
   tokenTracker,
   rateLimiter,
   withStatus,
+  TimeoutError,
+  fallback,
+  timeout,
+  cache,
   fromWebSocket,
   fromWebhook,
   fromHTTP,
@@ -5531,6 +6184,14 @@ export {
   toTempo,
   checkpointToS3,
   checkpointToRedis,
+  fromSqlite,
+  toSqlite,
+  fromPrisma,
+  fromDrizzle,
+  fromKysely,
+  lru,
+  cascadingCache,
+  tieredStorage,
   MemoryCheckpointAdapter,
   DictCheckpointAdapter,
   FileCheckpointAdapter,
@@ -5574,7 +6235,6 @@ export {
   throttle,
   sample,
   audit,
-  timeout,
   buffer,
   bufferCount,
   windowCount,
@@ -5605,4 +6265,4 @@ export {
   workerSelf,
   extra_exports
 };
-//# sourceMappingURL=chunk-ZERWUCGK.js.map
+//# sourceMappingURL=chunk-ONLYF6GA.js.map