@graphrefly/graphrefly 0.43.0 → 0.45.0

package/dist/reactive-map-48mnZ-nu.d.cts

@@ -1,296 +0,0 @@
-import { N as Node, V as VersioningLevel, a as NodeOptions } from './node-ClS5yC-B.cjs';
-
-type ReactiveMapOptions<K, V> = {
-    /** Optional registry name for `describe()` / debugging. */
-    name?: string;
-    /**
-     * LRU cap. When set, evicts least-recently-used keys after inserts that exceed this size.
-     * Forwarded to the default `NativeMapBackend`. Ignored if a custom `backend` is provided.
-     *
-     * **Mutually exclusive with `retention`** — the LRU cap is "youngest-access wins,"
-     * score-based retention is "highest-score wins." Configuring both would make
-     * eviction nondeterministic; construction throws if both are set.
-     */
-    maxSize?: number;
-    /**
-     * Default TTL in seconds. Used when `set`/`setMany` omits per-call `ttl`.
-     * Forwarded to the default `NativeMapBackend`. Ignored if a custom `backend` is provided.
-     */
-    defaultTtl?: number;
-    /**
-     * Storage backend. Defaults to `NativeMapBackend`. Users can plug in persistent
-     * (HAMT / Immutable.js) or shared-state backends via the {@link MapBackend} interface.
-     */
-    backend?: MapBackend<K, V>;
-    /**
-     * Optional versioning level for the underlying `entries` state node. Set at
-     * construction time; cannot be changed later. Pass `0` for V0 identity +
-     * monotonic version counter, or `1` for V1 + content-addressed cid.
-     */
-    versioning?: VersioningLevel;
-    /**
-     * Score-based retention policy. After every mutation, each live entry is
-     * scored; entries below `archiveThreshold` and / or over `maxSize` (lowest-
-     * scored first) are archived via `onArchive` before being removed.
-     *
-     * Retention replaces the ad-hoc "tierClassifier effect writing back to its
-     * own store dep" pattern — the feedback cycle is gone because archival is
-     * part of the atomic mutation, not a second reactive wave.
-     *
-     * Mutually exclusive with top-level `maxSize` (LRU). Pass one or the other.
-     */
-    retention?: ReactiveMapRetention<K, V>;
-} & Omit<NodeOptions, "initial" | "describeKind" | "equals" | "versioning">;
-/**
- * Score-based retention policy for {@link reactiveMap}. Evaluated synchronously
- * on every successful mutation (`set` / `setMany` / `delete` / `clear` /
- * `pruneExpired`). Entries are archived in ascending score order until the
- * map satisfies both constraints:
- *
- * 1. Every remaining entry has `score >= archiveThreshold` (if set).
- * 2. Total entry count `<= maxSize` (if set).
- *
- * At least one of `archiveThreshold` / `maxSize` must be set; otherwise there's
- * no eviction trigger.
- *
- * **Archival order.** When multiple entries are candidates for archival in the
- * same mutation, they are archived in ascending score order (lowest first). On
- * score ties, iteration order (insertion order in the default backend) is the
- * tiebreak.
- *
- * **No recursion.** Archival deletes happen on the backend directly — they do
- * NOT re-enter the retention evaluator. The one-pass scan collects archival
- * candidates against the post-mutation snapshot before removing them.
- *
- * @category extra
- */
-type ReactiveMapRetention<K, V> = {
-    /** Score entry — higher is kept. Should be a pure function of `(key, value)`. */
-    score: (key: K, value: V) => number;
-    /** Below-threshold entries are archived. Omit for pure `maxSize`-based retention. */
-    archiveThreshold?: number;
-    /**
-     * Cap on live entry count. Over this, the lowest-scored entries are
-     * archived until the size fits. Omit for pure threshold-based retention.
-     */
-    maxSize?: number;
-    /**
-     * Synchronous callback fired **before** archival deletion. Receives the
-     * key, value, and computed score. Callers typically persist the entry to
-     * a cold tier here (`await permanent.set(key, value)` — async is fine but
-     * the archival deletion happens synchronously after this callback
-     * returns).
-     */
-    onArchive?: (key: K, value: V, score: number) => void;
-};
-type ReactiveMapBundle<K, V> = {
-    /** Emits `ReadonlyMap<K, V>` on each structural change (two-phase). */
-    entries: Node<ReadonlyMap<K, V>>;
-    /**
-     * Checks existence. O(1) for live keys. If the key is expired, prunes it AND
-     * emits a snapshot so the reactive surface stays consistent with the return
-     * value. Reads on expired keys are therefore **observable side effects**.
-     *
-     * **LRU touch (F4):** When `maxSize` is configured, a live-key `has` also
-     * marks the entry as most-recently-used — which rearranges internal insertion
-     * order without bumping `version` or emitting. If you care about iteration
-     * order in a downstream subscriber, rely on the `entries` snapshot (a fresh
-     * `ReadonlyMap` per mutation) rather than iterating the backend directly.
-     */
-    has: (key: K) => boolean;
-    /**
-     * Gets value. O(1) for live keys. If the key is expired, prunes it AND emits
-     * a snapshot. Reads on expired keys are therefore **observable side effects**.
-     *
-     * **LRU touch (F4):** When `maxSize` is configured, a live-key `get` also
-     * marks the entry as most-recently-used (no version bump, no emission). See
-     * `has` for the full note on iteration order.
-     */
-    get: (key: K) => V | undefined;
-    /**
-     * Sets value with optional TTL (seconds). Throws on `ttl <= 0`. Applies LRU eviction
-     * if `maxSize` is set. Always emits.
-     */
-    set: (key: K, value: V, opts?: {
-        ttl?: number;
-    }) => void;
-    /**
-     * Bulk set — emits one snapshot for the whole batch. Applies `opts.ttl` (falls back
-     * to `defaultTtl`) to every entry. No-op if `entries` is empty.
-     *
-     * **Iterable consumption:** Consumes `entries` once (single-pass). Pass an array
-     * or `Set` for multi-shot consumers. If the iterator throws mid-iteration,
-     * entries already applied remain committed and a snapshot IS emitted (via the
-     * wrapper's finally-block).
-     */
-    setMany: (entries: Iterable<readonly [K, V]>, opts?: {
-        ttl?: number;
-    }) => void;
-    delete: (key: K) => void;
-    /**
-     * Bulk delete — emits one snapshot. No-op if no keys were present.
-     *
-     * **Iterable consumption:** Consumes `keys` once (single-pass).
-     */
-    deleteMany: (keys: Iterable<K>) => void;
-    clear: () => void;
-    /**
-     * Current entry count — O(1), **pure read** (no emission). May include
-     * expired entries on TTL maps until a mutation or explicit
-     * `pruneExpired()` / `has(key)` / `get(key)` prunes them. Call
-     * `pruneExpired()` first if you need a live count.
-     */
-    readonly size: number;
-    /** Explicitly prunes all expired entries. Emits if any were removed. */
-    pruneExpired: () => void;
-    /**
-     * Releases any internal keepalive subscriptions so the bundle can be
-     * GC'd. `reactiveMap` currently holds none (the `entries` node lives only
-     * as long as external subscribers keep it alive), so `dispose()` is a
-     * no-op today — exposed for API parity with `reactiveIndex.dispose` /
-     * `reactiveList.dispose` / `reactiveLog.dispose`. Idempotent. D6(a).
-     */
-    dispose: () => void;
-};
-/**
- * Storage contract for {@link reactiveMap}. Implementations own the mutable state,
- * including optional TTL and LRU semantics, and expose a monotonic `version` counter
- * that increments on every change to visible state.
- *
- * The reactive layer reads `version` before and after each backend call; when it
- * advances, a snapshot is emitted. Reads (`has`, `get`) may internally prune the
- * target key if expired and advance `version` — in which case the layer emits so
- * subscribers see state consistent with the read's return value.
- *
- * @remarks Post-1.0 op-log changesets will extend this interface with a
- * `changesSince(version: number): Iterable<Change>` method. Current consumers
- * should treat all methods here as stable.
- *
- * @category extra
- */
-interface MapBackend<K, V> {
-    /** Monotonic mutation counter; increments on every visible state change. */
-    readonly version: number;
-    /** Raw entry count (may include expired entries until a read / prune removes them). */
-    readonly size: number;
-    /** Checks existence. May prune target key if expired; advances `version` if pruned. */
-    has(key: K): boolean;
-    /** Gets value. May prune target key if expired; advances `version` if pruned. */
-    get(key: K): V | undefined;
-    /**
-     * Sets a value with optional TTL (seconds). Throws `RangeError` if `ttl <= 0`.
-     * Applies LRU eviction if `maxSize` is configured. Advances `version`.
-     *
-     * **Atomicity contract:** Either fully succeeds or throws before any state
-     * change; `version` advances only on success.
-     */
-    set(key: K, value: V, ttl?: number): void;
-    /**
-     * Atomic bulk set. Pre-validates TTL once, then applies all entries. Advances
-     * `version` at most once (even for N entries). No-op if iterable is empty.
-     *
-     * **Consumes `entries` once** — pass an array if you want repeatability.
-     *
-     * **Atomicity contract:** TTL validation throws before any mutation. If the
-     * iterable itself throws mid-iteration, entries committed before the throw
-     * remain persisted AND `version` is bumped once (surfaced via finally) so
-     * the reactive wrapper emits a snapshot reflecting the partial state. "At
-     * most once" invariant is preserved.
-     */
-    setMany(entries: Iterable<readonly [K, V]>, ttl?: number): void;
-    /** Removes a key. Returns `true` if the key existed. Advances `version` only if true. */
-    delete(key: K): boolean;
-    /**
-     * Atomic bulk delete. Returns count removed. Advances `version` at most once
-     * (even for N keys). No-op if no keys were present. Consumes `keys` once.
-     */
-    deleteMany(keys: Iterable<K>): number;
-    /** Removes all entries. Returns count removed. Advances `version` only if non-zero. */
-    clear(): number;
-    /** Removes all expired entries. Returns count removed. Advances `version` only if non-zero. */
-    pruneExpired(): number;
-    /** Fresh snapshot of non-expired entries (does NOT mutate state). */
-    toMap(): ReadonlyMap<K, V>;
-}
-type NativeMapBackendOptions = {
-    maxSize?: number;
-    /** Default TTL in seconds. */
-    defaultTtl?: number;
-};
-/**
- * Default `Map<K, {value, expiresAt}>` backend with optional per-key TTL and LRU cap.
- *
- * **Complexity:**
- * - `has`, `get`, `delete`, `size`: O(1)
- * - `set`: O(1) amortized (LRU touch + eviction)
- * - `pruneExpired`, `toMap`: O(n)
- *
- * LRU order uses native `Map` insertion order. `get` / `has` on a live key "touches"
- * it by delete-then-reinsert (moving it to the end). This touch does NOT advance
- * `version` — it's an internal optimization; the externally visible snapshot
- * preserves iteration order as of the last mutation. **Note:** because touch
- * reorders the internal `_store` without emitting, an in-process consumer iterating
- * `_store` directly (custom subclasses) could observe changing order; external
- * subscribers only see `toMap()` snapshots which are defensively copied and stable.
- *
- * @category extra
- */
-declare class NativeMapBackend<K, V> implements MapBackend<K, V> {
-    private _version;
-    private readonly _store;
-    private readonly _maxSize?;
-    private readonly _defaultTtl?;
-    constructor(options?: NativeMapBackendOptions);
-    get version(): number;
-    get size(): number;
-    has(key: K): boolean;
-    get(key: K): V | undefined;
-    set(key: K, value: V, ttl?: number): void;
-    setMany(entries: Iterable<readonly [K, V]>, ttl?: number): void;
-    delete(key: K): boolean;
-    deleteMany(keys: Iterable<K>): number;
-    clear(): number;
-    pruneExpired(): number;
-    toMap(): ReadonlyMap<K, V>;
-    private _resolveExpiresAt;
-    private _isExpired;
-    private _touchLru;
-    private _evictLruWhileOver;
-}
-/**
- * Creates a reactive `Map` with optional per-key TTL and optional LRU max size.
- *
- * @param options - `name`, `maxSize`, `defaultTtl` (seconds), or custom `backend`.
- * @returns `ReactiveMapBundle` — imperative methods (`has`/`get`/`set`/`setMany`/`delete`/
- *   `deleteMany`/`clear`/`pruneExpired`), reactive `entries` node, and O(1)-ish `size`.
- *
- * @remarks
- * **TTL:** Expiry is checked on `get`, `has`, `size`, `pruneExpired`, and before each
- * snapshot emission (expired keys are pruned first). Reads that discover expired keys
- * emit a snapshot so subscribers see state consistent with the read's return value.
- * There is no background timer; monotonic-clock expiry is immune to wall-clock changes.
- *
- * **LRU:** Uses native `Map` insertion order — `get` / `has` refreshes position via
- * delete-then-reinsert; under `maxSize` pressure the first key in iteration order is
- * evicted. LRU touching does NOT trigger emission (internal optimization).
- *
- * **Backend:** The default {@link NativeMapBackend} owns LRU/TTL. For persistent /
- * HAMT / shared-state semantics plug in a custom {@link MapBackend}. `maxSize` and
- * `defaultTtl` on the options object are only applied to the default backend — if
- * you supply `backend`, configure those on your backend directly.
- *
- * @example
- * ```ts
- * import { reactiveMap } from "@graphrefly/graphrefly-ts";
- *
- * const m = reactiveMap<string, number>({ name: "cache", maxSize: 100, defaultTtl: 60 });
- * m.set("x", 1);
- * m.setMany([["y", 2], ["z", 3]]);
- * m.entries.subscribe((msgs) => { console.log(msgs); });
- * ```
- *
- * @category extra
- */
-declare function reactiveMap<K, V>(options?: ReactiveMapOptions<K, V>): ReactiveMapBundle<K, V>;
-
-export { type MapBackend as M, NativeMapBackend as N, type ReactiveMapBundle as R, type NativeMapBackendOptions as a, type ReactiveMapOptions as b, type ReactiveMapRetention as c, reactiveMap as r };

