@graphrefly/graphrefly 0.45.0 → 0.47.0

package/dist/index-Bg-LwEt-.d.cts

@@ -0,0 +1,45 @@
+import { Node } from '@graphrefly/pure-ts/core';
+
+/** 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-Bg-LwEt-.d.ts

@@ -0,0 +1,45 @@
+import { Node } from '@graphrefly/pure-ts/core';
+
+/** 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-Brp888t0.d.cts

@@ -0,0 +1,127 @@
+import { Node } from '@graphrefly/pure-ts/core';
+
+/**
+ * A Nanostores-compatible atom.
+ *
+ * @category compat
+ */
+interface NanoAtom<T> {
+    /** Get current value. */
+    get(): T;
+    /** Set a new value (writable atoms only). */
+    set(value: T): void;
+    /** Subscribe to value changes. Callback receives the new value.
+     * Returns unsubscribe function. Called immediately with current value. */
+    subscribe(cb: (value: T) => void): () => void;
+    /** Listen to value changes (no immediate call). Returns unsubscribe. */
+    listen(cb: (value: T) => void): () => void;
+    /** The underlying GraphReFly node. */
+    readonly _node: Node<T>;
+}
+/**
+ * A Nanostores-compatible computed store.
+ *
+ * @category compat
+ */
+interface NanoComputed<T> {
+    /** Get current value. */
+    get(): T;
+    /** Subscribe to value changes. Called immediately with current value.
+     * Returns unsubscribe function. */
+    subscribe(cb: (value: T) => void): () => void;
+    /** Listen to value changes (no immediate call). Returns unsubscribe. */
+    listen(cb: (value: T) => void): () => void;
+    /** The underlying GraphReFly node. */
+    readonly _node: Node<T>;
+}
+/**
+ * A Nanostores-compatible map.
+ *
+ * @category compat
+ */
+interface NanoMap<T extends Record<string, unknown>> extends NanoAtom<T> {
+    /** Set a single key. */
+    setKey<K extends keyof T>(key: K, value: T[K]): void;
+}
+/**
+ * Creates a nanostores-compatible atom.
+ *
+ * @param initial - Initial value.
+ * @returns `NanoAtom<T>`
+ *
+ * @category compat
+ */
+declare function atom<T>(initial: T): NanoAtom<T>;
+/**
+ * Creates a nanostores-compatible computed store.
+ *
+ * @param stores - One or more atoms/computed stores.
+ * @param fn - Compute function.
+ * @returns `NanoComputed<T>`
+ *
+ * @category compat
+ */
+declare function computed<T, A>(storeA: NanoAtom<A> | NanoComputed<A>, fn: (a: A) => T): NanoComputed<T>;
+declare function computed<T, A, B>(stores: [NanoAtom<A> | NanoComputed<A>, NanoAtom<B> | NanoComputed<B>], fn: (a: A, b: B) => T): NanoComputed<T>;
+declare function computed<T, A, B, C>(stores: [
+    NanoAtom<A> | NanoComputed<A>,
+    NanoAtom<B> | NanoComputed<B>,
+    NanoAtom<C> | NanoComputed<C>
+], fn: (a: A, b: B, c: C) => T): NanoComputed<T>;
+/**
+ * Creates a nanostores-compatible map.
+ *
+ * @param initial - Initial object value.
+ * @returns `NanoMap<T>`
+ *
+ * @category compat
+ */
+declare function map<T extends Record<string, unknown>>(initial: T): NanoMap<T>;
+/**
+ * Returns the current value of the store.
+ *
+ * @category compat
+ */
+declare function getValue<T>(store: NanoAtom<T> | NanoComputed<T>): T;
+/**
+ * Adds a listener for the store start (first listener connected).
+ *
+ * @category compat
+ */
+declare function onStart(store: NanoAtom<any> | NanoComputed<any>, cb: () => void): void;
+/**
+ * Adds a listener for the store stop (last listener disconnected).
+ *
+ * @category compat
+ */
+declare function onStop(store: NanoAtom<any> | NanoComputed<any>, cb: () => void): void;
+/**
+ * Adds a listener for the store mount (first listener connected).
+ *
+ * @returns A cleanup function called when the last listener is removed.
+ * @category compat
+ */
+declare function onMount(store: NanoAtom<any> | NanoComputed<any>, cb: () => (() => void) | undefined): void;
+/**
+ * Batches multiple store updates.
+ *
+ * @category compat
+ */
+declare function action<Args extends any[], Return>(_store: NanoAtom<any> | NanoComputed<any>, _name: string, fn: (...args: Args) => Return): (...args: Args) => Return;
+
+type index_NanoAtom<T> = NanoAtom<T>;
+type index_NanoComputed<T> = NanoComputed<T>;
+type index_NanoMap<T extends Record<string, unknown>> = NanoMap<T>;
+declare const index_action: typeof action;
+declare const index_atom: typeof atom;
+declare const index_computed: typeof computed;
+declare const index_getValue: typeof getValue;
+declare const index_map: typeof map;
+declare const index_onMount: typeof onMount;
+declare const index_onStart: typeof onStart;
+declare const index_onStop: typeof onStop;
+declare namespace index {
+  export { type index_NanoAtom as NanoAtom, type index_NanoComputed as NanoComputed, type index_NanoMap as NanoMap, index_action as action, index_atom as atom, index_computed as computed, index_getValue as getValue, index_map as map, index_onMount as onMount, index_onStart as onStart, index_onStop as onStop };
+}
+
+export { type NanoAtom as N, type NanoComputed as a, type NanoMap as b, action as c, atom as d, computed as e, onStart as f, getValue as g, onStop as h, index as i, map as m, onMount as o };

