@graphrefly/graphrefly 0.25.0 → 0.27.0

package/dist/memory-C6Z2tGpC.d.cts

@@ -0,0 +1,139 @@
+import { N as Node } from './node-BmerH3kS.cjs';
+import { a as Graph } from './graph-DNCrvZSn.cjs';
+
+/**
+ * Memory patterns (roadmap §4.3).
+ *
+ * Domain-layer helpers composed from GraphRefly primitives. `vectorIndex` uses
+ * an exact-search backend by default; an HNSW adapter can be injected as an
+ * optional dependency.
+ */
+
+type CollectionPolicy = "fifo" | "lru";
+type VectorBackend = "flat" | "hnsw";
+type LightCollectionEntry<T> = {
+    readonly id: string;
+    readonly value: T;
+    readonly createdAtNs: number;
+    readonly lastAccessNs: number;
+};
+type LightCollectionOptions = {
+    name?: string;
+    maxSize?: number;
+    policy?: CollectionPolicy;
+};
+type LightCollectionBundle<T> = {
+    readonly entries: Node<ReadonlyMap<string, LightCollectionEntry<T>>>;
+    upsert: (id: string, value: T) => void;
+    remove: (id: string) => void;
+    clear: () => void;
+    get: (id: string) => T | undefined;
+    has: (id: string) => boolean;
+};
+type CollectionEntry<T> = LightCollectionEntry<T> & {
+    readonly baseScore: number;
+};
+type RankedCollectionEntry<T> = CollectionEntry<T> & {
+    readonly score: number;
+};
+type CollectionOptions<T> = {
+    maxSize?: number;
+    policy?: CollectionPolicy;
+    /**
+     * Produces a base score at insert/update time.
+     */
+    score?: (value: T) => number;
+    /**
+     * Exponential decay rate per second. 0 disables decay.
+     */
+    decayRate?: number;
+    /**
+     * Minimum score floor after decay.
+     */
+    minScore?: number;
+};
+type CollectionGraph<T> = Graph & {
+    upsert: (id: string, value: T, opts?: {
+        score?: number;
+    }) => void;
+    remove: (id: string) => void;
+    clear: () => void;
+    getItem: (id: string) => CollectionEntry<T> | undefined;
+};
+type VectorRecord<TMeta> = {
+    readonly id: string;
+    readonly vector: readonly number[];
+    readonly meta?: TMeta;
+};
+type VectorSearchResult<TMeta> = {
+    readonly id: string;
+    readonly score: number;
+    readonly meta?: TMeta;
+};
+type HnswAdapter<TMeta> = {
+    upsert: (id: string, vector: readonly number[], meta?: TMeta) => void;
+    remove: (id: string) => void;
+    clear: () => void;
+    search: (query: readonly number[], k: number) => ReadonlyArray<VectorSearchResult<TMeta>>;
+};
+type VectorIndexOptions<TMeta> = {
+    backend?: VectorBackend;
+    dimension?: number;
+    /**
+     * Optional dependency seam for HNSW.
+     */
+    hnswFactory?: () => HnswAdapter<TMeta>;
+};
+type VectorIndexBundle<TMeta> = {
+    readonly backend: VectorBackend;
+    readonly entries: Node<ReadonlyMap<string, VectorRecord<TMeta>>>;
+    upsert: (id: string, vector: readonly number[], meta?: TMeta) => void;
+    remove: (id: string) => void;
+    clear: () => void;
+    search: (query: readonly number[], k?: number) => ReadonlyArray<VectorSearchResult<TMeta>>;
+};
+type KnowledgeEdge<TRelation extends string = string> = {
+    readonly from: string;
+    readonly to: string;
+    readonly relation: TRelation;
+    readonly weight: number;
+};
+type KnowledgeGraphGraph<TEntity, TRelation extends string = string> = Graph & {
+    upsertEntity: (id: string, value: TEntity) => void;
+    removeEntity: (id: string) => void;
+    link: (from: string, to: string, relation: TRelation, weight?: number) => void;
+    unlink: (from: string, to: string, relation?: TRelation) => void;
+    related: (id: string, relation?: TRelation) => ReadonlyArray<KnowledgeEdge<TRelation>>;
+};
+declare function decay(baseScore: number, ageSeconds: number, ratePerSecond: number, minScore?: number): number;
+declare function lightCollection<T>(opts?: LightCollectionOptions): LightCollectionBundle<T>;
+declare function collection<T>(name: string, opts?: CollectionOptions<T>): CollectionGraph<T>;
+declare function vectorIndex<TMeta>(opts?: VectorIndexOptions<TMeta>): VectorIndexBundle<TMeta>;
+declare function knowledgeGraph<TEntity, TRelation extends string = string>(name: string): KnowledgeGraphGraph<TEntity, TRelation>;
+
+type memory_CollectionEntry<T> = CollectionEntry<T>;
+type memory_CollectionGraph<T> = CollectionGraph<T>;
+type memory_CollectionOptions<T> = CollectionOptions<T>;
+type memory_CollectionPolicy = CollectionPolicy;
+type memory_HnswAdapter<TMeta> = HnswAdapter<TMeta>;
+type memory_KnowledgeEdge<TRelation extends string = string> = KnowledgeEdge<TRelation>;
+type memory_KnowledgeGraphGraph<TEntity, TRelation extends string = string> = KnowledgeGraphGraph<TEntity, TRelation>;
+type memory_LightCollectionBundle<T> = LightCollectionBundle<T>;
+type memory_LightCollectionEntry<T> = LightCollectionEntry<T>;
+type memory_LightCollectionOptions = LightCollectionOptions;
+type memory_RankedCollectionEntry<T> = RankedCollectionEntry<T>;
+type memory_VectorBackend = VectorBackend;
+type memory_VectorIndexBundle<TMeta> = VectorIndexBundle<TMeta>;
+type memory_VectorIndexOptions<TMeta> = VectorIndexOptions<TMeta>;
+type memory_VectorRecord<TMeta> = VectorRecord<TMeta>;
+type memory_VectorSearchResult<TMeta> = VectorSearchResult<TMeta>;
+declare const memory_collection: typeof collection;
+declare const memory_decay: typeof decay;
+declare const memory_knowledgeGraph: typeof knowledgeGraph;
+declare const memory_lightCollection: typeof lightCollection;
+declare const memory_vectorIndex: typeof vectorIndex;
+declare namespace memory {
+  export { type memory_CollectionEntry as CollectionEntry, type memory_CollectionGraph as CollectionGraph, type memory_CollectionOptions as CollectionOptions, type memory_CollectionPolicy as CollectionPolicy, type memory_HnswAdapter as HnswAdapter, type memory_KnowledgeEdge as KnowledgeEdge, type memory_KnowledgeGraphGraph as KnowledgeGraphGraph, type memory_LightCollectionBundle as LightCollectionBundle, type memory_LightCollectionEntry as LightCollectionEntry, type memory_LightCollectionOptions as LightCollectionOptions, type memory_RankedCollectionEntry as RankedCollectionEntry, type memory_VectorBackend as VectorBackend, type memory_VectorIndexBundle as VectorIndexBundle, type memory_VectorIndexOptions as VectorIndexOptions, type memory_VectorRecord as VectorRecord, type memory_VectorSearchResult as VectorSearchResult, memory_collection as collection, memory_decay as decay, memory_knowledgeGraph as knowledgeGraph, memory_lightCollection as lightCollection, memory_vectorIndex as vectorIndex };
+}
+
+export { type CollectionEntry as C, type HnswAdapter as H, type KnowledgeGraphGraph as K, type LightCollectionBundle as L, type RankedCollectionEntry as R, type VectorIndexBundle as V, type VectorSearchResult as a, type CollectionGraph as b, type CollectionOptions as c, type CollectionPolicy as d, type KnowledgeEdge as e, type LightCollectionEntry as f, type LightCollectionOptions as g, type VectorBackend as h, type VectorIndexOptions as i, type VectorRecord as j, collection as k, decay as l, memory as m, knowledgeGraph as n, lightCollection as o, vectorIndex as v };

