@graphrefly/graphrefly 0.34.0 → 0.35.0

package/dist/index-CGKs5ixV.d.cts

@@ -0,0 +1,287 @@
+import { R as ReactiveLogBundle } from './reactive-log-CgbNqksB.cjs';
+import { NodeInput } from './extra/sources.cjs';
+import { AppendLogStorageTier } from './extra/storage-tiers.cjs';
+import { B as BaseAuditRecord } from './imperative-audit-ahAE65a9.cjs';
+import { C as CqrsEventMap, a as CqrsEvent, b as CqrsGraph } from './index-zK_mN1D-.cjs';
+
+/**
+ * Process Manager pattern (Phase 7 — roadmap §4.6, Audit 3 — locked 2026-04-24).
+ *
+ * Reactive long-running workflow primitive over CQRS event nodes.
+ * Correlates events across aggregates, tracks per-instance state, supports
+ * retries with backoff, and runs compensation on failure or explicit cancel.
+ *
+ * ## Architecture
+ *
+ * - Per-instance state lives in a `Map<correlationId, TState>` closure (in-memory),
+ *   optionally event-sourced via synthetic `_process_<name>_state` events that
+ *   use `correlationId` as `aggregateId`.
+ * - Watched-event subscriptions are imperative (coordinator role) — each
+ *   watched CQRS event type is subscribed to via `entries.subscribe(...)`.
+ *   These are NOT reactive node edges; the process manager is intentionally
+ *   a coordinator that bridges reactive CQRS events into imperative instance logic.
+ * - Step execution uses `fromAny` to uniformly handle sync and async handlers.
+ * - Retry delays use `setTimeout` (same sanctioned pattern as `extra/resilience.ts`
+ *   retry helper — this primitive is a coordinator, not a reactive pipeline stage).
+ * - Timer scheduling uses `fromTimer` from `extra/sources.ts` per spec §5.8.
+ * - Audit log uses `createAuditLog` per Audit 2.
+ *
+ * @module
+ */
+
+/**
+ * Discriminated union returned by each step handler.
+ *
+ * - `"continue"` — update state, optionally emit side-effect events and
+ *   schedule a future synthetic event.
+ * - `"terminate"` — workflow complete; instance moves to `"terminated"`.
+ * - `"fail"` — triggers compensation; instance moves to `"compensated"` /
+ *   `"failed"`.
+ */
+type ProcessStepResult<TState> = {
+    kind: "continue";
+    state: TState;
+    emit?: readonly {
+        type: string;
+        payload: unknown;
+    }[];
+    schedule?: ProcessSchedule;
+} | {
+    kind: "terminate";
+    state: TState;
+    emit?: readonly {
+        type: string;
+        payload: unknown;
+    }[];
+    reason?: string;
+} | {
+    kind: "fail";
+    error: unknown;
+};
+/**
+ * Schedule a synthetic timer event after `afterMs` milliseconds.
+ * When the timer fires, the synthetic event of `eventType` is routed to the
+ * matching step (if one is registered) for this correlationId.
+ */
+type ProcessSchedule = {
+    afterMs: number;
+    eventType: string;
+};
+/**
+ * Step handler signature.
+ *
+ * Receives the current instance state and the triggering CQRS event.
+ * Returns a {@link ProcessStepResult} — sync value, Promise, or any
+ * {@link NodeInput} consumed via `fromAny`.
+ */
+type ProcessStep<TState, EM extends CqrsEventMap, K extends keyof EM & string> = (state: TState, event: CqrsEvent<EM[K]>) => NodeInput<ProcessStepResult<TState>>;
+/**
+ * Compensation handler. Runs when a step returns `kind: "fail"`, throws, or
+ * when `cancel(correlationId)` is called on a running instance.
+ *
+ * Should undo any side effects performed by prior steps (refund, cancel
+ * reservation, etc.). Errors thrown inside compensate are swallowed and
+ * recorded in the audit log with `status: "failed"` to prevent cascading
+ * failure loops.
+ */
+type ProcessCompensate<TState> = (state: TState, error: unknown) => NodeInput<void>;
+/**
+ * Audit record for a single process instance state transition.
+ *
+ * Every status change (start → running → terminated / failed / compensated)
+ * appends one record. `correlationId` is the stable process key.
+ *
+ * Extends {@link BaseAuditRecord} so records carry `t_ns` / `seq` /
+ * `handlerVersion` from the cross-cutting Audit 2 schema.
+ */
+interface ProcessInstance<TState> extends BaseAuditRecord {
+    /** Stable correlation key that identifies this process instance. */
+    readonly correlationId: string;
+    /** Most-recent instance state at this transition. */
+    readonly state: TState;
+    /** Current lifecycle status after this transition. */
+    readonly status: "running" | "terminated" | "failed" | "compensated";
+    /** Wall-clock nanoseconds when `start()` was called. */
+    readonly startedAt: number;
+    /** Wall-clock nanoseconds of this transition. */
+    readonly updatedAt: number;
+    /** Handler version stamped at transition time (Audit 5). */
+    readonly handlerVersion?: {
+        id: string;
+        version: string | number;
+    };
+    /** Optional human-readable reason for cancellation. Present only on `"compensated"` records produced by `cancel()`. */
+    readonly reason?: string;
+}
+/**
+ * Recommended `keyOf` for storage tiers keyed by correlationId (Audit 2).
+ */
+declare const processInstanceKeyOf: <TState>(i: ProcessInstance<TState>) => string;
+/**
+ * Options for {@link processManager}.
+ */
+interface ProcessManagerOpts<TState, EM extends CqrsEventMap> {
+    /** Initial state value for every new process instance. */
+    readonly initial: TState;
+    /** CQRS event types to watch for correlation routing. */
+    readonly watching: readonly (keyof EM & string)[];
+    /**
+     * Per-event-type step handlers. A step is invoked when a watched event's
+     * `correlationId` matches a running instance and the event type is in
+     * `steps`. Events with no matching step are silently ignored.
+     */
+    readonly steps: {
+        [K in keyof EM & string]?: ProcessStep<TState, EM, K>;
+    };
+    /**
+     * Optional compensation handler. Runs on step `kind: "fail"` / step throw
+     * and on explicit `cancel()`. If omitted, instances fail silently with
+     * status `"failed"` instead of `"compensated"`.
+     */
+    readonly compensate?: ProcessCompensate<TState>;
+    /**
+     * Optional predicate called after each `"continue"` step. When it returns
+     * `true`, the instance is moved to `"terminated"` immediately without
+     * waiting for a `"terminate"` step result.
+     */
+    readonly isTerminal?: (state: TState) => boolean;
+    /**
+     * Maximum number of retry attempts after a step throws (not counting the
+     * first attempt). Default: `0` (no retry — fail immediately on throw).
+     */
+    readonly retryMax?: number;
+    /**
+     * Per-retry backoff delays in milliseconds. `backoffMs[i]` is the delay
+     * before attempt `i + 1`. If fewer entries than `retryMax`, the last entry
+     * is repeated. Default: `[0]` (no delay).
+     *
+     * **Implementation note:** retry delays are implemented with `setTimeout`
+     * (same sanctioned exception as `extra/resilience.ts`). This is a
+     * coordinator-layer primitive — `fromTimer` would require subscribing to
+     * an additional node per attempt, which would leak timer nodes without a
+     * clear disposal scope.
+     */
+    readonly backoffMs?: readonly number[];
+    /** Handler version tag stamped onto audit records (Audit 5). */
+    readonly handlerVersion?: {
+        id: string;
+        version: string | number;
+    };
+    /** Optional persistence wiring (Audit 4). */
+    readonly persistence?: {
+        /**
+         * Wire the per-process synthetic state event stream to append-log tiers.
+         * Reuses `CqrsGraph.attachEventStorage` so events persist across restarts.
+         */
+        eventStorage?: readonly AppendLogStorageTier<CqrsEvent>[];
+    };
+}
+/**
+ * Result handle returned by {@link processManager}.
+ */
+interface ProcessManagerResult<TState> {
+    /**
+     * Reactive audit log of every process instance state transition.
+     * Every `start()`, step result, retry, cancellation, and compensation
+     * appends a {@link ProcessInstance} record.
+     */
+    readonly instances: ReactiveLogBundle<ProcessInstance<TState>>;
+    /**
+     * Alias for {@link instances} (Audit 2 `.audit` duplication convention).
+     */
+    readonly audit: ReactiveLogBundle<ProcessInstance<TState>>;
+    /**
+     * Start a new process instance identified by `correlationId`.
+     *
+     * Emits a synthetic `_process_<name>_started` event into the CQRS graph
+     * with `correlationId` as `aggregateId` so per-aggregate streams record
+     * the process lifecycle. If the correlationId already has an active
+     * (running) instance, this call is a no-op (idempotent).
+     *
+     * @param correlationId - Stable key for this workflow instance.
+     * @param initialPayload - Optional payload carried on the start event.
+     */
+    start(correlationId: string, initialPayload?: unknown): void;
+    /**
+     * Cancel a running instance by correlationId.
+     *
+     * Triggers the `compensate` handler (if configured), then marks the
+     * instance as `"compensated"`. If the instance is not running, this is
+     * a no-op.
+     *
+     * @param correlationId - Instance to cancel.
+     * @param reason - Optional human-readable reason recorded in the audit log.
+     */
+    cancel(correlationId: string, reason?: string): void;
+    /**
+     * Synchronous read of the current in-memory state for a correlationId.
+     * Returns `undefined` if the instance does not exist or has terminated.
+     */
+    getState(correlationId: string): TState | undefined;
+    /**
+     * Release all watched-event subscriptions and stop processing new events.
+     *
+     * After `dispose()`, subsequent `start()` and `cancel()` calls are no-ops.
+     * In-flight async steps complete naturally; no new steps are dispatched.
+     */
+    dispose(): void;
+}
+/**
+ * Create a process manager that coordinates long-running reactive workflows
+ * over a {@link CqrsGraph}.
+ *
+ * Process instances are identified by `correlationId`. Events from the watched
+ * event types are routed to per-instance step handlers when the event's
+ * `correlationId` matches a running instance.
+ *
+ * ```ts
+ * const app = cqrs<{ orderPlaced: { orderId: string }; paymentReceived: { amount: number } }>("orders");
+ *
+ * const pm = processManager(app, "fulfillment", {
+ *   initial: { step: "awaiting-payment", total: 0 },
+ *   watching: ["orderPlaced", "paymentReceived"],
+ *   steps: {
+ *     orderPlaced(state, event) {
+ *       return { kind: "continue", state: { ...state, orderId: event.payload.orderId } };
+ *     },
+ *     paymentReceived(state, event) {
+ *       return { kind: "terminate", state: { ...state, total: event.payload.amount } };
+ *     },
+ *   },
+ *   compensate(state, _error) {
+ *     // undo reservation, issue refund, etc.
+ *   },
+ *   retryMax: 2,
+ *   backoffMs: [100, 500],
+ * });
+ *
+ * pm.start("order-123");
+ * app.dispatch("orderPlaced", { orderId: "order-123" }, { correlationId: "order-123" });
+ * ```
+ *
+ * @param cqrsGraph - The CQRS graph whose event streams the manager watches.
+ * @param name - Stable identifier for this process type; used for synthetic
+ *   event-type names (`_process_<name>_started`, `_process_<name>_state`).
+ * @param opts - Configuration: initial state, watched events, steps, retry,
+ *   compensation, and optional persistence.
+ * @returns {@link ProcessManagerResult} with `instances` audit log and
+ *   `start`, `cancel`, `getState` imperative controls.
+ *
+ * @category patterns
+ */
+declare function processManager<TState, EM extends CqrsEventMap = Record<string, unknown>>(cqrsGraph: CqrsGraph<EM>, name: string, opts: ProcessManagerOpts<TState, EM>): ProcessManagerResult<TState>;
+
+type index_ProcessCompensate<TState> = ProcessCompensate<TState>;
+type index_ProcessInstance<TState> = ProcessInstance<TState>;
+type index_ProcessManagerOpts<TState, EM extends CqrsEventMap> = ProcessManagerOpts<TState, EM>;
+type index_ProcessManagerResult<TState> = ProcessManagerResult<TState>;
+type index_ProcessSchedule = ProcessSchedule;
+type index_ProcessStep<TState, EM extends CqrsEventMap, K extends keyof EM & string> = ProcessStep<TState, EM, K>;
+type index_ProcessStepResult<TState> = ProcessStepResult<TState>;
+declare const index_processInstanceKeyOf: typeof processInstanceKeyOf;
+declare const index_processManager: typeof processManager;
+declare namespace index {
+  export { type index_ProcessCompensate as ProcessCompensate, type index_ProcessInstance as ProcessInstance, type index_ProcessManagerOpts as ProcessManagerOpts, type index_ProcessManagerResult as ProcessManagerResult, type index_ProcessSchedule as ProcessSchedule, type index_ProcessStep as ProcessStep, type index_ProcessStepResult as ProcessStepResult, index_processInstanceKeyOf as processInstanceKeyOf, index_processManager as processManager };
+}
+
+export { type ProcessCompensate as P, type ProcessInstance as a, type ProcessManagerOpts as b, type ProcessManagerResult as c, type ProcessSchedule as d, type ProcessStep as e, type ProcessStepResult as f, processManager as g, index as i, processInstanceKeyOf as p };