package/dist/index-Brp888t0.d.ts

@@ -0,0 +1,127 @@
+import { Node } from '@graphrefly/pure-ts/core';
+
+/**
+ * A Nanostores-compatible atom.
+ *
+ * @category compat
+ */
+interface NanoAtom<T> {
+    /** Get current value. */
+    get(): T;
+    /** Set a new value (writable atoms only). */
+    set(value: T): void;
+    /** Subscribe to value changes. Callback receives the new value.
+     * Returns unsubscribe function. Called immediately with current value. */
+    subscribe(cb: (value: T) => void): () => void;
+    /** Listen to value changes (no immediate call). Returns unsubscribe. */
+    listen(cb: (value: T) => void): () => void;
+    /** The underlying GraphReFly node. */
+    readonly _node: Node<T>;
+}
+/**
+ * A Nanostores-compatible computed store.
+ *
+ * @category compat
+ */
+interface NanoComputed<T> {
+    /** Get current value. */
+    get(): T;
+    /** Subscribe to value changes. Called immediately with current value.
+     * Returns unsubscribe function. */
+    subscribe(cb: (value: T) => void): () => void;
+    /** Listen to value changes (no immediate call). Returns unsubscribe. */
+    listen(cb: (value: T) => void): () => void;
+    /** The underlying GraphReFly node. */
+    readonly _node: Node<T>;
+}
+/**
+ * A Nanostores-compatible map.
+ *
+ * @category compat
+ */
+interface NanoMap<T extends Record<string, unknown>> extends NanoAtom<T> {
+    /** Set a single key. */
+    setKey<K extends keyof T>(key: K, value: T[K]): void;
+}
+/**
+ * Creates a nanostores-compatible atom.
+ *
+ * @param initial - Initial value.
+ * @returns `NanoAtom<T>`
+ *
+ * @category compat
+ */
+declare function atom<T>(initial: T): NanoAtom<T>;
+/**
+ * Creates a nanostores-compatible computed store.
+ *
+ * @param stores - One or more atoms/computed stores.
+ * @param fn - Compute function.
+ * @returns `NanoComputed<T>`
+ *
+ * @category compat
+ */
+declare function computed<T, A>(storeA: NanoAtom<A> | NanoComputed<A>, fn: (a: A) => T): NanoComputed<T>;
+declare function computed<T, A, B>(stores: [NanoAtom<A> | NanoComputed<A>, NanoAtom<B> | NanoComputed<B>], fn: (a: A, b: B) => T): NanoComputed<T>;
+declare function computed<T, A, B, C>(stores: [
+    NanoAtom<A> | NanoComputed<A>,
+    NanoAtom<B> | NanoComputed<B>,
+    NanoAtom<C> | NanoComputed<C>
+], fn: (a: A, b: B, c: C) => T): NanoComputed<T>;
+/**
+ * Creates a nanostores-compatible map.
+ *
+ * @param initial - Initial object value.
+ * @returns `NanoMap<T>`
+ *
+ * @category compat
+ */
+declare function map<T extends Record<string, unknown>>(initial: T): NanoMap<T>;
+/**
+ * Returns the current value of the store.
+ *
+ * @category compat
+ */
+declare function getValue<T>(store: NanoAtom<T> | NanoComputed<T>): T;
+/**
+ * Adds a listener for the store start (first listener connected).
+ *
+ * @category compat
+ */
+declare function onStart(store: NanoAtom<any> | NanoComputed<any>, cb: () => void): void;
+/**
+ * Adds a listener for the store stop (last listener disconnected).
+ *
+ * @category compat
+ */
+declare function onStop(store: NanoAtom<any> | NanoComputed<any>, cb: () => void): void;
+/**
+ * Adds a listener for the store mount (first listener connected).
+ *
+ * @returns A cleanup function called when the last listener is removed.
+ * @category compat
+ */
+declare function onMount(store: NanoAtom<any> | NanoComputed<any>, cb: () => (() => void) | undefined): void;
+/**
+ * Batches multiple store updates.
+ *
+ * @category compat
+ */
+declare function action<Args extends any[], Return>(_store: NanoAtom<any> | NanoComputed<any>, _name: string, fn: (...args: Args) => Return): (...args: Args) => Return;
+
+type index_NanoAtom<T> = NanoAtom<T>;
+type index_NanoComputed<T> = NanoComputed<T>;
+type index_NanoMap<T extends Record<string, unknown>> = NanoMap<T>;
+declare const index_action: typeof action;
+declare const index_atom: typeof atom;
+declare const index_computed: typeof computed;
+declare const index_getValue: typeof getValue;
+declare const index_map: typeof map;
+declare const index_onMount: typeof onMount;
+declare const index_onStart: typeof onStart;
+declare const index_onStop: typeof onStop;
+declare namespace index {
+  export { type index_NanoAtom as NanoAtom, type index_NanoComputed as NanoComputed, type index_NanoMap as NanoMap, index_action as action, index_atom as atom, index_computed as computed, index_getValue as getValue, index_map as map, index_onMount as onMount, index_onStart as onStart, index_onStop as onStop };
+}
+
+export { type NanoAtom as N, type NanoComputed as a, type NanoMap as b, action as c, atom as d, computed as e, onStart as f, getValue as g, onStop as h, index as i, map as m, onMount as o };

