@graphrefly/graphrefly 0.44.0 → 0.45.0

package/dist/index-Yq60JP3s.d.ts

@@ -1,209 +0,0 @@
-import { b as NodeGuard, N as Node } from './node-kK3CvTrR.js';
-import { G as Graph } from './graph-D9LFnda9.js';
-import { R as ReactiveLogOptions, a as ReactiveLogBundle } from './reactive-log-BKALbfal.js';
-
-/**
- * Audited-mutation framework (Audit 2 — locked 2026-04-24; promoted to
- * `extra/mutation/` per consolidation plan §1, Tier 2.2).
- *
- * Phase-4 primitives share the same shape: imperative mutation methods +
- * closure state + reactive audit log + freeze-at-entry + rollback-on-throw.
- * This module factors out the common machinery so each primitive becomes
- * declarative wiring over typed audit records:
- *  - `approvalGate`, `pipeline.approvalGate`  (Wave A.2 Unit 8)
- *  - `JobQueueGraph`                          (Wave B.3 Unit 15)
- *  - `CqrsGraph.dispatch`                     (Wave C.2 Unit 20)
- *  - `CqrsGraph.saga`                         (Wave C.3 Unit 22)
- *  - `processManager`                         (Wave 7)
- */
-
-/**
- * Bounded increment for a self-owned counter state node.
- *
- * Reads `counter.cache`, bumps by 1 if under `cap`, writes back. Returns
- * `false` when the cap is reached. Documented P3 exception: the counter is
- * not a declared dep of the caller — it's a private budget read+written from
- * a single call site. This helper keeps the `.cache` access in one named
- * place.
- *
- * **Safety today:**
- *   1. Single-threaded JS runner never invokes the caller concurrently.
- *   2. `counter.down` writes the cache synchronously before returning, so
- *      synchronous re-entry through a downstream publish reads the
- *      freshly-incremented value — no double-count.
- *
- * **Future risk:** under a free-threaded runner (PY no-GIL or hypothetical
- * concurrent TS runner), two concurrent firings could still race. Revisit
- * when that surfaces.
- */
-declare function tryIncrementBounded(counter: Node<number>, cap: number): boolean;
-/** Shared base shape for every audit record. Per-primitive types extend this. */
-interface BaseAuditRecord {
-    readonly t_ns: number;
-    readonly seq?: number;
-    readonly handlerVersion?: {
-        id: string;
-        version: string | number;
-    };
-}
-/**
- * Allow `observe` and `signal`; deny external `write` on the audit log so
- * consumers can subscribe + signal-bridge but cannot inject fake records.
- */
-declare const DEFAULT_AUDIT_GUARD: NodeGuard;
-type AuditLogOpts<R extends BaseAuditRecord> = {
-    name: string;
-    /** Bounded retention; default 1024 per Audit 2 / cross-cutting bounded-default policy. */
-    retainedLimit?: number;
-    /** Override the default audit guard. */
-    guard?: NodeGuard;
-    /** Mount the audit `entries` Node under this graph (and activate withLatest). */
-    graph?: Graph;
-    /** Pass-through to {@link reactiveLog}. */
-    versioning?: ReactiveLogOptions<R>["versioning"];
-};
-/**
- * Build a reactive audit log with sane defaults: bounded retention, deny-write
- * guard, `withLatest()` companions activated. Returns the {@link ReactiveLogBundle}
- * directly — primitives expose this as `<primitive>.events` / `.decisions` /
- * `.dispatches` / `.invocations` and alias it as `.audit`.
- *
- * @category internal
- */
-declare function createAuditLog<R extends BaseAuditRecord>(opts: AuditLogOpts<R>): ReactiveLogBundle<R>;
-type FailureMeta = {
-    t_ns: number;
-    seq?: number;
-    errorType: string;
-};
-type SuccessMeta = {
-    t_ns: number;
-    seq?: number;
-};
-/** Common opts shared by both tiers. */
-type MutationOpts<TArgs extends readonly unknown[], TResult, R extends BaseAuditRecord> = {
-    /**
-     * Optional audit log. When omitted, the wrapper still provides freeze /
-     * seq-advance / rollback-on-throw (`wrapMutation`) but skips audit-record
-     * emission entirely — useful for primitives that want centralized mutation
-     * semantics without a dedicated audit log surface (e.g. `Topic.publish`).
-     * Pair with `onSuccess` / `onFailure` to emit records.
-     */
-    audit?: ReactiveLogBundle<R>;
-    /** Build the success record from the action's args + result + meta. */
-    onSuccess?: (args: TArgs, result: TResult, meta: SuccessMeta) => R | undefined;
-    /** Build the failure record from the args + error + meta. */
-    onFailure?: (args: TArgs, error: unknown, meta: FailureMeta) => R | undefined;
-    /** Freeze inputs at entry (default `true`). Pass `false` for hot paths. */
-    freeze?: boolean;
-    /** Optional sequence cursor — auto-advanced and stamped onto records. */
-    seq?: Node<number>;
-    /** Optional handler version — stamped into the record (Audit 5). */
-    handlerVersion?: {
-        id: string;
-        version: string | number;
-    };
-};
-type WrapMutationOpts<TArgs extends readonly unknown[], TResult, R extends BaseAuditRecord> = MutationOpts<TArgs, TResult, R>;
-type LightMutationOpts<TArgs extends readonly unknown[], TResult, R extends BaseAuditRecord> = MutationOpts<TArgs, TResult, R>;
-declare function bumpCursor(seq: Node<number>): number;
-/**
- * Build a record via the supplied builder, stamp `handlerVersion` if present,
- * and append it to the audit log. `undefined` records are skipped (callers
- * pass an `onSuccess` / `onFailure` that returns `undefined` to opt out per
- * call).
- *
- * @category internal
- */
-declare function appendAudit<TArgs extends readonly unknown[], TValue, R extends BaseAuditRecord, M extends SuccessMeta | FailureMeta>(audit: ReactiveLogBundle<R>, builder: (args: TArgs, value: TValue, meta: M) => R | undefined, args: TArgs, value: TValue, meta: M, handlerVersion?: {
-    id: string;
-    version: string | number;
-}): void;
-/**
- * Substrate-tier wrapper: run `action`, optionally append a typed audit record
- * on success or failure, advance an optional `seq` cursor. No batch frame —
- * this is the hot-path-friendly variant for atomic single-write mutations.
- *
- * Behavior contract:
- * 1. Freeze args at entry (default `true`; opt out with `freeze: false` for
- *    hot paths — e.g. wrapping `vectorIndex.upsert(id, vector[768], meta)`
- *    where the deep-freeze of a 768-dim vector is a measurable tax).
- * 2. Bump `seq` (if provided) BEFORE the action runs. There is no batch frame,
- *    so the bump persists even on throw — the failure-audit record stamps the
- *    same `seq` so audit consumers see a contiguous sequence.
- * 3. Run `action(args)`. On success, if `audit` is provided AND `onSuccess`
- *    is set, `appendAudit(onSuccess, ...)`.
- * 4. On throw, if `audit` is provided AND `onFailure` is set,
- *    `appendAudit(onFailure, ...)` then re-throw. When `audit` is omitted the
- *    wrapper still provides freeze + seq + re-throw semantics — useful for
- *    primitives that want centralized mutation contracts without an audit log
- *    surface (e.g. `Topic.publish`).
- *
- * **Distinguish from {@link wrapMutation}:** `wrapMutation` opens a `batch()`
- * frame (rollback-on-throw, seq advance discarded on rollback) and is the
- * right choice when the action runs a user-supplied handler or a multi-step
- * sequence that could leave inconsistent state mid-throw.
- *
- * **Cursor / log alignment caveat (substrate-tier):** `seq` is bumped BEFORE
- * `action()` runs, and the audit-log append happens AFTER. There is no batch
- * frame, so a synchronous subscriber to `seq` that fires between the two —
- * including a subscriber on `audit.entries` itself if the substrate causes
- * it to fire transitively — observes `seq=N` while the corresponding record
- * is not yet in the log. Audit consumers that join `seq` and `audit.entries`
- * reactively must tolerate this one-tick lag, or use {@link wrapMutation}
- * (whose `batch()` frame defers downstream delivery until commit, so cursor
- * and log appear together to subscribers). The same caveat applies to
- * **re-entrant** invocation: if an `audit.entries` / `seq` subscriber
- * triggers another `lightMutation`, the inner record can land on the log
- * before the outer call's success/failure record.
- *
- * @category internal
- */
-declare function lightMutation<TArgs extends readonly unknown[], TResult, R extends BaseAuditRecord>(action: (...args: TArgs) => TResult, opts: LightMutationOpts<TArgs, TResult, R>): (...args: TArgs) => TResult;
-/**
- * Orchestration-tier wrapper: like {@link lightMutation} but adds a `batch()`
- * frame around the action so an in-flight throw rolls back partial state.
- *
- * Behavior contract:
- *  1. Freeze args at entry (default `true`).
- *  2. Open a batch frame (rollback-on-throw via core batch — Audit 2 #6).
- *  3. Bump `seq` INSIDE the batch so a framework-level rollback discards the
- *     cursor advance (cursor stays in sync with audit log). M5.
- *  4. Run `action(args)` and capture result.
- *  5. On success: if `audit` is provided AND `onSuccess` is set,
- *     `appendAudit(onSuccess, ...)` inside the batch.
- *  6. On throw: catch OUTSIDE the batch so the failure record (if any) emits
- *     in a fresh transaction after rollback — it persists. Re-throw so callers
- *     see the failure. When `audit` is omitted the wrapper still provides
- *     batch + freeze + rollback + re-throw semantics — useful for primitives
- *     that want orchestration-tier mutation contracts without an audit log
- *     surface.
- *
- * **Distinguish from the file-private `wrapMutation` in
- * `src/extra/reactive-map.ts:540`:** that helper is a transactional wrapper
- * for the reactiveMap version counter (`pre/post-version` snapshot diffing,
- * read vs. mutation gating). Different concern, file-private, not exported.
- * This `wrapMutation` is the public Phase-4 audit framework.
- *
- * @category internal
- */
-declare function wrapMutation<TArgs extends readonly unknown[], TResult, R extends BaseAuditRecord>(action: (...args: TArgs) => TResult, opts: WrapMutationOpts<TArgs, TResult, R>): (...args: TArgs) => TResult;
-/**
- * Promote a closure counter to a state node mounted under `graph`.
- * Replaces ad-hoc `let _seq = 0` patterns with a node observable in
- * `describe()` and persistable via storage tiers.
- *
- * @category internal
- */
-declare function registerCursor(graph: Graph, name: string, initial?: number): Node<number>;
-/**
- * Promote a closure `Map<K, number>` to N state nodes (one per key) mounted
- * under `<graph>::<name>::<key>`. Used by saga (per-event-type cursor).
- *
- * @category internal
- */
-declare function registerCursorMap<K extends string>(graph: Graph, name: string, keys: readonly K[], initial?: number): {
-    readonly [P in K]: Node<number>;
-};
-
-export { type AuditLogOpts as A, type BaseAuditRecord as B, DEFAULT_AUDIT_GUARD as D, type FailureMeta as F, type LightMutationOpts as L, type MutationOpts as M, type SuccessMeta as S, type WrapMutationOpts as W, appendAudit as a, bumpCursor as b, createAuditLog as c, registerCursorMap as d, lightMutation as l, registerCursor as r, tryIncrementBounded as t, wrapMutation as w };

