@graphrefly/graphrefly 0.45.0 → 0.46.0

package/dist/base/composition/index.cjs

@@ -0,0 +1,811 @@
+"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/composition/index.ts
+var composition_exports = {};
+__export(composition_exports, {
+  NativePubSubBackend: () => NativePubSubBackend,
+  createWatermarkController: () => createWatermarkController,
+  distill: () => distill,
+  externalBundle: () => externalBundle,
+  externalProducer: () => externalProducer,
+  materialize: () => materialize,
+  pubsub: () => pubsub,
+  selector: () => selector,
+  singleFromAny: () => singleFromAny,
+  singleNodeFromAny: () => singleNodeFromAny,
+  toObservable: () => toObservable,
+  verifiable: () => verifiable
+});
+module.exports = __toCommonJS(composition_exports);
+
+// src/base/composition/backpressure.ts
+var import_core = require("@graphrefly/pure-ts/core");
+var nextLockId = 0;
+function createWatermarkController(sendUp, opts) {
+  if (opts.highWaterMark < 1) throw new RangeError("highWaterMark must be >= 1");
+  if (opts.lowWaterMark < 0) throw new RangeError("lowWaterMark must be >= 0");
+  if (opts.lowWaterMark >= opts.highWaterMark)
+    throw new RangeError("lowWaterMark must be < highWaterMark");
+  const lockId = /* @__PURE__ */ Symbol(`bp-${++nextLockId}`);
+  let pending = 0;
+  let paused = false;
+  return {
+    onEnqueue() {
+      pending += 1;
+      if (!paused && pending >= opts.highWaterMark) {
+        paused = true;
+        sendUp([[import_core.PAUSE, lockId]]);
+        return true;
+      }
+      return false;
+    },
+    onDequeue() {
+      if (pending > 0) pending -= 1;
+      if (paused && pending <= opts.lowWaterMark) {
+        paused = false;
+        sendUp([[import_core.RESUME, lockId]]);
+        return true;
+      }
+      return false;
+    },
+    get pending() {
+      return pending;
+    },
+    get paused() {
+      return paused;
+    },
+    dispose() {
+      if (paused) {
+        paused = false;
+        sendUp([[import_core.RESUME, lockId]]);
+      }
+    }
+  };
+}
+
+// src/base/composition/distill.ts
+var import_core3 = require("@graphrefly/pure-ts/core");
+var import_extra3 = require("@graphrefly/pure-ts/extra");
+
+// src/base/sources/async.ts
+var import_core2 = require("@graphrefly/pure-ts/core");
+var import_extra = require("@graphrefly/pure-ts/extra");
+var import_extra2 = require("@graphrefly/pure-ts/extra");
+function forEach(source, fn, opts) {
+  const inner = (0, import_core2.node)(
+    [source],
+    (data, _actions) => {
+      const batch0 = data[0];
+      if (batch0 != null && batch0.length > 0) {
+        for (const v of batch0) fn(v);
+      }
+    },
+    { describeKind: "effect", ...opts }
+  );
+  return inner.subscribe(() => {
+  });
+}
+
+// src/base/composition/distill.ts
+function isNodeLike(value) {
+  return typeof value === "object" && value !== null && "cache" in value && typeof value.subscribe === "function";
+}
+function keepalive(node8) {
+  node8.subscribe(() => void 0);
+}
+function mapFromSnapshot(snapshot) {
+  if (snapshot instanceof Map) return snapshot;
+  return /* @__PURE__ */ new Map();
+}
+function applyExtraction(store, extraction) {
+  if (!Array.isArray(extraction.upsert)) {
+    throw new TypeError("distill extraction requires upsert: Array<{ key, value }>");
+  }
+  (0, import_core3.batch)(() => {
+    for (const { key, value } of extraction.upsert) {
+      store.set(key, value);
+    }
+    for (const key of extraction.remove ?? []) {
+      store.delete(key);
+    }
+  });
+}
+function distill(source, extractFn, opts) {
+  const sourceNode = (0, import_extra3.fromAny)(source);
+  const store = (0, import_extra3.reactiveMap)(opts.mapOptions ?? {});
+  const budget = opts.budget ?? 2e3;
+  const hasContext = opts.context !== void 0 && opts.context !== null;
+  const contextNode = hasContext ? (0, import_extra3.fromAny)(opts.context) : (0, import_core3.node)([], { initial: null });
+  const extractionStream = (0, import_extra3.fromAny)(
+    extractFn(sourceNode, store.entries)
+  );
+  forEach(extractionStream, (extraction) => {
+    applyExtraction(store, extraction);
+  });
+  if (opts.evict) {
+    const verdictUnsubs = /* @__PURE__ */ new Map();
+    const evictionKeys = (0, import_core3.node)(
+      [store.entries],
+      (batchData, actions, ctx) => {
+        const batch0 = batchData[0];
+        const snapshot = batch0 != null && batch0.length > 0 ? batch0.at(-1) : ctx.prevData[0];
+        const out = [];
+        const entries = mapFromSnapshot(snapshot);
+        for (const key of verdictUnsubs.keys()) {
+          if (!entries.has(key)) {
+            verdictUnsubs.get(key)();
+            verdictUnsubs.delete(key);
+          }
+        }
+        for (const [key, mem] of entries) {
+          const verdict = opts.evict(key, mem);
+          if (isNodeLike(verdict)) {
+            if (!verdictUnsubs.has(key)) {
+              const unsub = forEach(verdict, (val) => {
+                if (val === true && store.has(key)) {
+                  store.delete(key);
+                }
+              });
+              verdictUnsubs.set(key, unsub);
+            }
+            continue;
+          }
+          if (typeof verdict === "boolean") {
+            if (verdict) out.push(key);
+            continue;
+          }
+          throw new TypeError("distill evict() must return boolean or Node<boolean>");
+        }
+        actions.emit(out);
+      },
+      { describeKind: "derived" }
+    );
+    forEach(evictionKeys, (keys) => {
+      for (const key of keys) store.delete(key);
+    });
+  }
+  const hasConsolidateTrigger = opts.consolidateTrigger !== void 0 && opts.consolidateTrigger !== null;
+  if (opts.consolidate && hasConsolidateTrigger) {
+    const consolidateTriggerNode = (0, import_extra3.fromAny)(opts.consolidateTrigger);
+    const consolidatePaired = (0, import_extra3.withLatestFrom)(
+      consolidateTriggerNode,
+      store.entries
+    );
+    const consolidationStream = (0, import_extra3.switchMap)(
+      consolidatePaired,
+      ([, entries]) => opts.consolidate(mapFromSnapshot(entries))
+    );
+    forEach(consolidationStream, (extraction) => {
+      applyExtraction(store, extraction);
+    });
+  }
+  const compact = (0, import_core3.node)(
+    [store.entries, contextNode],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch5, i) => batch5 != null && batch5.length > 0 ? batch5.at(-1) : ctx.prevData[i]
+      );
+      const snapshot = data[0];
+      const context = data[1];
+      const map = mapFromSnapshot(snapshot);
+      const entries = [...map.entries()].map(([key, value]) => ({
+        key,
+        value,
+        score: opts.score(value, context),
+        cost: opts.cost(value)
+      }));
+      entries.sort((a, b) => b.score - a.score);
+      const packed = [];
+      let remaining = budget;
+      for (const item of entries) {
+        if (item.cost <= remaining) {
+          packed.push({ key: item.key, value: item.value, score: item.score });
+          remaining -= item.cost;
+        }
+      }
+      actions.emit(packed);
+    },
+    { describeKind: "derived", meta: { ...(0, import_core3.factoryTag)("distill", { budget }) } }
+  );
+  const size = (0, import_core3.node)(
+    [store.entries],
+    (batchData, actions, ctx) => {
+      const batch0 = batchData[0];
+      const snapshot = batch0 != null && batch0.length > 0 ? batch0.at(-1) : ctx.prevData[0];
+      actions.emit(mapFromSnapshot(snapshot).size);
+    },
+    { describeKind: "derived" }
+  );
+  keepalive(compact);
+  keepalive(size);
+  return { store, compact, size };
+}
+
+// src/base/composition/external-register.ts
+var import_core4 = require("@graphrefly/pure-ts/core");
+function sourceOpts2(opts) {
+  return { describeKind: "producer", ...opts };
+}
+function externalProducer(register, opts) {
+  return (0, import_core4.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_core4.ERROR, err]]);
+      },
+      complete() {
+        if (!active) return;
+        active = false;
+        a.down([[import_core4.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_core4.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_core4.DATA, value]]);
+    };
+  }
+  bundle.error = (err) => {
+    if (!active) return;
+    active = false;
+    (0, import_core4.batch)(() => {
+      for (const n of channelNodes) n.down([[import_core4.ERROR, err]]);
+    });
+    finishCleanup();
+  };
+  bundle.complete = () => {
+    if (!active) return;
+    active = false;
+    (0, import_core4.batch)(() => {
+      for (const n of channelNodes) n.down([[import_core4.COMPLETE]]);
+    });
+    finishCleanup();
+  };
+  const ret = register(bundle);
+  cleanup = typeof ret === "function" ? ret : void 0;
+  const dispose = () => {
+    if (!active) return;
+    active = false;
+    (0, import_core4.batch)(() => {
+      for (const n of channelNodes) {
+        try {
+          n.down([[import_core4.COMPLETE]]);
+        } catch {
+        }
+      }
+    });
+    finishCleanup();
+  };
+  return Object.assign(nodes, { dispose });
+}
+
+// src/base/composition/materialize.ts
+var import_core5 = require("@graphrefly/pure-ts/core");
+function operatorOpts(opts) {
+  return { describeKind: "derived", ...opts };
+}
+function selector(input, fn, opts) {
+  const equals = opts?.equals ?? Object.is;
+  let cleanup;
+  return (0, import_core5.node)(
+    [input],
+    (data, a, ctx) => {
+      if (cleanup === void 0) {
+        const store = ctx.store;
+        cleanup = {
+          onDeactivation: () => {
+            delete store.prev;
+            delete store.hasPrev;
+          }
+        };
+      }
+      const batch0 = data[0];
+      if (batch0 == null || batch0.length === 0) {
+        a.down([[import_core5.RESOLVED]]);
+        return cleanup;
+      }
+      const toEmit = [];
+      let prev = ctx.store.hasPrev ? ctx.store.prev : void 0;
+      let hasPrev = ctx.store.hasPrev;
+      for (const v of batch0) {
+        const key = fn(v);
+        if (hasPrev) {
+          let same;
+          try {
+            same = equals(prev, key);
+          } catch (err) {
+            a.down([[import_core5.ERROR, err]]);
+            return;
+          }
+          if (same) continue;
+        }
+        prev = key;
+        hasPrev = true;
+        toEmit.push(key);
+      }
+      if (toEmit.length === 0) {
+        a.down([[import_core5.RESOLVED]]);
+        return cleanup;
+      }
+      ctx.store.prev = prev;
+      ctx.store.hasPrev = true;
+      for (const k of toEmit) a.emit(k);
+      return cleanup;
+    },
+    {
+      ...operatorOpts(opts),
+      meta: { ...(0, import_core5.factoryTag)("selector"), ...opts?.meta ?? {} }
+    }
+  );
+}
+function materialize(key, factories, parent, opts) {
+  const slotName = opts?.slotName ?? "materialized";
+  return (0, import_core5.node)(
+    (_data, a) => {
+      let currentKey;
+      let hasCurrentKey = false;
+      let currentGraph;
+      let latestFactories;
+      let terminated = false;
+      function unmountCurrent() {
+        if (currentGraph === void 0) return;
+        try {
+          parent.remove(slotName);
+        } catch {
+        }
+        currentGraph = void 0;
+      }
+      const facUnsub = factories.subscribe((msgs) => {
+        if (terminated) return;
+        for (const m of msgs) {
+          if (m[0] === import_core5.DATA) {
+            latestFactories = m[1];
+          }
+        }
+      });
+      const keyUnsub = key.subscribe((msgs) => {
+        if (terminated) return;
+        for (const m of msgs) {
+          if (m[0] === import_core5.DATA) {
+            const newKey = m[1];
+            const keyChanged = !hasCurrentKey || newKey !== currentKey;
+            if (keyChanged) {
+              unmountCurrent();
+              if (latestFactories !== void 0) {
+                const factory = latestFactories.get(newKey);
+                if (factory !== void 0) {
+                  currentGraph = factory();
+                  parent.mount(slotName, currentGraph);
+                }
+              }
+              currentKey = newKey;
+              hasCurrentKey = true;
+            }
+            if (currentGraph !== void 0) {
+              a.emit(currentGraph);
+            } else {
+              a.down([[import_core5.RESOLVED]]);
+            }
+          } else if (m[0] === import_core5.COMPLETE) {
+            terminated = true;
+            a.down([[import_core5.COMPLETE]]);
+          } else if (m[0] === import_core5.ERROR) {
+            terminated = true;
+            a.down([m]);
+          }
+        }
+      });
+      return () => {
+        terminated = true;
+        keyUnsub();
+        facUnsub();
+        unmountCurrent();
+      };
+    },
+    {
+      ...operatorOpts(opts),
+      meta: { ...(0, import_core5.factoryTag)("materialize"), slotName, ...opts?.meta ?? {} }
+    }
+  );
+}
+
+// src/base/composition/observable.ts
+var import_core6 = require("@graphrefly/pure-ts/core");
+var import_rxjs = require("rxjs");
+function toObservable(node8, options) {
+  if (options?.raw) {
+    return new import_rxjs.Observable((subscriber) => {
+      const unsub = node8.subscribe((msgs) => {
+        if (subscriber.closed) return;
+        subscriber.next(msgs);
+        for (const m of msgs) {
+          if (m[0] === import_core6.ERROR) {
+            subscriber.error(m[1]);
+            return;
+          }
+          if (m[0] === import_core6.COMPLETE) {
+            subscriber.complete();
+            return;
+          }
+        }
+      });
+      return unsub;
+    });
+  }
+  return new import_rxjs.Observable((subscriber) => {
+    const unsub = node8.subscribe((msgs) => {
+      for (const m of msgs) {
+        if (subscriber.closed) return;
+        if (m[0] === import_core6.DATA) {
+          subscriber.next(m[1]);
+        } else if (m[0] === import_core6.ERROR) {
+          subscriber.error(m[1]);
+          return;
+        } else if (m[0] === import_core6.COMPLETE) {
+          subscriber.complete();
+          return;
+        }
+      }
+    });
+    return unsub;
+  });
+}
+
+// src/base/composition/pubsub.ts
+var import_core7 = require("@graphrefly/pure-ts/core");
+var import_extra4 = require("@graphrefly/pure-ts/extra");
+var NativePubSubBackend = class {
+  _version = 0;
+  _topics = /* @__PURE__ */ new Set();
+  get version() {
+    return this._version;
+  }
+  get topicCount() {
+    return this._topics.size;
+  }
+  hasTopic(name) {
+    return this._topics.has(name);
+  }
+  topicNames() {
+    return this._topics.values();
+  }
+  createTopic(name) {
+    if (this._topics.has(name)) return false;
+    this._topics.add(name);
+    this._version += 1;
+    return true;
+  }
+  removeTopic(name) {
+    const had = this._topics.delete(name);
+    if (had) this._version += 1;
+    return had;
+  }
+};
+function pubsub(options = {}) {
+  const { backend: userBackend, mutationLog: mutLogOpt } = options;
+  const backend = userBackend ?? new NativePubSubBackend();
+  const nodes = /* @__PURE__ */ new Map();
+  const mutLog = mutLogOpt ? (0, import_extra4.reactiveLog)(void 0, {
+    name: mutLogOpt === true ? "pubsub.mutationLog" : mutLogOpt.name ?? "pubsub.mutationLog",
+    maxSize: mutLogOpt === true ? void 0 : mutLogOpt.maxSize
+  }) : void 0;
+  let mutVersion = 0;
+  function recordChange(change) {
+    if (!mutLog) return;
+    mutLog.append({
+      structure: "pubsub",
+      version: ++mutVersion,
+      t_ns: (0, import_core7.wallClockNs)(),
+      lifecycle: "data",
+      change
+    });
+  }
+  function ensureTopic(name) {
+    let n = nodes.get(name);
+    if (n === void 0) {
+      n = (0, import_core7.node)({ describeKind: "state" });
+      nodes.set(name, n);
+      backend.createTopic(name);
+    }
+    return n;
+  }
+  return {
+    topic(name) {
+      return ensureTopic(name);
+    },
+    publish(name, value) {
+      if (!mutLog) {
+        ensureTopic(name).emit(value);
+        return;
+      }
+      (0, import_core7.batch)(() => {
+        ensureTopic(name).emit(value);
+        recordChange({ kind: "publish", value });
+      });
+    },
+    publishMany(entries) {
+      (0, import_core7.batch)(() => {
+        for (const [name, value] of entries) {
+          ensureTopic(name).emit(value);
+          recordChange({ kind: "publish", value });
+        }
+      });
+    },
+    removeTopic(name) {
+      const n = nodes.get(name);
+      if (n === void 0) return false;
+      nodes.delete(name);
+      backend.removeTopic(name);
+      if (!mutLog) {
+        n.down([[import_core7.TEARDOWN]]);
+        return true;
+      }
+      (0, import_core7.batch)(() => {
+        recordChange({ kind: "remove", name });
+        n.down([[import_core7.TEARDOWN]]);
+      });
+      return true;
+    },
+    has(name) {
+      return backend.hasTopic(name);
+    },
+    get size() {
+      return backend.topicCount;
+    },
+    topicNames() {
+      return backend.topicNames();
+    },
+    mutationLog: mutLog
+  };
+}
+
+// src/base/composition/single-from-any.ts
+var import_core9 = require("@graphrefly/pure-ts/core");
+var import_extra5 = require("@graphrefly/pure-ts/extra");
+
+// src/base/sources/settled.ts
+var import_core8 = require("@graphrefly/pure-ts/core");
+function firstValueFrom(source) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let shouldUnsub = false;
+    let unsub;
+    unsub = source.subscribe((msgs) => {
+      for (const m of msgs) {
+        if (settled) return;
+        if (m[0] === import_core8.DATA) {
+          settled = true;
+          resolve(m[1]);
+          if (unsub) {
+            unsub();
+            unsub = void 0;
+          } else shouldUnsub = true;
+          return;
+        }
+        if (m[0] === import_core8.ERROR) {
+          settled = true;
+          reject(m[1]);
+          if (unsub) {
+            unsub();
+            unsub = void 0;
+          } else shouldUnsub = true;
+          return;
+        }
+        if (m[0] === import_core8.COMPLETE) {
+          settled = true;
+          reject(new Error("completed without DATA"));
+          if (unsub) {
+            unsub();
+            unsub = void 0;
+          } else shouldUnsub = true;
+          return;
+        }
+      }
+    });
+    if (shouldUnsub) {
+      unsub?.();
+      unsub = void 0;
+    }
+  });
+}
+
+// src/base/composition/single-from-any.ts
+function singleFromAny(factory, opts = {}) {
+  const keyFn = opts.keyFn ?? ((k) => String(k));
+  const inFlight = /* @__PURE__ */ new Map();
+  return (key) => {
+    const k = keyFn(key);
+    const existing = inFlight.get(k);
+    if (existing) return existing;
+    const input = factory(key);
+    let rawPromise;
+    if (input != null && typeof input.then === "function") {
+      rawPromise = Promise.resolve(input);
+    } else if (input != null && typeof input === "object" && "subscribe" in input && "cache" in input) {
+      rawPromise = firstValueFrom(input);
+    } else if (input != null && typeof input === "object" && Symbol.asyncIterator in input) {
+      rawPromise = (async () => {
+        const iter = input[Symbol.asyncIterator]();
+        try {
+          const { value, done } = await iter.next();
+          if (done) throw new Error("singleFromAny: factory returned empty async iterable");
+          return value;
+        } finally {
+          await iter.return?.();
+        }
+      })();
+    } else if (input != null && typeof input === "object" && Symbol.iterator in input) {
+      rawPromise = (async () => {
+        const iter = input[Symbol.iterator]();
+        try {
+          const { value, done } = iter.next();
+          if (done) throw new Error("singleFromAny: factory returned empty iterable");
+          return value;
+        } finally {
+          iter.return?.();
+        }
+      })();
+    } else {
+      rawPromise = Promise.resolve(input);
+    }
+    let tracked;
+    const cleanup = () => {
+      if (inFlight.get(k) === tracked) inFlight.delete(k);
+    };
+    tracked = rawPromise.then(
+      (v) => {
+        cleanup();
+        return v;
+      },
+      (e) => {
+        cleanup();
+        throw e;
+      }
+    );
+    inFlight.set(k, tracked);
+    return tracked;
+  };
+}
+function singleNodeFromAny(factory, opts = {}) {
+  const keyFn = opts.keyFn ?? ((k) => String(k));
+  const inFlight = /* @__PURE__ */ new Map();
+  return (key) => {
+    const k = keyFn(key);
+    const existing = inFlight.get(k);
+    if (existing) return existing;
+    const node8 = (0, import_extra5.fromAny)(factory(key));
+    inFlight.set(k, node8);
+    const unsub = node8.subscribe((msgs) => {
+      for (const m of msgs) {
+        if (m[0] === import_core9.ERROR || m[0] === import_core9.COMPLETE) {
+          if (inFlight.get(k) === node8) inFlight.delete(k);
+          unsub();
+          return;
+        }
+      }
+    });
+    return node8;
+  };
+}
+
+// src/base/composition/verifiable.ts
+var import_core10 = require("@graphrefly/pure-ts/core");
+var import_extra6 = require("@graphrefly/pure-ts/extra");
+function verifiable(source, verifyFn, opts) {
+  const sourceNode = (0, import_extra6.fromAny)(source);
+  const hasSourceVersioning = sourceNode.v != null;
+  const verified = (0, import_core10.node)([], {
+    initial: opts?.initialVerified ?? null,
+    meta: {
+      ...(0, import_core10.factoryTag)("verifiable"),
+      ...hasSourceVersioning ? { sourceVersion: null } : {}
+    }
+  });
+  const hasTrigger = opts?.trigger !== void 0 && opts.trigger !== null;
+  let triggerNode = null;
+  if (hasTrigger && opts?.autoVerify) {
+    triggerNode = (0, import_extra6.merge)((0, import_extra6.fromAny)(opts.trigger), sourceNode);
+  } else if (hasTrigger) {
+    triggerNode = (0, import_extra6.fromAny)(opts.trigger);
+  } else if (opts?.autoVerify) {
+    triggerNode = sourceNode;
+  }
+  if (triggerNode !== null) {
+    let verifyStream;
+    if (triggerNode === sourceNode) {
+      verifyStream = (0, import_extra6.switchMap)(sourceNode, (src) => verifyFn(src));
+    } else {
+      const paired = (0, import_extra6.withLatestFrom)(triggerNode, sourceNode);
+      verifyStream = (0, import_extra6.switchMap)(paired, ([, source2]) => verifyFn(source2));
+    }
+    forEach(verifyStream, (value) => {
+      (0, import_core10.batch)(() => {
+        verified.down([[import_core10.DATA, value]]);
+        if (hasSourceVersioning) {
+          const sv = sourceNode.v;
+          if (sv != null) {
+            verified.meta.sourceVersion.down([[import_core10.DATA, { id: sv.id, version: sv.version }]]);
+          }
+        }
+      });
+    });
+  }
+  return { node: sourceNode, verified, trigger: triggerNode };
+}
+//# sourceMappingURL=index.cjs.map