@graphrefly/graphrefly 0.44.0 → 0.45.0

package/dist/index-CviRnE4K.d.ts

@@ -1,45 +0,0 @@
-import { N as Node } from './node-kK3CvTrR.js';
-
-/** 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-Cwv0KWcU.d.cts

@@ -1,102 +0,0 @@
-import { G as Graph } from './graph-CWvEUQAq.cjs';
-import { M as MeasurementAdapter } from './reactive-layout-DgctbqZo.cjs';
-
-/**
- * Three-pane demo shell (roadmap §7.2).
- *
- * A `Graph("demo-shell")` that dogfoods reactive coordination for the
- * main/side split layout with synchronized cross-highlighting.
- *
- * **Zero framework dependency** — framework bindings wrap pane components only.
- * The shell graph is headless and fully testable.
- */
-
-/** Identifies which pane is the source of a hover event. */
-type HoverPaneType = "visual" | "graph" | "code";
-/** Cross-highlighting hover target. `null` means nothing hovered. */
-type HoverTarget = {
-    pane: HoverPaneType;
-    id: string;
-} | null;
-/** Which pane is full-screened (null = normal layout). */
-type FullscreenPane = "main" | "graph" | "code" | null;
-/**
- * Cross-referencing registry: maps node paths to code line numbers and
- * visual element selectors. Provided by each demo's `store.ts`.
- */
-type NodeRegistry = Map<string, {
-    codeLine: number;
-    visualSelector: string;
-}>;
-/** Callbacks for cross-highlighting effect nodes. */
-type HighlightCallbacks = {
-    /** Called when code-scroll highlight target changes. */
-    codeScroll?: (line: number | null) => void;
-    /** Called when visual highlight target changes. */
-    visual?: (selector: string | null) => void;
-    /** Called when graph highlight target changes. */
-    graph?: (nodeId: string | null) => void;
-};
-/** Label dimensions for graph node sizing. */
-type GraphLabelSize = {
-    width: number;
-    height: number;
-};
-/** Options for {@link demoShell}. */
-type DemoShellOptions = {
-    /** Initial main/side split ratio (0–1). Default: `0.65`. */
-    mainRatio?: number;
-    /** Initial graph/code vertical split in the side pane (0–1). Default: `0.5`. */
-    sideSplit?: number;
-    /** Initial viewport width in pixels. Default: `1280`. */
-    viewportWidth?: number;
-    /** Cross-referencing registry for hover→code/visual/graph mapping. */
-    nodeRegistry?: NodeRegistry;
-    /** Measurement adapter for layout engine integration. When provided, enables layout/* derived nodes. */
-    adapter?: MeasurementAdapter;
-    /** Font string for layout measurement. Default: `"14px monospace"`. */
-    layoutFont?: string;
-    /** Callbacks for cross-highlighting effect nodes. When provided, creates effect nodes visible in describe(). */
-    onHighlight?: HighlightCallbacks;
-};
-/** Return type of {@link demoShell}. */
-type DemoShellHandle = {
-    /** The demo-shell graph. */
-    graph: Graph;
-    setMainRatio(ratio: number): void;
-    setSideSplit(ratio: number): void;
-    setFullscreen(pane: FullscreenPane): void;
-    setViewportWidth(width: number): void;
-    setHoverTarget(target: HoverTarget): void;
-    setDemoGraph(g: Graph | null): void;
-    bumpGraphTick(): void;
-    selectNode(path: string | null): void;
-    setMetaDebug(on: boolean): void;
-    /** Set code text for layout/code-lines measurement (requires adapter). */
-    setCodeText(text: string): void;
-    /** Atomic multi-set — wraps core `batch()` for glitch-free updates. */
-    batch(fn: () => void): void;
-    destroy(): void;
-};
-/**
- * Creates the three-pane demo shell graph (roadmap §7.2).
- *
- * All coordination is reactive — no polling, no imperative triggers.
- * Framework bindings subscribe to named nodes and drive `state` inputs.
- */
-declare function demoShell(opts?: DemoShellOptions): DemoShellHandle;
-
-type index_DemoShellHandle = DemoShellHandle;
-type index_DemoShellOptions = DemoShellOptions;
-type index_FullscreenPane = FullscreenPane;
-type index_GraphLabelSize = GraphLabelSize;
-type index_HighlightCallbacks = HighlightCallbacks;
-type index_HoverPaneType = HoverPaneType;
-type index_HoverTarget = HoverTarget;
-type index_NodeRegistry = NodeRegistry;
-declare const index_demoShell: typeof demoShell;
-declare namespace index {
-  export { type index_DemoShellHandle as DemoShellHandle, type index_DemoShellOptions as DemoShellOptions, type index_FullscreenPane as FullscreenPane, type index_GraphLabelSize as GraphLabelSize, type index_HighlightCallbacks as HighlightCallbacks, type index_HoverPaneType as HoverPaneType, type index_HoverTarget as HoverTarget, type index_NodeRegistry as NodeRegistry, index_demoShell as demoShell };
-}
-
-export { type DemoShellHandle as D, type FullscreenPane as F, type GraphLabelSize as G, type HighlightCallbacks as H, type NodeRegistry as N, type DemoShellOptions as a, type HoverPaneType as b, type HoverTarget as c, demoShell as d, index as i };

