@graphrefly/ts 0.0.0

package/dist/reactive-map-D-g3dv8I.d.cts

@@ -0,0 +1,256 @@
+import { N as Node } from './types-bNMSWKqF.cjs';
+import { J as CollectionCoreOptions, s as ReactiveOpt, L as ListChange, V as ViewCachePolicy, c as LogChange, t as ReactiveView, u as RetentionPolicy, M as MapChange } from './reactive-collection-BxBqtIOE.cjs';
+
+/**
+ * Reactive positional list (CSP-2.8, D54/D60) — the two-port collection template.
+ *
+ * Shape (D60 + review #2): a mutable array BACKEND (the single materialized state) + the shared
+ * {@link collectionCore} two ports — a DELTA stream ({@link ReactiveList.delta}, one event per
+ * mutation, O(1)) and a lazy pull SNAPSHOT ({@link ReactiveList.snapshot}, materialized only on a
+ * cone-routed RESUME demand). Mutation input is D54 A3 hybrid: ergonomic imperative methods (the
+ * external boundary, state-verb-legitimate, D4) + `appendFrom(src)` widening (an in-graph producer
+ * drives the list with zero imperative glue). Synchronous quick-reads (`at`/`size`/`toArray`) are
+ * the deliberately-non-reactive peek for cold/imperative reads (D60).
+ *
+ * Per-language (D6/D24, never in parity, no conformance — the substrate pull is already C-16).
+ */
+
+type ReactiveListOpt<T> = ReactiveOpt<T>;
+interface ReactiveListOptions extends CollectionCoreOptions {
+    /**
+     * Head-trim capacity policy (D72). A static number caps the list locally; a Node-valued maxSize
+     * must be graph-bound and becomes a declared policy dep that trims on policy changes.
+     */
+    maxSize?: ReactiveListOpt<number>;
+}
+interface ReactiveList<T> {
+    /** DELTA stream: one {@link ListChange} per mutation (O(1)). Subscribe to observe events. */
+    readonly delta: Node<ListChange<T>>;
+    /** SNAPSHOT pull node: demand via `ctx.upNext([[RESUME, pullId]])` → one `readonly T[]` (lazy O(n)). */
+    readonly snapshot: Node<readonly T[]>;
+    /** The snapshot node's pullId — write it verbatim into the demander's fn (D59). */
+    readonly pullId: symbol;
+    /** Current entry count (O(1), synchronous non-reactive read). */
+    readonly size: number;
+    /** Positional access (O(1)); negative indices Python-style; `undefined` out of range. Sync read. */
+    at(index: number): T | undefined;
+    /** Full current contents (O(n), fresh defensive copy). Sync non-reactive read (cold-start peek). */
+    toArray(): readonly T[];
+    append(value: T): void;
+    /** Append all values; one delta event + one snapshot-arm. No-op if `values` is empty. */
+    appendMany(values: readonly T[]): void;
+    /** Insert at `index` (0..size). Throws `RangeError` out of range. */
+    insert(index: number, value: T): void;
+    /** Insert all at `index` as one op. No-op if `values` is empty. Throws out of range. */
+    insertMany(index: number, values: readonly T[]): void;
+    /** Remove and return the value at `index` (default last; negative Python-style). Throws if empty/out of range. */
+    pop(index?: number): T;
+    clear(): void;
+    /** D54 widening: every value from `src` is appended. Returns a disposer. */
+    appendFrom(src: Node<T>): () => void;
+    /** Release the widening subscriptions (idempotent). */
+    dispose(): void;
+}
+/**
+ * Create a reactive list (D54/D60). The DELTA + SNAPSHOT ports + pullId come from the shared
+ * {@link collectionCore}; this layer adds the typed list method surface + backend.
+ *
+ * @example
+ * ```ts
+ * const list = reactiveList<number>([1]);
+ * // observe events:
+ * list.delta.subscribe((m) => { if (m[0] === "DATA") console.log("Δ", m[1]); });
+ * list.append(2);                 // delta: {kind:"append", value:2}
+ * // demand the snapshot (a downstream consumer, holding `list.snapshot` upstream, runs):
+ * //   ctx.upNext([["RESUME", list.pullId]]);  → SNAPSHOT delivers [1, 2]
+ * list.toArray();                 // [1, 2]   (synchronous non-reactive read)
+ * ```
+ */
+declare function reactiveList<T>(initial?: readonly T[], options?: ReactiveListOptions): ReactiveList<T>;
+
+/**
+ * Reactive append-only log (CSP-2.8, D54/D60) — two-port collection with incremental views.
+ *
+ * Shape = the shared {@link collectionCore} two ports over an array (or ring-buffer if `maxSize`)
+ * BACKEND (D60). Specializations (D60 #5 / review #5):
+ *   - SNAPSHOT (the full `readonly T[]`) is the lazy pull port like the others, BUT the log's main
+ *     consumption is INCREMENTAL: `tail()` / `slice()` / `scan()` re-derive on the DELTA backbone
+ *     (dep=[delta]), folding each appended value as it arrives — NOT re-scanning a pushed full array.
+ *   - `append(undefined)` throws: `undefined` is the substrate SENTINEL (R-data-payload / R-sentinel),
+ *     not a valid value.
+ *   - empty log: the snapshot is `[]` (a real empty array); a never-appended `scan` seeds its initial.
+ *     There is NO `[[RESOLVED]]`-for-empty dual role (D49 narrowed RESOLVED to undirty-only, D60 #5b).
+ *   - `attach(upstream)` = the D54 widening (a declared input-fold dep), NOT an imperative subscribe.
+ *   - {@link mergeReactiveLogs} is a DECLARED-DEP merge (deps=[...delta streams]), NOT the old
+ *     internal-subscribe island (D45 must-fix, D60 #5e).
+ *   - storage persistence = D57 (binding-layer observe-sink), out of scope here.
+ *
+ * Per-language (D6/D24, never in parity, no conformance — the substrate pull is already C-16).
+ */
+
+interface ReactiveLogOptions extends CollectionCoreOptions {
+    /** Ring-buffer cap: appends past `maxSize` evict the oldest (head-trim, append-only-safe). */
+    maxSize?: number;
+    /** Static D80 memo policy for D121 light views. Eviction does not dispose returned views. */
+    viewCache?: ViewCachePolicy;
+}
+interface ReactiveLog<T> {
+    readonly delta: Node<LogChange<T>>;
+    /** SNAPSHOT pull node: demand → full `readonly T[]` (lazy O(n)). For incremental use {@link tail}, {@link slice}, or {@link scan}. */
+    readonly snapshot: Node<readonly T[]>;
+    readonly pullId: symbol;
+    /** Entry count (O(1)). Sync non-reactive read. */
+    readonly size: number;
+    /** Positional access (O(1)); negative Python-style; `undefined` out of range. Sync read. */
+    at(index: number): T | undefined;
+    /** Full contents (O(n) fresh copy). Sync non-reactive read (cold-start peek). */
+    toArray(): readonly T[];
+    /** Append one value. Throws on `undefined` (substrate SENTINEL, R-data-payload). */
+    append(value: T): void;
+    /** Append many; one delta event. No-op if empty. Throws if any value is `undefined`. */
+    appendMany(values: readonly T[]): void;
+    clear(): void;
+    /** Remove the first `n` entries (clamped to size). */
+    trimHead(n: number): void;
+    /**
+     * Incremental tail view: a derived node emitting the last `n` entries, recomputed on each delta
+     * (dep=[delta], D60 #5a). Memoized per `n` until {@link dispose}; use stable ranges for
+     * long-lived logs. Subscribe to keep it live.
+     */
+    tail(n: number): Node<readonly T[]>;
+    /**
+     * Incremental positional view: a derived node emitting `toArray().slice(start, stop)`,
+     * recomputed on each delta (dep=[delta], D60 #5a). Memoized per `[start, stop]` until
+     * {@link dispose}; use stable ranges for long-lived logs.
+     */
+    slice(start: number, stop?: number): Node<readonly T[]>;
+    /**
+     * D121 light page view: `delta` forwards parent log mutations, and `snapshot` is a pull node
+     * that materializes the current page on demand.
+     */
+    page(offset: number, limit: number): ReactiveView<LogChange<T>, readonly T[]>;
+    /**
+     * Incremental running aggregate over appended values (dep=[delta], D60 #5a). O(1) per append —
+     * folds only the new values each delta; resets on `clear`/`trimHead` (a non-append delta) via a
+     * full re-fold. Emits the current accumulator on every mutation; seeds `initial` on an empty log.
+     */
+    scan<A>(initial: A, step: (acc: A, value: T) => A): Node<A>;
+    /** D54 widening: every value from `src` is appended. Returns a disposer. */
+    attach(src: Node<T>): () => void;
+    dispose(): void;
+}
+/**
+ * Create an append-only reactive log (D54/D60). DELTA + lazy pull SNAPSHOT + pullId via
+ * {@link collectionCore}; this layer adds the typed append surface + incremental view/scan.
+ */
+declare function reactiveLog<T>(initial?: readonly T[], options?: ReactiveLogOptions): ReactiveLog<T>;
+/**
+ * Fan-in N reactive logs into one merged DELTA stream (D60 #5e — a DECLARED-DEP merge, NOT the old
+ * internal-subscribe island). The returned node declares each log's `delta` as a dep (`partial`)
+ * and re-emits every change it sees — describe shows `log[i].delta → merged` truthfully (D45).
+ * For the merged SNAPSHOT, fold the merged delta with {@link ReactiveLog.scan}-style logic, or
+ * demand each source's snapshot independently.
+ */
+declare function mergeReactiveLogs<T>(logs: readonly ReactiveLog<T>[]): Node<LogChange<T>>;
+/**
+ * Standalone incremental scan over a reactive log. Equivalent to `log.scan(initial, step)`;
+ * provided for pipe-builder and helper-composition call sites.
+ */
+declare function scanLog<T, A>(log: ReactiveLog<T>, initial: A, step: (acc: A, value: T) => A): Node<A>;
+
+/**
+ * Reactive key–value map (CSP-2.8, D54/D60/D68) — two-port collection with policy opts.
+ *
+ * Shape = the shared {@link collectionCore} two ports over a `Map` BACKEND (D60). Specializations
+ * (D60 #3 / review #3):
+ *   - TTL/LRU are node-as-opt policies (D68). Static `maxSize` / `defaultTtl` values become constant
+ *     policy deps; Node-valued opts are declared deps. The graph-visible `reactiveMap.apply` node is
+ *     the normal backend mutation path and emits the public delta payloads it materializes.
+ *   - LAZY TTL (no background timer): expiry is checked at read (`get`/`has`) + at synchronous
+ *     snapshot materialization (`toMap`/`pruneExpired`). A read/prune that deletes an expired key
+ *     emits the normal delta `delete{reason:"expired"}` (D61). Snapshot demand uses an internal pull
+ *     `snapshotPrep` node: it prunes expired entries and reads the backend once, then public
+ *     `snapshot` and `delta` derive from that declared prep payload. No snapshot fn drives its own
+ *     dep (D37).
+ *   - delete-reason enum {expired|lru-evict|archived|explicit} on the delta (D60 #3c).
+ *   - LRU `maxSize`: an over-cap `set` evicts the oldest, emitting a `delete{reason:"lru-evict"}`.
+ *     A live-key `get`/`has` touches LRU order WITHOUT a version bump (internal, D60 #3d).
+ *   - retention (score-archive, D72): `retention.maxSize` is a value-or-Node numeric policy and
+ *     the static scorer selects archive victims through the normal `reactiveMap.apply` path.
+ *
+ * Per-language (D6/D24, never in parity, no conformance — the substrate pull is already C-16).
+ */
+
+type ReactiveMapOpt<T> = ReactiveOpt<T>;
+interface ReactiveMapRetentionEntry<K, V> {
+    readonly key: K;
+    readonly value: V;
+}
+interface ReactiveMapRetentionPolicy<K, V> extends RetentionPolicy<ReactiveMapRetentionEntry<K, V>> {
+    /** Archive capacity. Unlike LRU, zero is allowed and archives every live entry. */
+    readonly maxSize?: ReactiveMapOpt<number>;
+    /** Higher scores are retained; lowest finite scores are archived first. */
+    score(entry: ReactiveMapRetentionEntry<K, V>): number;
+}
+interface ReactiveMapOptions<K = unknown, V = unknown> extends CollectionCoreOptions {
+    /**
+     * LRU cap as a node-as-opt policy (D68). A static number is a constant policy config; a Node must
+     * be graph-bound and becomes a declared dep of `reactiveMap.apply`.
+     */
+    maxSize?: ReactiveMapOpt<number>;
+    /**
+     * Default TTL in milliseconds as a node-as-opt policy (D68). Per-call `set(...,{ttl})` overrides.
+     * Lazy expiry only; no active timer in this cut.
+     */
+    defaultTtl?: ReactiveMapOpt<number>;
+    /**
+     * Score-based retention/archive policy (D72). The scorer is static local code; only maxSize can be
+     * a Node-valued policy, keeping graph describe data serializable while apply owns the mutation.
+     */
+    retention?: ReactiveMapRetentionPolicy<K, V>;
+    /** Static D80 memo policy for D121 light views. Eviction does not dispose returned views. */
+    viewCache?: ViewCachePolicy;
+    /** Injectable monotonic-ish clock for TTL (default `Date.now`). Graph-local clock = follow-up (D26). */
+    now?: () => number;
+}
+interface ReactiveMap<K, V> {
+    readonly delta: Node<MapChange<K, V>>;
+    readonly snapshot: Node<ReadonlyMap<K, V>>;
+    readonly pullId: symbol;
+    /** Raw entry count (O(1)); may include not-yet-pruned expired entries. Sync non-reactive read. */
+    readonly size: number;
+    /** Get a live value (prunes the key if expired). Sync read. */
+    get(key: K): V | undefined;
+    /** Live-key existence (prunes if expired). Sync read. */
+    has(key: K): boolean;
+    /** Current live (non-expired) entries (fresh copy). Sync non-reactive read (cold-start peek). */
+    toMap(): ReadonlyMap<K, V>;
+    /**
+     * D121 light selected-map view. `delta` forwards parent map mutations, and `snapshot` is a pull
+     * node that materializes the currently matching live entries on demand.
+     */
+    select(predicate: (value: V, key: K) => boolean): ReactiveView<MapChange<K, V>, ReadonlyMap<K, V>>;
+    set(key: K, value: V, opts?: {
+        ttl?: number;
+    }): void;
+    /** Bulk set; one delta event per entry, one snapshot-arm. No-op if empty. */
+    setMany(entries: Iterable<readonly [K, V]>, opts?: {
+        ttl?: number;
+    }): void;
+    delete(key: K): void;
+    /** Bulk delete; one delta per removed key. No-op if none present. */
+    deleteMany(keys: Iterable<K>): void;
+    clear(): void;
+    /** Explicitly prune expired entries; every removed key emits `delete{reason:"expired"}` (D61). */
+    pruneExpired(): void;
+    /** D54 widening: every `[key, value]` from `src` is set. Returns a disposer. */
+    setFrom(src: Node<readonly [K, V]>): () => void;
+    dispose(): void;
+}
+/**
+ * Create a reactive map (D54/D60). DELTA stream of {@link MapChange} + lazy pull SNAPSHOT (a
+ * `ReadonlyMap`) + pullId via {@link collectionCore}; this layer adds the typed map surface.
+ */
+declare function reactiveMap<K, V>(options?: ReactiveMapOptions<K, V>): ReactiveMap<K, V>;
+
+export { type ReactiveList as R, type ReactiveListOpt as a, type ReactiveListOptions as b, type ReactiveLog as c, type ReactiveLogOptions as d, type ReactiveMap as e, type ReactiveMapOpt as f, type ReactiveMapOptions as g, type ReactiveMapRetentionEntry as h, type ReactiveMapRetentionPolicy as i, reactiveLog as j, reactiveMap as k, mergeReactiveLogs as m, reactiveList as r, scanLog as s };