package/dist/index-ZVQhLa2i.d.cts

@@ -1,37 +0,0 @@
-import { G as Graph } from './graph-CWvEUQAq.cjs';
-
-/** Zustand-compatible Store API. */
-interface StoreApi<T> {
-    getState: () => T;
-    setState: (partial: T | Partial<T> | ((state: T) => T | Partial<T>), replace?: boolean) => void;
-    getInitialState: () => T;
-    subscribe: (listener: (state: T, prevState: T) => void) => () => void;
-    destroy: () => void;
-}
-/** Function type for initializing the store. */
-type StateCreator<T> = (set: StoreApi<T>["setState"], get: StoreApi<T>["getState"], api: StoreApi<T>) => T;
-/**
- * Creates a Zustand-compatible store backed by a GraphReFly state node.
- * returns an object that is both a Graph and a StoreApi.
- *
- * @example
- * ```ts
- * const store = create((set) => ({
- *   count: 0,
- *   inc: () => set((s) => ({ count: s.count + 1 }))
- * }));
- * store.getState().inc();
- * ```
- *
- * @category compat
- */
-declare function create<T extends object>(initializer: StateCreator<T>): Graph & StoreApi<T>;
-
-type index_StateCreator<T> = StateCreator<T>;
-type index_StoreApi<T> = StoreApi<T>;
-declare const index_create: typeof create;
-declare namespace index {
-  export { type index_StateCreator as StateCreator, type index_StoreApi as StoreApi, index_create as create };
-}
-
-export { type StateCreator as S, type StoreApi as a, create as c, index as i };