package/dist/memory-li6FL5RM.d.ts

@@ -0,0 +1,139 @@
+import { N as Node } from './node-BmerH3kS.js';
+import { a as Graph } from './graph-CCwGKLCm.js';
+
+/**
+ * Memory patterns (roadmap §4.3).
+ *
+ * Domain-layer helpers composed from GraphRefly primitives. `vectorIndex` uses
+ * an exact-search backend by default; an HNSW adapter can be injected as an
+ * optional dependency.
+ */
+
+type CollectionPolicy = "fifo" | "lru";
+type VectorBackend = "flat" | "hnsw";
+type LightCollectionEntry<T> = {
+    readonly id: string;
+    readonly value: T;
+    readonly createdAtNs: number;
+    readonly lastAccessNs: number;
+};
+type LightCollectionOptions = {
+    name?: string;
+    maxSize?: number;
+    policy?: CollectionPolicy;
+};
+type LightCollectionBundle<T> = {
+    readonly entries: Node<ReadonlyMap<string, LightCollectionEntry<T>>>;
+    upsert: (id: string, value: T) => void;
+    remove: (id: string) => void;
+    clear: () => void;
+    get: (id: string) => T | undefined;
+    has: (id: string) => boolean;
+};
+type CollectionEntry<T> = LightCollectionEntry<T> & {
+    readonly baseScore: number;
+};
+type RankedCollectionEntry<T> = CollectionEntry<T> & {
+    readonly score: number;
+};
+type CollectionOptions<T> = {
+    maxSize?: number;
+    policy?: CollectionPolicy;
+    /**
+     * Produces a base score at insert/update time.
+     */
+    score?: (value: T) => number;
+    /**
+     * Exponential decay rate per second. 0 disables decay.
+     */
+    decayRate?: number;
+    /**
+     * Minimum score floor after decay.
+     */
+    minScore?: number;
+};
+type CollectionGraph<T> = Graph & {
+    upsert: (id: string, value: T, opts?: {
+        score?: number;
+    }) => void;
+    remove: (id: string) => void;
+    clear: () => void;
+    getItem: (id: string) => CollectionEntry<T> | undefined;
+};
+type VectorRecord<TMeta> = {
+    readonly id: string;
+    readonly vector: readonly number[];
+    readonly meta?: TMeta;
+};
+type VectorSearchResult<TMeta> = {
+    readonly id: string;
+    readonly score: number;
+    readonly meta?: TMeta;
+};
+type HnswAdapter<TMeta> = {
+    upsert: (id: string, vector: readonly number[], meta?: TMeta) => void;
+    remove: (id: string) => void;
+    clear: () => void;
+    search: (query: readonly number[], k: number) => ReadonlyArray<VectorSearchResult<TMeta>>;
+};
+type VectorIndexOptions<TMeta> = {
+    backend?: VectorBackend;
+    dimension?: number;
+    /**
+     * Optional dependency seam for HNSW.
+     */
+    hnswFactory?: () => HnswAdapter<TMeta>;
+};
+type VectorIndexBundle<TMeta> = {
+    readonly backend: VectorBackend;
+    readonly entries: Node<ReadonlyMap<string, VectorRecord<TMeta>>>;
+    upsert: (id: string, vector: readonly number[], meta?: TMeta) => void;
+    remove: (id: string) => void;
+    clear: () => void;
+    search: (query: readonly number[], k?: number) => ReadonlyArray<VectorSearchResult<TMeta>>;
+};
+type KnowledgeEdge<TRelation extends string = string> = {
+    readonly from: string;
+    readonly to: string;
+    readonly relation: TRelation;
+    readonly weight: number;
+};
+type KnowledgeGraphGraph<TEntity, TRelation extends string = string> = Graph & {
+    upsertEntity: (id: string, value: TEntity) => void;
+    removeEntity: (id: string) => void;
+    link: (from: string, to: string, relation: TRelation, weight?: number) => void;
+    unlink: (from: string, to: string, relation?: TRelation) => void;
+    related: (id: string, relation?: TRelation) => ReadonlyArray<KnowledgeEdge<TRelation>>;
+};
+declare function decay(baseScore: number, ageSeconds: number, ratePerSecond: number, minScore?: number): number;
+declare function lightCollection<T>(opts?: LightCollectionOptions): LightCollectionBundle<T>;
+declare function collection<T>(name: string, opts?: CollectionOptions<T>): CollectionGraph<T>;
+declare function vectorIndex<TMeta>(opts?: VectorIndexOptions<TMeta>): VectorIndexBundle<TMeta>;
+declare function knowledgeGraph<TEntity, TRelation extends string = string>(name: string): KnowledgeGraphGraph<TEntity, TRelation>;
+
+type memory_CollectionEntry<T> = CollectionEntry<T>;
+type memory_CollectionGraph<T> = CollectionGraph<T>;
+type memory_CollectionOptions<T> = CollectionOptions<T>;
+type memory_CollectionPolicy = CollectionPolicy;
+type memory_HnswAdapter<TMeta> = HnswAdapter<TMeta>;
+type memory_KnowledgeEdge<TRelation extends string = string> = KnowledgeEdge<TRelation>;
+type memory_KnowledgeGraphGraph<TEntity, TRelation extends string = string> = KnowledgeGraphGraph<TEntity, TRelation>;
+type memory_LightCollectionBundle<T> = LightCollectionBundle<T>;
+type memory_LightCollectionEntry<T> = LightCollectionEntry<T>;
+type memory_LightCollectionOptions = LightCollectionOptions;
+type memory_RankedCollectionEntry<T> = RankedCollectionEntry<T>;
+type memory_VectorBackend = VectorBackend;
+type memory_VectorIndexBundle<TMeta> = VectorIndexBundle<TMeta>;
+type memory_VectorIndexOptions<TMeta> = VectorIndexOptions<TMeta>;
+type memory_VectorRecord<TMeta> = VectorRecord<TMeta>;
+type memory_VectorSearchResult<TMeta> = VectorSearchResult<TMeta>;
+declare const memory_collection: typeof collection;
+declare const memory_decay: typeof decay;
+declare const memory_knowledgeGraph: typeof knowledgeGraph;
+declare const memory_lightCollection: typeof lightCollection;
+declare const memory_vectorIndex: typeof vectorIndex;
+declare namespace memory {
+  export { type memory_CollectionEntry as CollectionEntry, type memory_CollectionGraph as CollectionGraph, type memory_CollectionOptions as CollectionOptions, type memory_CollectionPolicy as CollectionPolicy, type memory_HnswAdapter as HnswAdapter, type memory_KnowledgeEdge as KnowledgeEdge, type memory_KnowledgeGraphGraph as KnowledgeGraphGraph, type memory_LightCollectionBundle as LightCollectionBundle, type memory_LightCollectionEntry as LightCollectionEntry, type memory_LightCollectionOptions as LightCollectionOptions, type memory_RankedCollectionEntry as RankedCollectionEntry, type memory_VectorBackend as VectorBackend, type memory_VectorIndexBundle as VectorIndexBundle, type memory_VectorIndexOptions as VectorIndexOptions, type memory_VectorRecord as VectorRecord, type memory_VectorSearchResult as VectorSearchResult, memory_collection as collection, memory_decay as decay, memory_knowledgeGraph as knowledgeGraph, memory_lightCollection as lightCollection, memory_vectorIndex as vectorIndex };
+}
+
+export { type CollectionEntry as C, type HnswAdapter as H, type KnowledgeGraphGraph as K, type LightCollectionBundle as L, type RankedCollectionEntry as R, type VectorIndexBundle as V, type VectorSearchResult as a, type CollectionGraph as b, type CollectionOptions as c, type CollectionPolicy as d, type KnowledgeEdge as e, type LightCollectionEntry as f, type LightCollectionOptions as g, type VectorBackend as h, type VectorIndexOptions as i, type VectorRecord as j, collection as k, decay as l, memory as m, knowledgeGraph as n, lightCollection as o, vectorIndex as v };

