@graphrefly/graphrefly 0.44.0 → 0.45.0

package/dist/index-CC-AvFTy.d.cts

@@ -1,557 +0,0 @@
-import { l as GraphReFlyConfig } from './node-kK3CvTrR.cjs';
-import { r as GraphPersistSnapshot, i as GraphCheckpointRecord, G as Graph, C as CausalChain, c as CausalStep, e as DescribeFilter, E as ExplainPathOptions, f as GRAPH_META_SEGMENT, g as GraphActorOptions, h as GraphAttachStorageOptions, j as GraphDescribeOptions, b as GraphDescribeOutput, k as GraphDiagramDirection, l as GraphDiffChange, m as GraphDiffResult, n as GraphFactoryContext, o as GraphNodeFactory, p as GraphObserveAll, q as GraphObserveOne, a as GraphOptions, s as GraphProfileOptions, t as GraphProfileResult, u as GraphVersionChange, v as GraphWALDiff, N as NodeProfile, O as ObserveChangeset, w as ObserveDetail, x as ObserveEvent, y as ObserveOptions, z as ObserveResult, A as ObserveTheme, B as ObserveThemeName, F as ObserveTier, R as ReachableDirection, H as ReachableOptions, S as SNAPSHOT_VERSION, T as TopologyEvent, I as TraceEntry, J as diffForWAL, K as explainPath, L as graphProfile, P as reachable } from './graph-CWvEUQAq.cjs';
-import { w as watchTopologyTree } from './topology-tree-Bcz27hpF.cjs';
-
-/**
- * Approximate in-memory size estimation for arbitrary JS values.
- *
- * Iterative walk with cycle detection via `WeakSet`. V8-tuned overhead
- * heuristics. Not exact — approximate enough for profiling and hotspot
- * detection.
- *
- * Use cases: `graphProfile` (per-node value size), reactive data structure
- * memory audits, heuristic cache admission.
- *
- * @module
- */
-/** Approximate per-type overhead in bytes (V8 heuristics). */
-declare const OVERHEAD: {
-    readonly object: 56;
-    readonly array: 64;
-    readonly string: 40;
-    readonly number: 8;
-    readonly boolean: 4;
-    readonly null: 0;
-    readonly undefined: 0;
-    readonly symbol: 40;
-    readonly bigint: 16;
-    readonly function: 120;
-    readonly map: 72;
-    readonly set: 72;
-    readonly mapEntry: 40;
-    readonly setEntry: 24;
-    readonly date: 24;
-    readonly regexp: 48;
-    readonly error: 64;
-    readonly url: 80;
-    readonly promise: 48;
-    readonly weakmap: 40;
-    readonly weakset: 40;
-};
-/**
- * Optional user hook. Declare a `sizeof` symbol key on any object to return
- * a precomputed size (in bytes); the walker will honor it and skip recursion.
- *
- * @example
- * ```ts
- * const SIZEOF = Symbol.for("sizeof");
- * class MyCache { [SIZEOF]() { return this.bytes; } }
- * ```
- */
-declare const SIZEOF_SYMBOL: unique symbol;
-/**
- * Estimate the approximate retained memory (in bytes) of a JS value.
- *
- * Handles primitives, plain objects, arrays, Maps, Sets, ArrayBuffers +
- * TypedArrays (shared-buffer dedup), Date, RegExp, Error, URL, Promise,
- * WeakMap, WeakSet, nested combinations. Cyclic refs are counted once.
- *
- * @param value - The value to measure.
- * @returns Approximate size in bytes.
- */
-declare function sizeof(value: unknown): number;
-
-/**
- * GraphCodec — pluggable serialization for graph snapshots (Phase 8.6).
- *
- * Design reference: `archive/docs/SESSION-serialization-memory-footprint.md`
- *
- * The codec interface decouples snapshot format from graph internals.
- * Default is JSON (current behavior). DAG-CBOR and compressed variants
- * ship as optional codecs. FlatBuffers/Arrow for advanced tiers.
- *
- * Tiered representation:
- *   HOT  — JS objects (live propagation, no codec involved)
- *   WARM — DAG-CBOR in-memory buffer (lazy hydration, delta checkpoints)
- *   COLD — Arrow/Parquet (bulk storage, ML pipelines, archival)
- *   PEEK — FlatBuffers (zero-copy read from dormant graph)
- *
- * Wire-protocol envelope (v1):
- *
- *   [envelope_v=1: u8][name_len: u8][name: utf8][codec_v: u16 BE][payload: rest]
- *
- * `graph.snapshot({format: "bytes", codec: name})` wraps the codec's
- * `encode` output in this envelope; `Graph.decode(bytes)` auto-dispatches
- * via the config's codec registry — no out-of-band content-type needed.
- */
-
-/**
- * Encode/decode graph snapshots to/from binary.
- *
- * Implementations must be deterministic: `encode(x)` always produces the
- * same bytes for the same input. This is critical for CID computation (V1)
- * and snapshot hash-comparison.
- */
-interface GraphCodec {
-    /** Human-readable name; used as the lookup key in the envelope and config registry. */
-    readonly name: string;
-    /**
-     * Codec version. Bumps on breaking wire format changes; `decode` receives
-     * this via the envelope so codecs can dispatch on historical layouts.
-     * Must fit in a `u16` (0–65535).
-     */
-    readonly version: number;
-    /** MIME-like content type identifier (e.g. `"application/dag-cbor+zstd"`). */
-    readonly contentType: string;
-    /** Encode a snapshot to binary. */
-    encode(snapshot: GraphPersistSnapshot): Uint8Array;
-    /**
-     * Decode binary back to a snapshot.
-     *
-     * `codecVersion` is the version that produced `buffer` (read from the
-     * envelope). Omit when the caller is sure of the version (tests, one-shot
-     * round-trips). Codecs that support multiple historical layouts dispatch
-     * on this value.
-     *
-     * For lazy codecs, this may return a proxy that decodes nodes on access
-     * (see {@link LazyGraphCodec}).
-     */
-    decode(buffer: Uint8Array, codecVersion?: number): GraphPersistSnapshot;
-}
-/**
- * Extended codec that supports lazy (on-demand) node decoding.
- *
- * `decodeLazy` returns a snapshot where `nodes` is a Proxy — individual
- * nodes are decoded only when accessed. This enables near-zero cold-start
- * for large graphs (decode envelope + topology, skip node values until read).
- */
-interface LazyGraphCodec extends GraphCodec {
-    /** Decode envelope and topology; defer node value decoding to access time. */
-    decodeLazy(buffer: Uint8Array, codecVersion?: number): GraphPersistSnapshot;
-}
-/**
- * WAL entry. Unified with {@link GraphCheckpointRecord} — every record
- * already carries `mode` / `seq` / `timestamp_ns` / `format_version`, so the
- * WAL is just an ordered list of records. `replayWAL` walks this list.
- */
-type WALEntry = GraphCheckpointRecord;
-/**
- * Policy for evicting dormant subgraphs to reduce memory.
- *
- * When a subgraph hasn't propagated for `idleTimeoutMs`, it is serialized
- * using the graph's codec and JS objects are released. Re-hydrated on next
- * access (read, propagation, describe).
- */
-interface EvictionPolicy {
-    /** Milliseconds of inactivity before eviction. */
-    idleTimeoutMs: number;
-    /** Codec to use for serializing evicted subgraphs (default: graph's codec). */
-    codec?: GraphCodec;
-}
-/** Metadata about an evicted subgraph, exposed via describe(). */
-interface EvictedSubgraphInfo {
-    /** True if currently evicted (serialized, JS objects released). */
-    evicted: true;
-    /** Wall-clock ns of last propagation before eviction. */
-    lastActiveNs: bigint;
-    /** Size of serialized buffer in bytes. */
-    serializedBytes: number;
-    /** Codec used for serialization. */
-    codecName: string;
-}
-/**
- * Default JSON codec. Wraps `JSON.stringify`/`JSON.parse` with deterministic
- * key ordering (matching current `snapshot()` behavior).
- */
-declare const JsonCodec: GraphCodec;
-/**
- * Create a DAG-CBOR codec.
- *
- * Requires `@ipld/dag-cbor` as a peer dependency. ~40-50% smaller than JSON,
- * deterministic encoding (required for V1 CID), CID links as native type.
- *
- * @example
- * ```ts
- * import * as dagCbor from "@ipld/dag-cbor";
- * const codec = createDagCborCodec(dagCbor);
- * config.registerCodec(codec);
- * const bytes = graph.snapshot({ format: "bytes", codec: "dag-cbor" });
- * ```
- */
-declare function createDagCborCodec(dagCbor: {
-    encode: (value: unknown) => Uint8Array;
-    decode: (bytes: Uint8Array) => unknown;
-}): GraphCodec;
-/**
- * Create a DAG-CBOR + zstd codec. ~80-90% smaller than JSON.
- *
- * Requires `@ipld/dag-cbor` and a zstd implementation (e.g. `fzstd` for
- * browser, `node:zlib` for Node.js).
- *
- * @example
- * ```ts
- * import * as dagCbor from "@ipld/dag-cbor";
- * import { compressSync, decompressSync } from "fzstd";
- * const codec = createDagCborZstdCodec(dagCbor, { compressSync, decompressSync });
- * config.registerCodec(codec);
- * ```
- */
-declare function createDagCborZstdCodec(dagCbor: {
-    encode: (value: unknown) => Uint8Array;
-    decode: (bytes: Uint8Array) => unknown;
-}, zstd: {
-    compressSync: (data: Uint8Array) => Uint8Array;
-    decompressSync: (data: Uint8Array) => Uint8Array;
-}): GraphCodec;
-/** Current envelope format version. Bump on breaking layout changes. */
-declare const ENVELOPE_VERSION = 1;
-/**
- * Prepend the v1 envelope to `payload` identifying `codec`. The resulting
- * bytes are self-describing — any caller with access to the registering
- * {@link GraphReFlyConfig} can {@link decodeEnvelope} without knowing the
- * codec up front.
- *
- * Layout:
- * `[envelope_v=1: u8][name_len: u8][name: utf8][codec_v: u16 BE][payload: rest]`
- *
- * @throws If `codec.name` encodes to more than 255 UTF-8 bytes or
- *   `codec.version` doesn't fit in a u16.
- */
-declare function encodeEnvelope(codec: Pick<GraphCodec, "name" | "version">, payload: Uint8Array): Uint8Array;
-/**
- * Inverse of {@link encodeEnvelope}. Reads the header, resolves the codec
- * via `config.lookupCodec(name)`, and returns the codec + its version + the
- * inner payload slice. The caller feeds `payload` to `codec.decode(payload,
- * codecVersion)` — or uses {@link Graph.decode} which does both steps.
- *
- * @throws If the envelope is truncated, the version is unsupported, or the
- *   named codec isn't registered on `config`.
- */
-declare function decodeEnvelope(bytes: Uint8Array, config: GraphReFlyConfig): {
-    codec: GraphCodec;
-    codecVersion: number;
-    payload: Uint8Array;
-};
-/**
- * Register the built-in {@link JsonCodec} on a config. Called once on
- * `defaultConfig` at module load so `graph.snapshot({format: "bytes", codec:
- * "json"})` works out of the box. Test / isolated configs should call this
- * manually before the first node is created.
- */
-declare function registerBuiltinCodecs(config: GraphReFlyConfig): void;
-/**
- * Reconstruct a snapshot from a WAL (sequence of {@link GraphCheckpointRecord}s).
- *
- * - Must start with a `"full"` record carrying a baseline snapshot — that's
- *   the anchor {@link Graph.attachSnapshotStorage} always emits on the first flush
- *   of any tier (and every `compactEvery`-th flush thereafter).
- * - Subsequent `"full"` entries (compaction points) **replace** the result
- *   wholesale.
- * - `"diff"` entries roll forward by applying the structural diff —
- *   added nodes (via `nodesAddedFull`), removed nodes, and changed fields
- *   are reflected into the accumulated snapshot.
- *
- * Validates monotonic `seq` progression across entries.
- */
-declare function replayWAL(entries: readonly WALEntry[]): GraphPersistSnapshot;
-
-/**
- * Topology check: detect "island" nodes with no in-edges AND no out-edges.
- *
- * Companion to {@link validateGraphObservability} for user validation. Catches
- * the kind of disconnected-node smell flagged in the pagerduty-demo audit
- * ("decisions/log not linked to any other nodes", "tokens only by itself") —
- * the visible symptom of imperative writes or closure-held state that bypassed
- * the reactive edge graph.
- *
- * **What counts as an island.** A node is an island when:
- *   - it has zero declared deps (zero **in-edges**), AND
- *   - no other node in the graph declares it as a dep (zero **out-edges**).
- *
- * Source nodes (producers / state nodes that act as roots) typically have zero
- * in-edges but ≥1 out-edge — those are NOT islands. Sink nodes (effects that
- * terminate a chain) have ≥1 in-edge but zero out-edges — also NOT islands.
- * Only nodes that satisfy BOTH conditions are reported.
- *
- * **Sub-graph paths.** When the graph mounts subgraphs, the check walks the
- * full path-qualified node table from `graph.describe({ detail: "minimal" })`
- * — both top-level and mounted children participate.
- *
- * **False-positive caveat (D7 /qa lock).** A `state(0, { name: "metric" })`
- * whose only consumer is an external (non-graph) subscriber — e.g. a React /
- * Vue / CLI subscription that calls `.subscribe(...)` directly — looks like
- * an island from `describe()`'s perspective: zero declared in-edges, and no
- * other node lists it as a dep. The check WILL flag it. Treat
- * `validateNoIslands` as a smell-detector, not a definitive correctness gate;
- * complement with `graph.observe(...)` instrumentation when external
- * consumers are part of the design. If you have known external-consumer
- * roots, filter them from `result.orphans` before deciding what to act on.
- *
- * **Synthetic `__internal__/` paths (EH-9).** Compound factories sometimes
- * surface unnamed helper nodes under the `__internal__/` namespace
- * (auto-generated when a producer / derived is added without a `name` and
- * the registrar falls back to a synthetic prefix). These never represent
- * user-authored topology and should not surface as actionable orphans;
- * `validateNoIslands` filters them out before reporting. If a real factory
- * regression accidentally leaks a user-meaningful node under this prefix,
- * the fix is to give the node a real name — not to remove the filter.
- *
- * **Non-throwing by default.** Returns a structured result so callers
- * (dry-run blocks, CI smoke tests) can exit non-zero with a diagnostic
- * instead of crashing.
- *
- * @module
- */
-
-/** A reported island node, surfacing both path and node kind for triage. */
-interface IslandReport {
-    /** Path-qualified node name (mounted children included). */
-    readonly path: string;
-    /** `describe()` node `type` — `"state"` / `"derived"` / `"effect"` etc. Helps distinguish "forgot to wire" from "compositional bug". */
-    readonly kind: string;
-}
-/** Result returned by {@link validateNoIslands}. */
-interface ValidateNoIslandsResult {
-    /** `true` when the graph has zero island nodes. */
-    readonly ok: boolean;
-    /**
-     * Path-qualified names + kinds of nodes that are both zero-in and
-     * zero-out. Sorted ASCII-asc by `path` for deterministic output.
-     */
-    readonly orphans: readonly IslandReport[];
-    /** Single-line summary suitable for `process.stderr`. */
-    summary(): string;
-}
-/**
- * Walk the graph's describe output and report island nodes (zero in + zero out edges).
- *
- * @example
- * ```ts
- * const result = validateNoIslands(graph);
- * if (!result.ok) {
- *   console.error(result.summary());
- *   for (const o of result.orphans) console.error(`  - ${o.path} (${o.kind})`);
- *   process.exit(3);
- * }
- * ```
- */
-declare function validateNoIslands(graph: Graph): ValidateNoIslandsResult;
-
-/**
- * Graph observability validation — smoke-exercise helper (D4).
- *
- * One library-level utility that walks every observability surface the library
- * ships — `describe()`, `explain(from, to)`, `observe(path)` — and reports
- * failures as a structured result. Non-throwing by default; composable into
- * example dry-run paths, CI smoke tests, and MCP reduce-path validators.
- *
- * **Motivation.** Dry-run equivalence (CLAUDE.md) requires every observability
- * call the real run exercises to also run under dry-run. Previously each
- * example reimplemented the walk (inbox-reducer caught a `describe()`
- * dangling-pointer bug only after adding an ad-hoc `graph.explain` check).
- * This utility centralizes the smoke-exercise so regressions in
- * `describe` / `explain` / `observe` surface BEFORE any wire spend.
- *
- * **Non-goals.** Not a deep correctness check. `describe()` structural
- * invariants (dangling deps, duplicate paths) are what this catches; actual
- * data assertions belong in application tests.
- *
- * @module
- */
-
-/** Describe render formats exercised by {@link validateGraphObservability}. */
-type ObservabilityDescribeFormat = "json" | "pretty" | "mermaid" | "mermaid-url" | "d2" | "ascii";
-/** One observability check performed by {@link validateGraphObservability}. */
-type ObservabilityCheck = 
-/** `describe()` was exercised and its structural invariants (nodes ⊇ deps) held. */
-{
-    kind: "describe";
-    ok: true;
-    nodeCount: number;
-    edgeCount: number;
-} | {
-    kind: "describe";
-    ok: false;
-    reason: string;
-    danglingDeps?: readonly string[];
-}
-/** `describe({ format })` render was exercised and produced non-empty output. */
- | {
-    kind: "describe-format";
-    ok: true;
-    format: ObservabilityDescribeFormat;
-    length: number;
-} | {
-    kind: "describe-format";
-    ok: false;
-    format: ObservabilityDescribeFormat;
-    reason: string;
-}
-/** `observe(path)` succeeded / failed. `path` is the requested path. */
- | {
-    kind: "observe";
-    ok: true;
-    path: string;
-} | {
-    kind: "observe";
-    ok: false;
-    path: string;
-    reason: string;
-}
-/** `explain(from, to)` succeeded / failed. `found` is the chain's found flag. */
- | {
-    kind: "explain";
-    ok: true;
-    from: string;
-    to: string;
-    found: boolean;
-    steps: number;
-} | {
-    kind: "explain";
-    ok: false;
-    from: string;
-    to: string;
-    reason: string;
-};
-/** Structured result returned by {@link validateGraphObservability}. */
-interface ValidateObservabilityResult {
-    /** `true` iff every performed check passed (`ok: true`). */
-    readonly ok: boolean;
-    /** All checks performed, in the order they ran. */
-    readonly checks: readonly ObservabilityCheck[];
-    /** Convenience — checks with `ok: false`. */
-    readonly failures: readonly ObservabilityCheck[];
-    /** Single-line summary (e.g. for `process.stderr`). */
-    summary(): string;
-}
-/** Options for {@link validateGraphObservability}. */
-interface ValidateObservabilityOptions {
-    /**
-     * Paths to exercise via `graph.observe(path)`. Each path is resolved against
-     * the same path grammar `graph.observe` / `graph.resolve` use. Non-existent
-     * paths are reported as observe failures.
-     */
-    readonly paths?: readonly string[];
-    /**
-     * `(from, to)` pairs to exercise via `graph.explain(from, to)`. Each pair
-     * records `found` and `steps`; a pair where `found === false` does NOT
-     * fail the overall result — pass `requireFound: true` to tighten that.
-     */
-    readonly pairs?: ReadonlyArray<readonly [from: string, to: string]>;
-    /**
-     * When `true`, `explain` pairs that return `found: false` count as failures.
-     * Default `true` — the common case is "assert this chain exists."
-     */
-    readonly requireFound?: boolean;
-    /**
-     * When `true`, skip the `describe()` structural check (nodes ⊇ deps).
-     * Default `false`. Turn off only when your graph intentionally keeps
-     * untracked deps (rare — COMPOSITION-GUIDE §24 argues against it).
-     */
-    readonly skipDescribe?: boolean;
-    /**
-     * Describe formats to exercise via `graph.describe({ format })`. Each
-     * format renders the graph once and checks that the result is a non-empty
-     * string. Useful in dry-run blocks so regressions in the render paths
-     * (ascii, mermaid, pretty, json, d2, mermaid-url) surface before any wire
-     * spend.
-     */
-    readonly formats?: readonly ObservabilityDescribeFormat[];
-}
-/**
- * Exercise every observability surface on `graph` and report failures.
- *
- * Does NOT throw — returns a structured result so callers (dry-run blocks,
- * CLI smoke tests, MCP reduce-path validators) can exit non-zero with a
- * diagnostic instead of letting the process crash mid-inspection.
- *
- * @example
- * ```ts
- * const result = validateGraphObservability(graph, {
- *   paths: ["input", "output"],
- *   pairs: [["input", "output"]],
- * });
- * if (!result.ok) {
- *   console.error(result.summary());
- *   for (const f of result.failures) console.error(f);
- *   process.exit(3);
- * }
- * ```
- */
-declare function validateGraphObservability(graph: Graph, opts?: ValidateObservabilityOptions): ValidateObservabilityResult;
-
-/**
- * Graph container: registry, wiring, introspection (Phase 1).
- */
-
-declare const index_CausalChain: typeof CausalChain;
-declare const index_CausalStep: typeof CausalStep;
-declare const index_DescribeFilter: typeof DescribeFilter;
-declare const index_ENVELOPE_VERSION: typeof ENVELOPE_VERSION;
-type index_EvictedSubgraphInfo = EvictedSubgraphInfo;
-type index_EvictionPolicy = EvictionPolicy;
-declare const index_ExplainPathOptions: typeof ExplainPathOptions;
-declare const index_GRAPH_META_SEGMENT: typeof GRAPH_META_SEGMENT;
-declare const index_Graph: typeof Graph;
-declare const index_GraphActorOptions: typeof GraphActorOptions;
-declare const index_GraphAttachStorageOptions: typeof GraphAttachStorageOptions;
-declare const index_GraphCheckpointRecord: typeof GraphCheckpointRecord;
-type index_GraphCodec = GraphCodec;
-declare const index_GraphDescribeOptions: typeof GraphDescribeOptions;
-declare const index_GraphDescribeOutput: typeof GraphDescribeOutput;
-declare const index_GraphDiagramDirection: typeof GraphDiagramDirection;
-declare const index_GraphDiffChange: typeof GraphDiffChange;
-declare const index_GraphDiffResult: typeof GraphDiffResult;
-declare const index_GraphFactoryContext: typeof GraphFactoryContext;
-declare const index_GraphNodeFactory: typeof GraphNodeFactory;
-declare const index_GraphObserveAll: typeof GraphObserveAll;
-declare const index_GraphObserveOne: typeof GraphObserveOne;
-declare const index_GraphOptions: typeof GraphOptions;
-declare const index_GraphPersistSnapshot: typeof GraphPersistSnapshot;
-declare const index_GraphProfileOptions: typeof GraphProfileOptions;
-declare const index_GraphProfileResult: typeof GraphProfileResult;
-declare const index_GraphVersionChange: typeof GraphVersionChange;
-declare const index_GraphWALDiff: typeof GraphWALDiff;
-type index_IslandReport = IslandReport;
-declare const index_JsonCodec: typeof JsonCodec;
-type index_LazyGraphCodec = LazyGraphCodec;
-declare const index_NodeProfile: typeof NodeProfile;
-type index_ObservabilityCheck = ObservabilityCheck;
-type index_ObservabilityDescribeFormat = ObservabilityDescribeFormat;
-declare const index_ObserveChangeset: typeof ObserveChangeset;
-declare const index_ObserveDetail: typeof ObserveDetail;
-declare const index_ObserveEvent: typeof ObserveEvent;
-declare const index_ObserveOptions: typeof ObserveOptions;
-declare const index_ObserveResult: typeof ObserveResult;
-declare const index_ObserveTheme: typeof ObserveTheme;
-declare const index_ObserveThemeName: typeof ObserveThemeName;
-declare const index_ObserveTier: typeof ObserveTier;
-declare const index_ReachableDirection: typeof ReachableDirection;
-declare const index_ReachableOptions: typeof ReachableOptions;
-declare const index_SIZEOF_SYMBOL: typeof SIZEOF_SYMBOL;
-declare const index_SNAPSHOT_VERSION: typeof SNAPSHOT_VERSION;
-declare const index_TopologyEvent: typeof TopologyEvent;
-declare const index_TraceEntry: typeof TraceEntry;
-type index_ValidateNoIslandsResult = ValidateNoIslandsResult;
-type index_ValidateObservabilityOptions = ValidateObservabilityOptions;
-type index_ValidateObservabilityResult = ValidateObservabilityResult;
-type index_WALEntry = WALEntry;
-declare const index_createDagCborCodec: typeof createDagCborCodec;
-declare const index_createDagCborZstdCodec: typeof createDagCborZstdCodec;
-declare const index_decodeEnvelope: typeof decodeEnvelope;
-declare const index_diffForWAL: typeof diffForWAL;
-declare const index_encodeEnvelope: typeof encodeEnvelope;
-declare const index_explainPath: typeof explainPath;
-declare const index_graphProfile: typeof graphProfile;
-declare const index_reachable: typeof reachable;
-declare const index_registerBuiltinCodecs: typeof registerBuiltinCodecs;
-declare const index_replayWAL: typeof replayWAL;
-declare const index_sizeof: typeof sizeof;
-declare const index_validateGraphObservability: typeof validateGraphObservability;
-declare const index_validateNoIslands: typeof validateNoIslands;
-declare const index_watchTopologyTree: typeof watchTopologyTree;
-declare namespace index {
-  export { index_CausalChain as CausalChain, index_CausalStep as CausalStep, index_DescribeFilter as DescribeFilter, index_ENVELOPE_VERSION as ENVELOPE_VERSION, type index_EvictedSubgraphInfo as EvictedSubgraphInfo, type index_EvictionPolicy as EvictionPolicy, index_ExplainPathOptions as ExplainPathOptions, index_GRAPH_META_SEGMENT as GRAPH_META_SEGMENT, index_Graph as Graph, index_GraphActorOptions as GraphActorOptions, index_GraphAttachStorageOptions as GraphAttachStorageOptions, index_GraphCheckpointRecord as GraphCheckpointRecord, type index_GraphCodec as GraphCodec, index_GraphDescribeOptions as GraphDescribeOptions, index_GraphDescribeOutput as GraphDescribeOutput, index_GraphDiagramDirection as GraphDiagramDirection, index_GraphDiffChange as GraphDiffChange, index_GraphDiffResult as GraphDiffResult, index_GraphFactoryContext as GraphFactoryContext, index_GraphNodeFactory as GraphNodeFactory, index_GraphObserveAll as GraphObserveAll, index_GraphObserveOne as GraphObserveOne, index_GraphOptions as GraphOptions, index_GraphPersistSnapshot as GraphPersistSnapshot, index_GraphProfileOptions as GraphProfileOptions, index_GraphProfileResult as GraphProfileResult, index_GraphVersionChange as GraphVersionChange, index_GraphWALDiff as GraphWALDiff, type index_IslandReport as IslandReport, index_JsonCodec as JsonCodec, type index_LazyGraphCodec as LazyGraphCodec, index_NodeProfile as NodeProfile, type index_ObservabilityCheck as ObservabilityCheck, type index_ObservabilityDescribeFormat as ObservabilityDescribeFormat, index_ObserveChangeset as ObserveChangeset, index_ObserveDetail as ObserveDetail, index_ObserveEvent as ObserveEvent, index_ObserveOptions as ObserveOptions, index_ObserveResult as ObserveResult, index_ObserveTheme as ObserveTheme, index_ObserveThemeName as ObserveThemeName, index_ObserveTier as ObserveTier, index_ReachableDirection as ReachableDirection, index_ReachableOptions as ReachableOptions, OVERHEAD as SIZEOF_OVERHEAD, index_SIZEOF_SYMBOL as SIZEOF_SYMBOL, index_SNAPSHOT_VERSION as SNAPSHOT_VERSION, index_TopologyEvent as TopologyEvent, index_TraceEntry as TraceEntry, type index_ValidateNoIslandsResult as ValidateNoIslandsResult, type index_ValidateObservabilityOptions as ValidateObservabilityOptions, type index_ValidateObservabilityResult as ValidateObservabilityResult, type index_WALEntry as WALEntry, index_createDagCborCodec as createDagCborCodec, index_createDagCborZstdCodec as createDagCborZstdCodec, index_decodeEnvelope as decodeEnvelope, index_diffForWAL as diffForWAL, index_encodeEnvelope as encodeEnvelope, index_explainPath as explainPath, index_graphProfile as graphProfile, index_reachable as reachable, index_registerBuiltinCodecs as registerBuiltinCodecs, index_replayWAL as replayWAL, index_sizeof as sizeof, index_validateGraphObservability as validateGraphObservability, index_validateNoIslands as validateNoIslands, index_watchTopologyTree as watchTopologyTree };
-}
-
-export { ENVELOPE_VERSION as E, type GraphCodec as G, type IslandReport as I, JsonCodec as J, type LazyGraphCodec as L, type ObservabilityCheck as O, SIZEOF_SYMBOL as S, type ValidateNoIslandsResult as V, type WALEntry as W, type EvictedSubgraphInfo as a, type EvictionPolicy as b, type ObservabilityDescribeFormat as c, OVERHEAD as d, type ValidateObservabilityOptions as e, type ValidateObservabilityResult as f, createDagCborCodec as g, createDagCborZstdCodec as h, decodeEnvelope as i, encodeEnvelope as j, index as k, replayWAL as l, validateNoIslands as m, registerBuiltinCodecs as r, sizeof as s, validateGraphObservability as v };