package/dist/{index-ygRFoyrN.d.ts → index-CI_yjtua.d.ts}

@@ -1,5 +1,5 @@
-import { a as Node } from './node-8qx0kgYt.js';
-import { G as Graph } from './graph-BROUZPG9.js';
+import { a as Node } from './node-fSc-hCv8.js';
+import { G as Graph } from './graph-Cv-8x0ZI.js';
 
 /**
  * Memory patterns (roadmap §4.3).

package/dist/{index-DxEcY7Om.d.ts → index-CIcu6fIR.d.ts}

@@ -1,4 +1,4 @@
-import { a as Node } from './node-8qx0kgYt.js';
+import { a as Node } from './node-fSc-hCv8.js';
 
 /**
  * Subscribe to a read-only `Node<T>` as a React value. Re-renders on node value settlement.

package/dist/{index-CQtnGFrZ.d.cts → index-CfOSES72.d.cts}

@@ -1,11 +1,11 @@
 import { NodeInput } from './extra/sources.cjs';
-import { a as Node } from './node-8qx0kgYt.cjs';
-import { L as LLMAdapter } from './types-Cp_4coR_.cjs';
-import { T as TopicGraph, M as MessagingHubGraph } from './index-Ccv_61jG.cjs';
-import { E as Evaluator, D as DatasetItem, a as EvalResult$1, R as RefineStrategy, b as RefineLoopOptions, c as RefineStatus } from './index-ChZvMC4M.cjs';
-import { G as Graph, s as GraphProfileResult, r as GraphProfileOptions } from './graph-DaoydJ_u.cjs';
-import { G as GateController } from './index-C2Dey3L-.cjs';
-import { J as JobQueueGraph } from './index-ClJUZAOr.cjs';
+import { a as Node } from './node-fSc-hCv8.cjs';
+import { L as LLMAdapter } from './types-BMSGPlpO.cjs';
+import { T as TopicGraph, M as MessagingHubGraph } from './index-B3Dfl5sS.cjs';
+import { E as Evaluator, D as DatasetItem, a as EvalResult$1, R as RefineStrategy, b as RefineLoopOptions, c as RefineStatus } from './index-DeyzuqAi.cjs';
+import { G as Graph, s as GraphProfileResult, r as GraphProfileOptions } from './graph-kTltt95s.cjs';
+import { G as GateController } from './pipeline-graph-B85HUrWg.cjs';
+import { J as JobQueueGraph } from './index-Qq-G9B6g.cjs';
 
 /**
  * Strategy model and priority scoring (roadmap §9.0).

package/dist/{index-Bd2AjMQY.d.ts → index-Cot94_82.d.ts}

@@ -1,6 +1,6 @@
-import { j as CompileSpecOptions, G as GraphSpec, c as GraphSpecCatalog, C as CatalogFnEntry, a as CatalogSourceEntry, b as ConfigFieldSchema, F as FnFactory, d as GraphSpecFeedbackEdge, e as GraphSpecNode, f as GraphSpecTemplate, g as GraphSpecTemplateRef, h as GraphSpecValidation, S as SourceFactory } from './index-Chi9IiHJ.js';
-import { G as Graph, o as GraphNodeFactory, m as GraphDiffResult } from './graph-BROUZPG9.js';
-import { StorageTier } from './extra/storage-core.js';
+import { j as CompileSpecOptions, G as GraphSpec, c as GraphSpecCatalog, C as CatalogFnEntry, a as CatalogSourceEntry, b as ConfigFieldSchema, F as FnFactory, d as GraphSpecFeedbackEdge, e as GraphSpecNode, f as GraphSpecTemplate, g as GraphSpecTemplateRef, h as GraphSpecValidation, S as SourceFactory } from './index-DlccEIi3.js';
+import { G as Graph, o as GraphNodeFactory, m as GraphDiffResult } from './graph-Cv-8x0ZI.js';
+import { KvStorageTier } from './extra/storage-tiers.js';
 
 /**
  * Surface: create a graph from a {@link GraphSpec} (§9.3-core).
@@ -121,15 +121,15 @@ interface ReduceOptions {
 declare function runReduction(spec: GraphSpec, input: unknown, opts?: ReduceOptions): Promise<unknown>;
 
 /**
- * Surface: snapshot save/restore/diff/list over {@link StorageTier} (§9.3-core).
+ * Surface: snapshot save/restore/diff/list over {@link KvStorageTier} (§9.3-core).
  *
  * One-shot snapshot management for stateless callers (MCP tools, CLI
  * commands) layered on the existing multi-tier auto-checkpoint substrate.
  * A saved snapshot is a `mode: "full"` {@link GraphCheckpointRecord} with
  * `seq: 0` — byte-identical to the baseline anchor
- * {@link Graph.attachStorage} writes on its first flush. An
+ * {@link Graph.attachSnapshotStorage} writes on its first flush. An
  * auto-checkpointed graph can therefore be restored through this surface,
- * and a surface-saved snapshot can be picked up by `attachStorage({
+ * and a surface-saved snapshot can be picked up by `attachSnapshotStorage({
  * autoRestore: true })`.
  *
  * The wire envelope stays at {@link SNAPSHOT_WIRE_VERSION}; no new format.
@@ -139,7 +139,7 @@ declare function runReduction(spec: GraphSpec, input: unknown, opts?: ReduceOpti
 
 /**
  * Current envelope version. Re-exported from `graph.ts` so the one-shot
- * surface path and `Graph.attachStorage` write byte-identical
+ * surface path and `Graph.attachSnapshotStorage` write byte-identical
  * `format_version` fields — no silent wire drift.
  */
 declare const SNAPSHOT_WIRE_VERSION = 1;