package/dist/read-through-B1CYPfq_.d.cts

@@ -0,0 +1,82 @@
+import { K as KvGeneration, f as KvStorageTier } from './append-log-DisvEReb.cjs';
+
+/** Result tier for read-through output facts. */
+interface ReadThroughLookupTier {
+    /** Tier index in the ordered lookup list. `-1` = optional loader fallback. */
+    readonly index: number;
+    /** Optional human-facing tier name. */
+    readonly name?: string;
+}
+/** Ordered lookup result from a single tier or loader attempt. */
+type ReadThroughOutcome = "hit" | "miss" | "error";
+/** Fact for one lookup attempt (one tier or the optional loader fallback). */
+interface ReadThroughLookupFact<T> {
+    readonly kind: ReadThroughOutcome;
+    readonly key: string;
+    readonly tier: ReadThroughLookupTier;
+    readonly value?: T;
+    readonly generation?: KvGeneration;
+    readonly error?: unknown;
+}
+/** Result of one promotion write attempt to an earlier tier. */
+interface ReadThroughPromotionFact {
+    readonly tier: ReadThroughLookupTier;
+    readonly ok: boolean;
+    readonly error?: unknown;
+}
+/** Final read-through outcome, with explicit lookup facts and promotion facts. */
+interface TieredReadThroughResult<T> {
+    readonly status: "hit" | "miss" | "error";
+    readonly key: string;
+    readonly value?: T;
+    readonly hitTier?: ReadThroughLookupTier;
+    readonly facts: readonly ReadThroughLookupFact<T>[];
+    readonly promotions: readonly ReadThroughPromotionFact[];
+}
+/** Optional hook/context for lookup misses. */
+interface ReadThroughMissContext {
+    readonly key: string;
+    readonly tier: ReadThroughLookupTier;
+}
+/** Optional hook/context for get/load/promotion errors. */
+interface ReadThroughErrorContext {
+    readonly key: string;
+    readonly tier: ReadThroughLookupTier;
+    readonly stage: "lookup" | "promotion";
+    readonly error: unknown;
+}
+/** Configuration for `tieredReadThrough`. */
+interface TieredReadThroughOptions<T> {
+    /** Lookup key for all tiers. */
+    readonly key: string;
+    /** Ordered lookup tiers, index 0 = hottest/fastest. */
+    readonly tiers: readonly KvStorageTier<T>[];
+    /** Optional friendly tier names, matched by index. */
+    readonly tierNames?: readonly string[];
+    /**
+     * Optional loader fallback for cache-miss. If provided and no tier hits, this runs
+     * after all tiers are checked and may write-through by promotion logic.
+     */
+    readonly load?: (key: string) => Promise<T | undefined> | T | undefined;
+    /**
+     * Optional promotion policy: set hit values to earlier (lower-index) tiers.
+     * `false` disables promotion; default promotes to all earlier tiers on any hit.
+     * Explicit indices can narrow promotion targets.
+     */
+    readonly promoteTo?: readonly number[] | false;
+    /** Optional callbacks for control-plane observability. */
+    readonly onMiss?: (context: ReadThroughMissContext) => void;
+    /** Called for lookup/load errors and promotion failures by default. */
+    readonly onError?: (context: ReadThroughErrorContext) => void;
+}
+/** Alias for callers that prefer loader-oriented naming. */
+declare function readThroughKv<T>(opts: TieredReadThroughOptions<T>): Promise<TieredReadThroughResult<T>>;
+/**
+ * Build explicit lookup facts across tiers plus optional loader fallback (D104 layer 1).
+ *
+ * This is a passive storage/domain helper: it creates no graph nodes, performs no hydration or
+ * restore, and treats promotion writes as facts rather than a graph commit barrier.
+ */
+declare function tieredReadThrough<T>(opts: TieredReadThroughOptions<T>): Promise<TieredReadThroughResult<T>>;
+
+export { type ReadThroughErrorContext as R, type TieredReadThroughOptions as T, type ReadThroughLookupFact as a, type ReadThroughLookupTier as b, type ReadThroughMissContext as c, type ReadThroughPromotionFact as d, type TieredReadThroughResult as e, readThroughKv as r, tieredReadThrough as t };

