@graphrefly/graphrefly 0.27.0 → 0.29.0

package/dist/{index-CxFrXH4m.d.ts → index-gsT79Xu9.d.ts}

@@ -1,4 +1,4 @@
-import { N as Node } from './node-BmerH3kS.js';
+import { a as Node } from './node-Dd6wHSib.js';
 
 /** Svelte store contract — implements the minimal `subscribe` method. */
 interface SvelteReadable<T> {

package/dist/{index-D8wS_PeY.d.cts → index-i99Ka8s7.d.cts}

@@ -1,12 +1,12 @@
-import { i as index$2 } from './index-ByQxazQJ.cjs';
-import { i as index$3 } from './index-DO_6JN9Z.cjs';
-import { i as index$4 } from './index-DlLp-2Xn.cjs';
-import { i as index$5 } from './index-DYme44FM.cjs';
-import { N as Node } from './node-BmerH3kS.cjs';
-import { i as index$6 } from './index-Xi3u0HCQ.cjs';
-import { i as index$7 } from './index-VHqptjhu.cjs';
-import { i as index$8 } from './index-B1tloyhO.cjs';
-import { i as index$9 } from './index-B6EhDnjH.cjs';
+import { i as index$2 } from './index-CABbltIu.cjs';
+import { i as index$3 } from './index-D80do5jX.cjs';
+import { i as index$4 } from './index-B-8FCEua.cjs';
+import { i as index$5 } from './index-y1RllPn4.cjs';
+import { a as Node } from './node-Dd6wHSib.cjs';
+import { i as index$6 } from './index-jleeotBT.cjs';
+import { i as index$7 } from './index-CHEBsnYv.cjs';
+import { i as index$8 } from './index-U1nir7MX.cjs';
+import { i as index$9 } from './index-H_oxVec5.cjs';
 
 /**
  * Options for creating signals.

package/dist/index-iKkyJosF.d.cts

@@ -0,0 +1,105 @@
+import { a as Node } from './node-Dd6wHSib.cjs';
+import { S as StatusValue, C as CircuitState, R as RateLimiterOptions, a as CircuitBreakerOptions, b as RetryOptions, F as FallbackInput, N as NS_PER_MS, c as NS_PER_SEC } from './resilience-uBz4yvYB.cjs';
+import { B as BudgetConstraint } from './index-BUVtw1Ay.cjs';
+
+/**
+ * Resilience composition with correct nesting order (roadmap §9.0b).
+ *
+ * {@link resilientPipeline} composes the resilience primitives from
+ * `extra/resilience.ts` in the order discovered during the §9.1 eval runs:
+ *
+ * ```text
+ *   rateLimit → budget → breaker → timeout → retry → fallback → status
+ * ```
+ *
+ * Note on retry/timeout ordering: `timeout` is applied BEFORE `retry` so each
+ * retry attempt resubscribes to a fresh deadline (per-attempt semantics). If
+ * `timeout` wrapped `retry`, a single deadline would apply to the entire
+ * retry chain — not what callers expect.
+ *
+ * Every step is optional — omit the option and that layer is skipped. The
+ * returned bundle exposes the final `Node<T>` plus the status/error/breaker
+ * companions so callers can wire them into dashboards, alerts, or
+ * {@link graphLens}.
+ *
+ * Subsumes the pre-1.0 `resilientFetch` template — that template becomes a
+ * preconfigured instance of this factory for the HTTP fetch case.
+ *
+ * @module
+ */
+
+/** Options for {@link resilientPipeline}. Every field is optional — omit to skip that layer. */
+interface ResilientPipelineOptions<T> {
+    /** Admission control — at most `maxEvents` DATA per `windowNs`. See {@link rateLimiter}. */
+    rateLimit?: RateLimiterOptions;
+    /** Cost/constraint gate. See {@link budgetGate}. */
+    budget?: ReadonlyArray<BudgetConstraint>;
+    /** Circuit breaker — fail-fast when the downstream resource is unhealthy. See {@link circuitBreaker}. */
+    breaker?: CircuitBreakerOptions;
+    /**
+     * Behavior when the breaker is open:
+     * - `"skip"` — emit RESOLVED (default, lets downstream drop the beat)
+     * - `"error"` — emit a `CircuitOpenError` so `retry`/`fallback` can react
+     *
+     * Only used when `breaker` is provided.
+     */
+    breakerOnOpen?: "skip" | "error";
+    /** Retry policy on terminal ERROR. See {@link retry}. */
+    retry?: RetryOptions;
+    /**
+     * Per-attempt deadline in milliseconds. Converted to ns internally. Omit to skip the timeout wrap.
+     *
+     * Specified in ms (not ns) because callers consistently think in millisecond deadlines;
+     * retry/breaker/ratelimit options take ns to match their primitives exactly.
+     */
+    timeoutMs?: number;
+    /** Final fallback value emitted on terminal ERROR after retry exhausts. See {@link fallback}. */
+    fallback?: FallbackInput<T>;
+    /** Initial status reported by the status node. Default `"pending"`. */
+    initialStatus?: StatusValue;
+}
+/** Output bundle of {@link resilientPipeline}. */
+interface ResilientPipelineBundle<T> {
+    /** The final resilient node. Subscribe to this for DATA emissions. */
+    node: Node<T>;
+    /** Live status: `"pending" | "active" | "completed" | "errored"`. */
+    status: Node<StatusValue>;
+    /** Last error payload, or `null` when not errored. */
+    error: Node<unknown | null>;
+    /** Breaker state when `opts.breaker` was provided; `undefined` otherwise. */
+    breakerState: Node<CircuitState> | undefined;
+}
+/**
+ * Compose a resilient pipeline around `source` in the canonical nesting
+ * order — `rateLimit → budget → breaker → timeout → retry → fallback → status`.
+ * Omit any option to skip that layer.
+ *
+ * @param source - Upstream node to wrap.
+ * @param opts - See {@link ResilientPipelineOptions}. All fields optional.
+ *
+ * @example
+ * ```ts
+ * const safeFetch = resilientPipeline(fetchNode, {
+ *   rateLimit: { maxEvents: 10, windowNs: NS_PER_SEC },
+ *   breaker: { failureThreshold: 5 },
+ *   retry: { count: 3, backoff: "exponential" },
+ *   timeoutMs: 10_000,
+ *   fallback: null,
+ * });
+ * safeFetch.status.subscribe(msgs => console.log(msgs));
+ * ```
+ *
+ * @category patterns
+ */
+declare function resilientPipeline<T>(source: Node<T>, opts?: ResilientPipelineOptions<T>): ResilientPipelineBundle<T>;
+
+declare const index_NS_PER_MS: typeof NS_PER_MS;
+declare const index_NS_PER_SEC: typeof NS_PER_SEC;
+type index_ResilientPipelineBundle<T> = ResilientPipelineBundle<T>;
+type index_ResilientPipelineOptions<T> = ResilientPipelineOptions<T>;
+declare const index_resilientPipeline: typeof resilientPipeline;
+declare namespace index {
+  export { index_NS_PER_MS as NS_PER_MS, index_NS_PER_SEC as NS_PER_SEC, type index_ResilientPipelineBundle as ResilientPipelineBundle, type index_ResilientPipelineOptions as ResilientPipelineOptions, index_resilientPipeline as resilientPipeline };
+}
+
+export { type ResilientPipelineBundle as R, type ResilientPipelineOptions as a, index as i, resilientPipeline as r };

package/dist/{index-Xi3u0HCQ.d.cts → index-jleeotBT.d.cts}

@@ -1,4 +1,4 @@
-import { N as Node } from './node-BmerH3kS.cjs';
+import { a as Node } from './node-Dd6wHSib.cjs';
 
 /** Solid accessor function — returns current value when called. */
 type Accessor<T> = () => T;

package/dist/{index-DVGiGFGT.d.cts → index-kykKWwV-.d.cts}

@@ -1,6 +1,6 @@
-import { s as Messages, A as Actor, C as COMPLETE, b as COMPLETE_MSG, c as COMPLETE_ONLY_BATCH, D as DATA, d as DEFAULT_ACTOR, e as DIRTY, f as DIRTY_MSG, g as DIRTY_ONLY_BATCH, h as DepRecord, E as ERROR, F as FnCtx, G as GlobalInspectorEvent, i as GlobalInspectorHook, j as GraphReFlyConfig, k as GuardAction, l as GuardDenied, m as GuardDeniedDetails, H as HashFn, I as INVALIDATE, n as INVALIDATE_MSG, o as INVALIDATE_ONLY_BATCH, M as Message, p as MessageContext, q as MessageTypeRegistration, r as MessageTypeRegistrationInput, N as Node, t as NodeActions, u as NodeCtx, v as NodeDescribeKind, w as NodeFn, x as NodeFnCleanup, y as NodeGuard, z as NodeImpl, B as NodeInspectorHook, J as NodeInspectorHookEvent, a as NodeOptions, K as NodeSink, L as NodeStatus, O as NodeTransportOptions, Q as NodeVersionInfo, R as OnMessageHandler, S as OnSubscribeHandler, T as PAUSE, U as PolicyAllow, V as PolicyDeny, P as PolicyRuleData, W as RESOLVED, X as RESOLVED_MSG, Y as RESOLVED_ONLY_BATCH, Z as RESUME, _ as START, $ as START_MSG, a0 as SubscribeContext, a1 as TEARDOWN, a2 as TEARDOWN_MSG, a3 as TEARDOWN_ONLY_BATCH, a4 as V0, a5 as V1, a6 as VersioningLevel, a7 as VersioningOptions, a8 as accessHintForGuard, a9 as advanceVersion, aa as configure, ab as createVersioning, ac as defaultConfig, ad as defaultHash, ae as isV1, af as node, ag as normalizeActor, ah as policy, ai as policyFromRules, aj as registerBuiltins } from './node-BmerH3kS.cjs';
-import { D as DescribeDetail, a as DescribeField, b as DescribeNodeOutput, r as resolveDescribeFields } from './meta-BxCA7rcr.cjs';
-import { A as AutoTrackOptions, D as DerivedFn, a as DynamicFn, E as EffectFn, P as PipeOperator, b as ProducerFn, T as TrackFn, c as autoTrackNode, d as derived, e as dynamicNode, f as effect, p as pipe, g as producer, s as state } from './sugar-D02n5JjF.cjs';
+import { b as Messages, A as Actor, C as COMPLETE, f as COMPLETE_MSG, g as COMPLETE_ONLY_BATCH, D as DATA, h as DEFAULT_ACTOR, i as DIRTY, j as DIRTY_MSG, k as DIRTY_ONLY_BATCH, l as DepRecord, E as ERROR, F as FnCtx, m as GlobalInspectorEvent, n as GlobalInspectorHook, o as GraphReFlyConfig, G as GuardAction, p as GuardDenied, q as GuardDeniedDetails, H as HashFn, I as INVALIDATE, r as INVALIDATE_MSG, s as INVALIDATE_ONLY_BATCH, M as Message, t as MessageContext, u as MessageTypeRegistration, v as MessageTypeRegistrationInput, a as Node, c as NodeActions, w as NodeCtx, e as NodeDescribeKind, x as NodeFn, d as NodeFnCleanup, y as NodeGuard, z as NodeImpl, B as NodeInspectorHook, J as NodeInspectorHookEvent, N as NodeOptions, K as NodeSink, L as NodeStatus, O as NodeTransportOptions, Q as NodeVersionInfo, R as OnMessageHandler, S as OnSubscribeHandler, T as PAUSE, U as PolicyAllow, W as PolicyDeny, P as PolicyRuleData, X as RESOLVED, Y as RESOLVED_MSG, Z as RESOLVED_ONLY_BATCH, _ as RESUME, $ as START, a0 as START_MSG, a1 as SubscribeContext, a2 as TEARDOWN, a3 as TEARDOWN_MSG, a4 as TEARDOWN_ONLY_BATCH, a5 as V0, a6 as V1, V as VersioningLevel, a7 as VersioningOptions, a8 as accessHintForGuard, a9 as advanceVersion, aa as configure, ab as createVersioning, ac as defaultConfig, ad as defaultHash, ae as isV1, af as node, ag as normalizeActor, ah as policy, ai as policyFromRules, aj as registerBuiltins } from './node-Dd6wHSib.cjs';
+import { D as DescribeDetail, a as DescribeField, b as DescribeNodeOutput, r as resolveDescribeFields } from './meta-CX7YsOzp.cjs';
+import { A as AutoTrackOptions, D as DerivedFn, a as DynamicFn, E as EffectFn, P as PipeOperator, b as ProducerFn, T as TrackFn, c as autoTrackNode, d as derived, e as dynamicNode, f as effect, p as pipe, g as producer, s as state } from './sugar-DHttV0LX.cjs';
 
 /**
  * Batch deferral for tier-3+ messages, plus per-node emit coalescing inside

package/dist/index-vgcLF5TH.d.cts

@@ -0,0 +1,192 @@
+import { a as Node } from './node-Dd6wHSib.cjs';
+import { a as GraphOptions, G as Graph } from './graph-DgohqXK-.cjs';
+
+/**
+ * CQRS patterns (roadmap §4.5).
+ *
+ * Composition layer over reactiveLog (3.2), pipeline/sagas (4.1), event bus (4.2),
+ * projections (4.3). Guards (1.5) enforce command/query boundary.
+ *
+ * - `cqrs(name, opts?)` → `CqrsGraph` — top-level factory
+ * - `CqrsGraph.command(name, handler)` — write-only node; guard rejects `observe`
+ * - `CqrsGraph.event(name)` — backed by `reactiveLog`; append-only
+ * - `CqrsGraph.projection(name, events, reducer, initial)` — read-only derived; guard rejects `write`
+ * - `CqrsGraph.saga(name, events, handler)` — event-driven side effects
+ */
+
+/**
+ * Immutable envelope for events emitted by command handlers.
+ *
+ * `seq` is a per-graph monotonic counter that provides stable ordering when
+ * multiple events share the same `timestampNs` (same wall-clock tick).
+ */
+type CqrsEvent<T = unknown> = {
+    type: string;
+    payload: T;
+    /** Wall-clock nanoseconds (via `wallClockNs()`). */
+    timestampNs: number;
+    /** Monotonic sequence within this CqrsGraph instance. */
+    seq: number;
+    /** V0 identity of the event log node at append time (§6.0b). */
+    v0?: {
+        id: string;
+        version: number;
+    };
+};
+/**
+ * Opaque replay cursor returned by `loadEvents`. Pass it back to
+ * `loadEvents` to resume from the last position.
+ */
+type EventStoreCursor = {
+    readonly __brand?: "EventStoreCursor";
+    [key: string]: unknown;
+};
+/**
+ * Result of `loadEvents` — events plus an opaque cursor for resumption.
+ */
+type LoadEventsResult = {
+    events: CqrsEvent[];
+    cursor: EventStoreCursor | undefined;
+};
+/**
+ * Pluggable persistence for CQRS events.
+ *
+ * **`persist`:** Must be synchronous. Called from the dispatch path inside
+ * `batch()`. Adapters that need async I/O should buffer internally and
+ * expose a `flush()` method for explicit drain.
+ */
+interface EventStoreAdapter {
+    persist(event: CqrsEvent): void;
+    /**
+     * Load persisted events. When `cursor` is provided, returns only events
+     * after that position. The returned `cursor` should be passed to the next
+     * `loadEvents` call for incremental replay.
+     */
+    loadEvents(eventType: string, cursor?: EventStoreCursor): LoadEventsResult | Promise<LoadEventsResult>;
+    /** Optional explicit flush for adapters with async I/O. */
+    flush?(): Promise<void>;
+}
+declare class MemoryEventStore implements EventStoreAdapter {
+    private readonly _store;
+    persist(event: CqrsEvent): void;
+    loadEvents(eventType: string, cursor?: EventStoreCursor): LoadEventsResult;
+    clear(): void;
+}
+type CommandActions = {
+    /** Append an event to a named event log (bypasses event guard). */
+    emit: (eventName: string, payload: unknown) => void;
+};
+/**
+ * Command handler receives the dispatch payload and actions to emit events.
+ *
+ * **Purity:** Handlers should not mutate the payload. Event emission via
+ * `actions.emit()` is the only sanctioned side effect.
+ */
+type CommandHandler<T = unknown> = (payload: T, actions: CommandActions) => void;
+/**
+ * Projection reducer folds events into a read model.
+ *
+ * **Purity contract:** Reducers MUST be pure — return a new state value
+ * without mutating `state` or any event. The `state` parameter is the
+ * original `initial` value on every invocation (full event-sourcing replay),
+ * so mutation would corrupt future recomputations.
+ */
+type ProjectionReducer<TState = unknown, TEvent = unknown> = (state: TState, events: readonly CqrsEvent<TEvent>[]) => TState;
+type SagaHandler<T = unknown> = (event: CqrsEvent<T>) => void;
+type CqrsOptions = {
+    graph?: GraphOptions;
+};
+declare class CqrsGraph extends Graph {
+    private readonly _eventLogs;
+    private readonly _commandHandlers;
+    private readonly _projections;
+    private readonly _sagas;
+    private readonly _keepaliveDisposers;
+    private _eventStore;
+    private _seq;
+    constructor(name: string, opts?: CqrsOptions);
+    destroy(): void;
+    /**
+     * Register a named event stream backed by `reactiveLog`.
+     * Guard denies external `write` — only commands append internally.
+     */
+    event(name: string): Node<readonly CqrsEvent[]>;
+    /** Internal: append to an event log, auto-registering if needed. */
+    private _appendEvent;
+    /**
+     * Register a command with its handler. Guard denies `observe` (write-only).
+     * Use `dispatch(name, payload)` to execute.
+     *
+     * The command node carries dynamic `meta.error` — a reactive companion
+     * that holds the last handler error (or `null` on success).
+     */
+    command<T = unknown>(name: string, handler: CommandHandler<T>): Node<T>;
+    /**
+     * Execute a registered command. Wraps the entire dispatch in `batch()` so
+     * the command node DATA and all emitted events settle atomically.
+     *
+     * If the handler throws, `meta.error` on the command node is set to the
+     * error and the exception is re-thrown.
+     */
+    dispatch<T = unknown>(commandName: string, payload: T): void;
+    /**
+     * Register a read-only projection derived from event streams.
+     * Guard denies `write` — value is computed from events only.
+     *
+     * **Purity contract:** The `reducer` must be a pure function — it receives
+     * the original `initial` on every invocation (full event-sourcing replay).
+     * Never mutate `initial`; always return a new value.
+     */
+    projection<TState>(name: string, eventNames: readonly string[], reducer: ProjectionReducer<TState>, initial: TState): Node<TState>;
+    /**
+     * Register an event-driven side effect. Runs handler for each **new** event
+     * from the specified streams (tracks last-processed entry count per stream).
+     *
+     * The saga node carries dynamic `meta.error` — a reactive companion that
+     * holds the last handler error (or `null` on success). Handler errors do
+     * not propagate out of the saga run (the event cursor still advances so
+     * the same entry is not delivered twice).
+     */
+    saga<T = unknown>(name: string, eventNames: readonly string[], handler: SagaHandler<T>): Node<unknown>;
+    useEventStore(adapter: EventStoreAdapter): void;
+    /**
+     * Replay persisted events through a reducer to rebuild a read model.
+     * Requires an event store adapter wired via `useEventStore()`.
+     */
+    rebuildProjection<TState>(eventNames: readonly string[], reducer: ProjectionReducer<TState>, initial: TState): Promise<TState>;
+}
+/**
+ * Create a CQRS graph container.
+ *
+ * @example
+ * ```ts
+ * const app = cqrs("orders");
+ * app.event("orderPlaced");
+ * app.command("placeOrder", (payload, { emit }) => {
+ *   emit("orderPlaced", { orderId: payload.id, amount: payload.amount });
+ * });
+ * app.projection("orderCount", ["orderPlaced"], (_s, events) => events.length, 0);
+ * app.dispatch("placeOrder", { id: "1", amount: 100 });
+ * ```
+ */
+declare function cqrs(name: string, opts?: CqrsOptions): CqrsGraph;
+
+type index_CommandActions = CommandActions;
+type index_CommandHandler<T = unknown> = CommandHandler<T>;
+type index_CqrsEvent<T = unknown> = CqrsEvent<T>;
+type index_CqrsGraph = CqrsGraph;
+declare const index_CqrsGraph: typeof CqrsGraph;
+type index_CqrsOptions = CqrsOptions;
+type index_EventStoreAdapter = EventStoreAdapter;
+type index_EventStoreCursor = EventStoreCursor;
+type index_LoadEventsResult = LoadEventsResult;
+type index_MemoryEventStore = MemoryEventStore;
+declare const index_MemoryEventStore: typeof MemoryEventStore;
+type index_ProjectionReducer<TState = unknown, TEvent = unknown> = ProjectionReducer<TState, TEvent>;
+type index_SagaHandler<T = unknown> = SagaHandler<T>;
+declare const index_cqrs: typeof cqrs;
+declare namespace index {
+  export { type index_CommandActions as CommandActions, type index_CommandHandler as CommandHandler, type index_CqrsEvent as CqrsEvent, index_CqrsGraph as CqrsGraph, type index_CqrsOptions as CqrsOptions, type index_EventStoreAdapter as EventStoreAdapter, type index_EventStoreCursor as EventStoreCursor, type index_LoadEventsResult as LoadEventsResult, index_MemoryEventStore as MemoryEventStore, type index_ProjectionReducer as ProjectionReducer, type index_SagaHandler as SagaHandler, index_cqrs as cqrs };
+}
+
+export { type CqrsOptions as C, type EventStoreAdapter as E, type LoadEventsResult as L, MemoryEventStore as M, type ProjectionReducer as P, type SagaHandler as S, CqrsGraph as a, type CommandActions as b, type CommandHandler as c, type CqrsEvent as d, type EventStoreCursor as e, cqrs as f, index as i };

package/dist/{index-DYme44FM.d.cts → index-y1RllPn4.d.cts}

@@ -1,4 +1,4 @@
-import { N as Node } from './node-BmerH3kS.cjs';
+import { a as Node } from './node-Dd6wHSib.cjs';
 
 /**
  * Subscribe to a read-only `Node<T>` as a React value. Re-renders on node value settlement.