@@ -157,11 +157,11 @@ interface RestoreSnapshotOptions {
  * Write a graph's current state as a one-shot `mode: "full"` record.
  *
  * Uses the same {@link GraphCheckpointRecord} envelope as
- * {@link Graph.attachStorage} so the two persistence paths interoperate.
+ * {@link Graph.attachSnapshotStorage} so the two persistence paths interoperate.
  *
  * @throws {SurfaceError} `snapshot-failed` when the tier's `save` throws.
  */
-declare function saveSnapshot(graph: Graph, snapshotId: string, tier: StorageTier): Promise<SaveSnapshotResult>;
+declare function saveSnapshot(graph: Graph, snapshotId: string, tier: KvStorageTier): Promise<SaveSnapshotResult>;
 /**
  * Load a snapshot from a tier and materialize it as a new {@link Graph}.
  *
@@ -171,18 +171,18 @@ declare function saveSnapshot(graph: Graph, snapshotId: string, tier: StorageTie
  *
  * **Requires a `mode: "full"` record.** Surface-written snapshots from
  * {@link saveSnapshot} always qualify. Records written by
- * {@link Graph.attachStorage} with `compactEvery > 1` may be
+ * {@link Graph.attachSnapshotStorage} with `compactEvery > 1` may be
  * `mode: "diff"` between compacts — those throw `restore-failed` until
  * the tier's next compact flush (or until Phase 8.7 WAL replay lands).
  * If you need interop during development, either call
  * {@link saveSnapshot} explicitly (always full) or configure
- * `attachStorage({compactEvery: 1})`.
+ * `attachSnapshotStorage({compactEvery: 1})`.
  *
  * @throws {SurfaceError} `snapshot-not-found` on miss; `restore-failed`
  *   when the payload shape doesn't match, when the record is
  *   `mode: "diff"`, or when `Graph.fromSnapshot` rejects.
  */
-declare function restoreSnapshot(snapshotId: string, tier: StorageTier, opts?: RestoreSnapshotOptions): Promise<Graph>;
+declare function restoreSnapshot(snapshotId: string, tier: KvStorageTier, opts?: RestoreSnapshotOptions): Promise<Graph>;
 /**
  * Load two snapshots and compute a {@link GraphDiffResult} via static
  * {@link Graph.diff}. Returns the audit shape (structural + value diff,
@@ -190,37 +190,37 @@ declare function restoreSnapshot(snapshotId: string, tier: StorageTier, opts?: R
  *
  * @throws {SurfaceError} `snapshot-not-found` on either miss.
  */
-declare function diffSnapshots(snapshotIdA: string, snapshotIdB: string, tier: StorageTier): Promise<GraphDiffResult>;
+declare function diffSnapshots(snapshotIdA: string, snapshotIdB: string, tier: KvStorageTier): Promise<GraphDiffResult>;
 /**
  * Enumerate snapshot ids on a tier.
  *
  * Only keys written by {@link saveSnapshot} are returned. Surface-written
  * records are stored under the `"snapshot:"` key prefix and decoded back to
  * the caller-visible id before being returned — other keys on the same tier
- * (notably `attachStorage` baseline/WAL keys written under `graph.name`) are
+ * (notably `attachSnapshotStorage` baseline/WAL keys written under `graph.name`) are
  * filtered out automatically. This lets a single tier back both the surface
- * and `attachStorage` without leaking graph names through `listSnapshots`.
+ * and `attachSnapshotStorage` without leaking graph names through `listSnapshots`.
  *
  * @param tier — the storage tier to enumerate.
  * @param opts.includeUnprefixed — when `true`, also return keys that are
  *   NOT under the namespacing prefix. Off by default; set this when reading
  *   pre-namespacing snapshot sets.
  *
- *   **Caveat:** when a tier is shared with {@link Graph.attachStorage}, its
+ *   **Caveat:** when a tier is shared with {@link Graph.attachSnapshotStorage}, its
  *   auto-checkpoint baseline + WAL keys (written under `graph.name`) are
  *   unprefixed. Calling with `includeUnprefixed: true` returns those keys
  *   alongside surface snapshots — and subsequent `restoreSnapshot` /
  *   `deleteSnapshot` will operate on them via the fallback-lookup path,
  *   potentially overwriting or deleting live auto-checkpoint state. Use
  *   `includeUnprefixed` only against tiers you know are NOT shared with
- *   `attachStorage`, or follow up with a predicate filter to separate
+ *   `attachSnapshotStorage`, or follow up with a predicate filter to separate
  *   ids you own from ones owned by other subsystems.
  *
  * @throws {SurfaceError} `tier-no-list` when the tier does not implement
  *   the optional `list()` method. Check `typeof tier.list === "function"`
  *   before calling if you want to branch on capability.
  */
-declare function listSnapshots(tier: StorageTier, opts?: {
+declare function listSnapshots(tier: KvStorageTier, opts?: {
     includeUnprefixed?: boolean;
 }): Promise<readonly string[]>;
 /**
@@ -232,7 +232,7 @@ declare function listSnapshots(tier: StorageTier, opts?: {
  * @throws {SurfaceError} `snapshot-failed` when `clear` is unsupported
  *   or throws.
  */
-declare function deleteSnapshot(snapshotId: string, tier: StorageTier): Promise<void>;
+declare function deleteSnapshot(snapshotId: string, tier: KvStorageTier): Promise<void>;
 
 /**
  * Surface layer (§9.3-core) — shared, JSON-safe operations consumed by
@@ -245,8 +245,8 @@ declare function deleteSnapshot(snapshotId: string, tier: StorageTier): Promise<
  * 1. {@link createGraph} — `compileSpec` wrapped with typed surface errors.
  * 2. {@link reduce} — one-shot `input → pipeline → output`.
  *
- * Snapshot persistence reuses the {@link StorageTier} substrate introduced
- * for `Graph.attachStorage`, so one-shot snapshots and auto-checkpoints
+ * Snapshot persistence reuses the {@link KvStorageTier} substrate introduced
+ * for `Graph.attachSnapshotStorage`, so one-shot snapshots and auto-checkpoints
  * share the {@link GraphCheckpointRecord} envelope. No new wire format.
  *
  * Errors throw as {@link SurfaceError} — wrappers map to their native

package/dist/{index-B1hFhK1K.d.cts → index-CpZKtdMw.d.cts}

@@ -1,4 +1,4 @@
-import { a as Node } from './node-8qx0kgYt.cjs';
+import { a as Node } from './node-fSc-hCv8.cjs';
 
 /** Svelte store contract — implements the minimal `subscribe` method. */
 interface SvelteReadable<T> {

package/dist/{index-BO6t0HjV.d.cts → index-CqSJ25A9.d.cts}

@@ -1,5 +1,5 @@
 import { Ref, WatchSource } from 'vue';
-import { a as Node } from './node-8qx0kgYt.cjs';
+import { a as Node } from './node-fSc-hCv8.cjs';
 
 /**
  * Subscribe to a read-only `Node<T>` as a Vue `Ref<T>`. Auto-unsubscribes on scope disposal.

package/dist/{index-Jgl7ev9I.d.cts → index-CzC0G0C3.d.cts}

@@ -1,12 +1,12 @@
-import { i as index$2 } from './index-BVTjuKeP.cjs';
-import { i as index$3 } from './index-DhWrMTI6.cjs';
-import { i as index$4 } from './index-CoR-tOZA.cjs';
-import { i as index$5 } from './index-ClKm7CFB.cjs';
-import { a as Node } from './node-8qx0kgYt.cjs';
-import { i as index$6 } from './index-CQ1gt4rn.cjs';
-import { i as index$7 } from './index-B1hFhK1K.cjs';
-import { i as index$8 } from './index-BO6t0HjV.cjs';
-import { i as index$9 } from './index-DR3XqZlV.cjs';
+import { i as index$2 } from './index-D_QQ_dTD.cjs';
+import { i as index$3 } from './index-B3D_z0Z6.cjs';
+import { i as index$4 } from './index-BtY2QVDf.cjs';
+import { i as index$5 } from './index-BFuVcqL8.cjs';
+import { a as Node } from './node-fSc-hCv8.cjs';
+import { i as index$6 } from './index-9xhIaM-w.cjs';
+import { i as index$7 } from './index-CpZKtdMw.cjs';
+import { i as index$8 } from './index-CqSJ25A9.cjs';
+import { i as index$9 } from './index-DmtWMP0X.cjs';
 
 /**
  * Options for creating signals.

package/dist/{index-p0bkNfby.d.cts → index-D6JRP-1_.d.cts}

@@ -1,6 +1,6 @@
-import { A as Actor, a as Node, P as PolicyRuleData, G as GuardAction } from './node-8qx0kgYt.cjs';
-import { G as Graph, a as GraphOptions, d as GraphPersistSnapshot, C as CausalChain } from './graph-DaoydJ_u.cjs';
-import { T as TopicGraph } from './index-Ccv_61jG.cjs';
+import { A as Actor, a as Node, P as PolicyRuleData, G as GuardAction } from './node-fSc-hCv8.cjs';
+import { G as Graph, a as GraphOptions, b as GraphPersistSnapshot, C as CausalChain } from './graph-kTltt95s.cjs';
+import { T as TopicGraph } from './index-B3Dfl5sS.cjs';
 
 /**
  * Audit, policy enforcement, and compliance export (roadmap §9.2).

package/dist/{index-D23g00HE.d.cts → index-D7r_vd0b.d.cts}

@@ -1,7 +1,7 @@
-import { P as PolicyRuleData, a as Node, A as Actor } from './node-8qx0kgYt.cjs';
-import { G as Graph, a as GraphOptions, b as GraphDescribeOptions, c as GraphDescribeOutput, D as DescribeFilter } from './graph-DaoydJ_u.cjs';
-import { P as PolicyEnforcerGraph, a as PolicyViolation } from './index-p0bkNfby.cjs';
-import { T as TopicGraph } from './index-Ccv_61jG.cjs';
+import { P as PolicyRuleData, a as Node, A as Actor } from './node-fSc-hCv8.cjs';
+import { G as Graph, a as GraphOptions, c as GraphDescribeOptions, d as GraphDescribeOutput, D as DescribeFilter } from './graph-kTltt95s.cjs';
+import { P as PolicyEnforcerGraph, a as PolicyViolation } from './index-D6JRP-1_.cjs';
+import { T as TopicGraph } from './index-B3Dfl5sS.cjs';
 
 /**
  * Composable safety layer (roadmap §9.0b).

package/dist/{index-Cp91Sxbo.d.cts → index-D8IyqHvT.d.cts}

@@ -1,6 +1,6 @@
-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 RigorRecorder, a0 as START, a1 as START_MSG, a2 as SubscribeContext, a3 as TEARDOWN, a4 as TEARDOWN_MSG, a5 as TEARDOWN_ONLY_BATCH, a6 as V0, a7 as V1, V as VersioningLevel, a8 as VersioningOptions, a9 as accessHintForGuard, aa as advanceVersion, ab as configure, ac as createVersioning, ad as defaultConfig, ae as defaultHash, af as isV1, ag as node, ah as normalizeActor, ai as policy, aj as policyFromRules, ak as registerBuiltins } from './node-8qx0kgYt.cjs';
-import { D as DescribeDetail, a as DescribeField, b as DescribeNodeOutput, r as resolveDescribeFields } from './meta-BdjSt8ky.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-DVEYhR7a.cjs';
+import { b as Messages, A as Actor, C as COMPLETE, g as COMPLETE_MSG, h as COMPLETE_ONLY_BATCH, D as DATA, i as DEFAULT_ACTOR, j as DIRTY, k as DIRTY_MSG, l as DIRTY_ONLY_BATCH, m as DepRecord, E as ERROR, F as FnCtx, n as GlobalInspectorEvent, o as GlobalInspectorHook, p as GraphReFlyConfig, G as GuardAction, q as GuardDenied, r as GuardDeniedDetails, H as HashFn, I as INVALIDATE, s as INVALIDATE_MSG, t as INVALIDATE_ONLY_BATCH, M as Message, u as MessageContext, v as MessageTypeRegistration, w as MessageTypeRegistrationInput, a as Node, c as NodeActions, x as NodeCtx, e as NodeDescribeKind, y as NodeFn, d as NodeFnCleanup, f 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 RigorRecorder, a0 as START, a1 as START_MSG, a2 as SubscribeContext, a3 as TEARDOWN, a4 as TEARDOWN_MSG, a5 as TEARDOWN_ONLY_BATCH, a6 as V0, a7 as V1, V as VersioningLevel, a8 as VersioningOptions, a9 as accessHintForGuard, aa as advanceVersion, ab as configure, ac as createVersioning, ad as defaultConfig, ae as defaultHash, af as isV1, ag as node, ah as normalizeActor, ai as policy, aj as policyFromRules, ak as registerBuiltins } from './node-fSc-hCv8.cjs';
+import { D as DescribeDetail, a as DescribeField, b as DescribeNodeOutput, r as resolveDescribeFields } from './meta-BGO6C7K9.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-DgaGJcI6.cjs';
 
 /**
  * Batch deferral for tier-3+ messages, plus per-node emit coalescing inside

package/dist/{index-iKsmdnq6.d.cts → index-D9qoEOj_.d.cts}

@@ -1,5 +1,5 @@
-import { a as Node } from './node-8qx0kgYt.cjs';
-import { G as Graph } from './graph-DaoydJ_u.cjs';
+import { a as Node } from './node-fSc-hCv8.cjs';
+import { G as Graph } from './graph-kTltt95s.cjs';
 
 /**
  * Memory patterns (roadmap §4.3).