package/dist/read-through-DwyJhGs1.d.ts

@@ -0,0 +1,82 @@
+import { K as KvGeneration, f as KvStorageTier } from './append-log-DzKMmjxx.js';
+
+/** Result tier for read-through output facts. */
+interface ReadThroughLookupTier {
+    /** Tier index in the ordered lookup list. `-1` = optional loader fallback. */
+    readonly index: number;
+    /** Optional human-facing tier name. */
+    readonly name?: string;
+}
+/** Ordered lookup result from a single tier or loader attempt. */
+type ReadThroughOutcome = "hit" | "miss" | "error";
+/** Fact for one lookup attempt (one tier or the optional loader fallback). */
+interface ReadThroughLookupFact<T> {
+    readonly kind: ReadThroughOutcome;
+    readonly key: string;
+    readonly tier: ReadThroughLookupTier;
+    readonly value?: T;
+    readonly generation?: KvGeneration;
+    readonly error?: unknown;
+}
+/** Result of one promotion write attempt to an earlier tier. */
+interface ReadThroughPromotionFact {
+    readonly tier: ReadThroughLookupTier;
+    readonly ok: boolean;
+    readonly error?: unknown;
+}
+/** Final read-through outcome, with explicit lookup facts and promotion facts. */
+interface TieredReadThroughResult<T> {
+    readonly status: "hit" | "miss" | "error";
+    readonly key: string;
+    readonly value?: T;
+    readonly hitTier?: ReadThroughLookupTier;
+    readonly facts: readonly ReadThroughLookupFact<T>[];
+    readonly promotions: readonly ReadThroughPromotionFact[];
+}
+/** Optional hook/context for lookup misses. */
+interface ReadThroughMissContext {
+    readonly key: string;
+    readonly tier: ReadThroughLookupTier;
+}
+/** Optional hook/context for get/load/promotion errors. */
+interface ReadThroughErrorContext {
+    readonly key: string;
+    readonly tier: ReadThroughLookupTier;
+    readonly stage: "lookup" | "promotion";
+    readonly error: unknown;
+}
+/** Configuration for `tieredReadThrough`. */
+interface TieredReadThroughOptions<T> {
+    /** Lookup key for all tiers. */
+    readonly key: string;
+    /** Ordered lookup tiers, index 0 = hottest/fastest. */
+    readonly tiers: readonly KvStorageTier<T>[];
+    /** Optional friendly tier names, matched by index. */
+    readonly tierNames?: readonly string[];
+    /**
+     * Optional loader fallback for cache-miss. If provided and no tier hits, this runs
+     * after all tiers are checked and may write-through by promotion logic.
+     */
+    readonly load?: (key: string) => Promise<T | undefined> | T | undefined;
+    /**
+     * Optional promotion policy: set hit values to earlier (lower-index) tiers.
+     * `false` disables promotion; default promotes to all earlier tiers on any hit.
+     * Explicit indices can narrow promotion targets.
+     */
+    readonly promoteTo?: readonly number[] | false;
+    /** Optional callbacks for control-plane observability. */
+    readonly onMiss?: (context: ReadThroughMissContext) => void;
+    /** Called for lookup/load errors and promotion failures by default. */
+    readonly onError?: (context: ReadThroughErrorContext) => void;
+}
+/** Alias for callers that prefer loader-oriented naming. */
+declare function readThroughKv<T>(opts: TieredReadThroughOptions<T>): Promise<TieredReadThroughResult<T>>;
+/**
+ * Build explicit lookup facts across tiers plus optional loader fallback (D104 layer 1).
+ *
+ * This is a passive storage/domain helper: it creates no graph nodes, performs no hydration or
+ * restore, and treats promotion writes as facts rather than a graph commit barrier.
+ */
+declare function tieredReadThrough<T>(opts: TieredReadThroughOptions<T>): Promise<TieredReadThroughResult<T>>;
+
+export { type ReadThroughErrorContext as R, type TieredReadThroughOptions as T, type ReadThroughLookupFact as a, type ReadThroughLookupTier as b, type ReadThroughMissContext as c, type ReadThroughPromotionFact as d, type TieredReadThroughResult as e, readThroughKv as r, tieredReadThrough as t };

