@graphrefly/graphrefly 0.25.0 → 0.27.0

package/dist/messaging-XDoYablx.d.ts

@@ -0,0 +1,269 @@
+import { N as Node } from './node-BmerH3kS.js';
+import { a as Graph, G as GraphOptions } from './graph-CCwGKLCm.js';
+
+/**
+ * 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 };

package/dist/{meta-DWbkoq1s.d.cts → meta-BxCA7rcr.d.cts}

@@ -1,4 +1,4 @@
-import { v as NodeDescribeKind, N as Node, A as Actor } from './node-B-f-Lu-k.cjs';
+import { v as NodeDescribeKind, N as Node, A as Actor } from './node-BmerH3kS.cjs';
 
 /**
  * JSON-shaped slice of a node for `Graph.describe()`

package/dist/{meta-CnkLA_43.d.ts → meta-CbznRPYJ.d.ts}

@@ -1,4 +1,4 @@
-import { v as NodeDescribeKind, N as Node, A as Actor } from './node-B-f-Lu-k.js';
+import { v as NodeDescribeKind, N as Node, A as Actor } from './node-BmerH3kS.js';
 
 /**
  * JSON-shaped slice of a node for `Graph.describe()`

package/dist/{node-B-f-Lu-k.d.cts → node-BmerH3kS.d.cts}

@@ -886,6 +886,12 @@ declare class NodeImpl<T = unknown> implements Node<T> {
     readonly _autoError: boolean;
     readonly _pausable: boolean | "resumeAll";
     readonly _guard: NodeGuard | undefined;
+    /**
+     * @internal Additional guards stacked at runtime via {@link NodeImpl._pushGuard}
+     * (e.g. by `policyEnforcer({ mode: "enforce" })`, roadmap §9.2). Effective
+     * write/signal/observe checks AND the original `_guard` with every entry here.
+     */
+    _extraGuards: Set<NodeGuard> | undefined;
     _hashFn: HashFn;
     _versioning: NodeVersionInfo | undefined;
     /**
@@ -967,6 +973,25 @@ declare class NodeImpl<T = unknown> implements Node<T> {
      * and returns a no-op disposer.
      */
     _setInspectorHook(hook?: NodeInspectorHook): () => void;
+    /**
+     * @internal Push an additional guard onto this node. Effective enforcement
+     * is the AND of `_guard` and every guard pushed via this hook — any one
+     * rejecting throws {@link GuardDenied}. Returns a disposer that removes
+     * the pushed guard. Multiple guards may be stacked simultaneously.
+     *
+     * Used by `policyEnforcer({ mode: "enforce" })` (roadmap §9.2) to overlay
+     * runtime constraint enforcement onto an existing graph without rebuilding
+     * its nodes. Pre-1.0 internal API; not part of the public surface.
+     *
+     * **Identity semantics:** guards are tracked in a `Set`, so pushing the
+     * same `NodeGuard` reference twice is a single registration. Wrap each
+     * push in a unique closure if independent stacking is needed.
+     *
+     * **Iteration order:** insertion-ordered (`Set` semantics). Determinism
+     * follows from single-threaded JS execution; nested re-entry from inside
+     * a guard body (push/pop while iterating) is undefined-but-survivable.
+     */
+    _pushGuard(guard: NodeGuard): () => void;
     allowsObserve(actor: Actor): boolean;
     private _checkGuard;
     down(messageOrMessages: Message | Messages, options?: NodeTransportOptions): void;