package/dist/index-CJF1URuX.d.ts

@@ -1,121 +0,0 @@
-import { i as index$2 } from './index-Dgl1HpPn.js';
-import { i as index$3 } from './index-CBBLl_rc.js';
-import { i as index$4 } from './index-CBGUK09R.js';
-import { i as index$5 } from './index-CdAlHFEt.js';
-import { N as Node } from './node-kK3CvTrR.js';
-import { i as index$6 } from './index-BmZXHqkE.js';
-import { i as index$7 } from './index-CviRnE4K.js';
-import { i as index$8 } from './index-CPQlGA29.js';
-import { i as index$9 } from './index-sqkqlb1p.js';
-
-/**
- * Options for creating signals.
- *
- * @category compat
- */
-interface SignalOptions {
-    /** Optional identifier for the underlying node. */
-    name?: string;
-    /** Custom equality function for change detection. */
-    equals?: (a: any, b: any) => boolean;
-}
-/**
- * Common interface for all reactive signals.
- *
- * @category compat
- */
-interface AnySignal<T> {
-    /** Returns the current value of the signal. */
-    get(): T;
-    /** @internal The underlying GraphReFly node. */
-    _node: Node<T>;
-}
-/**
- * TC39 `Signal.State` — a writable signal backed by a GraphReFly `state` node.
- * Automatically registers itself as a dependency if read inside a `Computed`.
- *
- * @example
- * ```ts
- * const count = new Signal.State(0);
- * count.get(); // 0
- * count.set(1);
- * count.get(); // 1
- * ```
- */
-declare class SignalState<T> implements AnySignal<T> {
-    /** @internal */
-    _node: Node<T>;
-    private readonly _equals;
-    constructor(initial: T, opts?: SignalOptions);
-    get(): T;
-    set(value: T): void;
-}
-/**
- * TC39 `Signal.Computed` — a read-only signal backed by `dynamicNode`.
- * Automatically tracks dependencies when `get()` is called on other signals
- * during its computation.
- *
- * @example
- * ```ts
- * const count = new Signal.State(0);
- * const doubled = new Signal.Computed(() => count.get() * 2);
- * ```
- */
-declare class SignalComputed<T> implements AnySignal<T> {
-    /** @internal */
-    _node: Node<T>;
-    constructor(computation: () => T, opts?: SignalOptions);
-    get(): T;
-}
-/**
- * TC39 Signals-compatible namespace. Wraps GraphReFly primitives.
- * Provides auto-tracking conforming to the TS39 signals proposal.
- *
- * @category compat
- */
-declare const Signal: {
-    readonly State: typeof SignalState;
-    readonly Computed: typeof SignalComputed;
-    /**
-     * Subscribes to changes on a signal.
-     * Returns an unsubscribe callback.
-     *
-     * @example
-     * ```ts
-     * const count = new Signal.State(0);
-     * const unsub = Signal.sub(count, v => console.log(v));
-     * ```
-     */
-    readonly sub: <T>(signal: AnySignal<T>, callback: ((value: T) => void) | {
-        data?: (value: T) => void;
-        error?: (err: unknown) => void;
-        complete?: () => void;
-    }) => (() => void);
-};
-
-type index$1_AnySignal<T> = AnySignal<T>;
-declare const index$1_Signal: typeof Signal;
-type index$1_SignalComputed<T> = SignalComputed<T>;
-declare const index$1_SignalComputed: typeof SignalComputed;
-type index$1_SignalOptions = SignalOptions;
-type index$1_SignalState<T> = SignalState<T>;
-declare const index$1_SignalState: typeof SignalState;
-declare namespace index$1 {
-  export { type index$1_AnySignal as AnySignal, index$1_Signal as Signal, index$1_SignalComputed as SignalComputed, type index$1_SignalOptions as SignalOptions, index$1_SignalState as SignalState };
-}
-
-/**
- * Compat layer: compatibility wrappers for other state management libraries (Phase 5.1b).
- *
- * Framework adapters are optional peers. Install only what you use:
- * - `@graphrefly/graphrefly-ts/compat/react` -> `react`, `react-dom`
- * - `@graphrefly/graphrefly-ts/compat/vue` -> `vue`
- * - `@graphrefly/graphrefly-ts/compat/svelte` -> `svelte`
- * - `@graphrefly/graphrefly-ts/compat/solid` -> `solid-js`
- */
-
-declare namespace index {
-  export { index$2 as jotai, index$3 as nanostores, index$4 as nestjs, index$5 as react, index$1 as signals, index$6 as solid, index$7 as svelte, index$8 as vue, index$9 as zustand };
-}
-
-export { index$1 as a, index as i };