@oobe-protocol-labs/synapse-client-sdk 1.0.7 → 1.2.0

package/dist/cjs/context/refs.d.ts

@@ -0,0 +1,491 @@
+/**
+ * Memory-safe service references — ref counting, leak detection, WeakRef sharing.
+ *
+ * ## Why refs?
+ *
+ * In an SDK, memory management is critical. Raw `resolve()` returns
+ * a direct reference with no tracking. `acquireRef()` returns a
+ * `ServiceRef<T>` that:
+ *
+ * 1. **Tracks** how many components hold the service (ref counting)
+ * 2. **Invalidates** automatically when the context is disposed
+ * 3. **Detects leaks** via `FinalizationRegistry` (if a ref is GC'd without release)
+ * 4. **Supports RAII** via `use()` / `useAsync()` / `withRef()`
+ *
+ * ## Architecture
+ *
+ * ```
+ * ┌──────────────────────────────────────────────────────────┐
+ * │ Component A                   Component B                │
+ * │  acquireRef(RPC) ──┐    ┌── acquireRef(RPC)              │
+ * │    ServiceRef #1   │    │    ServiceRef #2                │
+ * │     refCount: 2    ▼    ▼    refCount: 2                 │
+ * │               ┌──────────┐                               │
+ * │               │ Registry │  ← FinalizationRegistry       │
+ * │               │  RPC → 2 │     (leak detection)          │
+ * │               └────┬─────┘                               │
+ * │                    │                                      │
+ * │               ┌────▼─────┐                               │
+ * │               │ Singleton│  (one instance, N refs)        │
+ * │               │  RPC svc │                               │
+ * │               └──────────┘                               │
+ * │                                                          │
+ * │ A.release() → refCount: 1 │ B.release() → refCount: 0   │
+ * └──────────────────────────────────────────────────────────┘
+ * ```
+ *
+ * ## Component sharing pattern
+ *
+ * ```ts
+ * // Component A — acquires a tracked reference
+ * const rpcRef = ctx.acquireRef(Tokens.RPC);
+ * const balance = await rpcRef.current.getBalance(pubkey);
+ *
+ * // Component B — acquires its own tracked ref to the SAME instance
+ * const rpcRef2 = ctx.acquireRef(Tokens.RPC);
+ * const slot = await rpcRef2.current.getSlot();
+ *
+ * // Both hold the SAME singleton — ref count is 2
+ * ctx.refCount(Tokens.RPC); // → 2
+ *
+ * // Component A unmounts
+ * rpcRef.release();         // ref count → 1
+ *
+ * // Component B unmounts
+ * rpcRef2.release();        // ref count → 0
+ * ```
+ *
+ * ## RAII pattern (auto-release)
+ *
+ * ```ts
+ * // Sync — ref released in finally block
+ * const balance = withRef(ctx, Tokens.RPC, rpc => rpc.getBalance(pubkey));
+ *
+ * // Async — ref released after await completes
+ * const slot = await withRefAsync(ctx, Tokens.RPC, rpc => rpc.getSlot());
+ *
+ * // On the ref itself
+ * const result = ref.use(rpc => rpc.getBalance(pubkey));
+ * ```
+ *
+ * @module context/refs
+ * @since 1.2.0
+ */
+import { SynapseError } from '../core/errors';
+import type { ServiceToken, Disposable } from './types';
+/**
+ * Thrown when accessing `.current` on a released or invalidated reference.
+ * @since 1.2.0
+ */
+export declare class RefReleasedError extends SynapseError {
+    constructor(tokenName: string);
+}
+/**
+ * Leak report entry — one per ref that was GC'd without release
+ * or that has exceeded the maximum age threshold.
+ * @since 1.2.0
+ */
+export interface LeakReport {
+    /** Name of the service token. */
+    tokenName: string;
+    /** Unique ID of the leaked ref. */
+    refId: number;
+    /** `performance.now()` when the ref was acquired. */
+    acquiredAt: number;
+    /** `performance.now()` when the leak was detected. */
+    detectedAt: number;
+}
+/**
+ * Aggregate statistics from the {@link RefRegistry}.
+ * @since 1.2.0
+ */
+export interface RefStats {
+    /** Total refs acquired since creation. */
+    totalAcquired: number;
+    /** Total refs released since creation. */
+    totalReleased: number;
+    /** Currently active (unreleased) refs. */
+    active: number;
+    /** Peak concurrent active refs. */
+    peak: number;
+    /** Refs detected as leaked (GC'd without release). */
+    leaked: number;
+    /** Active ref count per token name. */
+    byToken: Record<string, number>;
+}
+/**
+ * Configuration for the {@link RefRegistry}.
+ * @since 1.2.0
+ */
+export interface RefRegistryConfig {
+    /**
+     * Enable FinalizationRegistry-based leak detection.
+     * Falls back to disabled if the runtime doesn't support it.
+     * @default true
+     */
+    enableLeakDetection?: boolean;
+}
+/**
+ * Configuration for the {@link MemoryGuard}.
+ * @since 1.2.0
+ */
+export interface MemoryGuardConfig {
+    /**
+     * Max age in ms before a ref is considered a potential leak.
+     * Used by `checkLeaks()`.
+     * @default 60000
+     */
+    maxRefAgeMs?: number;
+    /**
+     * Max total active refs before emitting a pressure warning.
+     * @default 100
+     */
+    maxActiveRefs?: number;
+    /**
+     * Interval in ms for automatic leak checks. `0` = disabled.
+     * The timer is `unref()`'d so it won't keep the process alive.
+     * @default 0
+     */
+    checkIntervalMs?: number;
+}
+/**
+ * A tracked, ref-counted reference to a resolved service.
+ *
+ * Provides memory-safe access: accessing `.current` after `.release()`
+ * throws {@link RefReleasedError} instead of returning a stale value.
+ *
+ * @typeParam T - The service type.
+ * @since 1.2.0
+ *
+ * @example
+ * ```ts
+ * const rpcRef = ctx.acquireRef(Tokens.RPC);
+ *
+ * // Use the service
+ * const balance = await rpcRef.current.getBalance(pubkey);
+ *
+ * // Release when done (e.g. on unmount)
+ * rpcRef.release();
+ *
+ * // Accessing after release throws
+ * rpcRef.current; // ❌ RefReleasedError
+ * ```
+ */
+export declare class ServiceRef<T> implements Disposable {
+    private readonly _value;
+    private readonly _token;
+    private readonly _onRelease;
+    /** Unique reference ID (monotonically increasing within a registry). */
+    readonly id: number;
+    private _released;
+    private readonly _acquiredAt;
+    /**
+     * @internal Use `ctx.acquireRef(token)` or `RefRegistry.acquire()` to create refs.
+     */
+    constructor(_value: T, _token: ServiceToken<T>, _onRelease: (ref: ServiceRef<T>) => void, 
+    /** Unique reference ID (monotonically increasing within a registry). */
+    id: number);
+    /**
+     * The resolved service instance.
+     *
+     * @throws {RefReleasedError} If the ref has been released or invalidated.
+     */
+    get current(): T;
+    /** Whether this reference is still valid (not released). */
+    get alive(): boolean;
+    /** The token this ref was acquired for. */
+    get token(): ServiceToken<T>;
+    /** `performance.now()` timestamp when this ref was acquired. */
+    get acquiredAt(): number;
+    /** How long this ref has been alive, in ms. */
+    get ageMs(): number;
+    /**
+     * Release this reference, decrementing the ref count.
+     *
+     * After release:
+     * - `.current` throws {@link RefReleasedError}
+     * - `.alive` returns `false`
+     * - The ref count for this token decreases by 1
+     *
+     * Safe to call multiple times (idempotent).
+     */
+    release(): void;
+    /** Alias for {@link release}. Implements {@link Disposable}. */
+    dispose(): void;
+    /**
+     * Execute a function with this reference, auto-releasing afterward.
+     *
+     * The ref is released in a `finally` block, guaranteeing cleanup
+     * even if the function throws.
+     *
+     * @param fn - Receives the unwrapped service value.
+     * @returns The return value of `fn`.
+     *
+     * @example
+     * ```ts
+     * const balance = rpcRef.use(rpc => rpc.getBalance(pubkey));
+     * // rpcRef is now released — no leak possible
+     * ```
+     */
+    use<R>(fn: (service: T) => R): R;
+    /**
+     * Async version of {@link use}. Awaits the function, then releases.
+     *
+     * @example
+     * ```ts
+     * const balance = await rpcRef.useAsync(rpc => rpc.getBalance(pubkey));
+     * ```
+     */
+    useAsync<R>(fn: (service: T) => Promise<R>): Promise<R>;
+    /**
+     * Create a weak reference that does **not** prevent garbage collection.
+     *
+     * The returned `WeakServiceRef` can be shared to components that
+     * only need the service optionally — if the strong refs are all
+     * released and the GC collects the object, `.deref()` returns
+     * `undefined` instead of throwing.
+     *
+     * @throws {SynapseError} If the service value is a primitive (not weakly referenceable).
+     *
+     * @example
+     * ```ts
+     * const weakRpc = rpcRef.toWeak();
+     * // Later:
+     * const rpc = weakRpc.deref();
+     * if (rpc) rpc.getBalance(pubkey);
+     * ```
+     */
+    toWeak(): WeakServiceRef<T & object>;
+}
+/**
+ * A non-preventing (weak) reference to a service.
+ *
+ * Unlike {@link ServiceRef}, this does **not** keep the service alive
+ * in memory. The garbage collector can collect the underlying object
+ * even while this ref exists. Use `.deref()` to check if the service
+ * is still available.
+ *
+ * @typeParam T - The service type (must be an object).
+ * @since 1.2.0
+ *
+ * @example
+ * ```ts
+ * const weakRpc = strongRef.toWeak();
+ *
+ * // In another component — check before use
+ * const rpc = weakRpc.deref();
+ * if (rpc) {
+ *   await rpc.getBalance(pubkey);
+ * } else {
+ *   // Service was GC'd — re-acquire if needed
+ * }
+ * ```
+ */
+export declare class WeakServiceRef<T extends object> {
+    private readonly _ref;
+    constructor(value: T);
+    /**
+     * Dereference the weak ref.
+     * @returns The service instance, or `undefined` if it was GC'd.
+     */
+    deref(): T | undefined;
+    /** Whether the underlying object is still alive (not yet GC'd). */
+    get alive(): boolean;
+}
+/**
+ * Centralized registry that tracks all active {@link ServiceRef}s.
+ *
+ * Provides ref counting, introspection, and leak detection via
+ * `FinalizationRegistry`. Each `SynapseContext` owns at most one
+ * `RefRegistry` (created lazily on first `acquireRef()`).
+ *
+ * @since 1.2.0
+ */
+export declare class RefRegistry implements Disposable {
+    /** @internal Active refs grouped by token. */
+    private readonly _entries;
+    /** @internal FinalizationRegistry for GC-based leak detection. */
+    private readonly _leakDetector?;
+    /** @internal Track which ref IDs are still active (for leak detection). */
+    private readonly _activeRefIds;
+    /** @internal Monotonically increasing ref ID. */
+    private _nextId;
+    /** @internal Counters. */
+    private _totalAcquired;
+    private _totalReleased;
+    private _peakActive;
+    private _leakedCount;
+    /** @internal Leak handlers. */
+    private readonly _leakHandlers;
+    /** @internal Whether the registry has been disposed. */
+    private _disposed;
+    constructor(config?: RefRegistryConfig);
+    /**
+     * Create a tracked ref for a resolved service value.
+     *
+     * @param token - The service token.
+     * @param value - The resolved service instance.
+     * @returns A new `ServiceRef<T>` linked to this registry.
+     */
+    acquire<T>(token: ServiceToken<T>, value: T): ServiceRef<T>;
+    /** @internal Handle a ref being released. */
+    private _handleRelease;
+    /**
+     * Number of active refs for a specific token.
+     */
+    refCount(token: ServiceToken): number;
+    /**
+     * Total number of active (unreleased) refs across all tokens.
+     */
+    totalActive(): number;
+    /**
+     * Aggregate statistics snapshot.
+     */
+    get stats(): RefStats;
+    /** @internal Build per-token breakdown. */
+    private _tokenBreakdown;
+    /**
+     * Check for potential leaks: refs that have been alive longer
+     * than `maxAgeMs` without being released.
+     *
+     * This is a **heuristic** — long-lived refs (e.g. for the lifetime
+     * of the app) are expected. Use this for debugging / dev mode.
+     *
+     * @param maxAgeMs - Threshold in ms. @default 60_000
+     */
+    checkLeaks(maxAgeMs?: number): LeakReport[];
+    /**
+     * Register a handler for GC-detected leaks.
+     *
+     * Called when a `ServiceRef` is garbage collected without
+     * `.release()` having been called first.
+     *
+     * @param handler - Receives a {@link LeakReport} for each leak.
+     */
+    onLeak(handler: (report: LeakReport) => void): void;
+    /**
+     * Force-release all active refs.
+     *
+     * Called automatically when the owning `SynapseContext` is disposed.
+     * After this, all refs' `.current` will throw {@link RefReleasedError}.
+     */
+    invalidateAll(): void;
+    /** Dispose the registry — invalidates all refs, clears handlers. */
+    dispose(): void;
+    /** Whether this registry has been disposed. */
+    get isDisposed(): boolean;
+}
+/**
+ * Memory safety monitor that wraps a {@link RefRegistry}.
+ *
+ * Provides configurable thresholds, periodic leak checks, and
+ * pressure alerts. Designed for dev-mode diagnostics or production
+ * monitoring of SDK memory usage.
+ *
+ * @since 1.2.0
+ *
+ * @example
+ * ```ts
+ * const guard = new MemoryGuard(registry, {
+ *   maxRefAgeMs: 30_000,
+ *   maxActiveRefs: 50,
+ *   checkIntervalMs: 10_000,
+ * });
+ *
+ * guard.onPressure(stats => {
+ *   console.warn('⚠️ Memory pressure:', stats.active, 'active refs');
+ * });
+ *
+ * guard.onLeak(report => {
+ *   console.error('🔴 Leaked ref:', report.tokenName, '#' + report.refId);
+ * });
+ * ```
+ */
+export declare class MemoryGuard implements Disposable {
+    private readonly _registry;
+    private _timer?;
+    private readonly _pressureHandlers;
+    private readonly _config;
+    constructor(_registry: RefRegistry, config?: MemoryGuardConfig);
+    /** Current ref statistics from the underlying registry. */
+    get stats(): RefStats;
+    /** Whether the active ref count exceeds the threshold. */
+    get underPressure(): boolean;
+    /** Number of currently active refs. */
+    get activeRefs(): number;
+    /**
+     * Check for potential leaks (refs older than `maxRefAgeMs`).
+     */
+    checkLeaks(): LeakReport[];
+    /**
+     * Subscribe to memory pressure events.
+     *
+     * Fires when the active ref count exceeds `maxActiveRefs`
+     * during a periodic check.
+     */
+    onPressure(handler: (stats: RefStats) => void): void;
+    /**
+     * Subscribe to GC-detected leak events.
+     *
+     * Delegates to the underlying {@link RefRegistry.onLeak}.
+     */
+    onLeak(handler: (report: LeakReport) => void): void;
+    /** @internal Periodic check callback. */
+    private _periodicCheck;
+    /** Dispose the guard — stops the timer, clears handlers. */
+    dispose(): void;
+}
+/**
+ * A batch of acquired refs, bound to a set of tokens.
+ *
+ * Provides a single `.release()` call that frees all refs at once —
+ * ideal for components that consume multiple services and need
+ * guaranteed cleanup.
+ *
+ * @since 1.2.0
+ */
+export interface ServiceBinding<T extends Record<string, ServiceToken>> {
+    /**
+     * Lazy-resolved services. Each property resolves and acquires a ref
+     * on first access.
+     */
+    readonly services: {
+        [K in keyof T]: T[K] extends ServiceToken<infer U> ? U : never;
+    };
+    /** All acquired refs (populated as services are accessed). */
+    readonly refs: Map<string, ServiceRef<unknown>>;
+    /** Whether any ref is still alive. */
+    readonly alive: boolean;
+    /** Release all acquired refs. Safe to call multiple times. */
+    release(): void;
+    /** Alias for {@link release}. */
+    dispose(): void;
+}
+/**
+ * Create a binding that acquires tracked refs for multiple tokens.
+ *
+ * Services are resolved **lazily** on first property access. All refs
+ * are released together with a single `.release()` call.
+ *
+ * @param acquireFn - Function that acquires a ref for a token (usually `ctx.acquireRef.bind(ctx)`).
+ * @param tokens    - Record mapping property names to service tokens.
+ * @returns A {@link ServiceBinding} with lazy services and batch release.
+ * @since 1.2.0
+ *
+ * @example
+ * ```ts
+ * const binding = createBinding(
+ *   token => ctx.acquireRef(token),
+ *   { rpc: Tokens.RPC, das: Tokens.DAS, programs: Tokens.PROGRAMS },
+ * );
+ *
+ * // Use services (each is acquired on first access):
+ * await binding.services.rpc.getBalance(pubkey);
+ * await binding.services.das.getAsset(assetId);
+ *
+ * // Release ALL refs at once:
+ * binding.release();
+ * ```
+ */
+export declare function createBinding<T extends Record<string, ServiceToken>>(acquireFn: <U>(token: ServiceToken<U>) => ServiceRef<U>, tokens: T): ServiceBinding<T>;
+//# sourceMappingURL=refs.d.ts.map

package/dist/cjs/context/refs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"refs.d.ts","sourceRoot":"","sources":["../../../src/context/refs.ts"],"names":[],"mappings":"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"}