@graphrefly/graphrefly 0.26.0 → 0.28.0

package/dist/index-DpHe5e0Q.d.ts

@@ -0,0 +1,186 @@
+import { a as Node, N as NodeOptions } from './node-Cc1TniY8.js';
+import { a as GraphOptions, G as Graph } from './graph-BZGRXwOm.js';
+
+/**
+ * Reduction primitives (roadmap §8.1).
+ *
+ * Composable building blocks for taking heterogeneous massive inputs and producing
+ * prioritized, auditable, human-actionable output. Each primitive is either a Graph
+ * factory or a Node factory, built on top of core + extra primitives.
+ *
+ * @module
+ */
+
+type StepRef = string | Node<unknown>;
+/** A named stage for {@link funnel}. */
+type FunnelStage = {
+    /** Stage name (mounted as subgraph). */
+    name: string;
+    /** Builder: receives a sub-graph, should add an `"input"` and `"output"` node. */
+    build: (sub: Graph) => void;
+};
+/** Options for {@link funnel}. */
+type FunnelOptions = GraphOptions & {
+    meta?: Record<string, unknown>;
+};
+/**
+ * Multi-source merge with sequential reduction stages.
+ *
+ * Sources are merged into a single stream. Each stage is a named subgraph
+ * (mounted via `graph.mount()`). Stages connect linearly:
+ * `merged → stage[0].input → stage[0].output → stage[1].input → ...`
+ *
+ * @param name - Graph name.
+ * @param sources - Input nodes to merge.
+ * @param stages - Sequential reduction stages.
+ * @param opts - Optional graph/meta options.
+ * @returns Graph with `"merged"` and mounted stage subgraphs.
+ *
+ * @category patterns
+ */
+declare function funnel<T>(name: string, sources: ReadonlyArray<Node<T>>, stages: ReadonlyArray<FunnelStage>, opts?: FunnelOptions): Graph;
+/** Options for {@link feedback}. */
+type FeedbackOptions = {
+    /** Maximum feedback iterations before stopping (default: 10). */
+    maxIterations?: number;
+    /** Optional budget gate node path for cost-bounded iteration. */
+    budgetNode?: StepRef;
+    meta?: Record<string, unknown>;
+};
+/**
+ * Introduce a bounded reactive cycle into an existing graph.
+ *
+ * When `condition` emits a non-null DATA value, the feedback effect routes it
+ * back to the `reentry` state node — creating a cycle. Bounded by
+ * `maxIterations` (default 10). The counter node (`__feedback_<condition>`)
+ * is the source of truth — reset it to 0 to allow more iterations.
+ *
+ * To remove the feedback cycle, call `graph.remove("__feedback_<condition>")`.
+ *
+ * @param graph - Existing graph to augment with a feedback cycle.
+ * @param condition - Path to a node whose DATA triggers feedback.
+ * @param reentry - Path to a state node that receives the feedback value.
+ * @param opts - Iteration bounds and metadata.
+ * @returns The same graph (mutated with feedback nodes added).
+ *
+ * @category patterns
+ */
+declare function feedback(graph: Graph, condition: string, reentry: string, opts?: FeedbackOptions): Graph;
+/** A reactive constraint for {@link budgetGate}. */
+type BudgetConstraint<T = unknown> = {
+    /** Constraint node whose value is checked. */
+    node: Node<T>;
+    /** Returns `true` when the constraint is satisfied (budget available). */
+    check: (value: T) => boolean;
+};
+/** Options for {@link budgetGate}. */
+type BudgetGateOptions = Omit<NodeOptions<unknown>, "describeKind" | "name" | "meta"> & {
+    meta?: Record<string, unknown>;
+};
+/**
+ * Pass-through that respects reactive constraint nodes.
+ *
+ * DATA flows through when all constraints are satisfied. When any constraint
+ * is exceeded, PAUSE is sent upstream and DATA is buffered. When constraints
+ * relax, RESUME is sent and buffered DATA flushes.
+ *
+ * @param source - Input node.
+ * @param constraints - Reactive constraint checks.
+ * @param opts - Optional node options.
+ * @returns Gated node.
+ *
+ * @category patterns
+ */
+declare function budgetGate<T>(source: Node<T>, constraints: ReadonlyArray<BudgetConstraint>, opts?: BudgetGateOptions): Node<T>;
+/** A scored item with full breakdown. */
+type ScoredItem<T = unknown> = {
+    /** Original value. */
+    value: T;
+    /** Final weighted score. */
+    score: number;
+    /** Per-signal breakdown: signal index → weighted contribution. */
+    breakdown: number[];
+};
+/** Options for {@link scorer}. */
+type ScorerOptions = Omit<NodeOptions<unknown>, "describeKind" | "name" | "meta"> & {
+    meta?: Record<string, unknown>;
+    /** Custom scoring function per signal. Default: identity (signal value IS the score). */
+    scoreFns?: ReadonlyArray<(value: unknown) => number>;
+};
+/**
+ * Reactive multi-signal scoring with live weights.
+ *
+ * Each source emits items to score. Weights are reactive state nodes that
+ * LLM or human can adjust live. Output is sorted scored items with full
+ * breakdown.
+ *
+ * @param sources - Signal nodes (each emits a numeric score dimension).
+ * @param weights - Reactive weight nodes (one per source).
+ * @param opts - Optional node/meta options.
+ * @returns Node emitting scored output.
+ *
+ * @category patterns
+ */
+declare function scorer(sources: ReadonlyArray<Node<number>>, weights: ReadonlyArray<Node<number>>, opts?: ScorerOptions): Node<ScoredItem<number[]>>;
+/** A single effectiveness record for an action×context pair. */
+type EffectivenessEntry = {
+    readonly key: string;
+    readonly attempts: number;
+    readonly successes: number;
+    readonly successRate: number;
+};
+/** Snapshot shape for the effectiveness tracker node. */
+type EffectivenessSnapshot = ReadonlyMap<string, EffectivenessEntry>;
+/** Bundle returned by {@link effectivenessTracker}. */
+interface EffectivenessTrackerBundle {
+    /** Reactive node — current effectiveness map snapshot. */
+    readonly node: Node<EffectivenessSnapshot>;
+    /** Record a completed action (success or failure). */
+    record(key: string, success: boolean): void;
+    /** Look up effectiveness for a specific key. */
+    lookup(key: string): EffectivenessEntry | undefined;
+    /** Tear down internal keepalive subscriptions. */
+    dispose(): void;
+}
+/** Options for {@link effectivenessTracker}. */
+type EffectivenessTrackerOptions = {
+    /** Name for the reactive map (default "effectiveness-entries"). */
+    name?: string;
+};
+/**
+ * Generic action×context → success rate tracker.
+ *
+ * Generalized from the harness `strategyModel` pattern. Tracks attempts and
+ * successes per string key, exposes a reactive snapshot node, and provides
+ * `record()` / `lookup()` methods.
+ *
+ * Use cases: A/B testing, routing optimization, cache policy tuning, retry
+ * strategy selection — any domain that tracks effectiveness per action.
+ *
+ * @param opts - Optional configuration.
+ * @returns Bundle with reactive node, record(), lookup(), dispose().
+ */
+declare function effectivenessTracker(opts?: EffectivenessTrackerOptions): EffectivenessTrackerBundle;
+
+type index_BudgetConstraint<T = unknown> = BudgetConstraint<T>;
+type index_BudgetGateOptions = BudgetGateOptions;
+type index_EffectivenessEntry = EffectivenessEntry;
+type index_EffectivenessSnapshot = EffectivenessSnapshot;
+type index_EffectivenessTrackerBundle = EffectivenessTrackerBundle;
+type index_EffectivenessTrackerOptions = EffectivenessTrackerOptions;
+type index_FeedbackOptions = FeedbackOptions;
+type index_FunnelOptions = FunnelOptions;
+type index_FunnelStage = FunnelStage;
+type index_ScoredItem<T = unknown> = ScoredItem<T>;
+type index_ScorerOptions = ScorerOptions;
+type index_StepRef = StepRef;
+declare const index_budgetGate: typeof budgetGate;
+declare const index_effectivenessTracker: typeof effectivenessTracker;
+declare const index_feedback: typeof feedback;
+declare const index_funnel: typeof funnel;
+declare const index_scorer: typeof scorer;
+declare namespace index {
+  export { type index_BudgetConstraint as BudgetConstraint, type index_BudgetGateOptions as BudgetGateOptions, type index_EffectivenessEntry as EffectivenessEntry, type index_EffectivenessSnapshot as EffectivenessSnapshot, type index_EffectivenessTrackerBundle as EffectivenessTrackerBundle, type index_EffectivenessTrackerOptions as EffectivenessTrackerOptions, type index_FeedbackOptions as FeedbackOptions, type index_FunnelOptions as FunnelOptions, type index_FunnelStage as FunnelStage, type index_ScoredItem as ScoredItem, type index_ScorerOptions as ScorerOptions, type index_StepRef as StepRef, index_budgetGate as budgetGate, index_effectivenessTracker as effectivenessTracker, index_feedback as feedback, index_funnel as funnel, index_scorer as scorer };
+}
+
+export { type BudgetConstraint as B, type EffectivenessEntry as E, type FeedbackOptions as F, type ScoredItem as S, type BudgetGateOptions as a, type EffectivenessSnapshot as b, type EffectivenessTrackerBundle as c, type EffectivenessTrackerOptions as d, type FunnelOptions as e, type FunnelStage as f, type ScorerOptions as g, type StepRef as h, index as i, budgetGate as j, effectivenessTracker as k, feedback as l, funnel as m, scorer as s };

