@graphrefly/graphrefly 0.45.0 → 0.47.0

package/dist/chunk-OCUDSN63.js

@@ -0,0 +1,2386 @@
+import {
+  sourceOpts
+} from "./chunk-SOOKUYVM.js";
+import {
+  withStatus
+} from "./chunk-Y52CS6YA.js";
+import {
+  retry
+} from "./chunk-Z4YXAUDN.js";
+import {
+  NS_PER_MS,
+  NS_PER_SEC,
+  resolveBackoffPreset
+} from "./chunk-P5LBT622.js";
+import {
+  externalBundle,
+  externalProducer
+} from "./chunk-IJRR6YAI.js";
+
+// src/base/io/checkpoint.ts
+import { wallClockNs } from "@graphrefly/pure-ts/core";
+function checkpointToS3(graph, client, bucket, opts) {
+  const { prefix = "checkpoints/", debounceMs = 500, compactEvery = 10, onError } = opts ?? {};
+  const tier = {
+    name: `s3:${bucket}`,
+    debounceMs,
+    compactEvery,
+    save(record) {
+      const ms = Math.floor(wallClockNs() / 1e6);
+      const s3Key = `${prefix}${graph.name}/checkpoint-${ms}.json`;
+      let body;
+      try {
+        body = JSON.stringify(record);
+      } catch (err) {
+        onError?.(err);
+        return;
+      }
+      void client.putObject({
+        Bucket: bucket,
+        Key: s3Key,
+        Body: body,
+        ContentType: "application/json"
+      }).catch((err) => onError?.(err));
+    }
+    // S3 tier is write-only here — one object per checkpoint timestamp,
+    // no canonical "latest" key for load.
+  };
+  return graph.attachSnapshotStorage([{ snapshot: tier }], {
+    onError: (err) => onError?.(err)
+  });
+}
+function checkpointToRedis(graph, client, opts) {
+  const {
+    prefix = "graphrefly:checkpoint:",
+    debounceMs = 500,
+    compactEvery = 10,
+    onError
+  } = opts ?? {};
+  const redisKey = `${prefix}${graph.name}`;
+  const tier = {
+    name: `redis:${redisKey}`,
+    debounceMs,
+    compactEvery,
+    save(record) {
+      let body;
+      try {
+        body = JSON.stringify(record);
+      } catch (err) {
+        onError?.(err);
+        return;
+      }
+      void client.set(redisKey, body).catch((err) => onError?.(err));
+    },
+    async load() {
+      const raw = await client.get(redisKey);
+      if (raw == null) return void 0;
+      try {
+        return JSON.parse(raw);
+      } catch {
+        return void 0;
+      }
+    }
+  };
+  return graph.attachSnapshotStorage([{ snapshot: tier }], {
+    onError: (err) => onError?.(err)
+  });
+}
+
+// src/base/io/clickhouse-watch.ts
+import { COMPLETE, ERROR, node } from "@graphrefly/pure-ts/core";
+import { fromTimer, switchMap } from "@graphrefly/pure-ts/extra";
+function fromClickHouseWatch(client, query, opts) {
+  const {
+    intervalNs = 5 * NS_PER_SEC,
+    format = "JSONEachRow",
+    signal: externalSignal,
+    maxConsecutiveErrors = 1
+  } = opts ?? {};
+  const intervalMs = Math.ceil(intervalNs / NS_PER_MS);
+  let consecutiveErrors = 0;
+  return switchMap(
+    fromTimer(0, { period: intervalMs, signal: externalSignal }),
+    () => node([], (_data, a) => {
+      let active = true;
+      const run = async () => {
+        try {
+          const result = await client.query({ query, format });
+          if (!active) return;
+          const rows = await result.json();
+          if (!active) return;
+          for (const row of rows) a.emit(row);
+          consecutiveErrors = 0;
+          a.down([[COMPLETE]]);
+        } catch (err) {
+          if (!active) return;
+          consecutiveErrors += 1;
+          if (consecutiveErrors >= maxConsecutiveErrors) {
+            a.down([[ERROR, err]]);
+          }
+        }
+      };
+      void run();
+      return () => {
+        active = false;
+      };
+    })
+  );
+}
+
+// src/base/io/csv.ts
+import { COMPLETE as COMPLETE2, ERROR as ERROR2, node as node2 } from "@graphrefly/pure-ts/core";
+function fromCSV(source, opts) {
+  const {
+    delimiter = ",",
+    hasHeader = true,
+    columns: explicitColumns,
+    parseLine,
+    ...rest
+  } = opts ?? {};
+  const parse = parseLine ?? ((line) => parseCSVLine(line, delimiter));
+  return node2(
+    [],
+    (_data, a) => {
+      let cancelled = false;
+      const run = async () => {
+        try {
+          let headers = explicitColumns;
+          let buffer = "";
+          for await (const chunk of source) {
+            if (cancelled) return;
+            buffer += chunk;
+            const lines = buffer.split(/\r?\n/);
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+              if (cancelled) return;
+              if (!line.trim()) continue;
+              const values = parse(line);
+              if (!headers && hasHeader) {
+                headers = values;
+                continue;
+              }
+              if (!headers) {
+                headers = values.map((_, i) => `col${i}`);
+              }
+              const row = {};
+              for (let i = 0; i < headers.length; i++) {
+                row[headers[i]] = values[i] ?? "";
+              }
+              a.emit(row);
+            }
+          }
+          if (!cancelled && buffer.trim()) {
+            const values = parse(buffer);
+            if (headers) {
+              const row = {};
+              for (let i = 0; i < headers.length; i++) {
+                row[headers[i]] = values[i] ?? "";
+              }
+              a.emit(row);
+            }
+          }
+          if (!cancelled) a.down([[COMPLETE2]]);
+        } catch (err) {
+          if (!cancelled) a.down([[ERROR2, err]]);
+        }
+      };
+      void run();
+      return () => {
+        cancelled = true;
+      };
+    },
+    sourceOpts(rest)
+  );
+}
+function csvRows(source, opts) {
+  const {
+    delimiter = ",",
+    hasHeader = true,
+    columns: explicitColumns,
+    parseLine,
+    ...rest
+  } = opts ?? {};
+  const parse = parseLine ?? ((line) => parseCSVLine(line, delimiter));
+  let cleanup;
+  return node2(
+    [source],
+    (data, a, ctx) => {
+      if (cleanup === void 0) {
+        const store = ctx.store;
+        cleanup = {
+          onDeactivation: () => {
+            delete store.buffer;
+            delete store.headers;
+          }
+        };
+      }
+      const batch0 = data[0];
+      if (batch0 == null || batch0.length === 0) return cleanup;
+      const s = ctx.store;
+      if (typeof s.buffer !== "string") s.buffer = "";
+      if (s.headers === void 0 && explicitColumns) s.headers = explicitColumns.slice();
+      for (const chunkRaw of batch0) {
+        s.buffer = s.buffer + chunkRaw;
+        const lines = s.buffer.split(/\r?\n/);
+        s.buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          const values = parse(line);
+          if (!s.headers && hasHeader) {
+            s.headers = values;
+            continue;
+          }
+          if (!s.headers) s.headers = values.map((_, i) => `col${i}`);
+          const row = {};
+          for (let i = 0; i < s.headers.length; i++) row[s.headers[i]] = values[i] ?? "";
+          a.emit(row);
+        }
+      }
+      return cleanup;
+    },
+    { describeKind: "derived", ...rest }
+  );
+}
+function parseCSVLine(line, delimiter) {
+  const values = [];
+  let current = "";
+  let inQuotes = false;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (inQuotes) {
+      if (ch === '"') {
+        if (line[i + 1] === '"') {
+          current += '"';
+          i++;
+        } else {
+          inQuotes = false;
+        }
+      } else {
+        current += ch;
+      }
+    } else if (ch === '"') {
+      inQuotes = true;
+    } else if (ch === delimiter) {
+      values.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  values.push(current);
+  return values;
+}
+
+// src/base/io/drizzle.ts
+import { COMPLETE as COMPLETE3, ERROR as ERROR3, node as node3 } from "@graphrefly/pure-ts/core";
+function fromDrizzle(query, opts) {
+  const { mapRow = (r) => r, ...rest } = opts ?? {};
+  return node3(
+    [],
+    (_data, a) => {
+      let active = true;
+      void query.execute().then((rows) => {
+        if (!active) return;
+        a.emit(rows.map(mapRow));
+        a.down([[COMPLETE3]]);
+      }).catch((err) => {
+        if (!active) return;
+        try {
+          a.down([[ERROR3, err instanceof Error ? err : new Error(String(err))]]);
+        } catch {
+        }
+      });
+      return () => {
+        active = false;
+      };
+    },
+    { ...rest, describeKind: "producer", completeWhenDepsComplete: false }
+  );
+}
+
+// src/base/io/http.ts
+import {
+  batch,
+  COMPLETE as COMPLETE5,
+  DATA as DATA2,
+  ERROR as ERROR5,
+  node as node5,
+  wallClockNs as wallClockNs2
+} from "@graphrefly/pure-ts/core";
+import { fromTimer as fromTimer2, switchMap as switchMap2 } from "@graphrefly/pure-ts/extra";
+
+// src/base/io/_sink.ts
+import {
+  COMPLETE as COMPLETE4,
+  DATA,
+  defaultConfig,
+  ERROR as ERROR4,
+  node as node4,
+  RingBuffer,
+  TEARDOWN
+} from "@graphrefly/pure-ts/core";
+var BackpressureBuffer = class {
+  ring;
+  arr;
+  constructor(cap) {
+    if (cap === Number.POSITIVE_INFINITY || cap <= 0) {
+      this.arr = [];
+      this.ring = null;
+    } else {
+      this.ring = new RingBuffer(cap);
+      this.arr = null;
+    }
+  }
+  get length() {
+    return this.ring != null ? this.ring.size : this.arr.length;
+  }
+  push(item) {
+    if (this.ring != null) this.ring.push(item);
+    else this.arr.push(item);
+  }
+  /** Drop-oldest — O(1) in bounded mode. Returns undefined when empty. */
+  shift() {
+    if (this.ring != null) return this.ring.shift();
+    return this.arr.shift();
+  }
+  /** Full drain — returns contents, resets to empty. */
+  drain() {
+    if (this.ring != null) {
+      const out2 = this.ring.toArray();
+      this.ring.clear();
+      return out2;
+    }
+    const out = this.arr;
+    this.arr = [];
+    return out;
+  }
+};
+function coerceError(err) {
+  return err instanceof Error ? err : new Error(String(err));
+}
+function resolveBackoff(backoff) {
+  if (backoff === void 0) return null;
+  if (typeof backoff === "string") return resolveBackoffPreset(backoff);
+  return backoff;
+}
+function reactiveSink(source, config) {
+  const {
+    name,
+    onTransportError,
+    retry: retry2,
+    backpressure,
+    batchSize = Number.POSITIVE_INFINITY,
+    flushIntervalMs = 0,
+    serialize,
+    stopOn,
+    onUpstreamMessage,
+    onDispose,
+    send,
+    sendBatch,
+    ctx: ctxValue
+  } = config;
+  if (!send && !sendBatch) {
+    throw new Error("reactiveSink: `send` or `sendBatch` must be provided");
+  }
+  const ctx = ctxValue;
+  const maxAttempts = Math.max(1, retry2?.maxAttempts ?? 1);
+  const backoffStrategy = resolveBackoff(
+    retry2?.backoff ?? (maxAttempts > 1 ? "exponential" : void 0)
+  );
+  const shouldRetry = retry2?.shouldRetry ?? (() => true);
+  const useBuffering = sendBatch !== void 0 || batchSize < Number.POSITIVE_INFINITY || flushIntervalMs > 0;
+  const nameFor = (suffix) => name ? `${name}::${suffix}` : void 0;
+  const sent = node4([], {
+    initial: void 0,
+    equals: () => false,
+    name: nameFor("sent")
+  });
+  const failed = node4([], { initial: null, name: nameFor("failed") });
+  const inFlightCountNode = node4([], { initial: 0, name: nameFor("inFlight") });
+  const errorsNode = node4([], {
+    initial: null,
+    name: nameFor("errors")
+  });
+  const bufferedNode = useBuffering ? node4([], { initial: 0, name: nameFor("buffered") }) : void 0;
+  const pausedNode = backpressure ? node4([], { initial: false, name: nameFor("paused") }) : void 0;
+  let inFlightCount = 0;
+  const bumpInFlight = (delta) => {
+    inFlightCount += delta;
+    inFlightCountNode.down([[DATA, inFlightCount]]);
+  };
+  const reportError = (err) => {
+    try {
+      onTransportError?.(err);
+    } catch {
+    }
+    try {
+      errorsNode.down([[DATA, err]]);
+    } catch {
+    }
+  };
+  const inFlightPromises = /* @__PURE__ */ new Set();
+  const trackPromise = (p) => {
+    inFlightPromises.add(p);
+    const done = () => inFlightPromises.delete(p);
+    p.then(done, done);
+  };
+  const scheduleRetry = (runAgain, attempt, error) => {
+    const raw = backoffStrategy ? backoffStrategy(attempt - 1, error, null) : 0;
+    const delayNs = raw === null || raw === void 0 ? 0 : typeof raw === "number" && raw > 0 ? raw : 0;
+    const delayMs = Math.max(1, Math.ceil(delayNs / NS_PER_MS));
+    return new Promise((resolve) => {
+      setTimeout(() => resolve(runAgain()), delayMs);
+    });
+  };
+  const isThenable = (v) => v != null && typeof v === "object" && typeof v.then === "function";
+  const performSend = (value) => {
+    let payload;
+    try {
+      payload = serialize ? serialize(value) : value;
+    } catch (rawErr) {
+      const error = coerceError(rawErr);
+      reportError({ stage: "serialize", error, value });
+      failed.down([[DATA, { value, error, attempts: 0 }]]);
+      return Promise.resolve();
+    }
+    let attempt = 0;
+    const onError = (rawErr) => {
+      bumpInFlight(-1);
+      const error = coerceError(rawErr);
+      reportError({ stage: "send", error, value, attempt });
+      const more = attempt < maxAttempts && shouldRetry(error, attempt);
+      if (!more) {
+        failed.down([[DATA, { value, error, attempts: attempt }]]);
+        return void 0;
+      }
+      return scheduleRetry(run, attempt, error);
+    };
+    const onSuccess = () => {
+      bumpInFlight(-1);
+      sent.down([[DATA, value]]);
+    };
+    function run() {
+      attempt += 1;
+      bumpInFlight(1);
+      let result;
+      try {
+        result = send(payload, ctx);
+      } catch (rawErr) {
+        return onError(rawErr) ?? Promise.resolve();
+      }
+      if (isThenable(result)) {
+        return result.then(onSuccess, (rawErr) => onError(rawErr));
+      }
+      onSuccess();
+      return Promise.resolve();
+    }
+    return run();
+  };
+  const maxBuf = backpressure?.maxBuffer ?? Number.POSITIVE_INFINITY;
+  const buffer = new BackpressureBuffer(maxBuf);
+  let flushTimer;
+  let disposed = false;
+  const updateBuffered = () => {
+    bufferedNode?.down([[DATA, buffer.length]]);
+  };
+  const markPaused = (paused) => {
+    if (!pausedNode) return;
+    pausedNode.down([[DATA, paused]]);
+  };
+  const bpStrategy = backpressure?.strategy ?? "drop-oldest";
+  const pushWithBackpressure = (value, payload) => {
+    const entry = { value, payload };
+    if (buffer.length < maxBuf) {
+      buffer.push(entry);
+      updateBuffered();
+      return true;
+    }
+    if (bpStrategy === "drop-oldest") {
+      const dropped = buffer.shift();
+      buffer.push(entry);
+      updateBuffered();
+      markPaused(true);
+      failed.down([
+        [
+          DATA,
+          {
+            value: dropped.value,
+            error: new Error("backpressure: buffer overflow \u2014 dropped oldest"),
+            attempts: 0
+          }
+        ]
+      ]);
+      return true;
+    }
+    if (bpStrategy === "drop-newest") {
+      markPaused(true);
+      failed.down([
+        [
+          DATA,
+          {
+            value,
+            error: new Error("backpressure: buffer overflow \u2014 dropped newest"),
+            attempts: 0
+          }
+        ]
+      ]);
+      return false;
+    }
+    const err = new Error("backpressure: buffer overflow");
+    reportError({ stage: "send", error: err, value });
+    failed.down([[DATA, { value, error: err, attempts: 0 }]]);
+    markPaused(true);
+    return false;
+  };
+  const performBufferedBatchFlush = (chunk) => {
+    let attempt = 0;
+    const payloads = chunk.map((e) => e.payload);
+    const onError = (rawErr) => {
+      bumpInFlight(-1);
+      const error = coerceError(rawErr);
+      reportError({ stage: "send", error, value: chunk.map((e) => e.value), attempt });
+      const more = attempt < maxAttempts && shouldRetry(error, attempt);
+      if (!more) {
+        for (const { value: v } of chunk) {
+          failed.down([[DATA, { value: v, error, attempts: attempt }]]);
+        }
+        return void 0;
+      }
+      return scheduleRetry(run, attempt, error);
+    };
+    const onSuccess = () => {
+      bumpInFlight(-1);
+      for (const { value: v } of chunk) sent.down([[DATA, v]]);
+    };
+    function run() {
+      attempt += 1;
+      bumpInFlight(1);
+      let result;
+      try {
+        result = sendBatch(payloads, ctx);
+      } catch (rawErr) {
+        return onError(rawErr) ?? Promise.resolve();
+      }
+      if (isThenable(result)) {
+        return result.then(onSuccess, (rawErr) => onError(rawErr));
+      }
+      onSuccess();
+      return Promise.resolve();
+    }
+    return run();
+  };
+  const performBufferedPerRecordFlush = async (chunk) => {
+    for (const entry of chunk) {
+      await performPreSerializedSend(entry.value, entry.payload);
+    }
+  };
+  const performPreSerializedSend = (value, payload) => {
+    let attempt = 0;
+    const onError = (rawErr) => {
+      bumpInFlight(-1);
+      const error = coerceError(rawErr);
+      reportError({ stage: "send", error, value, attempt });
+      const more = attempt < maxAttempts && shouldRetry(error, attempt);
+      if (!more) {
+        failed.down([[DATA, { value, error, attempts: attempt }]]);
+        return void 0;
+      }
+      return scheduleRetry(run, attempt, error);
+    };
+    const onSuccess = () => {
+      bumpInFlight(-1);
+      sent.down([[DATA, value]]);
+    };
+    function run() {
+      attempt += 1;
+      bumpInFlight(1);
+      let result;
+      try {
+        result = send(payload, ctx);
+      } catch (rawErr) {
+        return onError(rawErr) ?? Promise.resolve();
+      }
+      if (isThenable(result)) {
+        return result.then(onSuccess, (rawErr) => onError(rawErr));
+      }
+      onSuccess();
+      return Promise.resolve();
+    }
+    return run();
+  };
+  const doFlush = () => {
+    if (disposed || buffer.length === 0) return Promise.resolve();
+    const chunk = buffer.drain();
+    updateBuffered();
+    markPaused(false);
+    if (sendBatch !== void 0) {
+      const p2 = performBufferedBatchFlush(chunk);
+      trackPromise(p2);
+      return p2;
+    }
+    const p = performBufferedPerRecordFlush(chunk);
+    trackPromise(p);
+    return p;
+  };
+  const scheduleFlush = () => {
+    if (flushTimer !== void 0 || disposed) return;
+    if (flushIntervalMs <= 0) return;
+    flushTimer = setTimeout(() => {
+      flushTimer = void 0;
+      void doFlush();
+    }, flushIntervalMs);
+  };
+  const unsub = source.subscribe((msgs) => {
+    for (const msg of msgs) {
+      const type = msg[0];
+      if (type !== DATA) {
+        try {
+          onUpstreamMessage?.(msg);
+        } catch {
+        }
+      }
+      if (type === DATA) {
+        const value = msg[1];
+        if (useBuffering) {
+          let payload;
+          if (serialize) {
+            try {
+              payload = serialize(value);
+            } catch (rawErr) {
+              const error = coerceError(rawErr);
+              reportError({ stage: "serialize", error, value });
+              failed.down([[DATA, { value, error, attempts: 0 }]]);
+              continue;
+            }
+          } else {
+            payload = value;
+          }
+          const admitted = pushWithBackpressure(value, payload);
+          if (!admitted) continue;
+          if (buffer.length >= batchSize) void doFlush();
+          else scheduleFlush();
+        } else {
+          const p = performSend(value);
+          trackPromise(p);
+        }
+      } else if (defaultConfig.messageTier(type) >= 3) {
+        if (useBuffering) {
+          if (flushTimer !== void 0) {
+            clearTimeout(flushTimer);
+            flushTimer = void 0;
+          }
+          void doFlush();
+        }
+      }
+    }
+  });
+  let stopUnsub;
+  if (stopOn) {
+    let firstBatchSeen = false;
+    stopUnsub = stopOn.subscribe((msgs) => {
+      if (!firstBatchSeen) {
+        firstBatchSeen = true;
+        return;
+      }
+      if (msgs.length > 0 && !teardownRequested) dispose();
+    });
+  }
+  let teardownRequested = false;
+  const dispose = () => {
+    if (teardownRequested) return;
+    teardownRequested = true;
+    if (flushTimer !== void 0) {
+      clearTimeout(flushTimer);
+      flushTimer = void 0;
+    }
+    if (useBuffering) void doFlush();
+    disposed = true;
+    stopUnsub?.();
+    unsub();
+    const tearDown = (n) => {
+      try {
+        n.down([[TEARDOWN]]);
+      } catch {
+      }
+    };
+    tearDown(errorsNode);
+    tearDown(failed);
+    tearDown(sent);
+    tearDown(inFlightCountNode);
+    if (bufferedNode) tearDown(bufferedNode);
+    if (pausedNode) tearDown(pausedNode);
+    try {
+      onDispose?.();
+    } catch {
+    }
+  };
+  const handle = {
+    dispose,
+    sent,
+    failed,
+    inFlight: inFlightCountNode,
+    errors: errorsNode
+  };
+  if (useBuffering) {
+    handle.buffered = bufferedNode;
+    handle.flush = async () => {
+      if (disposed) return;
+      await doFlush();
+      await Promise.all(inFlightPromises);
+    };
+  }
+  if (pausedNode) handle.paused = pausedNode;
+  void COMPLETE4;
+  void ERROR4;
+  return handle;
+}
+
+// src/base/io/http.ts
+function fromHTTP(url, opts) {
+  const {
+    method = "GET",
+    headers,
+    body: bodyOpt,
+    transform = (r) => r.json(),
+    timeoutNs = 30 * NS_PER_SEC,
+    signal: externalSignal,
+    completeAfterFetch = false,
+    refetchOnSubscribe = false,
+    ...rest
+  } = opts ?? {};
+  const fetchCount = node5([], { initial: 0, name: `${rest.name ?? "http"}/fetchCount` });
+  const lastUpdated = node5([], { initial: 0, name: `${rest.name ?? "http"}/lastUpdated` });
+  const fetched = node5([], { initial: false, name: `${rest.name ?? "http"}/fetched` });
+  let fetchCountLocal = 0;
+  const body = bodyOpt !== void 0 ? typeof bodyOpt === "string" ? bodyOpt : JSON.stringify(bodyOpt) : void 0;
+  const runFetch = (a) => {
+    const abort = new AbortController();
+    let active = true;
+    if (externalSignal?.aborted) {
+      active = false;
+      a.down([[ERROR5, externalSignal.reason ?? new Error("Aborted")]]);
+      return () => {
+      };
+    }
+    externalSignal?.addEventListener("abort", () => abort.abort(externalSignal.reason), {
+      once: true
+    });
+    const timeoutId = setTimeout(
+      () => abort.abort(new Error("Request timeout")),
+      Math.ceil(timeoutNs / NS_PER_MS)
+    );
+    fetch(url, { method, headers, body, signal: abort.signal }).then(async (res) => {
+      clearTimeout(timeoutId);
+      if (!active) return;
+      if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+      const data = await transform(res);
+      if (!active) return;
+      batch(() => {
+        fetchCountLocal += 1;
+        fetchCount.down([[DATA2, fetchCountLocal]]);
+        lastUpdated.down([[DATA2, wallClockNs2()]]);
+        fetched.down([[DATA2, true]]);
+        a.emit(data);
+      });
+      if (completeAfterFetch) a.down([[COMPLETE5]]);
+    }).catch((err) => {
+      clearTimeout(timeoutId);
+      if (!active) return;
+      if (err && err.name === "AbortError") return;
+      a.down([[ERROR5, err]]);
+    });
+    return () => {
+      active = false;
+      abort.abort();
+    };
+  };
+  const sourceNode = node5(
+    [],
+    (_data, a) => runFetch({
+      emit: (v) => a.emit(v),
+      down: (msgs) => a.down(msgs)
+    }),
+    {
+      ...sourceOpts(rest),
+      // `resubscribable: true` when refetchOnSubscribe — each new activation
+      // (subscribe after full deactivation) re-runs the producer fn → fresh
+      // fetch. Default (cache-once) stays non-resubscribable: producer runs
+      // once on first activation, cached DATA replays to late subscribers.
+      resubscribable: refetchOnSubscribe
+    }
+  );
+  const tracked = withStatus(sourceNode);
+  return {
+    ...tracked,
+    fetchCount,
+    lastUpdated,
+    fetched
+  };
+}
+function toHTTP(source, url, opts) {
+  const {
+    method = "POST",
+    headers = { "Content-Type": "application/json" },
+    serialize = (v) => JSON.stringify(v),
+    timeoutNs,
+    batchFormat = "json-array",
+    batchSize,
+    flushIntervalMs,
+    retry: retry2,
+    onTransportError
+  } = opts ?? {};
+  const sendOne = async (body) => {
+    const controller = timeoutNs !== void 0 ? new AbortController() : void 0;
+    let timeoutId;
+    if (controller && timeoutNs !== void 0) {
+      timeoutId = setTimeout(
+        () => controller.abort(new Error("Request timeout")),
+        Math.ceil(timeoutNs / NS_PER_MS)
+      );
+    }
+    try {
+      const res = await fetch(url, {
+        method,
+        headers,
+        body,
+        signal: controller?.signal
+      });
+      const drain = async () => {
+        try {
+          await res.arrayBuffer?.();
+        } catch {
+        }
+      };
+      if (!res.ok) {
+        await drain();
+        throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+      }
+      await drain();
+    } finally {
+      if (timeoutId !== void 0) clearTimeout(timeoutId);
+    }
+  };
+  const buffered = batchSize !== void 0 || flushIntervalMs !== void 0;
+  if (buffered) {
+    return reactiveSink(source, {
+      onTransportError,
+      retry: retry2,
+      batchSize,
+      flushIntervalMs,
+      sendBatch: async (chunk) => {
+        let body;
+        if (batchFormat === "ndjson") {
+          body = chunk.map((v) => {
+            const s = serialize(v);
+            return typeof s === "string" ? s : new TextDecoder().decode(s);
+          }).join("\n");
+        } else {
+          body = JSON.stringify(chunk);
+        }
+        await sendOne(body);
+      }
+    });
+  }
+  return reactiveSink(source, {
+    onTransportError,
+    retry: retry2,
+    serialize,
+    send: async (payload) => {
+      await sendOne(payload);
+    }
+  });
+}
+function fromHTTPStream(url, opts) {
+  const { method = "GET", headers, body: bodyOpt, signal: externalSignal, ...rest } = opts ?? {};
+  return node5(
+    [],
+    (_data, a) => {
+      let active = true;
+      const abort = new AbortController();
+      if (externalSignal?.aborted) {
+        a.down([[ERROR5, externalSignal.reason ?? new Error("Aborted")]]);
+        return () => {
+        };
+      }
+      externalSignal?.addEventListener("abort", () => abort.abort(externalSignal.reason), {
+        once: true
+      });
+      const body = bodyOpt !== void 0 ? typeof bodyOpt === "string" ? bodyOpt : JSON.stringify(bodyOpt) : void 0;
+      const run = async () => {
+        try {
+          const res = await fetch(url, { method, headers, body, signal: abort.signal });
+          if (!active) return;
+          if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+          if (!res.body) throw new Error("HTTP response has no body");
+          const reader = res.body.getReader();
+          while (active) {
+            const { value, done } = await reader.read();
+            if (done) break;
+            if (value) a.emit(value);
+          }
+          if (active) a.down([[COMPLETE5]]);
+        } catch (err) {
+          if (!active) return;
+          if (err && err.name === "AbortError") return;
+          a.down([[ERROR5, err]]);
+        }
+      };
+      void run();
+      return () => {
+        active = false;
+        abort.abort();
+      };
+    },
+    sourceOpts(rest)
+  );
+}
+function fromHTTPPoll(url, opts) {
+  const { intervalMs = 5e3, ...httpOpts } = opts ?? {};
+  return switchMap2(
+    fromTimer2(intervalMs, { period: intervalMs }),
+    () => fromHTTP(url, { ...httpOpts, completeAfterFetch: true }).node
+  );
+}
+
+// src/base/io/kafka.ts
+import { ERROR as ERROR6, node as node6, wallClockNs as wallClockNs3 } from "@graphrefly/pure-ts/core";
+function fromKafka(consumer, topic, opts) {
+  const {
+    fromBeginning = false,
+    deserialize = (buf) => {
+      if (buf === null) return null;
+      try {
+        return JSON.parse(buf.toString());
+      } catch {
+        return buf.toString();
+      }
+    },
+    ...rest
+  } = opts ?? {};
+  return node6(
+    [],
+    (_data, a) => {
+      let active = true;
+      const start = async () => {
+        try {
+          await consumer.subscribe({ topic, fromBeginning });
+          await consumer.run({
+            eachMessage: async ({ topic: t, partition, message: msg }) => {
+              if (!active) return;
+              const headers = {};
+              if (msg.headers) {
+                for (const [k, v] of Object.entries(msg.headers)) {
+                  if (v !== void 0) headers[k] = typeof v === "string" ? v : v.toString();
+                }
+              }
+              a.emit({
+                topic: t,
+                partition,
+                key: msg.key?.toString() ?? null,
+                value: deserialize(msg.value),
+                headers,
+                offset: msg.offset,
+                timestamp: msg.timestamp,
+                timestampNs: wallClockNs3()
+              });
+            }
+          });
+        } catch (err) {
+          if (active) a.down([[ERROR6, err]]);
+        }
+      };
+      void start();
+      return () => {
+        active = false;
+      };
+    },
+    sourceOpts(rest)
+  );
+}
+function toKafka(source, kafkaProducer, topic, opts) {
+  const { serialize = (v) => JSON.stringify(v), keyExtractor, onTransportError } = opts ?? {};
+  return reactiveSink(source, {
+    onTransportError,
+    send: async (value) => {
+      const key = keyExtractor?.(value) ?? null;
+      const serialized = serialize(value);
+      await kafkaProducer.send({
+        topic,
+        messages: [{ key, value: Buffer.from(serialized) }]
+      });
+    }
+  });
+}
+
+// src/base/io/kysely.ts
+import { COMPLETE as COMPLETE6, ERROR as ERROR7, node as node7 } from "@graphrefly/pure-ts/core";
+function fromKysely(query, opts) {
+  const { mapRow = (r) => r, ...rest } = opts ?? {};
+  return node7(
+    [],
+    (_data, a) => {
+      let active = true;
+      void query.execute().then((rows) => {
+        if (!active) return;
+        a.emit(rows.map(mapRow));
+        a.down([[COMPLETE6]]);
+      }).catch((err) => {
+        if (!active) return;
+        try {
+          a.down([[ERROR7, err instanceof Error ? err : new Error(String(err))]]);
+        } catch {
+        }
+      });
+      return () => {
+        active = false;
+      };
+    },
+    { ...rest, describeKind: "producer", completeWhenDepsComplete: false }
+  );
+}
+
+// src/base/io/mcp.ts
+function fromMCP(client, opts) {
+  const { method = "notifications/message", onDisconnect, ...rest } = opts ?? {};
+  return externalProducer(({ emit, error }) => {
+    client.setNotificationHandler(method, (notification) => emit(notification));
+    onDisconnect?.((err) => error(err ?? new Error("MCP client disconnected")));
+    return () => client.setNotificationHandler(method, () => {
+    });
+  }, rest);
+}
+
+// src/base/io/nats.ts
+import { COMPLETE as COMPLETE7, ERROR as ERROR8, node as node8, wallClockNs as wallClockNs4 } from "@graphrefly/pure-ts/core";
+function fromNATS(client, subject, opts) {
+  const decoder = new TextDecoder();
+  const {
+    queue,
+    deserialize = (data) => {
+      const text = decoder.decode(data);
+      try {
+        return JSON.parse(text);
+      } catch {
+        return text;
+      }
+    },
+    ...rest
+  } = opts ?? {};
+  return node8(
+    [],
+    (_data, a) => {
+      let active = true;
+      const sub = client.subscribe(subject, queue ? { queue } : void 0);
+      const loop = async () => {
+        try {
+          for await (const msg of sub) {
+            if (!active) return;
+            const headers = {};
+            if (msg.headers) {
+              for (const k of msg.headers.keys()) {
+                headers[k] = msg.headers.get(k);
+              }
+            }
+            a.emit({
+              subject: msg.subject,
+              data: deserialize(msg.data),
+              headers,
+              reply: msg.reply,
+              sid: msg.sid,
+              timestampNs: wallClockNs4()
+            });
+          }
+          if (active) a.down([[COMPLETE7]]);
+        } catch (err) {
+          if (active) a.down([[ERROR8, err]]);
+        }
+      };
+      void loop();
+      return () => {
+        active = false;
+      };
+    },
+    sourceOpts(rest)
+  );
+}
+function toNATS(source, client, subject, opts) {
+  const encoder = new TextEncoder();
+  const { serialize = (v) => encoder.encode(JSON.stringify(v)), onTransportError } = opts ?? {};
+  return reactiveSink(source, {
+    onTransportError,
+    send: (value) => {
+      client.publish(subject, serialize(value));
+    }
+  });
+}
+
+// src/base/io/ndjson.ts
+import { COMPLETE as COMPLETE8, ERROR as ERROR9, node as node9 } from "@graphrefly/pure-ts/core";
+function ndjsonRows(source, opts) {
+  let cleanup;
+  return node9(
+    [source],
+    (data, a, ctx) => {
+      if (cleanup === void 0) {
+        const store = ctx.store;
+        cleanup = {
+          onDeactivation: () => {
+            delete store.buffer;
+          }
+        };
+      }
+      const batch0 = data[0];
+      if (batch0 == null || batch0.length === 0) return cleanup;
+      const s = ctx.store;
+      if (typeof s.buffer !== "string") s.buffer = "";
+      for (const chunkRaw of batch0) {
+        s.buffer = s.buffer + chunkRaw;
+        const lines = s.buffer.split(/\r?\n/);
+        s.buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            a.emit(JSON.parse(line));
+          } catch (err) {
+            a.down([[ERROR9, err]]);
+            return cleanup;
+          }
+        }
+      }
+      return cleanup;
+    },
+    { describeKind: "derived", ...opts ?? {} }
+  );
+}
+function fromNDJSON(source, opts) {
+  return node9(
+    [],
+    (_data, a) => {
+      let cancelled = false;
+      const run = async () => {
+        try {
+          let buffer = "";
+          for await (const chunk of source) {
+            if (cancelled) return;
+            buffer += chunk;
+            const lines = buffer.split(/\r?\n/);
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+              if (cancelled) return;
+              const trimmed = line.trim();
+              if (!trimmed) continue;
+              a.emit(JSON.parse(trimmed));
+            }
+          }
+          if (!cancelled && buffer.trim()) {
+            a.emit(JSON.parse(buffer.trim()));
+          }
+          if (!cancelled) a.down([[COMPLETE8]]);
+        } catch (err) {
+          if (!cancelled) a.down([[ERROR9, err]]);
+        }
+      };
+      void run();
+      return () => {
+        cancelled = true;
+      };
+    },
+    sourceOpts(opts)
+  );
+}
+
+// src/base/io/otel.ts
+import { batch as batch2 } from "@graphrefly/pure-ts/core";
+function fromOTel(register, opts) {
+  const nodes = externalBundle(
+    ({ traces, metrics, logs, error }) => {
+      return register({
+        onTraces: (spans) => {
+          batch2(() => {
+            for (const s of spans) traces(s);
+          });
+        },
+        onMetrics: (ms) => {
+          batch2(() => {
+            for (const m of ms) metrics(m);
+          });
+        },
+        onLogs: (ls) => {
+          batch2(() => {
+            for (const l of ls) logs(l);
+          });
+        },
+        onError: error
+      }) ?? void 0;
+    },
+    ["traces", "metrics", "logs"],
+    opts?.name ? { name: opts.name } : void 0
+  );
+  return nodes;
+}
+
+// src/base/io/prisma.ts
+import { COMPLETE as COMPLETE9, ERROR as ERROR10, node as node10 } from "@graphrefly/pure-ts/core";
+function fromPrisma(model, opts) {
+  const { args, mapRow = (r) => r, ...rest } = opts ?? {};
+  return node10(
+    [],
+    (_data, a) => {
+      let active = true;
+      void model.findMany(args).then((rows) => {
+        if (!active) return;
+        a.emit(rows.map(mapRow));
+        a.down([[COMPLETE9]]);
+      }).catch((err) => {
+        if (!active) return;
+        try {
+          a.down([[ERROR10, err instanceof Error ? err : new Error(String(err))]]);
+        } catch {
+        }
+      });
+      return () => {
+        active = false;
+      };
+    },
+    { ...rest, describeKind: "producer", completeWhenDepsComplete: false }
+  );
+}
+
+// src/base/io/prometheus.ts
+import { COMPLETE as COMPLETE10, ERROR as ERROR11, node as node11, wallClockNs as wallClockNs5 } from "@graphrefly/pure-ts/core";
+import { fromTimer as fromTimer3, switchMap as switchMap3 } from "@graphrefly/pure-ts/extra";
+function fromPrometheus(endpoint, opts) {
+  const {
+    intervalNs = 15 * NS_PER_SEC,
+    headers,
+    timeoutNs = 10 * NS_PER_SEC,
+    signal: externalSignal,
+    maxConsecutiveErrors = 1
+  } = opts ?? {};
+  const intervalMs = Math.ceil(intervalNs / NS_PER_MS);
+  let consecutiveErrors = 0;
+  return switchMap3(
+    fromTimer3(0, { period: intervalMs, signal: externalSignal }),
+    () => node11([], (_data, a) => {
+      let active = true;
+      const abort = new AbortController();
+      const timeoutId = setTimeout(
+        () => abort.abort(new Error("Scrape timeout")),
+        Math.ceil(timeoutNs / NS_PER_MS)
+      );
+      const run = async () => {
+        try {
+          const res = await fetch(endpoint, {
+            headers: { Accept: "text/plain", ...headers },
+            signal: abort.signal
+          });
+          clearTimeout(timeoutId);
+          if (!active) return;
+          if (!res.ok) throw new Error(`Prometheus scrape ${res.status}: ${res.statusText}`);
+          const text = await res.text();
+          if (!active) return;
+          const metrics = parsePrometheusText(text);
+          for (const m of metrics) a.emit(m);
+          consecutiveErrors = 0;
+          a.down([[COMPLETE10]]);
+        } catch (err) {
+          clearTimeout(timeoutId);
+          if (!active) return;
+          if (err instanceof Error && err.name === "AbortError") return;
+          consecutiveErrors += 1;
+          if (consecutiveErrors >= maxConsecutiveErrors) {
+            a.down([[ERROR11, err]]);
+          }
+        }
+      };
+      void run();
+      return () => {
+        active = false;
+        clearTimeout(timeoutId);
+        abort.abort();
+      };
+    })
+  );
+}
+function parsePrometheusText(text) {
+  const results = [];
+  const types = /* @__PURE__ */ new Map();
+  const helps = /* @__PURE__ */ new Map();
+  for (const rawLine of text.split("\n")) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    if (line.startsWith("# TYPE ")) {
+      const rest = line.slice(7);
+      const spaceIdx = rest.indexOf(" ");
+      if (spaceIdx > 0) {
+        types.set(rest.slice(0, spaceIdx), rest.slice(spaceIdx + 1).trim());
+      }
+      continue;
+    }
+    if (line.startsWith("# HELP ")) {
+      const rest = line.slice(7);
+      const spaceIdx = rest.indexOf(" ");
+      if (spaceIdx > 0) {
+        helps.set(rest.slice(0, spaceIdx), rest.slice(spaceIdx + 1).trim());
+      }
+      continue;
+    }
+    if (line.startsWith("#")) continue;
+    let name;
+    let labels = {};
+    let valueStr;
+    let tsStr;
+    const braceIdx = line.indexOf("{");
+    if (braceIdx >= 0) {
+      name = line.slice(0, braceIdx);
+      const closeBrace = line.indexOf("}", braceIdx);
+      if (closeBrace < 0) continue;
+      const labelStr = line.slice(braceIdx + 1, closeBrace);
+      labels = parsePrometheusLabels(labelStr);
+      const after = line.slice(closeBrace + 1).trim().split(/\s+/);
+      valueStr = after[0] ?? "";
+      tsStr = after[1];
+    } else {
+      const parts = line.split(/\s+/);
+      name = parts[0] ?? "";
+      valueStr = parts[1] ?? "";
+      tsStr = parts[2];
+    }
+    if (!name || !valueStr) continue;
+    const baseName = name.replace(/(_total|_count|_sum|_bucket|_created|_info)$/, "");
+    results.push({
+      name,
+      labels,
+      value: Number(valueStr),
+      timestampMs: tsStr ? Number(tsStr) : void 0,
+      type: types.get(baseName) ?? types.get(name),
+      help: helps.get(baseName) ?? helps.get(name),
+      timestampNs: wallClockNs5()
+    });
+  }
+  return results;
+}
+function parsePrometheusLabels(str) {
+  const labels = {};
+  const re = /(\w+)="((?:[^"\\]|\\.)*)"/g;
+  let m = re.exec(str);
+  while (m !== null) {
+    labels[m[1]] = m[2].replace(/\\(.)/g, "$1");
+    m = re.exec(str);
+  }
+  return labels;
+}
+
+// src/base/io/pulsar.ts
+import { ERROR as ERROR12, node as node12, wallClockNs as wallClockNs6 } from "@graphrefly/pure-ts/core";
+function fromPulsar(consumer, opts) {
+  const {
+    autoAck = true,
+    deserialize = (buf) => {
+      try {
+        return JSON.parse(buf.toString());
+      } catch {
+        return buf.toString();
+      }
+    },
+    onAckError,
+    ...rest
+  } = opts ?? {};
+  const reportAckError = (err) => {
+    if (!onAckError) return;
+    try {
+      onAckError(err instanceof Error ? err : new Error(String(err)));
+    } catch {
+    }
+  };
+  return node12(
+    [],
+    (_data, a) => {
+      let active = true;
+      const loop = async () => {
+        while (active) {
+          try {
+            const rawMsg = await consumer.receive();
+            if (!active) return;
+            const structured = {
+              topic: rawMsg.getTopicName(),
+              messageId: rawMsg.getMessageId().toString(),
+              key: rawMsg.getPartitionKey(),
+              value: deserialize(rawMsg.getData()),
+              properties: rawMsg.getProperties(),
+              publishTime: rawMsg.getPublishTimestamp(),
+              eventTime: rawMsg.getEventTimestamp(),
+              timestampNs: wallClockNs6()
+            };
+            if (autoAck) {
+              a.emit(structured);
+              void consumer.acknowledge(rawMsg).catch(reportAckError);
+            } else {
+              let settled = false;
+              const envelope = {
+                value: structured,
+                ack() {
+                  if (settled) return;
+                  settled = true;
+                  void consumer.acknowledge(rawMsg).catch(reportAckError);
+                },
+                nack(_opts) {
+                  if (settled) return;
+                  settled = true;
+                  const anyConsumer = consumer;
+                  try {
+                    const result = anyConsumer.negativeAcknowledge?.(rawMsg);
+                    if (result && typeof result.then === "function") {
+                      void result.catch(reportAckError);
+                    }
+                  } catch (err) {
+                    reportAckError(err);
+                  }
+                }
+              };
+              a.emit(envelope);
+            }
+          } catch (err) {
+            if (active) a.down([[ERROR12, err]]);
+            return;
+          }
+        }
+      };
+      void loop();
+      return () => {
+        active = false;
+      };
+    },
+    sourceOpts(rest)
+  );
+}
+function toPulsar(source, pulsarProducer, opts) {
+  const {
+    serialize = (v) => Buffer.from(JSON.stringify(v)),
+    keyExtractor,
+    propertiesExtractor,
+    onTransportError
+  } = opts ?? {};
+  return reactiveSink(source, {
+    onTransportError,
+    send: async (value) => {
+      await pulsarProducer.send({
+        data: serialize(value),
+        partitionKey: keyExtractor?.(value),
+        properties: propertiesExtractor?.(value)
+      });
+    }
+  });
+}
+
+// src/base/io/rabbitmq.ts
+import { ERROR as ERROR13, node as node13, wallClockNs as wallClockNs7 } from "@graphrefly/pure-ts/core";
+function fromRabbitMQ(channel, queue, opts) {
+  const {
+    autoAck = true,
+    deserialize = (buf) => {
+      try {
+        return JSON.parse(buf.toString());
+      } catch {
+        return buf.toString();
+      }
+    },
+    onAckError,
+    ...rest
+  } = opts ?? {};
+  const reportAckError = (err) => {
+    if (!onAckError) return;
+    try {
+      onAckError(err instanceof Error ? err : new Error(String(err)));
+    } catch {
+    }
+  };
+  return node13(
+    [],
+    (_data, a) => {
+      let active = true;
+      let consumerTag;
+      const start = async () => {
+        try {
+          const result = await channel.consume(
+            queue,
+            (rawMsg) => {
+              if (!active) return;
+              if (rawMsg === null) {
+                if (active) a.down([[ERROR13, new Error("Consumer cancelled by broker")]]);
+                return;
+              }
+              const structured = {
+                queue,
+                routingKey: rawMsg.fields.routingKey,
+                exchange: rawMsg.fields.exchange,
+                content: deserialize(rawMsg.content),
+                properties: rawMsg.properties,
+                deliveryTag: rawMsg.fields.deliveryTag,
+                redelivered: rawMsg.fields.redelivered,
+                timestampNs: wallClockNs7()
+              };
+              if (autoAck) {
+                a.emit(structured);
+                try {
+                  channel.ack(rawMsg);
+                } catch (err) {
+                  reportAckError(err);
+                }
+              } else {
+                let settled = false;
+                const channelWithNack = channel;
+                const envelope = {
+                  value: structured,
+                  ack() {
+                    if (settled) return;
+                    settled = true;
+                    try {
+                      channel.ack(rawMsg);
+                    } catch (err) {
+                      reportAckError(err);
+                    }
+                  },
+                  nack(nackOpts) {
+                    if (settled) return;
+                    settled = true;
+                    const requeue = nackOpts?.requeue;
+                    if (!channelWithNack.nack) {
+                      reportAckError(
+                        new Error("RabbitMQ channel does not expose `nack`; cannot negative-ack")
+                      );
+                      return;
+                    }
+                    try {
+                      channelWithNack.nack(rawMsg, false, requeue);
+                    } catch (err) {
+                      reportAckError(err);
+                    }
+                  }
+                };
+                a.emit(envelope);
+              }
+            },
+            { noAck: false }
+          );
+          consumerTag = result.consumerTag;
+        } catch (err) {
+          if (active) a.down([[ERROR13, err]]);
+        }
+      };
+      void start();
+      return () => {
+        active = false;
+        if (consumerTag !== void 0) {
+          void channel.cancel(consumerTag);
+        }
+      };
+    },
+    sourceOpts(rest)
+  );
+}
+function toRabbitMQ(source, channel, exchange, opts) {
+  const {
+    serialize = (v) => Buffer.from(JSON.stringify(v)),
+    routingKeyExtractor = () => "",
+    onTransportError
+  } = opts ?? {};
+  return reactiveSink(source, {
+    onTransportError,
+    send: (value) => {
+      const routingKey = routingKeyExtractor(value);
+      const content = serialize(value);
+      channel.publish(exchange, routingKey, content);
+    }
+  });
+}
+
+// src/base/io/redis-stream.ts
+import { ERROR as ERROR14, node as node14, wallClockNs as wallClockNs8 } from "@graphrefly/pure-ts/core";
+function fromRedisStream(client, key, opts) {
+  const {
+    blockMs = 5e3,
+    startId = "$",
+    parse = (fields) => {
+      for (let i = 0; i < fields.length; i += 2) {
+        if (fields[i] === "data") {
+          try {
+            return JSON.parse(fields[i + 1]);
+          } catch {
+            return fields[i + 1];
+          }
+        }
+      }
+      const obj = {};
+      for (let i = 0; i < fields.length; i += 2) {
+        obj[fields[i]] = fields[i + 1];
+      }
+      return obj;
+    },
+    ...rest
+  } = opts ?? {};
+  return node14(
+    [],
+    (_data, a) => {
+      let active = true;
+      let lastId = startId;
+      const poll = async () => {
+        while (active) {
+          try {
+            const result = await client.xread("BLOCK", blockMs, "STREAMS", key, lastId);
+            if (!active) return;
+            if (result) {
+              for (const [_streamKey, entries] of result) {
+                for (const [id, fields] of entries) {
+                  lastId = id;
+                  a.emit({
+                    id,
+                    key,
+                    data: parse(fields),
+                    timestampNs: wallClockNs8()
+                  });
+                }
+              }
+            }
+          } catch (err) {
+            if (!active) return;
+            a.down([[ERROR14, err]]);
+            return;
+          }
+        }
+      };
+      void poll();
+      return () => {
+        active = false;
+      };
+    },
+    sourceOpts(rest)
+  );
+}
+function toRedisStream(source, client, key, opts) {
+  const {
+    serialize = (v) => ["data", JSON.stringify(v)],
+    maxLen,
+    onTransportError
+  } = opts ?? {};
+  return reactiveSink(source, {
+    onTransportError,
+    send: async (value) => {
+      const fields = serialize(value);
+      await (maxLen !== void 0 ? client.xadd(key, "MAXLEN", "~", String(maxLen), "*", ...fields) : client.xadd(key, "*", ...fields));
+    }
+  });
+}
+
+// src/base/io/sqlite.ts
+import {
+  batch as batch3,
+  COMPLETE as COMPLETE11,
+  DATA as DATA3,
+  defaultConfig as defaultConfig2,
+  ERROR as ERROR15,
+  node as node15,
+  TEARDOWN as TEARDOWN2
+} from "@graphrefly/pure-ts/core";
+function fromSqlite(db, query, opts) {
+  const { mapRow = (r) => r, params, ...rest } = opts ?? {};
+  return node15(
+    [],
+    (_data, a) => {
+      try {
+        const rows = db.query(query, params);
+        const mapped = rows.map(mapRow);
+        a.emit(mapped);
+        a.down([[COMPLETE11]]);
+      } catch (err) {
+        a.down([[ERROR15, err instanceof Error ? err : new Error(String(err))]]);
+      }
+      return void 0;
+    },
+    { describeKind: "producer", completeWhenDepsComplete: false, ...rest }
+  );
+}
+function fromSqliteCursor(db, query, opts) {
+  const { mapRow = (r) => r, params, ...rest } = opts ?? {};
+  return node15(
+    [],
+    (_data, a) => {
+      try {
+        const it = db.iterate(query, params);
+        batch3(() => {
+          for (const row of it) a.emit(mapRow(row));
+          a.down([[COMPLETE11]]);
+        });
+      } catch (err) {
+        a.down([[ERROR15, err instanceof Error ? err : new Error(String(err))]]);
+      }
+      return void 0;
+    },
+    { describeKind: "producer", completeWhenDepsComplete: false, ...rest }
+  );
+}
+function toSqlite(source, db, table, opts) {
+  if (table.includes("\0") || table.length === 0) {
+    throw new Error(`toSqlite: invalid table name: ${JSON.stringify(table)}`);
+  }
+  const {
+    toSQL = (v, t) => ({
+      sql: `INSERT INTO "${t.replace(/"/g, '""')}" (data) VALUES (?)`,
+      params: [JSON.stringify(v)]
+    }),
+    onTransportError,
+    batchInsert = false,
+    maxBatchSize = 1e3,
+    flushIntervalMs = 0
+  } = opts ?? {};
+  const serialize = (value) => toSQL(value, table);
+  if (!batchInsert) {
+    return reactiveSink(source, {
+      onTransportError,
+      serialize,
+      send: (q) => {
+        const query = q;
+        db.query(query.sql, query.params);
+      }
+    });
+  }
+  const errorsNode = node15([], { initial: null });
+  const sentNode = node15([], {
+    initial: void 0,
+    equals: () => false
+  });
+  const failedNode = node15([], { initial: null });
+  const inFlightNode = node15([], { initial: 0 });
+  const bufferedNode = node15([], { initial: 0 });
+  const reportError = (err) => {
+    try {
+      onTransportError?.(err);
+    } catch {
+    }
+    try {
+      errorsNode.down([[DATA3, err]]);
+    } catch {
+    }
+  };
+  let pending = [];
+  let flushing = false;
+  let timer;
+  let disposed = false;
+  const updateBuffered = () => bufferedNode.down([[DATA3, pending.length]]);
+  const safeEmitSent = (v) => {
+    if (disposed) return;
+    sentNode.down([[DATA3, v]]);
+  };
+  const safeEmitFailed = (f) => {
+    if (disposed) return;
+    failedNode.down([[DATA3, f]]);
+  };
+  const safeSetInFlight = (n) => {
+    if (disposed) return;
+    inFlightNode.down([[DATA3, n]]);
+  };
+  const safeReportError = (err) => {
+    if (disposed) return;
+    reportError(err);
+  };
+  const flushTransaction = () => {
+    if (pending.length === 0 || flushing) return;
+    flushing = true;
+    safeSetInFlight(1);
+    try {
+      db.query("BEGIN", []);
+    } catch (err) {
+      flushing = false;
+      safeSetInFlight(0);
+      safeReportError({
+        stage: "send",
+        error: err instanceof Error ? err : new Error(String(err)),
+        value: void 0
+      });
+      return;
+    }
+    const chunk = pending;
+    pending = [];
+    updateBuffered();
+    let firstError;
+    let committedCount = 0;
+    for (const entry of chunk) {
+      try {
+        db.query(entry.query.sql, entry.query.params);
+        committedCount += 1;
+      } catch (err) {
+        firstError = err instanceof Error ? err : new Error(String(err));
+        break;
+      }
+    }
+    if (firstError) {
+      try {
+        db.query("ROLLBACK", []);
+      } catch {
+      }
+      safeReportError({ stage: "send", error: firstError, value: void 0 });
+      for (const entry of chunk) {
+        safeEmitFailed({ value: entry.value, error: firstError, attempts: 1 });
+      }
+    } else {
+      try {
+        db.query("COMMIT", []);
+        for (const entry of chunk) safeEmitSent(entry.value);
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        safeReportError({ stage: "send", error, value: void 0 });
+        for (let i = 0; i < committedCount; i++) {
+          safeEmitFailed({ value: chunk[i].value, error, attempts: 1 });
+        }
+      }
+    }
+    flushing = false;
+    safeSetInFlight(0);
+  };
+  const scheduleFlush = () => {
+    if (flushIntervalMs > 0 && timer === void 0 && !disposed) {
+      timer = setTimeout(() => {
+        timer = void 0;
+        flushTransaction();
+      }, flushIntervalMs);
+    }
+  };
+  const unsub = source.subscribe((msgs) => {
+    for (const msg of msgs) {
+      const t = msg[0];
+      if (t === DATA3) {
+        const value = msg[1];
+        let query;
+        try {
+          query = serialize(value);
+        } catch (err) {
+          const error = err instanceof Error ? err : new Error(String(err));
+          reportError({ stage: "serialize", error, value });
+          failedNode.down([[DATA3, { value, error, attempts: 0 }]]);
+          continue;
+        }
+        pending.push({ value, query });
+        updateBuffered();
+        if (pending.length >= maxBatchSize) flushTransaction();
+        else scheduleFlush();
+      } else if (defaultConfig2.messageTier(t) >= 3) {
+        flushTransaction();
+      }
+    }
+  });
+  const dispose = () => {
+    if (disposed) return;
+    if (timer !== void 0) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+    flushTransaction();
+    disposed = true;
+    unsub();
+    for (const n of [errorsNode, sentNode, failedNode, inFlightNode, bufferedNode]) {
+      try {
+        n.down([[TEARDOWN2]]);
+      } catch {
+      }
+    }
+  };
+  return {
+    dispose,
+    sent: sentNode,
+    failed: failedNode,
+    inFlight: inFlightNode,
+    errors: errorsNode,
+    buffered: bufferedNode,
+    flush: async () => {
+      if (!disposed) flushTransaction();
+    }
+  };
+}
+
+// src/base/io/statsd.ts
+import { wallClockNs as wallClockNs9 } from "@graphrefly/pure-ts/core";
+function fromStatsD(register, opts) {
+  return externalProducer(register, opts);
+}
+var STATSD_TYPES = {
+  c: "counter",
+  g: "gauge",
+  ms: "timer",
+  h: "histogram",
+  s: "set",
+  d: "distribution"
+};
+function parseStatsD(line) {
+  const parts = line.split("|");
+  const [name, valueStr] = (parts[0] ?? "").split(":");
+  if (!name || valueStr === void 0) {
+    throw new Error(`Invalid StatsD line: ${line}`);
+  }
+  const typeCode = parts[1]?.trim() ?? "c";
+  const type = STATSD_TYPES[typeCode] ?? "counter";
+  const value = type === "set" ? 0 : Number(valueStr);
+  let sampleRate;
+  const tags = {};
+  for (let i = 2; i < parts.length; i++) {
+    const part = parts[i].trim();
+    if (part.startsWith("@")) {
+      sampleRate = Number(part.slice(1));
+    } else if (part.startsWith("#")) {
+      for (const tag of part.slice(1).split(",")) {
+        const [k, v] = tag.split(":");
+        if (k) tags[k] = v ?? "";
+      }
+    }
+  }
+  return { name: name.trim(), value, type, sampleRate, tags, timestampNs: wallClockNs9() };
+}
+
+// src/base/io/syslog.ts
+import { wallClockNs as wallClockNs10 } from "@graphrefly/pure-ts/core";
+function fromSyslog(register, opts) {
+  return externalProducer(register, opts);
+}
+function parseSyslog(raw) {
+  const match = raw.match(/^<(\d{1,3})>\d?\s*(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s*(.*)/s);
+  if (!match) {
+    const nowNs = wallClockNs10();
+    return {
+      facility: 1,
+      severity: 6,
+      timestamp: new Date(Math.floor(nowNs / 1e6)).toISOString(),
+      hostname: "-",
+      appName: "-",
+      procId: "-",
+      msgId: "-",
+      message: raw.trim(),
+      timestampNs: nowNs
+    };
+  }
+  const pri = Number(match[1]);
+  return {
+    facility: pri >> 3,
+    severity: pri & 7,
+    timestamp: match[2],
+    hostname: match[3],
+    appName: match[4],
+    procId: match[5],
+    msgId: match[6],
+    message: (match[7] ?? "").trim(),
+    timestampNs: wallClockNs10()
+  };
+}
+
+// src/base/io/to-clickhouse.ts
+function toClickHouse(source, client, table, opts) {
+  const {
+    batchSize = 1e3,
+    flushIntervalMs = 5e3,
+    format = "JSONEachRow",
+    transform = (v) => v,
+    onTransportError
+  } = opts ?? {};
+  return reactiveSink(source, {
+    onTransportError,
+    batchSize,
+    flushIntervalMs,
+    serialize: transform,
+    sendBatch: async (batch4) => {
+      await client.insert({ table, values: batch4, format });
+    }
+  });
+}
+
+// src/base/io/to-file.ts
+function toFile(source, writer, opts) {
+  const {
+    serialize = (v) => `${JSON.stringify(v)}
+`,
+    flushIntervalMs = 0,
+    batchSize = Number.POSITIVE_INFINITY,
+    onTransportError,
+    mode: _mode
+  } = opts ?? {};
+  const buffered = flushIntervalMs > 0 || batchSize < Number.POSITIVE_INFINITY;
+  const handle = buffered ? reactiveSink(source, {
+    onTransportError,
+    batchSize,
+    flushIntervalMs,
+    serialize,
+    sendBatch: (chunk) => {
+      writer.write(chunk.join(""));
+    }
+  }) : reactiveSink(source, {
+    onTransportError,
+    serialize,
+    send: (line) => {
+      writer.write(line);
+    }
+  });
+  const originalDispose = handle.dispose;
+  handle.dispose = () => {
+    originalDispose();
+    try {
+      writer.end();
+    } catch {
+    }
+  };
+  return handle;
+}
+
+// src/base/io/to-csv.ts
+function escapeCSVField(value, delimiter) {
+  if (value.includes(delimiter) || value.includes('"') || value.includes("\n")) {
+    return `"${value.replace(/"/g, '""')}"`;
+  }
+  return value;
+}
+function toCSV(source, writer, opts) {
+  const {
+    columns,
+    delimiter = ",",
+    writeHeader = true,
+    cellExtractor = (row, col) => String(row[col] ?? ""),
+    flushIntervalMs = 0,
+    batchSize = Number.POSITIVE_INFINITY,
+    onTransportError,
+    ...rest
+  } = opts;
+  let headerWritten = false;
+  const serializeRow = (row) => {
+    if (!headerWritten && writeHeader) {
+      headerWritten = true;
+      const header = columns.map((c) => escapeCSVField(c, delimiter)).join(delimiter);
+      const data = columns.map((c) => escapeCSVField(cellExtractor(row, c), delimiter)).join(delimiter);
+      return `${header}
+${data}
+`;
+    }
+    return `${columns.map((c) => escapeCSVField(cellExtractor(row, c), delimiter)).join(delimiter)}
+`;
+  };
+  return toFile(source, writer, {
+    serialize: serializeRow,
+    flushIntervalMs,
+    batchSize,
+    onTransportError,
+    ...rest
+  });
+}
+
+// src/base/io/to-loki.ts
+import { wallClockNs as wallClockNs11 } from "@graphrefly/pure-ts/core";
+function toLoki(source, client, opts) {
+  const {
+    labels = {},
+    toLine = (v) => JSON.stringify(v),
+    toLabels,
+    onTransportError
+  } = opts ?? {};
+  return reactiveSink(source, {
+    onTransportError,
+    serialize: (value) => ({
+      line: toLine(value),
+      labels: toLabels ? { ...labels, ...toLabels(value) } : labels
+    }),
+    send: async (payload) => {
+      const { line, labels: streamLabels } = payload;
+      const ts = `${wallClockNs11()}`;
+      await client.push({ streams: [{ stream: streamLabels, values: [[ts, line]] }] });
+    }
+  });
+}
+
+// src/base/io/to-mongo.ts
+function toMongo(source, collection, opts) {
+  const { toDocument = (v) => v, onTransportError } = opts ?? {};
+  return reactiveSink(source, {
+    onTransportError,
+    serialize: toDocument,
+    send: async (doc) => {
+      await collection.insertOne(doc);
+    }
+  });
+}
+
+// src/base/io/to-postgres.ts
+function toPostgres(source, client, table, opts) {
+  const {
+    toSQL = (v, t) => ({
+      sql: `INSERT INTO "${t.replace(/"/g, '""')}" (data) VALUES ($1)`,
+      params: [JSON.stringify(v)]
+    }),
+    onTransportError
+  } = opts ?? {};
+  return reactiveSink(source, {
+    onTransportError,
+    serialize: (value) => toSQL(value, table),
+    send: async (q) => {
+      const query = q;
+      await client.query(query.sql, query.params);
+    }
+  });
+}
+
+// src/base/io/to-s3.ts
+import { wallClockNs as wallClockNs12 } from "@graphrefly/pure-ts/core";
+function toS3(source, client, bucket, opts) {
+  const {
+    format = "ndjson",
+    keyGenerator = (seq2, timestampNs) => {
+      const ms = Math.floor(timestampNs / 1e6);
+      const ts = new Date(ms).toISOString().replace(/[:.]/g, "-");
+      return `data/${ts}-${seq2}.${format === "ndjson" ? "ndjson" : "json"}`;
+    },
+    batchSize = 1e3,
+    flushIntervalMs = 1e4,
+    transform = (v) => v,
+    onTransportError
+  } = opts ?? {};
+  const contentType = format === "ndjson" ? "application/x-ndjson" : "application/json";
+  let seq = 0;
+  return reactiveSink(source, {
+    onTransportError,
+    batchSize,
+    flushIntervalMs,
+    serialize: transform,
+    sendBatch: async (batch4) => {
+      seq += 1;
+      const body = format === "ndjson" ? `${batch4.map((v) => JSON.stringify(v)).join("\n")}
+` : JSON.stringify(batch4);
+      const key = keyGenerator(seq, wallClockNs12());
+      await client.putObject({ Bucket: bucket, Key: key, Body: body, ContentType: contentType });
+    }
+  });
+}
+
+// src/base/io/to-tempo.ts
+function toTempo(source, client, opts) {
+  const { toResourceSpans = (v) => [v], onTransportError } = opts ?? {};
+  return reactiveSink(source, {
+    onTransportError,
+    serialize: toResourceSpans,
+    send: async (spans) => {
+      await client.push({ resourceSpans: spans });
+    }
+  });
+}
+
+// src/base/io/webhook.ts
+function fromWebhook(register, opts) {
+  return externalProducer(register, opts);
+}
+
+// src/base/io/websocket.ts
+import { COMPLETE as COMPLETE12, ERROR as ERROR16, node as node16 } from "@graphrefly/pure-ts/core";
+function fromWebSocket(socketOrRegister, opts) {
+  const { parse, closeOnTeardown = false, ...rest } = opts ?? {};
+  return node16(
+    [],
+    (_data, a) => {
+      let active = true;
+      let cleanup;
+      const runCleanup = () => {
+        const fn = cleanup;
+        cleanup = void 0;
+        fn?.();
+      };
+      const terminate = (message) => {
+        if (!active) return;
+        active = false;
+        a.down([message]);
+        runCleanup();
+      };
+      const emit = (raw, event = raw) => {
+        if (!active) return;
+        try {
+          const payload = raw !== null && typeof raw === "object" && "data" in raw ? raw.data : raw;
+          const parsed = parse ? parse(payload, event) : payload;
+          a.emit(parsed);
+        } catch (err) {
+          terminate([ERROR16, err]);
+        }
+      };
+      const error = (err) => {
+        terminate([ERROR16, err]);
+      };
+      const complete = () => {
+        terminate([COMPLETE12]);
+      };
+      if (typeof socketOrRegister === "function") {
+        try {
+          cleanup = socketOrRegister(emit, error, complete);
+          if (typeof cleanup !== "function") {
+            throw new Error(
+              "fromWebSocket register contract violation: register must return cleanup callable"
+            );
+          }
+        } catch (err) {
+          terminate([ERROR16, err]);
+        }
+        return () => {
+          active = false;
+          runCleanup();
+        };
+      }
+      const ws = socketOrRegister;
+      const onMessage = (event) => emit(event, event);
+      const onError = (event) => error(event);
+      const onClose = () => complete();
+      ws.addEventListener("message", onMessage);
+      ws.addEventListener("error", onError);
+      ws.addEventListener("close", onClose);
+      cleanup = () => {
+        ws.removeEventListener("message", onMessage);
+        ws.removeEventListener("error", onError);
+        ws.removeEventListener("close", onClose);
+        if (closeOnTeardown) ws.close();
+      };
+      return () => {
+        active = false;
+        runCleanup();
+      };
+    },
+    sourceOpts(rest)
+  );
+}
+function toWebSocket(source, socket, opts) {
+  const {
+    serialize = (value) => {
+      if (typeof value === "string" || value instanceof Blob || value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
+        return value;
+      }
+      try {
+        return JSON.stringify(value);
+      } catch {
+        return String(value);
+      }
+    },
+    closeOnComplete = true,
+    closeOnError = true,
+    closeCode,
+    closeReason,
+    onTransportError,
+    retry: retryOpt,
+    backpressure,
+    stopOn
+  } = opts ?? {};
+  let socketClosed = false;
+  const closeSocket = (trigger) => {
+    if (socketClosed) return;
+    socketClosed = true;
+    try {
+      socket.close(closeCode, closeReason);
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      try {
+        onTransportError?.({ stage: "close", error, value: void 0, message: trigger });
+      } catch {
+      }
+    }
+  };
+  let externalCloseHandler = null;
+  const removeExternalCloseHandler = () => {
+    if (externalCloseHandler) {
+      try {
+        socket.removeEventListener("close", externalCloseHandler);
+      } catch {
+      }
+      externalCloseHandler = null;
+    }
+  };
+  const handle = reactiveSink(source, {
+    onTransportError,
+    serialize: (value) => {
+      const s = serialize(value);
+      if (s === void 0) {
+        throw new Error("serialize returned undefined");
+      }
+      return s;
+    },
+    retry: retryOpt,
+    backpressure,
+    stopOn,
+    onDispose: removeExternalCloseHandler,
+    send: (payload) => {
+      socket.send(payload);
+    },
+    onUpstreamMessage: (msg) => {
+      if (msg[0] === COMPLETE12 && closeOnComplete) closeSocket(msg);
+      else if (msg[0] === ERROR16 && closeOnError) closeSocket(msg);
+    }
+  });
+  externalCloseHandler = () => {
+    socketClosed = true;
+    handle.dispose();
+  };
+  socket.addEventListener("close", externalCloseHandler);
+  return handle;
+}
+function fromWebSocketReconnect(factory, opts) {
+  const {
+    parse,
+    maxRetries,
+    backoff = "exponential",
+    closeOnTeardown = true,
+    ...rest
+  } = opts ?? {};
+  return retry(
+    () => fromWebSocket(factory(), {
+      parse,
+      closeOnTeardown,
+      ...rest
+    }),
+    { count: maxRetries, backoff }
+  ).node;
+}
+
+export {
+  checkpointToS3,
+  checkpointToRedis,
+  fromClickHouseWatch,
+  fromCSV,
+  csvRows,
+  fromDrizzle,
+  fromHTTP,
+  toHTTP,
+  fromHTTPStream,
+  fromHTTPPoll,
+  fromKafka,
+  toKafka,
+  fromKysely,
+  fromMCP,
+  fromNATS,
+  toNATS,
+  ndjsonRows,
+  fromNDJSON,
+  fromOTel,
+  fromPrisma,
+  fromPrometheus,
+  parsePrometheusText,
+  fromPulsar,
+  toPulsar,
+  fromRabbitMQ,
+  toRabbitMQ,
+  fromRedisStream,
+  toRedisStream,
+  fromSqlite,
+  fromSqliteCursor,
+  toSqlite,
+  fromStatsD,
+  parseStatsD,
+  fromSyslog,
+  parseSyslog,
+  toClickHouse,
+  toFile,
+  toCSV,
+  toLoki,
+  toMongo,
+  toPostgres,
+  toS3,
+  toTempo,
+  fromWebhook,
+  fromWebSocket,
+  toWebSocket,
+  fromWebSocketReconnect
+};
+//# sourceMappingURL=chunk-OCUDSN63.js.map