package/dist/index-_6ODbuOu.d.cts

@@ -1,45 +0,0 @@
-import { N as Node } from './node-kK3CvTrR.cjs';
-
-/** Svelte store contract — implements the minimal `subscribe` method. */
-interface SvelteReadable<T> {
-    subscribe(run: (value: T) => void): () => void;
-}
-/** Svelte writable store contract. */
-interface SvelteWritable<T> extends SvelteReadable<T> {
-    set(value: T): void;
-    update(updater: (value: T) => T): void;
-}
-/**
- * Subscribe to a `Node<T>` as a Svelte readable store (implements Svelte store contract).
- * Subscription lifecycle is tied to Svelte store unsubscription (not node terminal messages).
- */
-declare function useSubscribe<T>(node: Node<T>): SvelteReadable<T | undefined | null>;
-/**
- * Bind a writable `Node<T>` as a Svelte writable store.
- * Reads and writes adapt seamlessly.
- * Setter/update always forward `[[DIRTY], [DATA, value]]`, including `value === undefined`.
- * Subscription lifecycle is tied to Svelte store unsubscription (not node terminal messages).
- */
-declare function useStore<T>(node: Node<T>): SvelteWritable<T | undefined | null>;
-/** Maps a key to an object of nodes. Used by `useSubscribeRecord`. */
-type NodeFactory<K, R extends Record<string, any>> = (key: K) => {
-    [P in keyof R]: Node<R[P]>;
-};
-/**
- * Subscribe to a dynamic keyed record of nodes as a Svelte readable store.
- * Re-subscribes all per-key fields whenever `keysNode` changes.
- * Key re-sync is gated to settled batches (`messageTier >= 3`) to avoid DIRTY-phase churn.
- */
-declare function useSubscribeRecord<K extends string, R extends Record<string, any>>(keysNode: Node<K[]>, factory: NodeFactory<K, R>): SvelteReadable<Record<K, R>>;
-
-type index_NodeFactory<K, R extends Record<string, any>> = NodeFactory<K, R>;
-type index_SvelteReadable<T> = SvelteReadable<T>;
-type index_SvelteWritable<T> = SvelteWritable<T>;
-declare const index_useStore: typeof useStore;
-declare const index_useSubscribe: typeof useSubscribe;
-declare const index_useSubscribeRecord: typeof useSubscribeRecord;
-declare namespace index {
-  export { type index_NodeFactory as NodeFactory, type index_SvelteReadable as SvelteReadable, type index_SvelteWritable as SvelteWritable, index_useStore as useStore, index_useSubscribe as useSubscribe, index_useSubscribeRecord as useSubscribeRecord };
-}
-
-export { type NodeFactory as N, type SvelteReadable as S, type SvelteWritable as a, useSubscribe as b, useSubscribeRecord as c, index as i, useStore as u };