package/dist/index-DraikLjn.d.ts

@@ -0,0 +1,86 @@
+import { a as Node } from './node-Cc1TniY8.js';
+import { G as Graph, a as GraphOptions } from './graph-BZGRXwOm.js';
+
+/**
+ * Job queue patterns (roadmap §4.2).
+ *
+ * Queue / flow primitives modeled as graph factories:
+ * - `jobQueue()` — claim/ack/nack workflow with reactive depth.
+ * - `jobFlow()` — multi-stage queue chain.
+ *
+ * Topic / subscription / hub primitives live in `patterns/messaging`.
+ */
+
+type JobState = "queued" | "inflight";
+type JobEnvelope<T> = {
+    id: string;
+    payload: T;
+    attempts: number;
+    metadata: Readonly<Record<string, unknown>>;
+    state: JobState;
+};
+type JobQueueOptions = {
+    graph?: GraphOptions;
+};
+declare class JobQueueGraph<T> extends Graph {
+    private readonly _pending;
+    private readonly _jobs;
+    private _seq;
+    readonly pending: Node<readonly string[]>;
+    readonly jobs: Node<ReadonlyMap<string, JobEnvelope<T>>>;
+    readonly depth: Node<number>;
+    constructor(name: string, opts?: JobQueueOptions);
+    enqueue(payload: T, opts?: {
+        id?: string;
+        metadata?: Record<string, unknown>;
+    }): string;
+    claim(limit?: number): readonly JobEnvelope<T>[];
+    ack(id: string): boolean;
+    nack(id: string, opts?: {
+        requeue?: boolean;
+    }): boolean;
+}
+type JobFlowOptions = {
+    graph?: GraphOptions;
+    stages?: readonly string[];
+    maxPerPump?: number;
+};
+declare class JobFlowGraph<T> extends Graph {
+    private readonly _stageNames;
+    private readonly _queues;
+    private readonly _completed;
+    readonly completed: Node<readonly JobEnvelope<T>[]>;
+    readonly completedCount: Node<number>;
+    constructor(name: string, opts?: JobFlowOptions);
+    stages(): readonly string[];
+    queue(stage: string): JobQueueGraph<T>;
+    enqueue(payload: T, opts?: {
+        id?: string;
+        metadata?: Record<string, unknown>;
+    }): string;
+    retainedCompleted(): readonly JobEnvelope<T>[];
+}
+/**
+ * Creates a Pulsar-inspired job queue graph with claim/ack/nack workflow.
+ */
+declare function jobQueue<T>(name: string, opts?: JobQueueOptions): JobQueueGraph<T>;
+/**
+ * Creates an autonomous multi-stage queue chain graph.
+ */
+declare function jobFlow<T>(name: string, opts?: JobFlowOptions): JobFlowGraph<T>;
+
+type index_JobEnvelope<T> = JobEnvelope<T>;
+type index_JobFlowGraph<T> = JobFlowGraph<T>;
+declare const index_JobFlowGraph: typeof JobFlowGraph;
+type index_JobFlowOptions = JobFlowOptions;
+type index_JobQueueGraph<T> = JobQueueGraph<T>;
+declare const index_JobQueueGraph: typeof JobQueueGraph;
+type index_JobQueueOptions = JobQueueOptions;
+type index_JobState = JobState;
+declare const index_jobFlow: typeof jobFlow;
+declare const index_jobQueue: typeof jobQueue;
+declare namespace index {
+  export { type index_JobEnvelope as JobEnvelope, index_JobFlowGraph as JobFlowGraph, type index_JobFlowOptions as JobFlowOptions, index_JobQueueGraph as JobQueueGraph, type index_JobQueueOptions as JobQueueOptions, type index_JobState as JobState, index_jobFlow as jobFlow, index_jobQueue as jobQueue };
+}
+
+export { type JobEnvelope as J, JobFlowGraph as a, type JobFlowOptions as b, JobQueueGraph as c, type JobQueueOptions as d, type JobState as e, jobQueue as f, index as i, jobFlow as j };