package/dist/messaging-Gt4LPbyA.d.cts

@@ -0,0 +1,269 @@
+import { N as Node } from './node-BmerH3kS.cjs';
+import { a as Graph, G as GraphOptions } from './graph-DNCrvZSn.cjs';
+
+/**
+ * Messaging patterns (roadmap §4.2).
+ *
+ * Pulsar-inspired messaging features modeled as graph factories:
+ * - `topic()` for append-only topic streams
+ * - `subscription()` for cursor-based consumers
+ * - `jobQueue()` for queue claim/ack flow
+ */
+
+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 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>[];
+}
+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-ts";
+ *
+ * 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 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>;
+/**
+ * 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 messaging_JobEnvelope<T> = JobEnvelope<T>;
+type messaging_JobFlowGraph<T> = JobFlowGraph<T>;
+declare const messaging_JobFlowGraph: typeof JobFlowGraph;
+type messaging_JobFlowOptions = JobFlowOptions;
+type messaging_JobQueueGraph<T> = JobQueueGraph<T>;
+declare const messaging_JobQueueGraph: typeof JobQueueGraph;
+type messaging_JobQueueOptions = JobQueueOptions;
+type messaging_JobState = JobState;
+type messaging_MessagingHubGraph = MessagingHubGraph;
+declare const messaging_MessagingHubGraph: typeof MessagingHubGraph;
+type messaging_MessagingHubOptions = MessagingHubOptions;
+type messaging_SubscriptionGraph<T> = SubscriptionGraph<T>;
+declare const messaging_SubscriptionGraph: typeof SubscriptionGraph;
+type messaging_SubscriptionOptions = SubscriptionOptions;
+type messaging_TopicBridgeGraph<TIn, TOut = TIn> = TopicBridgeGraph<TIn, TOut>;
+declare const messaging_TopicBridgeGraph: typeof TopicBridgeGraph;
+type messaging_TopicBridgeOptions<TIn, TOut> = TopicBridgeOptions<TIn, TOut>;
+type messaging_TopicGraph<T> = TopicGraph<T>;
+declare const messaging_TopicGraph: typeof TopicGraph;
+type messaging_TopicOptions = TopicOptions;
+declare const messaging_jobFlow: typeof jobFlow;
+declare const messaging_jobQueue: typeof jobQueue;
+declare const messaging_messagingHub: typeof messagingHub;
+declare const messaging_subscription: typeof subscription;
+declare const messaging_topic: typeof topic;
+declare const messaging_topicBridge: typeof topicBridge;
+declare namespace messaging {
+  export { type messaging_JobEnvelope as JobEnvelope, messaging_JobFlowGraph as JobFlowGraph, type messaging_JobFlowOptions as JobFlowOptions, messaging_JobQueueGraph as JobQueueGraph, type messaging_JobQueueOptions as JobQueueOptions, type messaging_JobState as JobState, messaging_MessagingHubGraph as MessagingHubGraph, type messaging_MessagingHubOptions as MessagingHubOptions, messaging_SubscriptionGraph as SubscriptionGraph, type messaging_SubscriptionOptions as SubscriptionOptions, messaging_TopicBridgeGraph as TopicBridgeGraph, type messaging_TopicBridgeOptions as TopicBridgeOptions, messaging_TopicGraph as TopicGraph, type messaging_TopicOptions as TopicOptions, messaging_jobFlow as jobFlow, messaging_jobQueue as jobQueue, messaging_messagingHub as messagingHub, messaging_subscription as subscription, messaging_topic as topic, messaging_topicBridge as topicBridge };
+}
+
+export { TopicGraph as T, messaging as m };