package/dist/index-hcDJ8PSI.d.cts

@@ -1,36 +0,0 @@
-import { N as Node } from './node-kK3CvTrR.cjs';
-
-/** Solid accessor function — returns current value when called. */
-type Accessor<T> = () => T;
-/**
- * Subscribe to a `Node<T>` as a Solid signal. Auto-cleans up with the owning scope.
- * Subscription lifecycle is tied to Solid scope cleanup (not node terminal messages).
- */
-declare function useSubscribe<T>(node: Node<T>): Accessor<T | undefined | null>;
-/**
- * Bind a writable `Node<T>` as a Solid resource tuple `[accessor, setter]`.
- * Setter always forwards `[[DIRTY], [DATA, value]]`, including `value === undefined`.
- * Subscription lifecycle is tied to Solid scope cleanup (not node terminal messages).
- */
-declare function useStore<T>(node: Node<T>): [Accessor<T | undefined | null>, (v: T) => void];
-/** Maps a key to an object of nodes. Used by `useSubscribeRecord`. */
-type NodeFactory<K, R extends Record<string, any>> = (key: K) => {
-    [P in keyof R]: Node<R[P]>;
-};
-/**
- * Subscribe to a dynamic set of keyed node records as a Solid accessor.
- * Re-subscribes all per-key fields whenever `keys` changes.
- * Key re-sync is gated to settled batches (`messageTier >= 3`) to avoid DIRTY-phase churn.
- */
-declare function useSubscribeRecord<K extends string, R extends Record<string, any>>(keysNode: Node<K[]>, factory: NodeFactory<K, R>): Accessor<Record<K, R>>;
-
-type index_Accessor<T> = Accessor<T>;
-type index_NodeFactory<K, R extends Record<string, any>> = NodeFactory<K, R>;
-declare const index_useStore: typeof useStore;
-declare const index_useSubscribe: typeof useSubscribe;
-declare const index_useSubscribeRecord: typeof useSubscribeRecord;
-declare namespace index {
-  export { type index_Accessor as Accessor, type index_NodeFactory as NodeFactory, index_useStore as useStore, index_useSubscribe as useSubscribe, index_useSubscribeRecord as useSubscribeRecord };
-}
-
-export { type Accessor as A, type NodeFactory as N, useSubscribe as a, useSubscribeRecord as b, index as i, useStore as u };