package/dist/{index-BEfE8H_G.d.cts → index-DxsnAMWD.d.cts}

@@ -1,12 +1,12 @@
-import { i as index$2 } from './index-QBpffFW-.cjs';
-import { i as index$3 } from './index-CUyrtuOf.cjs';
-import { i as index$4 } from './index-_oMEWlDq.cjs';
-import { i as index$5 } from './index-DFhjO4Gg.cjs';
-import { N as Node } from './node-C_IBuvX2.cjs';
-import { i as index$6 } from './index-B_IP40nB.cjs';
-import { i as index$7 } from './index-Bd_fwmLf.cjs';
-import { i as index$8 } from './index-Bxb5ZYc9.cjs';
-import { i as index$9 } from './index-B4MP_8V_.cjs';
+import { i as index$2 } from './index-CRO83MmV.cjs';
+import { i as index$3 } from './index-Cyojz0AE.cjs';
+import { i as index$4 } from './index-cByzxQIC.cjs';
+import { i as index$5 } from './index-DL-rYJrx.cjs';
+import { a as Node } from './node-Cc1TniY8.cjs';
+import { i as index$6 } from './index-B_agccPe.cjs';
+import { i as index$7 } from './index-B2pwesl9.cjs';
+import { i as index$8 } from './index-D_NwnRYS.cjs';
+import { i as index$9 } from './index-Oi8d8w4R.cjs';
 
 /**
  * Options for creating signals.

package/dist/index-DyxjtScX.d.cts

@@ -0,0 +1,207 @@
+import { a as Node } from './node-Cc1TniY8.cjs';
+import { G as Graph, a as GraphOptions } from './graph-D48Qw9Cg.cjs';
+
+/**
+ * Messaging patterns (roadmap §4.2).
+ *
+ * Pulsar-inspired messaging primitives modeled as graph factories:
+ * - `topic()` for append-only topic streams with a retained window.
+ * - `subscription()` for cursor-based consumers.
+ * - `topicBridge()` for autonomous topic-to-topic relay.
+ * - `messagingHub()` for a lazy topic registry.
+ *
+ * Job queue / job flow primitives live in `patterns/job-queue` — they are a
+ * distinct domain that happens to share reactive-log / reactive-map
+ * infrastructure with topics.
+ */
+
+type TopicOptions = {
+    graph?: GraphOptions;
+    retainedLimit?: number;
+};
+declare class TopicGraph<T> extends Graph {
+    private readonly _log;
+    readonly events: Node<readonly T[]>;
+    /**
+     * Most recently published value, or `null` when the topic has no entries
+     * yet. Spec §5.12 reserves `undefined` as the protocol-internal "never
+     * sent DATA" sentinel — `null` is the idiomatic "empty / no value" signal
+     * for domain nodes. F7.
+     *
+     * **Caveat when `T` itself includes `null`** (e.g., `topic<number | null>`):
+     * `latest === null` is ambiguous — it could mean "no publish yet" OR "a
+     * `null` value was published". Use {@link hasLatest} to disambiguate, or
+     * observe {@link events} directly and track length yourself.
+     */
+    readonly latest: Node<T | null>;
+    /**
+     * Reactive `true` once the topic has at least one published entry.
+     * Disambiguates "`null` never published" from "`null` was published" when
+     * `T` includes `null`.
+     */
+    readonly hasLatest: Node<boolean>;
+    constructor(name: string, opts?: TopicOptions);
+    publish(value: T): void;
+    retained(): readonly T[];
+}
+type SubscriptionOptions = {
+    graph?: GraphOptions;
+    cursor?: number;
+};
+declare class SubscriptionGraph<T> extends Graph {
+    readonly source: Node<readonly T[]>;
+    readonly cursor: Node<number>;
+    readonly available: Node<readonly T[]>;
+    /**
+     * 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).
+     */
+    readonly topic: TopicGraph<T>;
+    constructor(name: string, topicGraph: TopicGraph<T>, opts?: SubscriptionOptions);
+    ack(count?: number): number;
+    pull(limit?: number, opts?: {
+        ack?: boolean;
+    }): readonly T[];
+}
+type TopicBridgeOptions<TIn, TOut> = {
+    graph?: GraphOptions;
+    cursor?: number;
+    maxPerPump?: number;
+    map?: (value: TIn) => TOut | undefined;
+};
+declare class TopicBridgeGraph<TIn, TOut = TIn> extends Graph {
+    private readonly _sourceSub;
+    private readonly _target;
+    readonly bridgedCount: Node<number>;
+    constructor(name: string, sourceTopic: TopicGraph<TIn>, targetTopic: TopicGraph<TOut>, opts?: TopicBridgeOptions<TIn, TOut>);
+}
+type MessagingHubOptions = {
+    graph?: GraphOptions;
+    /**
+     * Default `TopicOptions` applied to every topic created via `topic(name)`
+     * without explicit options. Per-call opts override. Default: `{}`
+     * (unbounded retention per topic unless `retainedLimit` is set per call).
+     */
+    defaultTopicOptions?: TopicOptions;
+};
+/**
+ * Lazy Pulsar-inspired topic registry. Manages a named set of {@link TopicGraph}
+ * instances with retention + cursor semantics. Topics are created on first
+ * access; `removeTopic(name)` unmounts and tears down via {@link Graph.remove}.
+ *
+ * **Relationship to `pubsub()` in `src/extra/pubsub.ts`:** `pubsub` is a
+ * lightweight last-value state hub (no retention, no cursors). `MessagingHubGraph`
+ * is the full messaging hub — retained message logs, cursor-based subscriptions,
+ * and pattern-layer lifecycle management.
+ *
+ * @category patterns
+ */
+declare class MessagingHubGraph extends Graph {
+    private readonly _topics;
+    private _version;
+    private readonly _defaultTopicOptions;
+    constructor(name: string, opts?: MessagingHubOptions);
+    /** Monotonic counter advancing on topic create/remove. */
+    get version(): number;
+    /** Number of topics currently in the hub. */
+    get size(): number;
+    /** Checks topic existence without creating. */
+    has(name: string): boolean;
+    /** Iterator over topic names. */
+    topicNames(): IterableIterator<string>;
+    /**
+     * 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<T = unknown>(name: string, opts?: TopicOptions): TopicGraph<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<T = unknown>(name: string, value: T): void;
+    /**
+     * 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: Iterable<[string, unknown]>): void;
+    /**
+     * 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<T = unknown>(subName: string, topicName: string, opts?: SubscriptionOptions): SubscriptionGraph<T>;
+    /**
+     * Unmounts and tears down the topic's graph. Returns `true` if the topic
+     * existed. Subscribers receive `TEARDOWN` via {@link Graph.remove}.
+     */
+    removeTopic(name: string): boolean;
+}
+/**
+ * Creates a Pulsar-inspired topic graph (append-only retained stream + latest value).
+ */
+declare function topic<T>(name: string, opts?: TopicOptions): TopicGraph<T>;
+/**
+ * Creates a lazy Pulsar-inspired messaging hub. Topics are created on first access
+ * via `hub.topic(name)`; `hub.publish(name, value)` shortcuts through the registry.
+ *
+ * @example
+ * ```ts
+ * import { messagingHub } from "@graphrefly/graphrefly/patterns/messaging";
+ *
+ * const hub = messagingHub("main", { defaultTopicOptions: { retainedLimit: 256 } });
+ * hub.publish("orders", { id: 1 });
+ * hub.publishMany([["shipments", { id: 1 }], ["orders", { id: 2 }]]);
+ * const sub = hub.subscribe("orders-worker", "orders", { cursor: 0 });
+ * ```
+ */
+declare function messagingHub(name: string, opts?: MessagingHubOptions): MessagingHubGraph;
+/**
+ * Creates a cursor-based subscription graph over a topic.
+ */
+declare function subscription<T>(name: string, topicGraph: TopicGraph<T>, opts?: SubscriptionOptions): SubscriptionGraph<T>;
+/**
+ * Creates an autonomous cursor-based topic relay graph.
+ */
+declare function topicBridge<TIn, TOut = TIn>(name: string, sourceTopic: TopicGraph<TIn>, targetTopic: TopicGraph<TOut>, opts?: TopicBridgeOptions<TIn, TOut>): TopicBridgeGraph<TIn, TOut>;
+
+type index_MessagingHubGraph = MessagingHubGraph;
+declare const index_MessagingHubGraph: typeof MessagingHubGraph;
+type index_MessagingHubOptions = MessagingHubOptions;
+type index_SubscriptionGraph<T> = SubscriptionGraph<T>;
+declare const index_SubscriptionGraph: typeof SubscriptionGraph;
+type index_SubscriptionOptions = SubscriptionOptions;
+type index_TopicBridgeGraph<TIn, TOut = TIn> = TopicBridgeGraph<TIn, TOut>;
+declare const index_TopicBridgeGraph: typeof TopicBridgeGraph;
+type index_TopicBridgeOptions<TIn, TOut> = TopicBridgeOptions<TIn, TOut>;
+type index_TopicGraph<T> = TopicGraph<T>;
+declare const index_TopicGraph: typeof TopicGraph;
+type index_TopicOptions = TopicOptions;
+declare const index_messagingHub: typeof messagingHub;
+declare const index_subscription: typeof subscription;
+declare const index_topic: typeof topic;
+declare const index_topicBridge: typeof topicBridge;
+declare namespace index {
+  export { index_MessagingHubGraph as MessagingHubGraph, type index_MessagingHubOptions as MessagingHubOptions, index_SubscriptionGraph as SubscriptionGraph, type index_SubscriptionOptions as SubscriptionOptions, index_TopicBridgeGraph as TopicBridgeGraph, type index_TopicBridgeOptions as TopicBridgeOptions, index_TopicGraph as TopicGraph, type index_TopicOptions as TopicOptions, index_messagingHub as messagingHub, index_subscription as subscription, index_topic as topic, index_topicBridge as topicBridge };
+}
+
+export { MessagingHubGraph as M, SubscriptionGraph as S, TopicGraph as T, type MessagingHubOptions as a, type SubscriptionOptions as b, TopicBridgeGraph as c, type TopicBridgeOptions as d, type TopicOptions as e, topicBridge as f, index as i, messagingHub as m, subscription as s, topic as t };