package/dist/index-CDfk6jHN.d.cts

@@ -0,0 +1,37 @@
+import { Graph } from '@graphrefly/pure-ts/graph';
+
+/** Zustand-compatible Store API. */
+interface StoreApi<T> {
+    getState: () => T;
+    setState: (partial: T | Partial<T> | ((state: T) => T | Partial<T>), replace?: boolean) => void;
+    getInitialState: () => T;
+    subscribe: (listener: (state: T, prevState: T) => void) => () => void;
+    destroy: () => void;
+}
+/** Function type for initializing the store. */
+type StateCreator<T> = (set: StoreApi<T>["setState"], get: StoreApi<T>["getState"], api: StoreApi<T>) => T;
+/**
+ * Creates a Zustand-compatible store backed by a GraphReFly state node.
+ * returns an object that is both a Graph and a StoreApi.
+ *
+ * @example
+ * ```ts
+ * const store = create((set) => ({
+ *   count: 0,
+ *   inc: () => set((s) => ({ count: s.count + 1 }))
+ * }));
+ * store.getState().inc();
+ * ```
+ *
+ * @category compat
+ */
+declare function create<T extends object>(initializer: StateCreator<T>): Graph & StoreApi<T>;
+
+type index_StateCreator<T> = StateCreator<T>;
+type index_StoreApi<T> = StoreApi<T>;
+declare const index_create: typeof create;
+declare namespace index {
+  export { type index_StateCreator as StateCreator, type index_StoreApi as StoreApi, index_create as create };
+}
+
+export { type StateCreator as S, type StoreApi as a, create as c, index as i };

package/dist/index-CDfk6jHN.d.ts

@@ -0,0 +1,37 @@
+import { Graph } from '@graphrefly/pure-ts/graph';
+
+/** Zustand-compatible Store API. */
+interface StoreApi<T> {
+    getState: () => T;
+    setState: (partial: T | Partial<T> | ((state: T) => T | Partial<T>), replace?: boolean) => void;
+    getInitialState: () => T;
+    subscribe: (listener: (state: T, prevState: T) => void) => () => void;
+    destroy: () => void;
+}
+/** Function type for initializing the store. */
+type StateCreator<T> = (set: StoreApi<T>["setState"], get: StoreApi<T>["getState"], api: StoreApi<T>) => T;
+/**
+ * Creates a Zustand-compatible store backed by a GraphReFly state node.
+ * returns an object that is both a Graph and a StoreApi.
+ *
+ * @example
+ * ```ts
+ * const store = create((set) => ({
+ *   count: 0,
+ *   inc: () => set((s) => ({ count: s.count + 1 }))
+ * }));
+ * store.getState().inc();
+ * ```
+ *
+ * @category compat
+ */
+declare function create<T extends object>(initializer: StateCreator<T>): Graph & StoreApi<T>;
+
+type index_StateCreator<T> = StateCreator<T>;
+type index_StoreApi<T> = StoreApi<T>;
+declare const index_create: typeof create;
+declare namespace index {
+  export { type index_StateCreator as StateCreator, type index_StoreApi as StoreApi, index_create as create };
+}
+
+export { type StateCreator as S, type StoreApi as a, create as c, index as i };