package/dist/index-nozs3fFC.d.ts

@@ -1,301 +0,0 @@
-import { N as Node } from './node-kK3CvTrR.js';
-import { G as Graph, a as GraphOptions } from './graph-D9LFnda9.js';
-import { a as ReactiveLogBundle } from './reactive-log-BKALbfal.js';
-import { AppendLogStorageTier } from './extra/storage-tiers.js';
-
-type TopicOptions = {
-    graph?: GraphOptions;
-    /** Bounded retention; default 1024 per cross-cutting policy (Audit 2/4). */
-    retainedLimit?: number;
-};
-declare class TopicGraph<T> extends Graph {
-    private readonly _log;
-    private readonly _publishImpl;
-    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;
-    /**
-     * 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
-     * snapshot-based `StorageTier[]` shape.
-     *
-     * @returns Disposer.
-     */
-    attachEventStorage(tiers: readonly AppendLogStorageTier<T>[]): () => void;
-    retained(): readonly T[];
-    /** Internal log bundle — used by TopicBridgeGraph for `attach`. */
-    get _logBundle(): ReactiveLogBundle<T>;
-}
-type SubscriptionOptions = {
-    graph?: GraphOptions;
-    /**
-     * Starting cursor position.
-     * @deprecated Use `from` instead.
-     */
-    cursor?: number;
-    /**
-     * Starting position for the subscription.
-     * - `"retained"` (default) — cursor starts at 0; consumer sees all retained history.
-     * - `"now"` — cursor starts at current topic length; consumer ignores history.
-     * - `number` — explicit cursor position.
-     */
-    from?: "now" | "retained" | number;
-    /**
-     * When this signal node emits DATA, the subscription auto-advances cursor
-     * to current `available.length`. Useful for "ack everything when X happens"
-     * patterns. The reactive edge `advanceOn → cursor` is visible in `explain()`.
-     */
-    advanceOn?: Node<unknown>;
-};
-/** Result of {@link SubscriptionGraph.pullAndAck}. */
-type PullAndAckResult<T> = {
-    items: readonly T[];
-    cursor: number;
-};
-declare class SubscriptionGraph<T> extends Graph {
-    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>;
-    private _disposed;
-    private readonly _ackImpl;
-    private readonly _pullAndAckImpl;
-    constructor(name: string, topicGraph: TopicGraph<T>, opts?: SubscriptionOptions);
-    ack(count?: number): number;
-    pull(limit?: number): readonly T[];
-    /**
-     * 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?: number): PullAndAckResult<T>;
-    /**
-     * 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(): void;
-}
-type TopicBridgeOptions<TIn, TOut> = {
-    graph?: GraphOptions;
-    cursor?: number;
-    maxPerPump?: number;
-    /**
-     * Optional transform/filter applied to each item before republishing.
-     *
-     * **At-most-once with silent drop:** when `map` returns `undefined`, the
-     * input is consumed from the source cursor but NOT republished. Filtered
-     * items are not retained for retry. If you need filter-with-retry
-     * semantics, do the filtering in a downstream subscription on the bridged
-     * output rather than in the `map` function.
-     */
-    map?: (value: TIn) => TOut | undefined;
-};
-declare class TopicBridgeGraph<TIn, TOut = TIn> extends Graph {
-    private readonly _sourceSub;
-    readonly bridgedCount: Node<number>;
-    /**
-     * Emits each mapped batch as DATA — gives downstream observers a reactive
-     * stream of bridged values. Also the link target for `target._log.attach`.
-     */
-    readonly output: Node<readonly TOut[]>;
-    constructor(name: string, sourceTopic: TopicGraph<TIn>, targetTopic: TopicGraph<TOut>, opts?: TopicBridgeOptions<TIn, TOut>);
-}
-/**
- * Private pure data structure managing a named set of {@link TopicGraph}
- * instances. Extracted from {@link MessagingHubGraph} for separation of
- * concerns (B.2 Unit 14 lock: D — split into TopicRegistry + facade).
- *
- * Reusable if other domain consumers (e.g. cqrs.eventLogs) want a shared
- * topic registry later.
- *
- * @internal
- */
-declare class TopicRegistry {
-    private readonly _map;
-    /** Reactive monotonic version counter. Advances on topic create/remove. */
-    readonly version: Node<number>;
-    constructor(versionNode: Node<number>);
-    get size(): number;
-    has(name: string): boolean;
-    get<T>(name: string): TopicGraph<T> | undefined;
-    set<T>(name: string, t: TopicGraph<T>): void;
-    delete(name: string): boolean;
-    keys(): IterableIterator<string>;
-}
-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}.
- *
- * Internally delegates to {@link TopicRegistry} for topic map management
- * (B.2 Unit 14 lock: D facade split).
- *
- * **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 _registry;
-    /** Reactive monotonic version counter — advances on topic create/remove. */
-    readonly version: Node<number>;
-    private readonly _defaultTopicOptions;
-    private readonly _removeTopicImpl;
-    constructor(name: string, opts?: MessagingHubOptions);
-    /** 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}.
-     *
-     * **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. `lightMutation`
-     * 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: 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.
- *
- * When `opts.map` is provided, items where `map` returns `undefined` are
- * consumed from the source cursor but NOT republished (at-most-once with
- * silent drop). For filter-with-retry semantics, apply the filter in a
- * downstream subscription on the bridge's `output` node instead.
- */
-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_PullAndAckResult<T> = PullAndAckResult<T>;
-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;
-type index_TopicRegistry = TopicRegistry;
-declare const index_TopicRegistry: typeof TopicRegistry;
-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, type index_PullAndAckResult as PullAndAckResult, 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_TopicRegistry as TopicRegistry, index_messagingHub as messagingHub, index_subscription as subscription, index_topic as topic, index_topicBridge as topicBridge };
-}
-
-export { MessagingHubGraph as M, type PullAndAckResult as P, 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, TopicRegistry as f, topicBridge as g, index as i, messagingHub as m, subscription as s, topic as t };