package/dist/render/index.cjs

@@ -0,0 +1,250 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/render/index.ts
+var render_exports = {};
+__export(render_exports, {
+  describeToAscii: () => describeToAscii,
+  describeToD2: () => describeToD2,
+  describeToJson: () => describeToJson,
+  describeToMermaid: () => describeToMermaid,
+  describeToMermaidUrl: () => describeToMermaidUrl,
+  describeToPretty: () => describeToPretty,
+  mermaidLiveUrl: () => mermaidLiveUrl
+});
+module.exports = __toCommonJS(render_exports);
+
+// src/graph/render.ts
+function describeToMermaid(snapshot, opts = {}) {
+  const direction = normalizeDirection(opts.direction);
+  const flat = flattenDescribe(snapshot);
+  const nodes = sortedNodes(flat.nodes);
+  const ids = /* @__PURE__ */ new Map();
+  for (let i = 0; i < nodes.length; i += 1) ids.set(nodes[i].id, `n${i}`);
+  const lines = [`flowchart ${direction}`];
+  for (const node of nodes) {
+    lines.push(`  ${ids.get(node.id)}["${escapeMermaidLabel(node.id)}"]`);
+  }
+  for (const edge of sortedEdges(flat.edges)) {
+    const from = ids.get(edge.from);
+    const to = ids.get(edge.to);
+    if (from === void 0 || to === void 0) continue;
+    lines.push(`  ${from} --> ${to}`);
+  }
+  return lines.join("\n");
+}
+function mermaidLiveUrl(mermaidSource, opts = {}) {
+  const payload = {
+    code: mermaidSource,
+    mermaid: { theme: opts.theme ?? "default" },
+    autoSync: opts.autoSync ?? true
+  };
+  return `https://mermaid.live/edit#base64:${base64UrlEncode(JSON.stringify(payload))}`;
+}
+function describeToMermaidUrl(snapshot, opts = {}) {
+  return mermaidLiveUrl(describeToMermaid(snapshot, opts), opts);
+}
+function describeToD2(snapshot, opts = {}) {
+  const direction = normalizeDirection(opts.direction);
+  const flat = flattenDescribe(snapshot);
+  const nodes = sortedNodes(flat.nodes);
+  const ids = /* @__PURE__ */ new Map();
+  for (let i = 0; i < nodes.length; i += 1) ids.set(nodes[i].id, `n${i}`);
+  const lines = [`direction: ${d2Direction(direction)}`];
+  for (const node of nodes) {
+    lines.push(`${ids.get(node.id)}: "${escapeD2Label(node.id)}"`);
+  }
+  for (const edge of sortedEdges(flat.edges)) {
+    const from = ids.get(edge.from);
+    const to = ids.get(edge.to);
+    if (from === void 0 || to === void 0) continue;
+    lines.push(`${from} -> ${to}`);
+  }
+  return lines.join("\n");
+}
+function describeToPretty(snapshot, opts = {}) {
+  const flat = flattenDescribe(snapshot);
+  const includeEdges = opts.includeEdges ?? true;
+  const lines = [`Graph ${flat.name ?? "(anonymous)"}`, "Nodes:"];
+  for (const node of sortedNodes(flat.nodes)) {
+    lines.push(`- ${node.id} (${node.factory}/${node.status}): ${formatValue(node)}`);
+  }
+  if (includeEdges) {
+    lines.push("Edges:");
+    for (const edge of sortedEdges(flat.edges)) lines.push(`- ${edge.from} -> ${edge.to}`);
+  }
+  return lines.join("\n");
+}
+function describeToAscii(snapshot, opts = {}) {
+  const flat = flattenDescribe(snapshot);
+  const outgoing = /* @__PURE__ */ new Map();
+  for (const edge of sortedEdges(flat.edges)) {
+    const list = outgoing.get(edge.from);
+    if (list) list.push(edge.to);
+    else outgoing.set(edge.from, [edge.to]);
+  }
+  const lines = [`Graph ${flat.name ?? "(anonymous)"}`];
+  for (const node of sortedNodes(flat.nodes)) {
+    const value = opts.includeValues ? ` ${formatValue(node)}` : "";
+    const to = outgoing.get(node.id)?.join(", ") ?? "-";
+    lines.push(`${node.id} [${node.factory}/${node.status}${value}] -> ${to}`);
+  }
+  return lines.join("\n");
+}
+function describeToJson(snapshot, opts = {}) {
+  const includeEdges = opts.includeEdges ?? true;
+  const flat = flattenDescribe(snapshot);
+  const payload = {
+    ...flat.name !== void 0 ? { name: flat.name } : {},
+    nodes: sortedNodes(flat.nodes).map((node) => sortJsonValue(node)),
+    edges: includeEdges ? sortedEdges(flat.edges) : []
+  };
+  return JSON.stringify(sortJsonValue(payload), null, opts.indent ?? 2);
+}
+function flattenDescribe(snapshot) {
+  const nodes = [];
+  const edges = [];
+  const visit = (snap) => {
+    nodes.push(...snap.nodes);
+    edges.push(...snap.edges);
+    for (const child of snap.subgraphs ?? []) visit(child);
+  };
+  visit(snapshot);
+  return { ...snapshot.name !== void 0 ? { name: snapshot.name } : {}, nodes, edges };
+}
+function sortedNodes(nodes) {
+  return [...nodes].sort((a, b) => compareText(a.id, b.id));
+}
+function sortedEdges(edges) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const edge of edges) {
+    const key = `${edge.from}\0${edge.to}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(edge);
+  }
+  return out.sort((a, b) => compareText(a.from, b.from) || compareText(a.to, b.to));
+}
+function compareText(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function normalizeDirection(direction) {
+  if (direction === void 0) return "LR";
+  if (direction === "TD" || direction === "LR" || direction === "BT" || direction === "RL") {
+    return direction;
+  }
+  throw new Error(
+    `invalid diagram direction ${String(direction)}; expected one of: TD, LR, BT, RL`
+  );
+}
+function d2Direction(direction) {
+  if (direction === "TD") return "down";
+  if (direction === "BT") return "up";
+  if (direction === "RL") return "left";
+  return "right";
+}
+function escapeMermaidLabel(value) {
+  return escapeQuotedLabel(value);
+}
+function escapeD2Label(value) {
+  return escapeQuotedLabel(value);
+}
+function escapeQuotedLabel(value) {
+  return JSON.stringify(value).slice(1, -1);
+}
+function formatValue(node) {
+  if (!("value" in node)) return "<SENTINEL>";
+  const value = node.value;
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "number" || typeof value === "boolean" || value == null)
+    return String(value);
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "[unserializable]";
+  }
+}
+function sortJsonValue(value, seen = /* @__PURE__ */ new WeakSet()) {
+  if (typeof value === "bigint") return value.toString();
+  if (value === null || typeof value !== "object") return value;
+  if (seen.has(value)) return "[Circular]";
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const out2 = value.map((item) => sortJsonValue(item, seen));
+    seen.delete(value);
+    return out2;
+  }
+  const obj = value;
+  const out = {};
+  for (const key of Object.keys(obj).sort(compareText)) out[key] = sortJsonValue(obj[key], seen);
+  seen.delete(value);
+  return out;
+}
+var B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function base64UrlEncode(value) {
+  const bytes = utf8Bytes(value);
+  let out = "";
+  for (let i = 0; i < bytes.length; i += 3) {
+    const a = bytes[i];
+    const b = bytes[i + 1];
+    const c = bytes[i + 2];
+    out += B64[a >> 2];
+    out += B64[(a & 3) << 4 | (b ?? 0) >> 4];
+    out += b === void 0 ? "=" : B64[(b & 15) << 2 | (c ?? 0) >> 6];
+    out += c === void 0 ? "=" : B64[c & 63];
+  }
+  return out.replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+}
+function utf8Bytes(value) {
+  const bytes = [];
+  for (let i = 0; i < value.length; i += 1) {
+    let cp = value.charCodeAt(i);
+    if (cp >= 55296 && cp <= 56319 && i + 1 < value.length) {
+      const lo = value.charCodeAt(i + 1);
+      if (lo >= 56320 && lo <= 57343) {
+        cp = 65536 + (cp - 55296 << 10) + (lo - 56320);
+        i += 1;
+      }
+    }
+    if (cp <= 127) bytes.push(cp);
+    else if (cp <= 2047) bytes.push(192 | cp >> 6, 128 | cp & 63);
+    else if (cp <= 65535)
+      bytes.push(224 | cp >> 12, 128 | cp >> 6 & 63, 128 | cp & 63);
+    else
+      bytes.push(
+        240 | cp >> 18,
+        128 | cp >> 12 & 63,
+        128 | cp >> 6 & 63,
+        128 | cp & 63
+      );
+  }
+  return bytes;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  describeToAscii,
+  describeToD2,
+  describeToJson,
+  describeToMermaid,
+  describeToMermaidUrl,
+  describeToPretty,
+  mermaidLiveUrl
+});
+//# sourceMappingURL=index.cjs.map