package/dist/index-DLAxYaN5.d.cts

@@ -0,0 +1,169 @@
+import { Node } from '@graphrefly/pure-ts/core';
+import { Graph } from '@graphrefly/pure-ts/graph';
+
+/**
+ * DS-14.6.A U-A — tagged context substrate (Phase 14.5).
+ *
+ * Per-view tagged context (SESSION-DS-14.6-A L3–L6 + SESSION-DS-14.6-A-9Q
+ * implementation walk). Pool stores immutable tier-0 originals on an
+ * **append-only `reactiveLog`** (D-A4 — structural tier-0 immutability, free
+ * `LogChange` mutations, side-steps the DS14R1 TTL/LRU prune-fidelity bug).
+ * Each consumer holds a `ContextView` that materialises its own filtered +
+ * compressed slice (`Node<readonly RenderedEntry[]>`). Routing is mechanical
+ * tag comparison (zero LLM); only `llm-summary` rules cross to an injected
+ * `llmCompress` (D-A3). Compression cache is one shared `(id, tier)` map in
+ * the pool bundle, bounded LRU (D-A5). Schema is pure data, presentation
+ * layer (D-A1) — no `@graphrefly/pure-ts` consumer.
+ *
+ * @module
+ */
+
+type Tag = string;
+/** Compression tier. 0 = original; higher = more compressed. */
+type Tier = 0 | 1 | 2 | 3;
+interface ContextEntry<T> {
+    /** Stable id — cache key component `(id, tier)`. Auto-assigned if omitted. */
+    readonly id: string;
+    readonly payload: T;
+    readonly tags: readonly Tag[];
+    /** 0..1. Budget/GC ordering. */
+    readonly importance: number;
+    readonly compressible: boolean;
+    readonly topic: string;
+    /** Wall-clock at add (ns) — used by `poolGC({ olderThanNs })`. */
+    readonly t_ns: number;
+}
+interface RuleMatch {
+    readonly topic?: string | RegExp;
+    readonly tagsAny?: readonly Tag[];
+    readonly importanceMin?: number;
+    readonly importanceMax?: number;
+    readonly compressible?: boolean;
+}
+type CompressionRule = {
+    readonly match: RuleMatch;
+    readonly action: "evict";
+} | {
+    readonly match: RuleMatch;
+    readonly action: "truncate";
+    readonly maxChars: number;
+} | {
+    readonly match: RuleMatch;
+    readonly action: "reference";
+} | {
+    readonly match: RuleMatch;
+    readonly action: "llm-summary";
+    readonly toTier: Tier;
+};
+interface RenderedEntry<T> {
+    readonly id: string;
+    readonly topic: string;
+    readonly tags: readonly Tag[];
+    readonly tier: Tier;
+    /** Original payload at tier 0; compressed `string` otherwise. */
+    readonly payload: T | string;
+    readonly compressed: boolean;
+}
+interface ContextView<T> {
+    readonly filter: (e: ContextEntry<T>) => boolean;
+    /** 0..1. A rule fires when `pressure > 0` and the entry matches. */
+    readonly pressure: Node<number>;
+    readonly budgetTokens: number;
+    readonly rules: readonly CompressionRule[];
+    /** Default `s => Math.ceil(s.length / 4)`. */
+    readonly tokenizer?: (s: string) => number;
+}
+interface PoolGCPolicy {
+    /** Drop entries with `t_ns < (now - olderThanNs)`. */
+    readonly olderThanNs?: number;
+    /** Drop entries with `importance < importanceBelow`. */
+    readonly importanceBelow?: number;
+    /**
+     * **Scope**, not a match-to-evict rule: when set, GC only considers
+     * entries whose `topic === this`; entries of other topics always survive.
+     * `olderThanNs` / `importanceBelow` are ANDed *within* this scope.
+     */
+    readonly topic?: string;
+    /** Keep at most this many most-recent entries. */
+    readonly max?: number;
+}
+/** `(entry, toTier) => compressedText`. Injected; required iff a view uses `llm-summary`. */
+type LlmCompress<T> = (entry: ContextEntry<T>, toTier: Tier) => string;
+interface TaggedContextPoolOptions<T> {
+    readonly topic: string;
+    /** Forwarded to the backing append-only `reactiveLog` (poolGC ceiling). */
+    readonly maxEntries?: number;
+    /** Required iff any rendered view uses an `llm-summary` rule (D-A3). */
+    readonly llmCompress?: LlmCompress<T>;
+    /** Shared `(id, tier)` compression cache cap (D-A5). Default 512. */
+    readonly cacheMax?: number;
+    readonly name?: string;
+}
+interface TaggedContextPoolBundle<T> {
+    /**
+     * Append an entry (immutable tier-0). Returns its id (auto-assigned
+     * `ctx-N` per-pool if omitted).
+     *
+     * **Caller-supplied ids must be unique within the pool.** The log is
+     * append-only and does NOT dedupe; the compression cache is keyed by
+     * `(id, tier)`, so appending two different entries with the same explicit
+     * `id` makes the second render the first's cached summary (QA P11).
+     */
+    add(entry: Omit<ContextEntry<T>, "id" | "t_ns"> & {
+        id?: string;
+    }): string;
+    /** All live tier-0 entries. */
+    readonly entries: Node<readonly ContextEntry<T>[]>;
+    /** Entries carrying `tag`. */
+    byTag(tag: Tag): Node<readonly ContextEntry<T>[]>;
+    /** Pool-global retention (L6 — distinct from per-view filtering). Returns removed count. */
+    poolGC(policy: PoolGCPolicy): number;
+    readonly graph: Graph;
+    /** Internal — shared compression cache (one per pool, D-A5). */
+    readonly _cache: CompressionCache;
+    readonly _opts: TaggedContextPoolOptions<T>;
+    dispose(): void;
+}
+/**
+ * Bounded LRU cache keyed by `(id, tier)`. Uses a nested `Map<id, Map<tier,
+ * value>>` (NOT a `${id}::${tier}` string key) so a caller-supplied `id`
+ * containing the separator cannot collide (QA P5). LRU is tracked at the
+ * (id,tier) leaf via a flat insertion-order key list.
+ */
+declare class CompressionCache {
+    private readonly _max;
+    private readonly _m;
+    /** Insertion-order list of `id` keys for LRU eviction at the id granularity. */
+    private readonly _order;
+    constructor(_max: number);
+    get(id: string, tier: Tier): string | undefined;
+    set(id: string, tier: Tier, value: string): void;
+}
+/**
+ * Append-only tagged context pool (D-A4). The pool is a `reactiveLog` of
+ * immutable tier-0 entries plus a derived `entries` node; `byTag` derives a
+ * filtered view; `poolGC` is the explicit pool-global retention (L6).
+ */
+declare function taggedContextPool<T>(parent: Graph, opts: TaggedContextPoolOptions<T>): TaggedContextPoolBundle<T>;
+/**
+ * Apply the first matching rule to one entry under `pressure`. Non-LLM
+ * strategies (truncate / evict / reference) are pure data; `llm-summary`
+ * calls the injected `llmCompress`, caching by `(id, toTier)` (D-A5).
+ * Returns `undefined` for evicted / pressure-filtered entries.
+ */
+declare function tierCompress<T>(e: ContextEntry<T>, rules: readonly CompressionRule[], pressure: number, cache: CompressionCache, llmCompress?: LlmCompress<T>): RenderedEntry<T> | undefined;
+/**
+ * Per-consumer reactive rendering (D-A2). Materialises a
+ * `Node<readonly RenderedEntry[]>` over the pool: filter → per-entry rule
+ * application under `pressure` → token-budget trim (lowest-importance first).
+ *
+ * Recomputes the slice per `(entries | pressure)` wave (O(n) — behaviourally
+ * identical to the incremental closure-mirror; incremental is a perf
+ * follow-up, not a correctness gap).
+ *
+ * @throws if any rule is `llm-summary` and the pool has no `llmCompress`
+ *   (D-A3 construction guard).
+ */
+declare function renderContextView<T>(pool: TaggedContextPoolBundle<T>, view: ContextView<T>): Node<readonly RenderedEntry<T>[]>;
+
+export { CompressionCache as C, type LlmCompress as L, type PoolGCPolicy as P, type RenderedEntry as R, type Tag as T, type CompressionRule as a, type ContextEntry as b, type ContextView as c, type RuleMatch as d, type TaggedContextPoolBundle as e, type TaggedContextPoolOptions as f, type Tier as g, tierCompress as h, renderContextView as r, taggedContextPool as t };