package/dist/reactive-map-BVVPdvmi.d.ts

@@ -1,296 +0,0 @@
-import { N as Node, V as VersioningLevel, a as NodeOptions } from './node-ClS5yC-B.js';
-
-type ReactiveMapOptions<K, V> = {
-    /** Optional registry name for `describe()` / debugging. */
-    name?: string;
-    /**
-     * LRU cap. When set, evicts least-recently-used keys after inserts that exceed this size.
-     * Forwarded to the default `NativeMapBackend`. Ignored if a custom `backend` is provided.
-     *
-     * **Mutually exclusive with `retention`** — the LRU cap is "youngest-access wins,"
-     * score-based retention is "highest-score wins." Configuring both would make
-     * eviction nondeterministic; construction throws if both are set.
-     */
-    maxSize?: number;
-    /**
-     * Default TTL in seconds. Used when `set`/`setMany` omits per-call `ttl`.
-     * Forwarded to the default `NativeMapBackend`. Ignored if a custom `backend` is provided.
-     */
-    defaultTtl?: number;
-    /**
-     * Storage backend. Defaults to `NativeMapBackend`. Users can plug in persistent
-     * (HAMT / Immutable.js) or shared-state backends via the {@link MapBackend} interface.
-     */
-    backend?: MapBackend<K, V>;
-    /**
-     * Optional versioning level for the underlying `entries` state node. Set at
-     * construction time; cannot be changed later. Pass `0` for V0 identity +
-     * monotonic version counter, or `1` for V1 + content-addressed cid.
-     */
-    versioning?: VersioningLevel;
-    /**
-     * Score-based retention policy. After every mutation, each live entry is
-     * scored; entries below `archiveThreshold` and / or over `maxSize` (lowest-
-     * scored first) are archived via `onArchive` before being removed.
-     *
-     * Retention replaces the ad-hoc "tierClassifier effect writing back to its
-     * own store dep" pattern — the feedback cycle is gone because archival is
-     * part of the atomic mutation, not a second reactive wave.
-     *
-     * Mutually exclusive with top-level `maxSize` (LRU). Pass one or the other.
-     */
-    retention?: ReactiveMapRetention<K, V>;
-} & Omit<NodeOptions, "initial" | "describeKind" | "equals" | "versioning">;
-/**
- * Score-based retention policy for {@link reactiveMap}. Evaluated synchronously
- * on every successful mutation (`set` / `setMany` / `delete` / `clear` /
- * `pruneExpired`). Entries are archived in ascending score order until the
- * map satisfies both constraints:
- *
- * 1. Every remaining entry has `score >= archiveThreshold` (if set).
- * 2. Total entry count `<= maxSize` (if set).
- *
- * At least one of `archiveThreshold` / `maxSize` must be set; otherwise there's
- * no eviction trigger.
- *
- * **Archival order.** When multiple entries are candidates for archival in the
- * same mutation, they are archived in ascending score order (lowest first). On
- * score ties, iteration order (insertion order in the default backend) is the
- * tiebreak.
- *
- * **No recursion.** Archival deletes happen on the backend directly — they do
- * NOT re-enter the retention evaluator. The one-pass scan collects archival
- * candidates against the post-mutation snapshot before removing them.
- *
- * @category extra
- */
-type ReactiveMapRetention<K, V> = {
-    /** Score entry — higher is kept. Should be a pure function of `(key, value)`. */
-    score: (key: K, value: V) => number;
-    /** Below-threshold entries are archived. Omit for pure `maxSize`-based retention. */
-    archiveThreshold?: number;
-    /**
-     * Cap on live entry count. Over this, the lowest-scored entries are
-     * archived until the size fits. Omit for pure threshold-based retention.
-     */
-    maxSize?: number;
-    /**
-     * Synchronous callback fired **before** archival deletion. Receives the
-     * key, value, and computed score. Callers typically persist the entry to
-     * a cold tier here (`await permanent.set(key, value)` — async is fine but
-     * the archival deletion happens synchronously after this callback
-     * returns).
-     */
-    onArchive?: (key: K, value: V, score: number) => void;
-};
-type ReactiveMapBundle<K, V> = {
-    /** Emits `ReadonlyMap<K, V>` on each structural change (two-phase). */
-    entries: Node<ReadonlyMap<K, V>>;
-    /**
-     * Checks existence. O(1) for live keys. If the key is expired, prunes it AND
-     * emits a snapshot so the reactive surface stays consistent with the return
-     * value. Reads on expired keys are therefore **observable side effects**.
-     *
-     * **LRU touch (F4):** When `maxSize` is configured, a live-key `has` also
-     * marks the entry as most-recently-used — which rearranges internal insertion
-     * order without bumping `version` or emitting. If you care about iteration
-     * order in a downstream subscriber, rely on the `entries` snapshot (a fresh
-     * `ReadonlyMap` per mutation) rather than iterating the backend directly.
-     */
-    has: (key: K) => boolean;
-    /**
-     * Gets value. O(1) for live keys. If the key is expired, prunes it AND emits
-     * a snapshot. Reads on expired keys are therefore **observable side effects**.
-     *
-     * **LRU touch (F4):** When `maxSize` is configured, a live-key `get` also
-     * marks the entry as most-recently-used (no version bump, no emission). See
-     * `has` for the full note on iteration order.
-     */
-    get: (key: K) => V | undefined;
-    /**
-     * Sets value with optional TTL (seconds). Throws on `ttl <= 0`. Applies LRU eviction
-     * if `maxSize` is set. Always emits.
-     */
-    set: (key: K, value: V, opts?: {
-        ttl?: number;
-    }) => void;
-    /**
-     * Bulk set — emits one snapshot for the whole batch. Applies `opts.ttl` (falls back
-     * to `defaultTtl`) to every entry. No-op if `entries` is empty.
-     *
-     * **Iterable consumption:** Consumes `entries` once (single-pass). Pass an array
-     * or `Set` for multi-shot consumers. If the iterator throws mid-iteration,
-     * entries already applied remain committed and a snapshot IS emitted (via the
-     * wrapper's finally-block).
-     */
-    setMany: (entries: Iterable<readonly [K, V]>, opts?: {
-        ttl?: number;
-    }) => void;
-    delete: (key: K) => void;
-    /**
-     * Bulk delete — emits one snapshot. No-op if no keys were present.
-     *
-     * **Iterable consumption:** Consumes `keys` once (single-pass).
-     */
-    deleteMany: (keys: Iterable<K>) => void;
-    clear: () => void;
-    /**
-     * Current entry count — O(1), **pure read** (no emission). May include
-     * expired entries on TTL maps until a mutation or explicit
-     * `pruneExpired()` / `has(key)` / `get(key)` prunes them. Call
-     * `pruneExpired()` first if you need a live count.
-     */
-    readonly size: number;
-    /** Explicitly prunes all expired entries. Emits if any were removed. */
-    pruneExpired: () => void;
-    /**
-     * Releases any internal keepalive subscriptions so the bundle can be
-     * GC'd. `reactiveMap` currently holds none (the `entries` node lives only
-     * as long as external subscribers keep it alive), so `dispose()` is a
-     * no-op today — exposed for API parity with `reactiveIndex.dispose` /
-     * `reactiveList.dispose` / `reactiveLog.dispose`. Idempotent. D6(a).
-     */
-    dispose: () => void;
-};
-/**
- * Storage contract for {@link reactiveMap}. Implementations own the mutable state,
- * including optional TTL and LRU semantics, and expose a monotonic `version` counter
- * that increments on every change to visible state.
- *
- * The reactive layer reads `version` before and after each backend call; when it
- * advances, a snapshot is emitted. Reads (`has`, `get`) may internally prune the
- * target key if expired and advance `version` — in which case the layer emits so
- * subscribers see state consistent with the read's return value.
- *
- * @remarks Post-1.0 op-log changesets will extend this interface with a
- * `changesSince(version: number): Iterable<Change>` method. Current consumers
- * should treat all methods here as stable.
- *
- * @category extra
- */
-interface MapBackend<K, V> {
-    /** Monotonic mutation counter; increments on every visible state change. */
-    readonly version: number;
-    /** Raw entry count (may include expired entries until a read / prune removes them). */
-    readonly size: number;
-    /** Checks existence. May prune target key if expired; advances `version` if pruned. */
-    has(key: K): boolean;
-    /** Gets value. May prune target key if expired; advances `version` if pruned. */
-    get(key: K): V | undefined;
-    /**
-     * Sets a value with optional TTL (seconds). Throws `RangeError` if `ttl <= 0`.
-     * Applies LRU eviction if `maxSize` is configured. Advances `version`.
-     *
-     * **Atomicity contract:** Either fully succeeds or throws before any state
-     * change; `version` advances only on success.
-     */
-    set(key: K, value: V, ttl?: number): void;
-    /**
-     * Atomic bulk set. Pre-validates TTL once, then applies all entries. Advances
-     * `version` at most once (even for N entries). No-op if iterable is empty.
-     *
-     * **Consumes `entries` once** — pass an array if you want repeatability.
-     *
-     * **Atomicity contract:** TTL validation throws before any mutation. If the
-     * iterable itself throws mid-iteration, entries committed before the throw
-     * remain persisted AND `version` is bumped once (surfaced via finally) so
-     * the reactive wrapper emits a snapshot reflecting the partial state. "At
-     * most once" invariant is preserved.
-     */
-    setMany(entries: Iterable<readonly [K, V]>, ttl?: number): void;
-    /** Removes a key. Returns `true` if the key existed. Advances `version` only if true. */
-    delete(key: K): boolean;
-    /**
-     * Atomic bulk delete. Returns count removed. Advances `version` at most once
-     * (even for N keys). No-op if no keys were present. Consumes `keys` once.
-     */
-    deleteMany(keys: Iterable<K>): number;
-    /** Removes all entries. Returns count removed. Advances `version` only if non-zero. */
-    clear(): number;
-    /** Removes all expired entries. Returns count removed. Advances `version` only if non-zero. */
-    pruneExpired(): number;
-    /** Fresh snapshot of non-expired entries (does NOT mutate state). */
-    toMap(): ReadonlyMap<K, V>;
-}
-type NativeMapBackendOptions = {
-    maxSize?: number;
-    /** Default TTL in seconds. */
-    defaultTtl?: number;
-};
-/**
- * Default `Map<K, {value, expiresAt}>` backend with optional per-key TTL and LRU cap.
- *
- * **Complexity:**
- * - `has`, `get`, `delete`, `size`: O(1)
- * - `set`: O(1) amortized (LRU touch + eviction)
- * - `pruneExpired`, `toMap`: O(n)
- *
- * LRU order uses native `Map` insertion order. `get` / `has` on a live key "touches"
- * it by delete-then-reinsert (moving it to the end). This touch does NOT advance
- * `version` — it's an internal optimization; the externally visible snapshot
- * preserves iteration order as of the last mutation. **Note:** because touch
- * reorders the internal `_store` without emitting, an in-process consumer iterating
- * `_store` directly (custom subclasses) could observe changing order; external
- * subscribers only see `toMap()` snapshots which are defensively copied and stable.
- *
- * @category extra
- */
-declare class NativeMapBackend<K, V> implements MapBackend<K, V> {
-    private _version;
-    private readonly _store;
-    private readonly _maxSize?;
-    private readonly _defaultTtl?;
-    constructor(options?: NativeMapBackendOptions);
-    get version(): number;
-    get size(): number;
-    has(key: K): boolean;
-    get(key: K): V | undefined;
-    set(key: K, value: V, ttl?: number): void;
-    setMany(entries: Iterable<readonly [K, V]>, ttl?: number): void;
-    delete(key: K): boolean;
-    deleteMany(keys: Iterable<K>): number;
-    clear(): number;
-    pruneExpired(): number;
-    toMap(): ReadonlyMap<K, V>;
-    private _resolveExpiresAt;
-    private _isExpired;
-    private _touchLru;
-    private _evictLruWhileOver;
-}
-/**
- * Creates a reactive `Map` with optional per-key TTL and optional LRU max size.
- *
- * @param options - `name`, `maxSize`, `defaultTtl` (seconds), or custom `backend`.
- * @returns `ReactiveMapBundle` — imperative methods (`has`/`get`/`set`/`setMany`/`delete`/
- *   `deleteMany`/`clear`/`pruneExpired`), reactive `entries` node, and O(1)-ish `size`.
- *
- * @remarks
- * **TTL:** Expiry is checked on `get`, `has`, `size`, `pruneExpired`, and before each
- * snapshot emission (expired keys are pruned first). Reads that discover expired keys
- * emit a snapshot so subscribers see state consistent with the read's return value.
- * There is no background timer; monotonic-clock expiry is immune to wall-clock changes.
- *
- * **LRU:** Uses native `Map` insertion order — `get` / `has` refreshes position via
- * delete-then-reinsert; under `maxSize` pressure the first key in iteration order is
- * evicted. LRU touching does NOT trigger emission (internal optimization).
- *
- * **Backend:** The default {@link NativeMapBackend} owns LRU/TTL. For persistent /
- * HAMT / shared-state semantics plug in a custom {@link MapBackend}. `maxSize` and
- * `defaultTtl` on the options object are only applied to the default backend — if
- * you supply `backend`, configure those on your backend directly.
- *
- * @example
- * ```ts
- * import { reactiveMap } from "@graphrefly/graphrefly-ts";
- *
- * const m = reactiveMap<string, number>({ name: "cache", maxSize: 100, defaultTtl: 60 });
- * m.set("x", 1);
- * m.setMany([["y", 2], ["z", 3]]);
- * m.entries.subscribe((msgs) => { console.log(msgs); });
- * ```
- *
- * @category extra
- */
-declare function reactiveMap<K, V>(options?: ReactiveMapOptions<K, V>): ReactiveMapBundle<K, V>;
-
-export { type MapBackend as M, NativeMapBackend as N, type ReactiveMapBundle as R, type NativeMapBackendOptions as a, type ReactiveMapOptions as b, type ReactiveMapRetention as c, reactiveMap as r };

package/dist/resilience-YIWPK4YC.js

@@ -1 +0,0 @@
-import{a,b,c,d,e,f,g,h,i,j,k,l,m,n}from"./chunk-VNC3TMVY.js";import"./chunk-L6NSJVJZ.js";import"./chunk-KVV66NN2.js";import"./chunk-3G5U5QNE.js";import"./chunk-C72GO4IZ.js";import"./chunk-626TESAC.js";import"./chunk-ESMPEKEV.js";import"./chunk-VOPGGIL7.js";import"./chunk-4VVTGLXJ.js";import"./chunk-35JTVPOX.js";import"./chunk-V5A7M7RJ.js";import"./chunk-LYCLF26R.js";import"./chunk-CK2E7BTU.js";import"./chunk-QYADASLV.js";export{e as CircuitOpenError,i as RateLimiterOverflowError,b as ResilientPipelineGraph,l as TimeoutError,a as budgetGate,f as circuitBreaker,m as fallback,j as rateLimiter,c as resilientPipeline,d as retry,n as timeout,h as tokenBucket,g as withBreaker,k as withStatus};