@graphrefly/graphrefly 0.45.0 → 0.46.0

package/dist/base/io/index.cjs

@@ -0,0 +1,3270 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/base/io/index.ts
+var io_exports = {};
+__export(io_exports, {
+  checkpointToRedis: () => checkpointToRedis,
+  checkpointToS3: () => checkpointToS3,
+  csvRows: () => csvRows,
+  fromCSV: () => fromCSV,
+  fromClickHouseWatch: () => fromClickHouseWatch,
+  fromDrizzle: () => fromDrizzle,
+  fromHTTP: () => fromHTTP,
+  fromHTTPPoll: () => fromHTTPPoll,
+  fromHTTPStream: () => fromHTTPStream,
+  fromKafka: () => fromKafka,
+  fromKysely: () => fromKysely,
+  fromMCP: () => fromMCP,
+  fromNATS: () => fromNATS,
+  fromNDJSON: () => fromNDJSON,
+  fromOTel: () => fromOTel,
+  fromPrisma: () => fromPrisma,
+  fromPrometheus: () => fromPrometheus,
+  fromPulsar: () => fromPulsar,
+  fromRabbitMQ: () => fromRabbitMQ,
+  fromRedisStream: () => fromRedisStream,
+  fromSSE: () => fromSSE,
+  fromSqlite: () => fromSqlite,
+  fromSqliteCursor: () => fromSqliteCursor,
+  fromStatsD: () => fromStatsD,
+  fromSyslog: () => fromSyslog,
+  fromWebSocket: () => fromWebSocket,
+  fromWebSocketReconnect: () => fromWebSocketReconnect,
+  fromWebhook: () => fromWebhook,
+  ndjsonRows: () => ndjsonRows,
+  parsePrometheusText: () => parsePrometheusText,
+  parseSSEStream: () => parseSSEStream,
+  parseStatsD: () => parseStatsD,
+  parseSyslog: () => parseSyslog,
+  toCSV: () => toCSV,
+  toClickHouse: () => toClickHouse,
+  toFile: () => toFile,
+  toHTTP: () => toHTTP,
+  toKafka: () => toKafka,
+  toLoki: () => toLoki,
+  toMongo: () => toMongo,
+  toNATS: () => toNATS,
+  toPostgres: () => toPostgres,
+  toPulsar: () => toPulsar,
+  toRabbitMQ: () => toRabbitMQ,
+  toReadableStream: () => toReadableStream,
+  toRedisStream: () => toRedisStream,
+  toS3: () => toS3,
+  toSSE: () => toSSE,
+  toSSEBytes: () => toSSEBytes,
+  toSqlite: () => toSqlite,
+  toTempo: () => toTempo,
+  toWebSocket: () => toWebSocket
+});
+module.exports = __toCommonJS(io_exports);
+
+// src/base/io/checkpoint.ts
+var import_core = require("@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((0, import_core.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
+var import_core2 = require("@graphrefly/pure-ts/core");
+var import_extra = require("@graphrefly/pure-ts/extra");
+
+// src/base/resilience/backoff.ts
+var NS_PER_MS = 1e6;
+var NS_PER_SEC = 1e9;
+function clampNonNegative(value) {
+  return value < 0 ? 0 : value;
+}
+function applyJitter(delay, jitter) {
+  if (jitter === "none") return delay;
+  if (jitter === "full") return Math.random() * delay;
+  return delay / 2 + Math.random() * (delay / 2);
+}
+function randomBetween(min, max) {
+  return min + Math.random() * (max - min);
+}
+function constant(delayNs) {
+  const safe = clampNonNegative(delayNs);
+  return () => safe;
+}
+function linear(baseNs, stepNs) {
+  const safeBase = clampNonNegative(baseNs);
+  const safeStep = stepNs === void 0 ? safeBase : clampNonNegative(stepNs);
+  return (attempt) => safeBase + safeStep * Math.max(0, attempt);
+}
+function exponential(options) {
+  const baseNs = clampNonNegative(options?.baseNs ?? 100 * NS_PER_MS);
+  const factor = options?.factor !== void 0 && options.factor < 1 ? 1 : options?.factor ?? 2;
+  const maxDelayNs = clampNonNegative(options?.maxDelayNs ?? 30 * NS_PER_SEC);
+  const jitter = options?.jitter ?? "none";
+  return (attempt) => {
+    let delay;
+    if (baseNs === 0) {
+      delay = 0;
+    } else if (factor === 1) {
+      delay = baseNs;
+    } else {
+      const capRatio = maxDelayNs / baseNs;
+      let growth = 1;
+      for (let i = 0; i < Math.max(0, attempt); i++) {
+        if (growth >= capRatio) {
+          growth = capRatio;
+          break;
+        }
+        growth *= factor;
+      }
+      delay = baseNs * growth;
+      if (delay > maxDelayNs) delay = maxDelayNs;
+    }
+    return applyJitter(delay, jitter);
+  };
+}
+function fibonacci(baseNs = 100 * NS_PER_MS, maxDelayNs = 30 * NS_PER_SEC) {
+  const safeBase = clampNonNegative(baseNs);
+  const safeMax = clampNonNegative(maxDelayNs);
+  function fibUnit(attempt) {
+    if (attempt <= 0) return 1;
+    let prev = 1;
+    let cur = 2;
+    for (let i = 1; i < attempt; i++) {
+      const next = prev + cur;
+      prev = cur;
+      cur = next;
+    }
+    return cur;
+  }
+  return (attempt) => {
+    const raw = fibUnit(attempt) * safeBase;
+    return raw <= safeMax ? raw : safeMax;
+  };
+}
+function decorrelatedJitter(baseNs = 100 * NS_PER_MS, maxNs = 30 * NS_PER_SEC) {
+  return (_attempt, _error, prevDelayNs) => {
+    const last = prevDelayNs ?? baseNs;
+    const ceiling = Math.min(maxNs, last * 3);
+    return randomBetween(baseNs, ceiling);
+  };
+}
+function resolveBackoffPreset(name) {
+  if (name === "constant") return constant(1 * NS_PER_SEC);
+  if (name === "linear") return linear(1 * NS_PER_SEC);
+  if (name === "exponential") return exponential();
+  if (name === "fibonacci") return fibonacci();
+  if (name === "decorrelatedJitter") return decorrelatedJitter();
+  throw new Error(
+    `Unknown backoff preset: "${String(name)}". Use one of: constant, linear, exponential, fibonacci, decorrelatedJitter`
+  );
+}
+
+// src/base/io/clickhouse-watch.ts
+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 (0, import_extra.switchMap)(
+    (0, import_extra.fromTimer)(0, { period: intervalMs, signal: externalSignal }),
+    () => (0, import_core2.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([[import_core2.COMPLETE]]);
+        } catch (err) {
+          if (!active) return;
+          consecutiveErrors += 1;
+          if (consecutiveErrors >= maxConsecutiveErrors) {
+            a.down([[import_core2.ERROR, err]]);
+          }
+        }
+      };
+      void run();
+      return () => {
+        active = false;
+      };
+    })
+  );
+}
+
+// src/base/io/csv.ts
+var import_core3 = require("@graphrefly/pure-ts/core");
+
+// src/base/io/_internal.ts
+function sourceOpts(opts) {
+  return { describeKind: "producer", ...opts };
+}
+
+// src/base/io/csv.ts
+function fromCSV(source, opts) {
+  const {
+    delimiter = ",",
+    hasHeader = true,
+    columns: explicitColumns,
+    parseLine,
+    ...rest
+  } = opts ?? {};
+  const parse = parseLine ?? ((line) => parseCSVLine(line, delimiter));
+  return (0, import_core3.node)(
+    [],
+    (_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([[import_core3.COMPLETE]]);
+        } catch (err) {
+          if (!cancelled) a.down([[import_core3.ERROR, 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 (0, import_core3.node)(
+    [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
+var import_core4 = require("@graphrefly/pure-ts/core");
+function fromDrizzle(query, opts) {
+  const { mapRow = (r) => r, ...rest } = opts ?? {};
+  return (0, import_core4.node)(
+    [],
+    (_data, a) => {
+      let active = true;
+      void query.execute().then((rows) => {
+        if (!active) return;
+        a.emit(rows.map(mapRow));
+        a.down([[import_core4.COMPLETE]]);
+      }).catch((err) => {
+        if (!active) return;
+        try {
+          a.down([[import_core4.ERROR, err instanceof Error ? err : new Error(String(err))]]);
+        } catch {
+        }
+      });
+      return () => {
+        active = false;
+      };
+    },
+    { ...rest, describeKind: "producer", completeWhenDepsComplete: false }
+  );
+}
+
+// src/base/io/http.ts
+var import_core8 = require("@graphrefly/pure-ts/core");
+var import_extra2 = require("@graphrefly/pure-ts/extra");
+
+// src/base/resilience/status.ts
+var import_core6 = require("@graphrefly/pure-ts/core");
+
+// src/base/resilience/_internal.ts
+var import_core5 = require("@graphrefly/pure-ts/core");
+function operatorOpts(opts) {
+  return { describeKind: "derived", ...opts };
+}
+function msgVal(m) {
+  return m[1];
+}
+function coerceDelayNs(raw) {
+  if (typeof raw !== "number" || !Number.isFinite(raw)) {
+    throw new TypeError("backoff strategy must return a finite number");
+  }
+  return raw < 0 ? 0 : raw;
+}
+function isNode(x) {
+  return x != null && typeof x === "object" && "cache" in x && typeof x.subscribe === "function";
+}
+
+// src/base/resilience/status.ts
+function withStatus(src, options) {
+  const initialStatus = options?.initialStatus ?? "pending";
+  const callerMeta = options?.meta;
+  const out = (0, import_core6.node)(
+    [],
+    (_deps, a) => {
+      let currentStatus = initialStatus;
+      out.meta.status.down([[import_core6.DATA, initialStatus]]);
+      out.meta.error.down([[import_core6.DATA, null]]);
+      const unsub = src.subscribe((msgs) => {
+        for (const m of msgs) {
+          const t = m[0];
+          if (t === import_core6.DIRTY) a.down([[import_core6.DIRTY]]);
+          else if (t === import_core6.DATA) {
+            if (currentStatus === "errored") {
+              (0, import_core6.batch)(() => {
+                out.meta.error.down([[import_core6.DATA, null]]);
+                out.meta.status.down([[import_core6.DATA, "running"]]);
+                a.emit(m[1]);
+              });
+              currentStatus = "running";
+            } else if (currentStatus !== "running") {
+              (0, import_core6.batch)(() => {
+                out.meta.status.down([[import_core6.DATA, "running"]]);
+                a.emit(m[1]);
+              });
+              currentStatus = "running";
+            } else {
+              a.emit(m[1]);
+            }
+          } else if (t === import_core6.RESOLVED) a.down([[import_core6.RESOLVED]]);
+          else if (t === import_core6.COMPLETE) {
+            out.meta.status.down([[import_core6.DATA, "completed"]]);
+            currentStatus = "completed";
+            a.down([[import_core6.COMPLETE]]);
+          } else if (t === import_core6.ERROR) {
+            const err = msgVal(m);
+            (0, import_core6.batch)(() => {
+              out.meta.error.down([[import_core6.DATA, err]]);
+              out.meta.status.down([[import_core6.DATA, "errored"]]);
+            });
+            currentStatus = "errored";
+            a.down([m]);
+          } else a.down([m]);
+        }
+      });
+      return unsub;
+    },
+    {
+      ...operatorOpts(),
+      meta: {
+        ...callerMeta ?? {},
+        status: initialStatus,
+        error: null,
+        ...(0, import_core6.factoryTag)("withStatus", { initialStatus })
+      },
+      completeWhenDepsComplete: false,
+      resubscribable: true,
+      initial: src.cache
+    }
+  );
+  return {
+    node: out,
+    status: out.meta.status,
+    error: out.meta.error
+  };
+}
+
+// src/base/io/_sink.ts
+var import_core7 = require("@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 import_core7.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 = (0, import_core7.node)([], {
+    initial: void 0,
+    equals: () => false,
+    name: nameFor("sent")
+  });
+  const failed = (0, import_core7.node)([], { initial: null, name: nameFor("failed") });
+  const inFlightCountNode = (0, import_core7.node)([], { initial: 0, name: nameFor("inFlight") });
+  const errorsNode = (0, import_core7.node)([], {
+    initial: null,
+    name: nameFor("errors")
+  });
+  const bufferedNode = useBuffering ? (0, import_core7.node)([], { initial: 0, name: nameFor("buffered") }) : void 0;
+  const pausedNode = backpressure ? (0, import_core7.node)([], { initial: false, name: nameFor("paused") }) : void 0;
+  let inFlightCount = 0;
+  const bumpInFlight = (delta) => {
+    inFlightCount += delta;
+    inFlightCountNode.down([[import_core7.DATA, inFlightCount]]);
+  };
+  const reportError = (err) => {
+    try {
+      onTransportError?.(err);
+    } catch {
+    }
+    try {
+      errorsNode.down([[import_core7.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([[import_core7.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([[import_core7.DATA, { value, error, attempts: attempt }]]);
+        return void 0;
+      }
+      return scheduleRetry(run, attempt, error);
+    };
+    const onSuccess = () => {
+      bumpInFlight(-1);
+      sent.down([[import_core7.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([[import_core7.DATA, buffer.length]]);
+  };
+  const markPaused = (paused) => {
+    if (!pausedNode) return;
+    pausedNode.down([[import_core7.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([
+        [
+          import_core7.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([
+        [
+          import_core7.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([[import_core7.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([[import_core7.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([[import_core7.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([[import_core7.DATA, { value, error, attempts: attempt }]]);
+        return void 0;
+      }
+      return scheduleRetry(run, attempt, error);
+    };
+    const onSuccess = () => {
+      bumpInFlight(-1);
+      sent.down([[import_core7.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 !== import_core7.DATA) {
+        try {
+          onUpstreamMessage?.(msg);
+        } catch {
+        }
+      }
+      if (type === import_core7.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([[import_core7.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 (import_core7.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([[import_core7.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 import_core7.COMPLETE;
+  void import_core7.ERROR;
+  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 = (0, import_core8.node)([], { initial: 0, name: `${rest.name ?? "http"}/fetchCount` });
+  const lastUpdated = (0, import_core8.node)([], { initial: 0, name: `${rest.name ?? "http"}/lastUpdated` });
+  const fetched = (0, import_core8.node)([], { 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([[import_core8.ERROR, externalSignal.reason ?? new Error("Aborted")]]);
+      return () => {
+      };
+    }
+    externalSignal?.addEventListener("abort", () => abort.abort(externalSignal.reason), {
+      once: true
+    });
+    const timeoutId = setTimeout(
+      () => abort.abort(new Error("Request timeout")),
+      Math.ceil(timeoutNs / NS_PER_MS)
+    );
+    fetch(url, { method, headers, body, signal: abort.signal }).then(async (res) => {
+      clearTimeout(timeoutId);
+      if (!active) return;
+      if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+      const data = await transform(res);
+      if (!active) return;
+      (0, import_core8.batch)(() => {
+        fetchCountLocal += 1;
+        fetchCount.down([[import_core8.DATA, fetchCountLocal]]);
+        lastUpdated.down([[import_core8.DATA, (0, import_core8.wallClockNs)()]]);
+        fetched.down([[import_core8.DATA, true]]);
+        a.emit(data);
+      });
+      if (completeAfterFetch) a.down([[import_core8.COMPLETE]]);
+    }).catch((err) => {
+      clearTimeout(timeoutId);
+      if (!active) return;
+      if (err && err.name === "AbortError") return;
+      a.down([[import_core8.ERROR, err]]);
+    });
+    return () => {
+      active = false;
+      abort.abort();
+    };
+  };
+  const sourceNode = (0, import_core8.node)(
+    [],
+    (_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 (0, import_core8.node)(
+    [],
+    (_data, a) => {
+      let active = true;
+      const abort = new AbortController();
+      if (externalSignal?.aborted) {
+        a.down([[import_core8.ERROR, externalSignal.reason ?? new Error("Aborted")]]);
+        return () => {
+        };
+      }
+      externalSignal?.addEventListener("abort", () => abort.abort(externalSignal.reason), {
+        once: true
+      });
+      const body = bodyOpt !== void 0 ? typeof bodyOpt === "string" ? bodyOpt : JSON.stringify(bodyOpt) : void 0;
+      const run = async () => {
+        try {
+          const res = await fetch(url, { method, headers, body, signal: abort.signal });
+          if (!active) return;
+          if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+          if (!res.body) throw new Error("HTTP response has no body");
+          const reader = res.body.getReader();
+          while (active) {
+            const { value, done } = await reader.read();
+            if (done) break;
+            if (value) a.emit(value);
+          }
+          if (active) a.down([[import_core8.COMPLETE]]);
+        } catch (err) {
+          if (!active) return;
+          if (err && err.name === "AbortError") return;
+          a.down([[import_core8.ERROR, err]]);
+        }
+      };
+      void run();
+      return () => {
+        active = false;
+        abort.abort();
+      };
+    },
+    sourceOpts(rest)
+  );
+}
+function fromHTTPPoll(url, opts) {
+  const { intervalMs = 5e3, ...httpOpts } = opts ?? {};
+  return (0, import_extra2.switchMap)(
+    (0, import_extra2.fromTimer)(intervalMs, { period: intervalMs }),
+    () => fromHTTP(url, { ...httpOpts, completeAfterFetch: true }).node
+  );
+}
+
+// src/base/io/kafka.ts
+var import_core9 = require("@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 (0, import_core9.node)(
+    [],
+    (_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: (0, import_core9.wallClockNs)()
+              });
+            }
+          });
+        } catch (err) {
+          if (active) a.down([[import_core9.ERROR, 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
+var import_core10 = require("@graphrefly/pure-ts/core");
+function fromKysely(query, opts) {
+  const { mapRow = (r) => r, ...rest } = opts ?? {};
+  return (0, import_core10.node)(
+    [],
+    (_data, a) => {
+      let active = true;
+      void query.execute().then((rows) => {
+        if (!active) return;
+        a.emit(rows.map(mapRow));
+        a.down([[import_core10.COMPLETE]]);
+      }).catch((err) => {
+        if (!active) return;
+        try {
+          a.down([[import_core10.ERROR, err instanceof Error ? err : new Error(String(err))]]);
+        } catch {
+        }
+      });
+      return () => {
+        active = false;
+      };
+    },
+    { ...rest, describeKind: "producer", completeWhenDepsComplete: false }
+  );
+}
+
+// src/base/composition/external-register.ts
+var import_core11 = require("@graphrefly/pure-ts/core");
+function sourceOpts2(opts) {
+  return { describeKind: "producer", ...opts };
+}
+function externalProducer(register, opts) {
+  return (0, import_core11.node)((_data, a) => {
+    let active = true;
+    const triad = {
+      emit(value) {
+        if (!active) return;
+        a.emit(value);
+      },
+      error(err) {
+        if (!active) return;
+        active = false;
+        a.down([[import_core11.ERROR, err]]);
+      },
+      complete() {
+        if (!active) return;
+        active = false;
+        a.down([[import_core11.COMPLETE]]);
+      }
+    };
+    let cleanup;
+    try {
+      const ret = register(triad);
+      cleanup = typeof ret === "function" ? ret : void 0;
+    } catch (err) {
+      triad.error(err);
+      return () => {
+        active = false;
+      };
+    }
+    return () => {
+      active = false;
+      try {
+        cleanup?.();
+      } catch {
+      }
+    };
+  }, sourceOpts2(opts));
+}
+function externalBundle(register, channels, opts) {
+  let active = true;
+  let cleanup;
+  let activatedCount = 0;
+  let teardownCount = 0;
+  const nodes = {};
+  const channelNodes = [];
+  const finishCleanup = () => {
+    const fn = cleanup;
+    cleanup = void 0;
+    try {
+      fn?.();
+    } catch {
+    }
+  };
+  for (const ch of channels) {
+    const name = opts?.name ? `${opts.name}::${ch}` : ch;
+    const chOpts = opts?.channelOpts?.[ch];
+    const n = (0, import_core11.node)(
+      (_data, _a) => {
+        activatedCount++;
+        return () => {
+          teardownCount++;
+          if (activatedCount > 0 && teardownCount >= activatedCount && teardownCount >= channels.length) {
+            finishCleanup();
+          }
+        };
+      },
+      sourceOpts2({ ...chOpts, name })
+    );
+    nodes[ch] = n;
+    channelNodes.push(n);
+  }
+  const bundle = {};
+  for (const ch of channels) {
+    bundle[ch] = (value) => {
+      if (!active) return;
+      nodes[ch].down([[import_core11.DATA, value]]);
+    };
+  }
+  bundle.error = (err) => {
+    if (!active) return;
+    active = false;
+    (0, import_core11.batch)(() => {
+      for (const n of channelNodes) n.down([[import_core11.ERROR, err]]);
+    });
+    finishCleanup();
+  };
+  bundle.complete = () => {
+    if (!active) return;
+    active = false;
+    (0, import_core11.batch)(() => {
+      for (const n of channelNodes) n.down([[import_core11.COMPLETE]]);
+    });
+    finishCleanup();
+  };
+  const ret = register(bundle);
+  cleanup = typeof ret === "function" ? ret : void 0;
+  const dispose = () => {
+    if (!active) return;
+    active = false;
+    (0, import_core11.batch)(() => {
+      for (const n of channelNodes) {
+        try {
+          n.down([[import_core11.COMPLETE]]);
+        } catch {
+        }
+      }
+    });
+    finishCleanup();
+  };
+  return Object.assign(nodes, { dispose });
+}
+
+// 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
+var import_core12 = require("@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 (0, import_core12.node)(
+    [],
+    (_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: (0, import_core12.wallClockNs)()
+            });
+          }
+          if (active) a.down([[import_core12.COMPLETE]]);
+        } catch (err) {
+          if (active) a.down([[import_core12.ERROR, 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
+var import_core13 = require("@graphrefly/pure-ts/core");
+function ndjsonRows(source, opts) {
+  let cleanup;
+  return (0, import_core13.node)(
+    [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([[import_core13.ERROR, err]]);
+            return cleanup;
+          }
+        }
+      }
+      return cleanup;
+    },
+    { describeKind: "derived", ...opts ?? {} }
+  );
+}
+function fromNDJSON(source, opts) {
+  return (0, import_core13.node)(
+    [],
+    (_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([[import_core13.COMPLETE]]);
+        } catch (err) {
+          if (!cancelled) a.down([[import_core13.ERROR, err]]);
+        }
+      };
+      void run();
+      return () => {
+        cancelled = true;
+      };
+    },
+    sourceOpts(opts)
+  );
+}
+
+// src/base/io/otel.ts
+var import_core14 = require("@graphrefly/pure-ts/core");
+function fromOTel(register, opts) {
+  const nodes = externalBundle(
+    ({ traces, metrics, logs, error }) => {
+      return register({
+        onTraces: (spans) => {
+          (0, import_core14.batch)(() => {
+            for (const s of spans) traces(s);
+          });
+        },
+        onMetrics: (ms) => {
+          (0, import_core14.batch)(() => {
+            for (const m of ms) metrics(m);
+          });
+        },
+        onLogs: (ls) => {
+          (0, import_core14.batch)(() => {
+            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
+var import_core15 = require("@graphrefly/pure-ts/core");
+function fromPrisma(model, opts) {
+  const { args, mapRow = (r) => r, ...rest } = opts ?? {};
+  return (0, import_core15.node)(
+    [],
+    (_data, a) => {
+      let active = true;
+      void model.findMany(args).then((rows) => {
+        if (!active) return;
+        a.emit(rows.map(mapRow));
+        a.down([[import_core15.COMPLETE]]);
+      }).catch((err) => {
+        if (!active) return;
+        try {
+          a.down([[import_core15.ERROR, err instanceof Error ? err : new Error(String(err))]]);
+        } catch {
+        }
+      });
+      return () => {
+        active = false;
+      };
+    },
+    { ...rest, describeKind: "producer", completeWhenDepsComplete: false }
+  );
+}
+
+// src/base/io/prometheus.ts
+var import_core16 = require("@graphrefly/pure-ts/core");
+var import_extra3 = require("@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 (0, import_extra3.switchMap)(
+    (0, import_extra3.fromTimer)(0, { period: intervalMs, signal: externalSignal }),
+    () => (0, import_core16.node)([], (_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([[import_core16.COMPLETE]]);
+        } catch (err) {
+          clearTimeout(timeoutId);
+          if (!active) return;
+          if (err instanceof Error && err.name === "AbortError") return;
+          consecutiveErrors += 1;
+          if (consecutiveErrors >= maxConsecutiveErrors) {
+            a.down([[import_core16.ERROR, err]]);
+          }
+        }
+      };
+      void run();
+      return () => {
+        active = false;
+        clearTimeout(timeoutId);
+        abort.abort();
+      };
+    })
+  );
+}
+function parsePrometheusText(text) {
+  const results = [];
+  const types = /* @__PURE__ */ new Map();
+  const helps = /* @__PURE__ */ new Map();
+  for (const rawLine of text.split("\n")) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    if (line.startsWith("# TYPE ")) {
+      const rest = line.slice(7);
+      const spaceIdx = rest.indexOf(" ");
+      if (spaceIdx > 0) {
+        types.set(rest.slice(0, spaceIdx), rest.slice(spaceIdx + 1).trim());
+      }
+      continue;
+    }
+    if (line.startsWith("# HELP ")) {
+      const rest = line.slice(7);
+      const spaceIdx = rest.indexOf(" ");
+      if (spaceIdx > 0) {
+        helps.set(rest.slice(0, spaceIdx), rest.slice(spaceIdx + 1).trim());
+      }
+      continue;
+    }
+    if (line.startsWith("#")) continue;
+    let name;
+    let labels = {};
+    let valueStr;
+    let tsStr;
+    const braceIdx = line.indexOf("{");
+    if (braceIdx >= 0) {
+      name = line.slice(0, braceIdx);
+      const closeBrace = line.indexOf("}", braceIdx);
+      if (closeBrace < 0) continue;
+      const labelStr = line.slice(braceIdx + 1, closeBrace);
+      labels = parsePrometheusLabels(labelStr);
+      const after = line.slice(closeBrace + 1).trim().split(/\s+/);
+      valueStr = after[0] ?? "";
+      tsStr = after[1];
+    } else {
+      const parts = line.split(/\s+/);
+      name = parts[0] ?? "";
+      valueStr = parts[1] ?? "";
+      tsStr = parts[2];
+    }
+    if (!name || !valueStr) continue;
+    const baseName = name.replace(/(_total|_count|_sum|_bucket|_created|_info)$/, "");
+    results.push({
+      name,
+      labels,
+      value: Number(valueStr),
+      timestampMs: tsStr ? Number(tsStr) : void 0,
+      type: types.get(baseName) ?? types.get(name),
+      help: helps.get(baseName) ?? helps.get(name),
+      timestampNs: (0, import_core16.wallClockNs)()
+    });
+  }
+  return results;
+}
+function parsePrometheusLabels(str) {
+  const labels = {};
+  const re = /(\w+)="((?:[^"\\]|\\.)*)"/g;
+  let m = re.exec(str);
+  while (m !== null) {
+    labels[m[1]] = m[2].replace(/\\(.)/g, "$1");
+    m = re.exec(str);
+  }
+  return labels;
+}
+
+// src/base/io/pulsar.ts
+var import_core17 = require("@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 (0, import_core17.node)(
+    [],
+    (_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: (0, import_core17.wallClockNs)()
+            };
+            if (autoAck) {
+              a.emit(structured);
+              void consumer.acknowledge(rawMsg).catch(reportAckError);
+            } else {
+              let settled = false;
+              const envelope = {
+                value: structured,
+                ack() {
+                  if (settled) return;
+                  settled = true;
+                  void consumer.acknowledge(rawMsg).catch(reportAckError);
+                },
+                nack(_opts) {
+                  if (settled) return;
+                  settled = true;
+                  const anyConsumer = consumer;
+                  try {
+                    const result = anyConsumer.negativeAcknowledge?.(rawMsg);
+                    if (result && typeof result.then === "function") {
+                      void result.catch(reportAckError);
+                    }
+                  } catch (err) {
+                    reportAckError(err);
+                  }
+                }
+              };
+              a.emit(envelope);
+            }
+          } catch (err) {
+            if (active) a.down([[import_core17.ERROR, 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
+var import_core18 = require("@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 (0, import_core18.node)(
+    [],
+    (_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([[import_core18.ERROR, new Error("Consumer cancelled by broker")]]);
+                return;
+              }
+              const structured = {
+                queue,
+                routingKey: rawMsg.fields.routingKey,
+                exchange: rawMsg.fields.exchange,
+                content: deserialize(rawMsg.content),
+                properties: rawMsg.properties,
+                deliveryTag: rawMsg.fields.deliveryTag,
+                redelivered: rawMsg.fields.redelivered,
+                timestampNs: (0, import_core18.wallClockNs)()
+              };
+              if (autoAck) {
+                a.emit(structured);
+                try {
+                  channel.ack(rawMsg);
+                } catch (err) {
+                  reportAckError(err);
+                }
+              } else {
+                let settled = false;
+                const channelWithNack = channel;
+                const envelope = {
+                  value: structured,
+                  ack() {
+                    if (settled) return;
+                    settled = true;
+                    try {
+                      channel.ack(rawMsg);
+                    } catch (err) {
+                      reportAckError(err);
+                    }
+                  },
+                  nack(nackOpts) {
+                    if (settled) return;
+                    settled = true;
+                    const requeue = nackOpts?.requeue;
+                    if (!channelWithNack.nack) {
+                      reportAckError(
+                        new Error("RabbitMQ channel does not expose `nack`; cannot negative-ack")
+                      );
+                      return;
+                    }
+                    try {
+                      channelWithNack.nack(rawMsg, false, requeue);
+                    } catch (err) {
+                      reportAckError(err);
+                    }
+                  }
+                };
+                a.emit(envelope);
+              }
+            },
+            { noAck: false }
+          );
+          consumerTag = result.consumerTag;
+        } catch (err) {
+          if (active) a.down([[import_core18.ERROR, 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
+var import_core19 = require("@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 (0, import_core19.node)(
+    [],
+    (_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: (0, import_core19.wallClockNs)()
+                  });
+                }
+              }
+            }
+          } catch (err) {
+            if (!active) return;
+            a.down([[import_core19.ERROR, err]]);
+            return;
+          }
+        }
+      };
+      void poll();
+      return () => {
+        active = false;
+      };
+    },
+    sourceOpts(rest)
+  );
+}
+function toRedisStream(source, client, key, opts) {
+  const {
+    serialize = (v) => ["data", JSON.stringify(v)],
+    maxLen,
+    onTransportError
+  } = 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
+var import_core20 = require("@graphrefly/pure-ts/core");
+function fromSqlite(db, query, opts) {
+  const { mapRow = (r) => r, params, ...rest } = opts ?? {};
+  return (0, import_core20.node)(
+    [],
+    (_data, a) => {
+      try {
+        const rows = db.query(query, params);
+        const mapped = rows.map(mapRow);
+        a.emit(mapped);
+        a.down([[import_core20.COMPLETE]]);
+      } catch (err) {
+        a.down([[import_core20.ERROR, err instanceof Error ? err : new Error(String(err))]]);
+      }
+      return void 0;
+    },
+    { describeKind: "producer", completeWhenDepsComplete: false, ...rest }
+  );
+}
+function fromSqliteCursor(db, query, opts) {
+  const { mapRow = (r) => r, params, ...rest } = opts ?? {};
+  return (0, import_core20.node)(
+    [],
+    (_data, a) => {
+      try {
+        const it = db.iterate(query, params);
+        (0, import_core20.batch)(() => {
+          for (const row of it) a.emit(mapRow(row));
+          a.down([[import_core20.COMPLETE]]);
+        });
+      } catch (err) {
+        a.down([[import_core20.ERROR, err instanceof Error ? err : new Error(String(err))]]);
+      }
+      return void 0;
+    },
+    { describeKind: "producer", completeWhenDepsComplete: false, ...rest }
+  );
+}
+function toSqlite(source, db, table, opts) {
+  if (table.includes("\0") || table.length === 0) {
+    throw new Error(`toSqlite: invalid table name: ${JSON.stringify(table)}`);
+  }
+  const {
+    toSQL = (v, t) => ({
+      sql: `INSERT INTO "${t.replace(/"/g, '""')}" (data) VALUES (?)`,
+      params: [JSON.stringify(v)]
+    }),
+    onTransportError,
+    batchInsert = false,
+    maxBatchSize = 1e3,
+    flushIntervalMs = 0
+  } = opts ?? {};
+  const serialize = (value) => toSQL(value, table);
+  if (!batchInsert) {
+    return reactiveSink(source, {
+      onTransportError,
+      serialize,
+      send: (q) => {
+        const query = q;
+        db.query(query.sql, query.params);
+      }
+    });
+  }
+  const errorsNode = (0, import_core20.node)([], { initial: null });
+  const sentNode = (0, import_core20.node)([], {
+    initial: void 0,
+    equals: () => false
+  });
+  const failedNode = (0, import_core20.node)([], { initial: null });
+  const inFlightNode = (0, import_core20.node)([], { initial: 0 });
+  const bufferedNode = (0, import_core20.node)([], { initial: 0 });
+  const reportError = (err) => {
+    try {
+      onTransportError?.(err);
+    } catch {
+    }
+    try {
+      errorsNode.down([[import_core20.DATA, err]]);
+    } catch {
+    }
+  };
+  let pending = [];
+  let flushing = false;
+  let timer;
+  let disposed = false;
+  const updateBuffered = () => bufferedNode.down([[import_core20.DATA, pending.length]]);
+  const safeEmitSent = (v) => {
+    if (disposed) return;
+    sentNode.down([[import_core20.DATA, v]]);
+  };
+  const safeEmitFailed = (f) => {
+    if (disposed) return;
+    failedNode.down([[import_core20.DATA, f]]);
+  };
+  const safeSetInFlight = (n) => {
+    if (disposed) return;
+    inFlightNode.down([[import_core20.DATA, n]]);
+  };
+  const safeReportError = (err) => {
+    if (disposed) return;
+    reportError(err);
+  };
+  const flushTransaction = () => {
+    if (pending.length === 0 || flushing) return;
+    flushing = true;
+    safeSetInFlight(1);
+    try {
+      db.query("BEGIN", []);
+    } catch (err) {
+      flushing = false;
+      safeSetInFlight(0);
+      safeReportError({
+        stage: "send",
+        error: err instanceof Error ? err : new Error(String(err)),
+        value: void 0
+      });
+      return;
+    }
+    const chunk = pending;
+    pending = [];
+    updateBuffered();
+    let firstError;
+    let committedCount = 0;
+    for (const entry of chunk) {
+      try {
+        db.query(entry.query.sql, entry.query.params);
+        committedCount += 1;
+      } catch (err) {
+        firstError = err instanceof Error ? err : new Error(String(err));
+        break;
+      }
+    }
+    if (firstError) {
+      try {
+        db.query("ROLLBACK", []);
+      } catch {
+      }
+      safeReportError({ stage: "send", error: firstError, value: void 0 });
+      for (const entry of chunk) {
+        safeEmitFailed({ value: entry.value, error: firstError, attempts: 1 });
+      }
+    } else {
+      try {
+        db.query("COMMIT", []);
+        for (const entry of chunk) safeEmitSent(entry.value);
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        safeReportError({ stage: "send", error, value: void 0 });
+        for (let i = 0; i < committedCount; i++) {
+          safeEmitFailed({ value: chunk[i].value, error, attempts: 1 });
+        }
+      }
+    }
+    flushing = false;
+    safeSetInFlight(0);
+  };
+  const scheduleFlush = () => {
+    if (flushIntervalMs > 0 && timer === void 0 && !disposed) {
+      timer = setTimeout(() => {
+        timer = void 0;
+        flushTransaction();
+      }, flushIntervalMs);
+    }
+  };
+  const unsub = source.subscribe((msgs) => {
+    for (const msg of msgs) {
+      const t = msg[0];
+      if (t === import_core20.DATA) {
+        const value = msg[1];
+        let query;
+        try {
+          query = serialize(value);
+        } catch (err) {
+          const error = err instanceof Error ? err : new Error(String(err));
+          reportError({ stage: "serialize", error, value });
+          failedNode.down([[import_core20.DATA, { value, error, attempts: 0 }]]);
+          continue;
+        }
+        pending.push({ value, query });
+        updateBuffered();
+        if (pending.length >= maxBatchSize) flushTransaction();
+        else scheduleFlush();
+      } else if (import_core20.defaultConfig.messageTier(t) >= 3) {
+        flushTransaction();
+      }
+    }
+  });
+  const dispose = () => {
+    if (disposed) return;
+    if (timer !== void 0) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+    flushTransaction();
+    disposed = true;
+    unsub();
+    for (const n of [errorsNode, sentNode, failedNode, inFlightNode, bufferedNode]) {
+      try {
+        n.down([[import_core20.TEARDOWN]]);
+      } catch {
+      }
+    }
+  };
+  return {
+    dispose,
+    sent: sentNode,
+    failed: failedNode,
+    inFlight: inFlightNode,
+    errors: errorsNode,
+    buffered: bufferedNode,
+    flush: async () => {
+      if (!disposed) flushTransaction();
+    }
+  };
+}
+
+// src/base/io/sse.ts
+var import_core21 = require("@graphrefly/pure-ts/core");
+function messageTypeLabel(t) {
+  return Symbol.keyFor(t) ?? t.description ?? "message";
+}
+function serializeSseData(value, serialize) {
+  if (typeof value === "string") return value;
+  return serialize(value);
+}
+function sseFrame(event, data) {
+  let out = `event: ${event}
+`;
+  if (data !== void 0) {
+    const lines = data.split(/\r?\n/);
+    for (const line of lines) {
+      out += `data: ${line}
+`;
+    }
+  }
+  return `${out}
+`;
+}
+function toSSE(source, opts) {
+  const {
+    serialize = (value) => {
+      if (value instanceof Error) return value.message;
+      try {
+        return JSON.stringify(value);
+      } catch {
+        return String(value);
+      }
+    },
+    dataEvent = "data",
+    errorEvent = "error",
+    completeEvent = "complete",
+    includeResolved = false,
+    includeDirty = false,
+    keepAliveMs,
+    signal,
+    eventNameResolver = messageTypeLabel
+  } = opts ?? {};
+  const encoder = new TextEncoder();
+  let stop;
+  return new ReadableStream({
+    start(controller) {
+      let closed = false;
+      let keepAlive;
+      let unsub = () => {
+      };
+      const close = () => {
+        if (closed) return;
+        closed = true;
+        if (keepAlive !== void 0) clearInterval(keepAlive);
+        signal?.removeEventListener("abort", onAbort);
+        unsub();
+        controller.close();
+      };
+      stop = close;
+      const write = (event, data) => {
+        if (closed) return;
+        controller.enqueue(encoder.encode(sseFrame(event, data)));
+      };
+      const onAbort = () => {
+        if (closed) return;
+        close();
+      };
+      unsub = source.subscribe((msgs) => {
+        for (const msg of msgs) {
+          const t = msg[0];
+          if (import_core21.defaultConfig.isLocalOnly(t)) {
+            if (t === import_core21.DIRTY && includeDirty) {
+            } else continue;
+          }
+          if (t === import_core21.DATA) {
+            write(dataEvent, serializeSseData(msg[1], serialize));
+            continue;
+          }
+          if (t === import_core21.ERROR) {
+            write(errorEvent, serializeSseData(msg[1], serialize));
+            close();
+            return;
+          }
+          if (t === import_core21.COMPLETE) {
+            write(completeEvent);
+            close();
+            return;
+          }
+          if (!includeResolved && t === import_core21.RESOLVED) continue;
+          write(
+            eventNameResolver(t),
+            msg.length > 1 ? serializeSseData(msg[1], serialize) : void 0
+          );
+        }
+      });
+      if (keepAliveMs !== void 0 && keepAliveMs > 0) {
+        keepAlive = setInterval(() => {
+          if (closed) return;
+          controller.enqueue(encoder.encode(": keepalive\n\n"));
+        }, keepAliveMs);
+      }
+      if (signal?.aborted) onAbort();
+      else signal?.addEventListener("abort", onAbort, { once: true });
+    },
+    cancel() {
+      stop?.();
+    }
+  });
+}
+function toSSEBytes(source, opts) {
+  const {
+    serialize = (value) => {
+      if (value instanceof Error) return value.message;
+      try {
+        return JSON.stringify(value);
+      } catch {
+        return String(value);
+      }
+    },
+    dataEvent = "data",
+    errorEvent = "error",
+    completeEvent = "complete",
+    includeResolved = false,
+    includeDirty = false,
+    keepAliveMs,
+    signal,
+    eventNameResolver = messageTypeLabel
+  } = opts ?? {};
+  const encoder = new TextEncoder();
+  return (0, import_core21.node)([], (_data, a) => {
+    let active = true;
+    let keepAlive;
+    const emitFrame = (event, data) => {
+      if (!active) return;
+      a.emit(encoder.encode(sseFrame(event, data)));
+    };
+    const onAbort = () => {
+      if (!active) return;
+      active = false;
+      a.down([[import_core21.COMPLETE]]);
+    };
+    const unsub = source.subscribe((msgs) => {
+      if (!active) return;
+      for (const msg of msgs) {
+        const t = msg[0];
+        if (import_core21.defaultConfig.isLocalOnly(t)) {
+          if (t === import_core21.DIRTY && includeDirty) {
+          } else continue;
+        }
+        if (t === import_core21.DATA) {
+          emitFrame(dataEvent, serializeSseData(msg[1], serialize));
+          continue;
+        }
+        if (t === import_core21.ERROR) {
+          emitFrame(errorEvent, serializeSseData(msg[1], serialize));
+          active = false;
+          a.down([[import_core21.COMPLETE]]);
+          return;
+        }
+        if (t === import_core21.COMPLETE) {
+          emitFrame(completeEvent);
+          active = false;
+          a.down([[import_core21.COMPLETE]]);
+          return;
+        }
+        if (!includeResolved && t === import_core21.RESOLVED) continue;
+        emitFrame(
+          eventNameResolver(t),
+          msg.length > 1 ? serializeSseData(msg[1], serialize) : void 0
+        );
+      }
+    });
+    if (keepAliveMs !== void 0 && keepAliveMs > 0) {
+      keepAlive = setInterval(() => {
+        if (!active) return;
+        a.emit(encoder.encode(": keepalive\n\n"));
+      }, keepAliveMs);
+    }
+    if (signal?.aborted) onAbort();
+    else signal?.addEventListener("abort", onAbort, { once: true });
+    return () => {
+      active = false;
+      if (keepAlive !== void 0) clearInterval(keepAlive);
+      signal?.removeEventListener("abort", onAbort);
+      unsub();
+    };
+  });
+}
+function toReadableStream(bytes) {
+  let unsub;
+  let closed = false;
+  return new ReadableStream({
+    start(controller) {
+      unsub = bytes.subscribe((msgs) => {
+        for (const m of msgs) {
+          const t = m[0];
+          if (closed) return;
+          if (t === import_core21.DATA) {
+            try {
+              controller.enqueue(m[1]);
+            } catch {
+              closed = true;
+              unsub?.();
+            }
+          } else if (t === import_core21.ERROR) {
+            closed = true;
+            try {
+              controller.error(m[1]);
+            } catch {
+            }
+            return;
+          } else if (t === import_core21.COMPLETE) {
+            closed = true;
+            try {
+              controller.close();
+            } catch {
+            }
+            return;
+          }
+        }
+      });
+    },
+    cancel() {
+      closed = true;
+      unsub?.();
+    }
+  });
+}
+async function* parseSSEStream(source, opts) {
+  const parse = opts?.parse ?? ((raw) => raw);
+  const externalSignal = opts?.signal;
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let currentEvent = "message";
+  let currentData = [];
+  let currentId;
+  let currentRetry;
+  const queue = [];
+  const flushEvent = () => {
+    if (currentData.length === 0 && currentEvent === "message" && currentId === void 0) {
+      currentData = [];
+      return;
+    }
+    const raw = currentData.join("\n");
+    queue.push({
+      event: currentEvent,
+      data: parse(raw),
+      id: currentId,
+      retry: currentRetry
+    });
+    currentEvent = "message";
+    currentData = [];
+    currentId = void 0;
+    currentRetry = void 0;
+  };
+  const processLine = (line) => {
+    if (line === "") {
+      flushEvent();
+      return;
+    }
+    if (line.startsWith(":")) return;
+    const colon = line.indexOf(":");
+    const field = colon < 0 ? line : line.slice(0, colon);
+    let value = colon < 0 ? "" : line.slice(colon + 1);
+    if (value.startsWith(" ")) value = value.slice(1);
+    switch (field) {
+      case "event":
+        currentEvent = value;
+        break;
+      case "data":
+        currentData.push(value);
+        break;
+      case "id":
+        if (!value.includes("\0")) currentId = value;
+        break;
+      case "retry": {
+        const n = Number(value);
+        if (Number.isFinite(n)) currentRetry = n;
+        break;
+      }
+    }
+  };
+  const processChunk = (chunk, done) => {
+    buffer += decoder.decode(chunk, { stream: !done });
+    const parts = buffer.split(/\r?\n/);
+    buffer = parts.pop() ?? "";
+    for (const line of parts) processLine(line);
+  };
+  const resp = source;
+  const stream = source instanceof ReadableStream ? source : resp && typeof resp === "object" && resp.body instanceof ReadableStream ? resp.body : null;
+  let reader;
+  let iter;
+  let cleanupDone = false;
+  const cleanupReader = () => {
+    if (cleanupDone) return;
+    cleanupDone = true;
+    if (reader) {
+      void reader.cancel().catch(() => void 0);
+    }
+    if (iter && typeof iter.return === "function") {
+      void Promise.resolve(iter.return()).catch(() => void 0);
+    }
+  };
+  const onAbort = () => {
+    cleanupReader();
+  };
+  if (externalSignal) {
+    if (externalSignal.aborted) return;
+    externalSignal.addEventListener("abort", onAbort, { once: true });
+  }
+  try {
+    if (stream) {
+      reader = stream.getReader();
+      while (!externalSignal?.aborted) {
+        const { value, done } = await reader.read();
+        if (done) break;
+        processChunk(value, false);
+        while (queue.length > 0) {
+          const ev = queue.shift();
+          yield ev;
+        }
+      }
+      processChunk(new Uint8Array(), true);
+    } else {
+      const asyncIter = source;
+      iter = asyncIter[Symbol.asyncIterator]();
+      while (!externalSignal?.aborted) {
+        const step = await iter.next();
+        if (step.done) break;
+        processChunk(step.value, false);
+        while (queue.length > 0) {
+          const ev = queue.shift();
+          yield ev;
+        }
+      }
+      processChunk(new Uint8Array(), true);
+    }
+    if (buffer.trim()) {
+      for (const line of buffer.split(/\r?\n/)) processLine(line);
+      flushEvent();
+    }
+    while (queue.length > 0) {
+      const ev = queue.shift();
+      yield ev;
+    }
+  } finally {
+    if (externalSignal) {
+      externalSignal.removeEventListener("abort", onAbort);
+    }
+    cleanupReader();
+  }
+}
+function fromSSE(source, opts) {
+  const { parse, ...rest } = opts ?? {};
+  return (0, import_core21.node)(
+    [],
+    (_data, a) => {
+      let active = true;
+      const ctrl = new AbortController();
+      const run = async () => {
+        try {
+          for await (const ev of parseSSEStream(source, { parse, signal: ctrl.signal })) {
+            if (!active) return;
+            a.emit(ev);
+          }
+          if (active) a.down([[import_core21.COMPLETE]]);
+        } catch (err) {
+          if (active) a.down([[import_core21.ERROR, err]]);
+        }
+      };
+      void run();
+      return () => {
+        active = false;
+        ctrl.abort();
+      };
+    },
+    sourceOpts(rest)
+  );
+}
+
+// src/base/io/statsd.ts
+var import_core22 = require("@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: (0, import_core22.wallClockNs)() };
+}
+
+// src/base/io/syslog.ts
+var import_core23 = require("@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 = (0, import_core23.wallClockNs)();
+    return {
+      facility: 1,
+      severity: 6,
+      timestamp: new Date(Math.floor(nowNs / 1e6)).toISOString(),
+      hostname: "-",
+      appName: "-",
+      procId: "-",
+      msgId: "-",
+      message: raw.trim(),
+      timestampNs: nowNs
+    };
+  }
+  const pri = Number(match[1]);
+  return {
+    facility: pri >> 3,
+    severity: pri & 7,
+    timestamp: match[2],
+    hostname: match[3],
+    appName: match[4],
+    procId: match[5],
+    msgId: match[6],
+    message: (match[7] ?? "").trim(),
+    timestampNs: (0, import_core23.wallClockNs)()
+  };
+}
+
+// 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 (batch6) => {
+      await client.insert({ table, values: batch6, 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
+var import_core24 = require("@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 = `${(0, import_core24.wallClockNs)()}`;
+      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
+var import_core25 = require("@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 (batch6) => {
+      seq += 1;
+      const body = format === "ndjson" ? `${batch6.map((v) => JSON.stringify(v)).join("\n")}
+` : JSON.stringify(batch6);
+      const key = keyGenerator(seq, (0, import_core25.wallClockNs)());
+      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
+var import_core27 = require("@graphrefly/pure-ts/core");
+
+// src/base/resilience/retry.ts
+var import_core26 = require("@graphrefly/pure-ts/core");
+function resolveRetryConfig(opts) {
+  const count = opts?.count;
+  const backoffOpt = opts?.backoff;
+  if (backoffOpt !== void 0 && count === void 0) {
+    throw new RangeError(
+      "retry({ backoff }) requires explicit count to prevent unbounded retries; pass { count: <n>, backoff: ... }"
+    );
+  }
+  const maxRetries = count !== void 0 ? count : 0;
+  if (maxRetries < 0) throw new RangeError("retry count must be >= 0");
+  const strategy = backoffOpt === void 0 ? null : typeof backoffOpt === "string" ? resolveBackoffPreset(backoffOpt) : backoffOpt;
+  return { maxRetries, strategy };
+}
+function retryFactoryArgs(opts) {
+  const args = {};
+  if (opts?.count !== void 0) args.count = opts.count;
+  if (typeof opts?.backoff === "string") args.backoff = opts.backoff;
+  return Object.keys(args).length > 0 ? args : void 0;
+}
+function _runRetryStateMachine(getCfg, acquireSource, a, emitState) {
+  let attempt = 0;
+  let stopped = false;
+  let prevDelay = null;
+  let unsub;
+  const timer = new import_core26.ResettableTimer();
+  const publish = (status) => {
+    emitState?.({ status, attempt, lastDelay_ns: prevDelay });
+  };
+  publish("pending");
+  function disconnectUpstream() {
+    unsub?.();
+    unsub = void 0;
+  }
+  function scheduleRetryOrFinish(err) {
+    if (stopped) return;
+    const cfg = getCfg();
+    if (attempt >= cfg.maxRetries) {
+      disconnectUpstream();
+      publish("errored");
+      a.down([[import_core26.ERROR, err]]);
+      return;
+    }
+    const raw = cfg.strategy === null ? 0 : cfg.strategy(attempt, err, prevDelay);
+    if (raw === null || raw === void 0) {
+      disconnectUpstream();
+      publish("errored");
+      a.down([[import_core26.ERROR, err]]);
+      return;
+    }
+    let delayNs;
+    try {
+      delayNs = coerceDelayNs(raw);
+    } catch {
+      disconnectUpstream();
+      publish("errored");
+      a.down([[import_core26.ERROR, err]]);
+      return;
+    }
+    prevDelay = delayNs;
+    attempt += 1;
+    disconnectUpstream();
+    publish("paused");
+    const delayMs = delayNs > 0 ? delayNs / NS_PER_MS : 1;
+    timer.start(delayMs, () => {
+      if (stopped) return;
+      connect();
+    });
+  }
+  function connect() {
+    timer.cancel();
+    disconnectUpstream();
+    let src;
+    try {
+      src = acquireSource();
+    } catch (err) {
+      scheduleRetryOrFinish(err);
+      return;
+    }
+    publish("running");
+    unsub = src.subscribe((msgs) => {
+      if (stopped) return;
+      for (const m of msgs) {
+        const t = m[0];
+        if (t === import_core26.DIRTY) a.down([[import_core26.DIRTY]]);
+        else if (t === import_core26.DATA) {
+          attempt = 0;
+          prevDelay = null;
+          a.emit(m[1]);
+          publish("running");
+        } else if (t === import_core26.RESOLVED) a.down([[import_core26.RESOLVED]]);
+        else if (t === import_core26.COMPLETE) {
+          stopped = true;
+          disconnectUpstream();
+          publish("completed");
+          a.down([[import_core26.COMPLETE]]);
+        } else if (t === import_core26.ERROR) {
+          scheduleRetryOrFinish(msgVal(m));
+          return;
+        } else a.down([m]);
+      }
+    });
+  }
+  connect();
+  return () => {
+    const wasStopped = stopped;
+    stopped = true;
+    timer.cancel();
+    disconnectUpstream();
+    if (!wasStopped) publish("cancelled");
+  };
+}
+function retry(input, opts) {
+  const retryState = (0, import_core26.node)([], {
+    name: "retryState",
+    describeKind: "state",
+    initial: { status: "pending", attempt: 0, lastDelay_ns: null },
+    equals: (a, b) => a === b || a != null && b != null && typeof a === "object" && typeof b === "object" && JSON.stringify(a) === JSON.stringify(b)
+  });
+  const emit = (s) => {
+    retryState.down([[import_core26.DIRTY], [import_core26.DATA, s]]);
+  };
+  if (typeof input === "function") {
+    return {
+      node: _retryFactory(input, opts, emit),
+      retryState
+    };
+  }
+  return {
+    node: _retrySource(input, opts, emit),
+    retryState
+  };
+}
+function makeMergedOptsMirror(arg) {
+  if (arg === void 0) {
+    return { current: () => void 0, unsub: () => void 0 };
+  }
+  if (!isNode(arg)) {
+    return { current: () => arg, unsub: () => void 0 };
+  }
+  const optsNode = arg;
+  let merged = optsNode.cache ?? void 0;
+  const unsub = optsNode.subscribe((msgs) => {
+    for (const m of msgs) {
+      if (m[0] !== import_core26.DATA) continue;
+      const next = m[1];
+      if (next == null || typeof next !== "object") continue;
+      if (Object.keys(next).length === 0) continue;
+      merged = { ...merged ?? {}, ...next };
+    }
+  });
+  return { current: () => merged, unsub };
+}
+var _retrySourceNonResubscribableWarned = /* @__PURE__ */ new WeakSet();
+function _retrySource(source, opts, emitState) {
+  const sourceWithFlag = source;
+  if (sourceWithFlag._resubscribable === false && !_retrySourceNonResubscribableWarned.has(source)) {
+    _retrySourceNonResubscribableWarned.add(source);
+    console.warn(
+      "retry(source, opts): source-mode requires `resubscribable: true` on the upstream node. Retries will be silent no-ops after the first ERROR. Either pass `resubscribable: true` to the source factory, OR use factory-mode retry `retry(() => buildSource(), opts)` so each attempt builds a fresh node."
+    );
+  }
+  const staticOpts = isNode(opts) ? void 0 : opts;
+  if (!isNode(opts)) resolveRetryConfig(staticOpts);
+  return (0, import_core26.node)(
+    (_data, a) => {
+      const merged = makeMergedOptsMirror(opts);
+      const getCfg = () => resolveRetryConfig(merged.current());
+      const inner = _runRetryStateMachine(getCfg, () => source, a, emitState);
+      return () => {
+        inner();
+        merged.unsub();
+      };
+    },
+    {
+      ...operatorOpts(),
+      initial: source.cache,
+      meta: {
+        ...staticOpts?.meta ?? {},
+        ...(0, import_core26.factoryTag)(
+          "retry",
+          isNode(opts) ? { reactiveOpts: true } : retryFactoryArgs(staticOpts)
+        )
+      }
+    }
+  );
+}
+function _retryFactory(factory, opts, emitState) {
+  const staticOpts = isNode(opts) ? void 0 : opts;
+  if (!isNode(opts)) resolveRetryConfig(staticOpts);
+  return (0, import_core26.node)(
+    (_data, a) => {
+      const merged = makeMergedOptsMirror(opts);
+      const getCfg = () => resolveRetryConfig(merged.current());
+      const inner = _runRetryStateMachine(getCfg, factory, a, emitState);
+      return () => {
+        inner();
+        merged.unsub();
+      };
+    },
+    {
+      ...operatorOpts(),
+      initial: staticOpts?.initial,
+      meta: {
+        ...staticOpts?.meta ?? {},
+        ...(0, import_core26.factoryTag)(
+          "retry",
+          isNode(opts) ? { reactiveOpts: true } : retryFactoryArgs(staticOpts)
+        )
+      }
+    }
+  );
+}
+
+// src/base/io/websocket.ts
+function fromWebSocket(socketOrRegister, opts) {
+  const { parse, closeOnTeardown = false, ...rest } = opts ?? {};
+  return (0, import_core27.node)(
+    [],
+    (_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([import_core27.ERROR, err]);
+        }
+      };
+      const error = (err) => {
+        terminate([import_core27.ERROR, err]);
+      };
+      const complete = () => {
+        terminate([import_core27.COMPLETE]);
+      };
+      if (typeof socketOrRegister === "function") {
+        try {
+          cleanup = socketOrRegister(emit, error, complete);
+          if (typeof cleanup !== "function") {
+            throw new Error(
+              "fromWebSocket register contract violation: register must return cleanup callable"
+            );
+          }
+        } catch (err) {
+          terminate([import_core27.ERROR, err]);
+        }
+        return () => {
+          active = false;
+          runCleanup();
+        };
+      }
+      const ws = socketOrRegister;
+      const onMessage = (event) => emit(event, event);
+      const onError = (event) => error(event);
+      const onClose = () => complete();
+      ws.addEventListener("message", onMessage);
+      ws.addEventListener("error", onError);
+      ws.addEventListener("close", onClose);
+      cleanup = () => {
+        ws.removeEventListener("message", onMessage);
+        ws.removeEventListener("error", onError);
+        ws.removeEventListener("close", onClose);
+        if (closeOnTeardown) ws.close();
+      };
+      return () => {
+        active = false;
+        runCleanup();
+      };
+    },
+    sourceOpts(rest)
+  );
+}
+function 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] === import_core27.COMPLETE && closeOnComplete) closeSocket(msg);
+      else if (msg[0] === import_core27.ERROR && closeOnError) closeSocket(msg);
+    }
+  });
+  externalCloseHandler = () => {
+    socketClosed = true;
+    handle.dispose();
+  };
+  socket.addEventListener("close", externalCloseHandler);
+  return handle;
+}
+function fromWebSocketReconnect(factory, opts) {
+  const {
+    parse,
+    maxRetries,
+    backoff = "exponential",
+    closeOnTeardown = true,
+    ...rest
+  } = opts ?? {};
+  return retry(
+    () => fromWebSocket(factory(), {
+      parse,
+      closeOnTeardown,
+      ...rest
+    }),
+    { count: maxRetries, backoff }
+  ).node;
+}
+//# sourceMappingURL=index.cjs.map