@@ -1187,4 +1212,4 @@ declare class NodeImpl<T = unknown> implements Node<T> {
  */
 declare function node<T = unknown>(depsOrFn?: readonly Node[] | NodeFn | NodeOptions<T>, fnOrOpts?: NodeFn | NodeOptions<T>, optsArg?: NodeOptions<T>): Node<T>;
 
-export { START_MSG as $, type Actor as A, type NodeInspectorHook as B, COMPLETE as C, DATA as D, ERROR as E, type FnCtx as F, type GlobalInspectorEvent as G, type HashFn as H, INVALIDATE as I, type NodeInspectorHookEvent as J, type NodeSink as K, type NodeStatus as L, type Message as M, type Node as N, type NodeTransportOptions as O, type NodeVersionInfo as P, type OnMessageHandler as Q, type OnSubscribeHandler as R, PAUSE as S, type PolicyAllow as T, type PolicyDeny as U, type PolicyRuleData as V, RESOLVED as W, RESOLVED_MSG as X, RESOLVED_ONLY_BATCH as Y, RESUME as Z, START as _, type NodeOptions as a, type SubscribeContext as a0, TEARDOWN as a1, TEARDOWN_MSG as a2, TEARDOWN_ONLY_BATCH as a3, type V0 as a4, type V1 as a5, type VersioningLevel as a6, type VersioningOptions as a7, accessHintForGuard as a8, advanceVersion as a9, configure as aa, createVersioning as ab, defaultConfig as ac, defaultHash as ad, isV1 as ae, node as af, normalizeActor as ag, policy as ah, policyFromRules as ai, registerBuiltins as aj, type NodeActions as b, COMPLETE_MSG as c, COMPLETE_ONLY_BATCH as d, DEFAULT_ACTOR as e, DIRTY as f, DIRTY_MSG as g, DIRTY_ONLY_BATCH as h, type DepRecord as i, type GlobalInspectorHook as j, GraphReFlyConfig as k, type GuardAction as l, GuardDenied as m, type GuardDeniedDetails as n, INVALIDATE_MSG as o, INVALIDATE_ONLY_BATCH as p, type MessageContext as q, type MessageTypeRegistration as r, type MessageTypeRegistrationInput as s, type Messages as t, type NodeCtx as u, type NodeDescribeKind as v, type NodeFn as w, type NodeFnCleanup as x, type NodeGuard as y, NodeImpl as z };
+export { START_MSG as $, type Actor as A, type NodeInspectorHook as B, COMPLETE as C, DATA as D, ERROR as E, type FnCtx as F, type GlobalInspectorEvent as G, type HashFn as H, INVALIDATE as I, type NodeInspectorHookEvent as J, type NodeSink as K, type NodeStatus as L, type Message as M, type Node as N, type NodeTransportOptions as O, type PolicyRuleData as P, type NodeVersionInfo as Q, type OnMessageHandler as R, type OnSubscribeHandler as S, PAUSE as T, type PolicyAllow as U, type PolicyDeny as V, RESOLVED as W, RESOLVED_MSG as X, RESOLVED_ONLY_BATCH as Y, RESUME as Z, START as _, type NodeOptions as a, type SubscribeContext as a0, TEARDOWN as a1, TEARDOWN_MSG as a2, TEARDOWN_ONLY_BATCH as a3, type V0 as a4, type V1 as a5, type VersioningLevel as a6, type VersioningOptions as a7, accessHintForGuard as a8, advanceVersion as a9, configure as aa, createVersioning as ab, defaultConfig as ac, defaultHash as ad, isV1 as ae, node as af, normalizeActor as ag, policy as ah, policyFromRules as ai, registerBuiltins as aj, COMPLETE_MSG as b, COMPLETE_ONLY_BATCH as c, DEFAULT_ACTOR as d, DIRTY as e, DIRTY_MSG as f, DIRTY_ONLY_BATCH as g, type DepRecord as h, type GlobalInspectorHook as i, GraphReFlyConfig as j, type GuardAction as k, GuardDenied as l, type GuardDeniedDetails as m, INVALIDATE_MSG as n, INVALIDATE_ONLY_BATCH as o, type MessageContext as p, type MessageTypeRegistration as q, type MessageTypeRegistrationInput as r, type Messages as s, type NodeActions as t, type NodeCtx as u, type NodeDescribeKind as v, type NodeFn as w, type NodeFnCleanup as x, type NodeGuard as y, NodeImpl as z };

package/dist/{node-B-f-Lu-k.d.ts → node-BmerH3kS.d.ts}

@@ -886,6 +886,12 @@ declare class NodeImpl<T = unknown> implements Node<T> {
     readonly _autoError: boolean;
     readonly _pausable: boolean | "resumeAll";
     readonly _guard: NodeGuard | undefined;
+    /**
+     * @internal Additional guards stacked at runtime via {@link NodeImpl._pushGuard}
+     * (e.g. by `policyEnforcer({ mode: "enforce" })`, roadmap §9.2). Effective
+     * write/signal/observe checks AND the original `_guard` with every entry here.
+     */
+    _extraGuards: Set<NodeGuard> | undefined;
     _hashFn: HashFn;
     _versioning: NodeVersionInfo | undefined;
     /**
@@ -967,6 +973,25 @@ declare class NodeImpl<T = unknown> implements Node<T> {
      * and returns a no-op disposer.
      */
     _setInspectorHook(hook?: NodeInspectorHook): () => void;
+    /**
+     * @internal Push an additional guard onto this node. Effective enforcement
+     * is the AND of `_guard` and every guard pushed via this hook — any one
+     * rejecting throws {@link GuardDenied}. Returns a disposer that removes
+     * the pushed guard. Multiple guards may be stacked simultaneously.
+     *
+     * Used by `policyEnforcer({ mode: "enforce" })` (roadmap §9.2) to overlay
+     * runtime constraint enforcement onto an existing graph without rebuilding
+     * its nodes. Pre-1.0 internal API; not part of the public surface.
+     *
+     * **Identity semantics:** guards are tracked in a `Set`, so pushing the
+     * same `NodeGuard` reference twice is a single registration. Wrap each
+     * push in a unique closure if independent stacking is needed.
+     *
+     * **Iteration order:** insertion-ordered (`Set` semantics). Determinism
+     * follows from single-threaded JS execution; nested re-entry from inside
+     * a guard body (push/pop while iterating) is undefined-but-survivable.
+     */
+    _pushGuard(guard: NodeGuard): () => void;
     allowsObserve(actor: Actor): boolean;
     private _checkGuard;
     down(messageOrMessages: Message | Messages, options?: NodeTransportOptions): void;
@@ -1187,4 +1212,4 @@ declare class NodeImpl<T = unknown> implements Node<T> {
  */
 declare function node<T = unknown>(depsOrFn?: readonly Node[] | NodeFn | NodeOptions<T>, fnOrOpts?: NodeFn | NodeOptions<T>, optsArg?: NodeOptions<T>): Node<T>;
 
-export { START_MSG as $, type Actor as A, type NodeInspectorHook as B, COMPLETE as C, DATA as D, ERROR as E, type FnCtx as F, type GlobalInspectorEvent as G, type HashFn as H, INVALIDATE as I, type NodeInspectorHookEvent as J, type NodeSink as K, type NodeStatus as L, type Message as M, type Node as N, type NodeTransportOptions as O, type NodeVersionInfo as P, type OnMessageHandler as Q, type OnSubscribeHandler as R, PAUSE as S, type PolicyAllow as T, type PolicyDeny as U, type PolicyRuleData as V, RESOLVED as W, RESOLVED_MSG as X, RESOLVED_ONLY_BATCH as Y, RESUME as Z, START as _, type NodeOptions as a, type SubscribeContext as a0, TEARDOWN as a1, TEARDOWN_MSG as a2, TEARDOWN_ONLY_BATCH as a3, type V0 as a4, type V1 as a5, type VersioningLevel as a6, type VersioningOptions as a7, accessHintForGuard as a8, advanceVersion as a9, configure as aa, createVersioning as ab, defaultConfig as ac, defaultHash as ad, isV1 as ae, node as af, normalizeActor as ag, policy as ah, policyFromRules as ai, registerBuiltins as aj, type NodeActions as b, COMPLETE_MSG as c, COMPLETE_ONLY_BATCH as d, DEFAULT_ACTOR as e, DIRTY as f, DIRTY_MSG as g, DIRTY_ONLY_BATCH as h, type DepRecord as i, type GlobalInspectorHook as j, GraphReFlyConfig as k, type GuardAction as l, GuardDenied as m, type GuardDeniedDetails as n, INVALIDATE_MSG as o, INVALIDATE_ONLY_BATCH as p, type MessageContext as q, type MessageTypeRegistration as r, type MessageTypeRegistrationInput as s, type Messages as t, type NodeCtx as u, type NodeDescribeKind as v, type NodeFn as w, type NodeFnCleanup as x, type NodeGuard as y, NodeImpl as z };
+export { START_MSG as $, type Actor as A, type NodeInspectorHook as B, COMPLETE as C, DATA as D, ERROR as E, type FnCtx as F, type GlobalInspectorEvent as G, type HashFn as H, INVALIDATE as I, type NodeInspectorHookEvent as J, type NodeSink as K, type NodeStatus as L, type Message as M, type Node as N, type NodeTransportOptions as O, type PolicyRuleData as P, type NodeVersionInfo as Q, type OnMessageHandler as R, type OnSubscribeHandler as S, PAUSE as T, type PolicyAllow as U, type PolicyDeny as V, RESOLVED as W, RESOLVED_MSG as X, RESOLVED_ONLY_BATCH as Y, RESUME as Z, START as _, type NodeOptions as a, type SubscribeContext as a0, TEARDOWN as a1, TEARDOWN_MSG as a2, TEARDOWN_ONLY_BATCH as a3, type V0 as a4, type V1 as a5, type VersioningLevel as a6, type VersioningOptions as a7, accessHintForGuard as a8, advanceVersion as a9, configure as aa, createVersioning as ab, defaultConfig as ac, defaultHash as ad, isV1 as ae, node as af, normalizeActor as ag, policy as ah, policyFromRules as ai, registerBuiltins as aj, COMPLETE_MSG as b, COMPLETE_ONLY_BATCH as c, DEFAULT_ACTOR as d, DIRTY as e, DIRTY_MSG as f, DIRTY_ONLY_BATCH as g, type DepRecord as h, type GlobalInspectorHook as i, GraphReFlyConfig as j, type GuardAction as k, GuardDenied as l, type GuardDeniedDetails as m, INVALIDATE_MSG as n, INVALIDATE_ONLY_BATCH as o, type MessageContext as p, type MessageTypeRegistration as q, type MessageTypeRegistrationInput as r, type Messages as s, type NodeActions as t, type NodeCtx as u, type NodeDescribeKind as v, type NodeFn as w, type NodeFnCleanup as x, type NodeGuard as y, NodeImpl as z };

package/dist/{observable-uP-wy_uK.d.ts → observable-BgGUwcqp.d.ts}

@@ -1,5 +1,5 @@
 import { Observable } from 'rxjs';
-import { N as Node, t as Messages } from './node-B-f-Lu-k.js';
+import { N as Node, s as Messages } from './node-BmerH3kS.js';
 
 /** Options for {@link toObservable}. */
 type ToObservableOptions = {

package/dist/{observable-DBnrwcar.d.cts → observable-DJt_AxzQ.d.cts}

@@ -1,5 +1,5 @@
 import { Observable } from 'rxjs';
-import { N as Node, t as Messages } from './node-B-f-Lu-k.cjs';
+import { N as Node, s as Messages } from './node-BmerH3kS.cjs';
 
 /** Options for {@link toObservable}. */
 type ToObservableOptions = {