@graphrefly/graphrefly 0.45.0 → 0.47.0

package/dist/utils/memory/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/utils/messaging/index.cjs

@@ -0,0 +1,666 @@
+"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/utils/messaging/index.ts
+var messaging_exports = {};
+__export(messaging_exports, {
+  CONTEXT_TOPIC: () => CONTEXT_TOPIC,
+  DEFERRED_TOPIC: () => DEFERRED_TOPIC,
+  INJECTIONS_TOPIC: () => INJECTIONS_TOPIC,
+  MessagingHubGraph: () => MessagingHubGraph,
+  PROMPTS_TOPIC: () => PROMPTS_TOPIC,
+  RESPONSES_TOPIC: () => RESPONSES_TOPIC,
+  SPAWNS_TOPIC: () => SPAWNS_TOPIC,
+  STANDARD_TOPICS: () => STANDARD_TOPICS,
+  SubscriptionGraph: () => SubscriptionGraph,
+  TODOS_TOPIC: () => TODOS_TOPIC,
+  TopicBridgeGraph: () => TopicBridgeGraph,
+  TopicGraph: () => TopicGraph,
+  TopicRegistry: () => TopicRegistry,
+  hubRemoveTopicKeyOf: () => hubRemoveTopicKeyOf,
+  messagingHub: () => messagingHub,
+  subscription: () => subscription,
+  subscriptionAckKeyOf: () => subscriptionAckKeyOf,
+  subscriptionPullAndAckKeyOf: () => subscriptionPullAndAckKeyOf,
+  topic: () => topic,
+  topicBridge: () => topicBridge,
+  topicPublishKeyOf: () => topicPublishKeyOf
+});
+module.exports = __toCommonJS(messaging_exports);
+
+// src/utils/messaging/audit-records.ts
+var topicPublishKeyOf = (r) => `${r.topicName}::${r.itemKey}`;
+var subscriptionAckKeyOf = (r) => `${r.subscriptionId}::${r.cursor}`;
+var subscriptionPullAndAckKeyOf = (r) => `${r.subscriptionId}::${r.cursor}`;
+var hubRemoveTopicKeyOf = (r) => r.topicName;
+
+// src/utils/messaging/message.ts
+var PROMPTS_TOPIC = "prompts";
+var RESPONSES_TOPIC = "responses";
+var INJECTIONS_TOPIC = "injections";
+var DEFERRED_TOPIC = "deferred";
+var SPAWNS_TOPIC = "spawns";
+var CONTEXT_TOPIC = "context";
+var TODOS_TOPIC = "todos";
+var STANDARD_TOPICS = [
+  PROMPTS_TOPIC,
+  RESPONSES_TOPIC,
+  INJECTIONS_TOPIC,
+  DEFERRED_TOPIC,
+  SPAWNS_TOPIC,
+  CONTEXT_TOPIC,
+  TODOS_TOPIC
+];
+
+// src/utils/messaging/index.ts
+var import_core2 = require("@graphrefly/pure-ts/core");
+var import_extra2 = require("@graphrefly/pure-ts/extra");
+var import_graph2 = require("@graphrefly/pure-ts/graph");
+
+// src/base/meta/domain-meta.ts
+function domainMeta(domain, kind, extra) {
+  return {
+    [domain]: true,
+    [`${domain}_type`]: kind,
+    ...extra ?? {}
+  };
+}
+
+// src/base/mutation/index.ts
+var import_core = require("@graphrefly/pure-ts/core");
+var import_extra = require("@graphrefly/pure-ts/extra");
+var import_graph = require("@graphrefly/pure-ts/graph");
+var DEFAULT_AUDIT_GUARD = (0, import_core.policy)((allow, deny) => {
+  allow("observe");
+  allow("signal");
+  deny("write");
+});
+function deepFreeze(value) {
+  if (value === null || typeof value !== "object" || Object.isFrozen(value)) return value;
+  for (const k of Object.keys(value)) {
+    deepFreeze(value[k]);
+  }
+  return Object.freeze(value);
+}
+function mutate(act, opts) {
+  const { up, down } = typeof act === "function" ? { up: act, down: void 0 } : act;
+  const freeze = opts.freeze ?? true;
+  if (opts.frame === "inline") {
+    return function wrapped(...args) {
+      const sealed = freeze ? args.map(deepFreeze) : args;
+      const t_ns = (0, import_core.wallClockNs)();
+      const seq = opts.seq ? bumpCursor(opts.seq) : void 0;
+      try {
+        const result = up(...sealed);
+        if (opts.log && opts.onSuccessRecord) {
+          appendAudit(
+            opts.log,
+            opts.onSuccessRecord,
+            sealed,
+            result,
+            { t_ns, seq },
+            opts.handlerVersion
+          );
+        }
+        return result;
+      } catch (err) {
+        if (opts.log && opts.onFailureRecord) {
+          const errorType = err instanceof Error ? err.name : typeof err;
+          appendAudit(
+            opts.log,
+            opts.onFailureRecord,
+            sealed,
+            err,
+            { t_ns, seq, errorType },
+            opts.handlerVersion
+          );
+        }
+        throw err;
+      }
+    };
+  }
+  return function wrapped(...args) {
+    const sealed = freeze ? args.map(deepFreeze) : args;
+    const t_ns = (0, import_core.wallClockNs)();
+    let result;
+    let captured;
+    let captureSet = false;
+    let seq;
+    try {
+      (0, import_core.batch)(() => {
+        if (opts.seq) seq = bumpCursor(opts.seq);
+        try {
+          result = up(...sealed);
+          if (opts.log && opts.onSuccessRecord) {
+            appendAudit(
+              opts.log,
+              opts.onSuccessRecord,
+              sealed,
+              result,
+              { t_ns, seq },
+              opts.handlerVersion
+            );
+          }
+        } catch (err) {
+          captured = err;
+          captureSet = true;
+          throw err;
+        }
+      });
+    } catch (outerErr) {
+      if (captureSet && down) {
+        try {
+          down(...sealed);
+        } catch (downErr) {
+          console.error(
+            `mutate: down hook threw \u2014 original action error preserved (${captured instanceof Error ? captured.name : typeof captured}). Down error:`,
+            downErr
+          );
+        }
+      }
+      if (captureSet && opts.log && opts.onFailureRecord) {
+        const errorType = captured instanceof Error ? captured.name : typeof captured;
+        appendAudit(
+          opts.log,
+          opts.onFailureRecord,
+          sealed,
+          captured,
+          { t_ns, seq, errorType },
+          opts.handlerVersion
+        );
+      }
+      throw captureSet ? captured : outerErr;
+    }
+    return result;
+  };
+}
+var _bumpCursorWarned = /* @__PURE__ */ new WeakSet();
+function bumpCursor(seq) {
+  const raw = seq.cache;
+  const valid = typeof raw === "number" && Number.isFinite(raw);
+  if (!valid && raw !== void 0 && !_bumpCursorWarned.has(seq)) {
+    _bumpCursorWarned.add(seq);
+    console.warn(
+      `bumpCursor: cursor cache held a non-numeric value (${String(raw)}); resetting to 0. Causes include: a snapshot codec round-tripping the cursor as a string / null / NaN, OR a malformed initial seed (e.g. state<number>(NaN)). Audit consumers may see colliding seq values after this point.`
+    );
+  }
+  const cur = valid ? raw : 0;
+  const next = cur + 1;
+  seq.down([[import_core.DIRTY], [import_core.DATA, next]]);
+  return next;
+}
+function appendAudit(audit, builder, args, value, meta, handlerVersion) {
+  const record = builder(args, value, meta);
+  if (record === void 0) return;
+  const stamped = handlerVersion != null ? { ...record, handlerVersion } : record;
+  audit.append(stamped);
+}
+
+// src/utils/messaging/index.ts
+var DEFAULT_MAX_PER_PUMP = 256;
+function requireNonNegativeInt(value, label) {
+  if (!Number.isFinite(value) || !Number.isInteger(value) || value < 0) {
+    throw new Error(`${label} must be a non-negative integer`);
+  }
+  return value;
+}
+function messagingMeta(kind, extra) {
+  return domainMeta("messaging", kind, extra);
+}
+var DEFAULT_TOPIC_RETAINED_LIMIT = 1024;
+var TopicGraph = class extends import_graph2.Graph {
+  _log;
+  _publishImpl;
+  events;
+  /**
+   * Most recently published value. Stays in the protocol SENTINEL state
+   * (`cache === undefined`, no DATA emitted) until the first publish, then
+   * tracks the latest entry. Spec §5.12 reserves `undefined` as the
+   * "never sent DATA" sentinel — and `TopicGraph.publish(undefined)` is
+   * rejected — so `cache === undefined` unambiguously signals "empty topic"
+   * even when `T` itself includes `null` (i.e., `topic<number | null>`).
+   *
+   * **Within a reactive fn:** detect the empty-topic case via
+   * `ctx.prevData[i] === undefined` for the dep slot holding `topic.latest`,
+   * or check `latest.cache === undefined` outside reactive code. No
+   * separate `hasLatest` companion needed — the SENTINEL is the answer.
+   */
+  latest;
+  constructor(name, opts = {}) {
+    super(name, opts.graph);
+    this._log = (0, import_extra2.reactiveLog)([], {
+      name: "events",
+      maxSize: opts.retainedLimit ?? DEFAULT_TOPIC_RETAINED_LIMIT
+    });
+    this.events = this._log.entries;
+    this.add(this.events, { name: "events" });
+    this.latest = this.derived(
+      "latest",
+      ["events"],
+      (batchData, ctx) => {
+        const data = batchData.map(
+          (batch3, i) => batch3 != null && batch3.length > 0 ? batch3.at(-1) : ctx.prevData[i]
+        );
+        const entries = data[0];
+        return entries.length === 0 ? [] : [entries[entries.length - 1]];
+      },
+      { meta: messagingMeta("topic_latest") }
+    );
+    this.addDisposer((0, import_extra2.keepalive)(this.latest));
+    this.addDisposer(() => {
+      this.events.down([[import_core2.COMPLETE]]);
+    });
+    this.addDisposer(() => this._log.disposeAllViews());
+    this._publishImpl = mutate(
+      (value) => {
+        this._log.append(value);
+      },
+      { frame: "inline", freeze: false }
+    );
+  }
+  publish(value) {
+    if (value === void 0) {
+      throw new TypeError(
+        `TopicGraph "${this.name}": publish(undefined) is not allowed (spec \xA75.12 SENTINEL).`
+      );
+    }
+    this._publishImpl(value);
+  }
+  /**
+   * Wire one or more append-log storage tiers (Audit 4). Each tier receives
+   * appended events per wave; rollback honors the wave-as-transaction model.
+   *
+   * Named `attachEventStorage` (not `attachStorage`) to avoid colliding with
+   * the inherited {@link Graph.attachSnapshotStorage} which takes the
+   * paired `AttachSnapshotTierPair[]` shape (Phase 14.6) — distinct
+   * concerns, distinct surfaces.
+   *
+   * @returns Disposer.
+   */
+  attachEventStorage(tiers) {
+    return this._log.attachStorage(tiers);
+  }
+  retained() {
+    return this.events.cache;
+  }
+  /** Internal log bundle — used by TopicBridgeGraph for `attach`. */
+  get _logBundle() {
+    return this._log;
+  }
+};
+var SubscriptionGraph = class extends import_graph2.Graph {
+  cursor;
+  available;
+  /**
+   * Reference to the upstream topic graph. Intentionally NOT mounted
+   * under this subscription: a subscription is a VIEW over an
+   * externally-owned topic. Double-mounting (e.g. hub-owned topic +
+   * sub-mount here) would make either-side teardown leave the other
+   * holding a dead reference. Node-level `derived([topicEvents], …)`
+   * still wires the data dependency across graph boundaries. D1(e).
+   */
+  topic;
+  _disposed = false;
+  _ackImpl;
+  _pullAndAckImpl;
+  constructor(name, topicGraph, opts = {}) {
+    super(name, opts.graph);
+    this.topic = topicGraph;
+    let initialCursor;
+    if (opts.from !== void 0) {
+      if (opts.from === "retained") {
+        initialCursor = 0;
+      } else if (opts.from === "now") {
+        initialCursor = topicGraph.events.cache.length;
+      } else {
+        initialCursor = requireNonNegativeInt(opts.from, "subscription from");
+      }
+    } else {
+      initialCursor = requireNonNegativeInt(opts.cursor ?? 0, "subscription cursor");
+    }
+    this.cursor = this.state("cursor", initialCursor, {
+      meta: messagingMeta("subscription_cursor")
+    });
+    this.available = topicGraph._logBundle.view({ kind: "fromCursor", cursor: this.cursor });
+    this.add(this.available, { name: "available" });
+    this.addDisposer((0, import_extra2.keepalive)(this.available));
+    if (opts.advanceOn !== void 0) {
+      const advanceOn = opts.advanceOn;
+      let advanceInitialized = false;
+      const advancePump = (0, import_core2.node)(
+        [advanceOn],
+        () => {
+          if (!advanceInitialized) {
+            advanceInitialized = true;
+            return;
+          }
+          if (this._disposed) return;
+          const avail = this.available.cache;
+          if (avail.length === 0) return;
+          const next = this.cursor.cache + avail.length;
+          this.cursor.emit(next);
+        },
+        {
+          name: "advancePump",
+          describeKind: "effect",
+          meta: messagingMeta("subscription_advance_pump")
+        }
+      );
+      this.add(advancePump, { name: "advancePump" });
+      this.addDisposer((0, import_extra2.keepalive)(advancePump));
+    }
+    this._ackImpl = mutate(
+      (count) => {
+        const available = this.available.cache;
+        const requested = count === void 0 ? available.length : requireNonNegativeInt(count, "subscription ack count");
+        const step = Math.min(requested, available.length);
+        if (step <= 0) return this.cursor.cache;
+        const next = this.cursor.cache + step;
+        this.cursor.emit(next);
+        return next;
+      },
+      { frame: "inline", freeze: false }
+    );
+    this._pullAndAckImpl = mutate(
+      (limit) => {
+        const available = this.available.cache;
+        const max = limit === void 0 ? available.length : requireNonNegativeInt(limit, "subscription pullAndAck limit");
+        const items = available.slice(0, max);
+        if (items.length === 0) return { items, cursor: this.cursor.cache };
+        const next = this.cursor.cache + items.length;
+        this.cursor.emit(next);
+        return { items, cursor: next };
+      },
+      { frame: "inline", freeze: false }
+    );
+  }
+  ack(count) {
+    if (this._disposed) return this.cursor.cache;
+    return this._ackImpl(count);
+  }
+  pull(limit) {
+    if (this._disposed) return [];
+    const available = this.available.cache;
+    const max = limit === void 0 ? available.length : requireNonNegativeInt(limit, "subscription pull limit");
+    return available.slice(0, max);
+  }
+  /**
+   * Atomic pull-and-acknowledge. Returns `{ items, cursor }` where `cursor`
+   * is the new cursor position after advancing. Under single-threaded JS the
+   * snapshot and advance are atomic; PY callers use a per-subscription Lock.
+   *
+   * Replaces `pull(limit, { ack: true })`.
+   */
+  pullAndAck(limit) {
+    if (this._disposed) return { items: [], cursor: this.cursor.cache };
+    return this._pullAndAckImpl(limit);
+  }
+  /**
+   * Release internal subscriptions and mark the subscription torn-down.
+   * Subsequent `pull`, `pullAndAck`, `ack` return empty / current cursor.
+   * Emits COMPLETE on `cursor` so derived consumers (e.g. `available`) see
+   * the termination signal. Also drains `addDisposer` callbacks (including
+   * the `keepalive(advancePump)` subscription) so no keepalive leak occurs.
+   */
+  dispose() {
+    if (this._disposed) return;
+    this._disposed = true;
+    this.cursor.down([[import_core2.COMPLETE]]);
+    this.destroy();
+  }
+};
+var TopicBridgeGraph = class extends import_graph2.Graph {
+  _sourceSub;
+  bridgedCount;
+  /**
+   * Emits each mapped batch as DATA — gives downstream observers a reactive
+   * stream of bridged values. Also the link target for `target._log.attach`.
+   */
+  output;
+  constructor(name, sourceTopic, targetTopic, opts = {}) {
+    super(name, opts.graph);
+    this._sourceSub = subscription(`${name}-subscription`, sourceTopic, {
+      cursor: opts.cursor
+    });
+    this.mount("subscription", this._sourceSub);
+    const maxPerPump = Math.max(
+      1,
+      requireNonNegativeInt(opts.maxPerPump ?? DEFAULT_MAX_PER_PUMP, "topic bridge maxPerPump")
+    );
+    const mapValue = opts.map ?? ((value) => value);
+    this.output = (0, import_core2.node)(
+      [this._sourceSub.available],
+      (batchData, actions, ctx) => {
+        const data = batchData.map(
+          (batch3, i) => batch3 != null && batch3.length > 0 ? batch3.at(-1) : ctx.prevData[i]
+        );
+        const arr = data[0];
+        const outBatch = [];
+        const take = Math.min(arr.length, maxPerPump);
+        for (let i = 0; i < take; i++) {
+          const mapped = mapValue(arr[i]);
+          if (mapped !== void 0) outBatch.push(mapped);
+        }
+        actions.emit(outBatch);
+      },
+      {
+        name: "output",
+        describeKind: "derived",
+        meta: messagingMeta("topic_bridge_output", { targetRef: targetTopic.name }),
+        initial: []
+      }
+    );
+    this.add(this.output, { name: "output" });
+    this.addDisposer((0, import_extra2.keepalive)(this.output));
+    this.bridgedCount = this.state("bridgedCount", 0, {
+      meta: messagingMeta("topic_bridge_count")
+    });
+    this.addDisposer((0, import_extra2.keepalive)(this.bridgedCount));
+    const outputRef = this.output;
+    const subRef = this._sourceSub;
+    const countRef = this.bridgedCount;
+    const ackPump = this.effect(
+      "ackPump",
+      ["output"],
+      () => {
+        const outBatch = outputRef.cache;
+        if (outBatch.length === 0) return;
+        const availLen = subRef.available.cache.length;
+        const toAck = Math.min(availLen, maxPerPump);
+        if (toAck > 0) {
+          subRef.ack(toAck);
+          const prev = countRef.cache ?? 0;
+          countRef.emit(prev + outBatch.length);
+        }
+      },
+      {
+        meta: messagingMeta("topic_bridge_ack_pump")
+      }
+    );
+    this.addDisposer((0, import_extra2.keepalive)(ackPump));
+    const detach = _attachArrayToLog(this.output, targetTopic);
+    this.addDisposer(detach);
+  }
+};
+function _attachArrayToLog(source, targetTopic) {
+  return source.subscribe((msgs) => {
+    for (const m of msgs) {
+      if (m[0] !== import_core2.DATA) continue;
+      const arr = m[1];
+      if (arr.length === 0) continue;
+      (0, import_core2.batch)(() => {
+        for (const v of arr) targetTopic.publish(v);
+      });
+    }
+  });
+}
+var TopicRegistry = class {
+  _map = /* @__PURE__ */ new Map();
+  /** Reactive monotonic version counter. Advances on topic create/remove. */
+  version;
+  constructor(versionNode) {
+    this.version = versionNode;
+  }
+  get size() {
+    return this._map.size;
+  }
+  has(name) {
+    return this._map.has(name);
+  }
+  get(name) {
+    return this._map.get(name);
+  }
+  set(name, t) {
+    this._map.set(name, t);
+  }
+  delete(name) {
+    return this._map.delete(name);
+  }
+  keys() {
+    return this._map.keys();
+  }
+};
+var MessagingHubGraph = class extends import_graph2.Graph {
+  _registry;
+  /** Reactive monotonic version counter — advances on topic create/remove. */
+  version;
+  _defaultTopicOptions;
+  _removeTopicImpl;
+  constructor(name, opts = {}) {
+    super(name, opts.graph);
+    const versionNode = this.state("version", 0, {
+      meta: messagingMeta("hub_version")
+    });
+    this.version = versionNode;
+    this._registry = new TopicRegistry(versionNode);
+    this._defaultTopicOptions = { ...opts.defaultTopicOptions ?? {} };
+    this._removeTopicImpl = mutate(
+      (topicName) => {
+        try {
+          this.remove(topicName);
+        } finally {
+          this._registry.delete(topicName);
+          const cur = this.version.cache ?? 0;
+          this.version.emit(cur + 1);
+        }
+      },
+      { frame: "inline", freeze: false }
+    );
+  }
+  /** Number of topics currently in the hub. */
+  get size() {
+    return this._registry.size;
+  }
+  /** Checks topic existence without creating. */
+  has(name) {
+    return this._registry.has(name);
+  }
+  /** Iterator over topic names. */
+  topicNames() {
+    return this._registry.keys();
+  }
+  /**
+   * Returns the {@link TopicGraph} for `name`, creating lazily on first call.
+   * Subsequent calls with the same name return the same instance (options on
+   * repeat calls are ignored — the topic is already configured).
+   */
+  topic(name, opts) {
+    let t = this._registry.get(name);
+    if (t === void 0) {
+      const effective = { ...this._defaultTopicOptions, ...opts ?? {} };
+      t = new TopicGraph(name, effective);
+      this._registry.set(name, t);
+      this.mount(name, t);
+      const cur = this.version.cache ?? 0;
+      this.version.emit(cur + 1);
+    }
+    return t;
+  }
+  /**
+   * Publishes a value to the topic, lazily creating it on first publish.
+   *
+   * **Late-subscriber caveat:** the topic is created lazily, so subscribers
+   * that attach AFTER a publish only see the retained window (governed by
+   * `retainedLimit` on `TopicOptions` / `defaultTopicOptions`). If
+   * `retainedLimit === 0` is set explicitly, early publishes are
+   * effectively dropped — prefer an unset `retainedLimit` (unbounded
+   * retention) or subscribe before publishing when late-subscribers matter.
+   */
+  publish(name, value) {
+    this.topic(name).publish(value);
+  }
+  /**
+   * Bulk publish — issues all publishes inside one outer batch. New topics
+   * are created on demand. No-op if `entries` yields nothing.
+   *
+   * **Iterable consumption (F6):** `entries` is consumed once (single-pass)
+   * INSIDE the batch frame. If the iterator throws mid-way, the batch is
+   * discarded and NO publishes are visible to subscribers (all-or-nothing).
+   * Pass an array or `Set` for multi-shot callers.
+   */
+  publishMany(entries) {
+    (0, import_core2.batch)(() => {
+      for (const [name, value] of entries) {
+        this.topic(name).publish(value);
+      }
+    });
+  }
+  /**
+   * Creates a {@link SubscriptionGraph} over a named topic. The topic is
+   * lazily created if missing. Subscription lifecycle is owned by the caller —
+   * the hub does NOT mount the subscription.
+   *
+   * @param subName - Local name for the subscription graph.
+   * @param topicName - Hub topic to subscribe to.
+   * @param opts - `SubscriptionOptions` (initial cursor, etc.).
+   */
+  subscribe(subName, topicName, opts) {
+    const t = this.topic(topicName);
+    return new SubscriptionGraph(subName, t, opts);
+  }
+  /**
+   * Unmounts and tears down the topic's graph. Returns `true` if the topic
+   * existed. Subscribers receive `TEARDOWN` via {@link Graph.remove}.
+   *
+   * **Closure-state caveat:** the registry mutation (`_registry.delete`) and
+   * version bump happen in a `try/finally`, so registry/version converge to
+   * a consistent state even when {@link Graph.remove} throws. `mutate`
+   * does not roll back this mutation on throw — `Map.delete` on closure
+   * state is invisible to any batch frame. The pre-existing try/finally is
+   * load-bearing for that invariant.
+   */
+  removeTopic(name) {
+    if (!this._registry.has(name)) return false;
+    this._removeTopicImpl(name);
+    return true;
+  }
+};
+function topic(name, opts) {
+  return new TopicGraph(name, opts);
+}
+function messagingHub(name, opts) {
+  return new MessagingHubGraph(name, opts);
+}
+function subscription(name, topicGraph, opts) {
+  return new SubscriptionGraph(name, topicGraph, opts);
+}
+function topicBridge(name, sourceTopic, targetTopic, opts) {
+  return new TopicBridgeGraph(name, sourceTopic, targetTopic, opts);
+}
+//# sourceMappingURL=index.cjs.map