package/dist/index-CzLVrjxn.d.ts

@@ -1,231 +0,0 @@
-import { N as Node } from './node-kK3CvTrR.js';
-import { a as GraphOptions, G as Graph } from './graph-D9LFnda9.js';
-
-/**
- * Domain templates (roadmap §8.2).
- *
- * Opinionated Graph factories for common "info → action" domains.
- * Each template wires up §8.1 reduction primitives (stratify, funnel, feedback,
- * budgetGate, scorer) with domain-specific stages. Users fork/extend by
- * accessing named nodes and swapping stages.
- *
- * **Source injection (option B):** templates accept a `source` node, not a
- * hardcoded adapter. Pass `fromOTel(...)`, `fromGitHook(...)`, or a test
- * `state()` — the topology is the same.
- *
- * @module
- */
-
-/** Stratification branch config for observability signals. */
-type ObservabilityBranch = {
-    name: string;
-    classify: (value: unknown) => boolean;
-};
-/** Options for {@link observabilityGraph}. */
-type ObservabilityGraphOptions = GraphOptions & {
-    /** Ingested signal source (e.g. fromOTel(...) or test state). */
-    source: Node<unknown>;
-    /**
-     * Classification rules for signal stratification.
-     * Default: errors / traces / metrics branches.
-     */
-    branches?: ObservabilityBranch[];
-    /**
-     * Correlation function: receives stratified branch values and produces
-     * correlated insights. Default: identity pass-through.
-     */
-    correlate?: (values: unknown[]) => unknown;
-    /**
-     * SLO verification function: returns a verification result for a
-     * correlated insight. Default: always passes.
-     */
-    sloCheck?: (value: unknown) => unknown;
-    /**
-     * Scorer weights for alert prioritization. One per branch.
-     * Default: equal weights [1, 1, 1].
-     */
-    weights?: number[];
-    /** Max feedback iterations for false-positive learning. Default: 5. */
-    maxFeedbackIterations?: number;
-};
-/**
- * OTel ingest → stratified reduction → correlation → SLO verification →
- * alert prioritization → output.
- *
- * Well-known node names:
- * - `"source"` — injected signal source
- * - `"stratify::branch/<name>"` — per-branch classification
- * - `"correlate"` — cross-branch correlation
- * - `"slo_value"`, `"slo_verified"` — SLO verification pair
- * - `"alerts"` — scored, prioritized output
- * - `"output"` — final output (alias for alerts)
- *
- * @category patterns
- */
-declare function observabilityGraph(name: string, opts: ObservabilityGraphOptions): Graph;
-/** A structured issue extracted from raw findings. */
-type ExtractedIssue = {
-    id: string;
-    title: string;
-    severity: number;
-    source: string;
-    raw: unknown;
-};
-/** Options for {@link issueTrackerGraph}. */
-type IssueTrackerGraphOptions = GraphOptions & {
-    /** Findings source (e.g. fromGitHook(...), fromFSWatch(...)). */
-    source: Node<unknown>;
-    /**
-     * Extract structured issues from raw findings.
-     * Default: wraps raw value as a single issue.
-     */
-    extract?: (raw: unknown) => ExtractedIssue;
-    /**
-     * Verify an extracted issue (assertion check).
-     * Default: always valid.
-     */
-    verify?: (issue: ExtractedIssue) => unknown;
-    /**
-     * Detect regression by comparing against known patterns.
-     * Receives (current issue, known patterns).
-     * Default: no regression detected.
-     */
-    detectRegression?: (issue: ExtractedIssue, known: unknown) => unknown;
-    /** Max feedback iterations for re-scanning. Default: 3. */
-    maxFeedbackIterations?: number;
-};
-/**
- * Findings ingest → extraction → verification → regression detection →
- * distillation → prioritized queue.
- *
- * Well-known node names:
- * - `"source"` — injected findings source
- * - `"extract"` — structured issue extraction
- * - `"verify"` — issue verification
- * - `"known_patterns"` — accumulated known issue patterns (state)
- * - `"regression"` — regression detection
- * - `"priority"` — severity-based prioritization
- * - `"output"` — final prioritized output
- *
- * @category patterns
- */
-declare function issueTrackerGraph(name: string, opts: IssueTrackerGraphOptions): Graph;
-/** Classification result from LLM moderation. */
-type ModerationResult = {
-    label: "safe" | "review" | "block";
-    confidence: number;
-    reason?: string;
-    original: unknown;
-};
-/** Options for {@link contentModerationGraph}. */
-type ContentModerationGraphOptions = GraphOptions & {
-    /** Content source (text/multimedia ingest). */
-    source: Node<unknown>;
-    /**
-     * Classification function: returns a ModerationResult.
-     * Default: labels everything "review" with confidence 0.5.
-     */
-    classify?: (content: unknown) => ModerationResult;
-    /** System prompt for LLM classification. */
-    systemPrompt?: string;
-    /** Scorer weights: [safe, review, block]. Default: [0.1, 1, 2]. */
-    weights?: [number, number, number];
-    /** Max feedback iterations for policy refinement. Default: 5. */
-    maxFeedbackIterations?: number;
-    /** Max review queue size. When set, oldest entries are trimmed on overflow. */
-    maxQueueSize?: number;
-};
-/**
- * Content ingest → LLM/rule classification → stratified routing (safe/review/block) →
- * human review queue → scorer → feedback (false positives → policy refinement) → output.
- *
- * Well-known node names:
- * - `"source"` — content ingest
- * - `"classify"` — LLM or rule-based classification
- * - `"stratify::branch/safe"`, `"stratify::branch/review"`, `"stratify::branch/block"` — routed branches
- * - `"review_queue"` — state node for human review items
- * - `"priority"` — scored priority output
- * - `"policy"` — writable state for policy refinement
- * - `"output"` — final moderation output
- *
- * @category patterns
- */
-declare function contentModerationGraph(name: string, opts: ContentModerationGraphOptions): Graph;
-/** Schema validation result. */
-type ValidationResult = {
-    valid: boolean;
-    errors: string[];
-    record: unknown;
-};
-/** Anomaly detection result. */
-type AnomalyResult = {
-    anomaly: boolean;
-    score: number;
-    detail?: string;
-    record: unknown;
-};
-/** Options for {@link dataQualityGraph}. */
-type DataQualityGraphOptions = GraphOptions & {
-    /** Data source (e.g. fromPrisma(...), fromKysely(...)). */
-    source: Node<unknown>;
-    /**
-     * Schema validation function.
-     * Default: always valid.
-     */
-    validate?: (record: unknown) => ValidationResult;
-    /**
-     * Anomaly detection function.
-     * Default: no anomaly.
-     */
-    detectAnomaly?: (record: unknown) => AnomalyResult;
-    /**
-     * Drift detection: compares current record against baseline.
-     * Default: no drift.
-     */
-    detectDrift?: (record: unknown, baseline: unknown) => unknown;
-    /**
-     * Remediation suggestion function.
-     * Default: no suggestion.
-     */
-    suggest?: (result: {
-        validation: ValidationResult;
-        anomaly: AnomalyResult;
-    }) => unknown;
-    /** Max feedback iterations for rule refinement. Default: 3. */
-    maxFeedbackIterations?: number;
-};
-/**
- * Data ingest → schema validation → anomaly detection → drift alerting →
- * auto-remediation suggestions → output.
- *
- * Well-known node names:
- * - `"source"` — data ingest
- * - `"validate"` — schema validation
- * - `"anomaly"` — anomaly detection
- * - `"baseline"` — rolling baseline state
- * - `"drift"` — drift detection
- * - `"remediate"` — auto-remediation suggestions
- * - `"output"` — combined quality report
- *
- * @category patterns
- */
-declare function dataQualityGraph(name: string, opts: DataQualityGraphOptions): Graph;
-
-type index_AnomalyResult = AnomalyResult;
-type index_ContentModerationGraphOptions = ContentModerationGraphOptions;
-type index_DataQualityGraphOptions = DataQualityGraphOptions;
-type index_ExtractedIssue = ExtractedIssue;
-type index_IssueTrackerGraphOptions = IssueTrackerGraphOptions;
-type index_ModerationResult = ModerationResult;
-type index_ObservabilityBranch = ObservabilityBranch;
-type index_ObservabilityGraphOptions = ObservabilityGraphOptions;
-type index_ValidationResult = ValidationResult;
-declare const index_contentModerationGraph: typeof contentModerationGraph;
-declare const index_dataQualityGraph: typeof dataQualityGraph;
-declare const index_issueTrackerGraph: typeof issueTrackerGraph;
-declare const index_observabilityGraph: typeof observabilityGraph;
-declare namespace index {
-  export { type index_AnomalyResult as AnomalyResult, type index_ContentModerationGraphOptions as ContentModerationGraphOptions, type index_DataQualityGraphOptions as DataQualityGraphOptions, type index_ExtractedIssue as ExtractedIssue, type index_IssueTrackerGraphOptions as IssueTrackerGraphOptions, type index_ModerationResult as ModerationResult, type index_ObservabilityBranch as ObservabilityBranch, type index_ObservabilityGraphOptions as ObservabilityGraphOptions, type index_ValidationResult as ValidationResult, index_contentModerationGraph as contentModerationGraph, index_dataQualityGraph as dataQualityGraph, index_issueTrackerGraph as issueTrackerGraph, index_observabilityGraph as observabilityGraph };
-}
-
-export { type AnomalyResult as A, type ContentModerationGraphOptions as C, type DataQualityGraphOptions as D, type ExtractedIssue as E, type IssueTrackerGraphOptions as I, type ModerationResult as M, type ObservabilityBranch as O, type ValidationResult as V, type ObservabilityGraphOptions as a, issueTrackerGraph as b, contentModerationGraph as c, dataQualityGraph as d, index as i, observabilityGraph as o };

package/dist/index-D0aciIex.d.cts

@@ -1,209 +0,0 @@
-import { b as NodeGuard, N as Node } from './node-kK3CvTrR.cjs';
-import { G as Graph } from './graph-CWvEUQAq.cjs';
-import { R as ReactiveLogOptions, a as ReactiveLogBundle } from './reactive-log-DIGdYqQ6.cjs';
-
-/**
- * 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 };