@blac/core 2.0.0-rc.6 → 2.0.0-rc.8

package/dist/plugin/BlacPlugin.d.ts

@@ -0,0 +1,115 @@
+/**
+ * BlacPlugin - Plugin system for BlaC state management
+ *
+ * Provides a safe and powerful API for plugins to observe and interact with
+ * StateContainer instances without coupling to the core.
+ */
+import type { StateContainer } from '../core/StateContainer';
+import type { Vertex } from '../core/Vertex';
+import type { BaseEvent } from '../types/events';
+/**
+ * Instance metadata exposed to plugins
+ */
+export interface InstanceMetadata {
+    /** Unique instance ID */
+    id: string;
+    /** Class name (e.g., 'CounterCubit') */
+    className: string;
+    isDisposed: boolean;
+    /** Custom name if provided */
+    name: string;
+    lastStateChangeTimestamp: number;
+    state: any;
+    createdAt: number;
+    /** Whether this is an isolated instance */
+    isIsolated: boolean;
+    /** Call stack for state update (optional, for DevTools) */
+    callstack?: string;
+    /** Previous state (optional, for state change events) */
+    previousState?: any;
+    /** Current state (optional, for state change events) */
+    currentState?: any;
+}
+/**
+ * Plugin context - provides safe access to BlaC internals
+ */
+export interface PluginContext {
+    /**
+     * Get metadata for an instance
+     */
+    getInstanceMetadata(instance: StateContainer<any>): InstanceMetadata;
+    /**
+     * Get current state of an instance
+     */
+    getState<S>(instance: StateContainer<S>): S;
+    /**
+     * Query all instances of a specific type
+     */
+    queryInstances<T extends StateContainer<any>>(typeClass: new (...args: any[]) => T): T[];
+    /**
+     * Query all registered types
+     */
+    getAllTypes(): Array<new (...args: any[]) => StateContainer<any>>;
+    /**
+     * Get registry statistics
+     */
+    getStats(): {
+        registeredTypes: number;
+        totalInstances: number;
+        typeBreakdown: Record<string, number>;
+    };
+}
+/**
+ * Base plugin interface
+ */
+export interface BlacPlugin {
+    /** Plugin name for identification */
+    readonly name: string;
+    /** Plugin version */
+    readonly version: string;
+    /**
+     * Called when plugin is installed
+     * @param context - Plugin context for safe access to BlaC internals
+     */
+    onInstall?(context: PluginContext): void;
+    /**
+     * Called when plugin is uninstalled
+     */
+    onUninstall?(): void;
+    /**
+     * Called when a StateContainer instance is created
+     */
+    onInstanceCreated?(instance: StateContainer<any>, context: PluginContext): void;
+    /**
+     * Called when state changes
+     */
+    onStateChanged?<S>(instance: StateContainer<S>, previousState: S, currentState: S, callstack: string | undefined, context: PluginContext): void;
+    /**
+     * Called when an event is added (Vertex only)
+     */
+    onEventAdded?<E extends BaseEvent>(vertex: Vertex<any, E>, event: E, context: PluginContext): void;
+    /**
+     * Called when an instance is disposed
+     */
+    onInstanceDisposed?(instance: StateContainer<any>, context: PluginContext): void;
+}
+/**
+ * Plugin with initialization hook
+ */
+export interface BlacPluginWithInit extends BlacPlugin {
+    onInstall(context: PluginContext): void;
+}
+/**
+ * Plugin configuration options
+ */
+export interface PluginConfig {
+    /** Whether plugin is enabled */
+    enabled?: boolean;
+    /** Environment filter (e.g., only run in development) */
+    environment?: 'development' | 'production' | 'test' | 'all';
+}
+/**
+ * Type guard for plugins with init
+ */
+export declare function hasInitHook(plugin: BlacPlugin): plugin is BlacPluginWithInit;
+//# sourceMappingURL=BlacPlugin.d.ts.map

package/dist/plugin/BlacPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlacPlugin.d.ts","sourceRoot":"","sources":["../../src/plugin/BlacPlugin.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,yBAAyB;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,wCAAwC;IACxC,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,OAAO,CAAC;IACpB,8BAA8B;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,wBAAwB,EAAE,MAAM,CAAC;IACjC,KAAK,EAAE,GAAG,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,2CAA2C;IAC3C,UAAU,EAAE,OAAO,CAAC;IACpB,2DAA2D;IAC3D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,yDAAyD;IACzD,aAAa,CAAC,EAAE,GAAG,CAAC;IACpB,wDAAwD;IACxD,YAAY,CAAC,EAAE,GAAG,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B;;OAEG;IACH,mBAAmB,CAAC,QAAQ,EAAE,cAAc,CAAC,GAAG,CAAC,GAAG,gBAAgB,CAAC;IAErE;;OAEG;IACH,QAAQ,CAAC,CAAC,EAAE,QAAQ,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IAE5C;;OAEG;IACH,cAAc,CAAC,CAAC,SAAS,cAAc,CAAC,GAAG,CAAC,EAC1C,SAAS,EAAE,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,GACnC,CAAC,EAAE,CAAC;IAEP;;OAEG;IACH,WAAW,IAAI,KAAK,CAAC,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC;IAElE;;OAEG;IACH,QAAQ,IAAI;QACV,eAAe,EAAE,MAAM,CAAC;QACxB,cAAc,EAAE,MAAM,CAAC;QACvB,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;KACvC,CAAC;CACH;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,qCAAqC;IACrC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,qBAAqB;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAEzB;;;OAGG;IACH,SAAS,CAAC,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,CAAC;IAEzC;;OAEG;IACH,WAAW,CAAC,IAAI,IAAI,CAAC;IAErB;;OAEG;IACH,iBAAiB,CAAC,CAChB,QAAQ,EAAE,cAAc,CAAC,GAAG,CAAC,EAC7B,OAAO,EAAE,aAAa,GACrB,IAAI,CAAC;IAER;;OAEG;IACH,cAAc,CAAC,CAAC,CAAC,EACf,QAAQ,EAAE,cAAc,CAAC,CAAC,CAAC,EAC3B,aAAa,EAAE,CAAC,EAChB,YAAY,EAAE,CAAC,EACf,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,OAAO,EAAE,aAAa,GACrB,IAAI,CAAC;IAER;;OAEG;IACH,YAAY,CAAC,CAAC,CAAC,SAAS,SAAS,EAC/B,MAAM,EAAE,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,EACtB,KAAK,EAAE,CAAC,EACR,OAAO,EAAE,aAAa,GACrB,IAAI,CAAC;IAER;;OAEG;IACH,kBAAkB,CAAC,CACjB,QAAQ,EAAE,cAAc,CAAC,GAAG,CAAC,EAC7B,OAAO,EAAE,aAAa,GACrB,IAAI,CAAC;CACT;AAED;;GAEG;AACH,MAAM,WAAW,kBAAmB,SAAQ,UAAU;IACpD,SAAS,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,CAAC;CACzC;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,gCAAgC;IAChC,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB,yDAAyD;IACzD,WAAW,CAAC,EAAE,aAAa,GAAG,YAAY,GAAG,MAAM,GAAG,KAAK,CAAC;CAC7D;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,IAAI,kBAAkB,CAE5E"}

package/dist/plugin/PluginManager.d.ts

@@ -0,0 +1,63 @@
+/**
+ * PluginManager - Manages plugins and provides plugin context
+ * TESTS ARE FOR AN OLDER VERSION AND NEED TO BE REWRITTEN
+ */
+import type { StateContainerRegistry } from '../core/StateContainerRegistry';
+import type { BlacPlugin, PluginConfig } from './BlacPlugin';
+/**
+ * Plugin manager for registering and coordinating plugins
+ */
+export declare class PluginManager {
+    private plugins;
+    private registry;
+    constructor(registry: StateContainerRegistry);
+    /**
+     * Install a plugin
+     */
+    install(plugin: BlacPlugin, config?: PluginConfig): void;
+    /**
+     * Uninstall a plugin
+     */
+    uninstall(pluginName: string): void;
+    /**
+     * Get installed plugin
+     */
+    getPlugin(pluginName: string): BlacPlugin | undefined;
+    /**
+     * Get all installed plugins
+     */
+    getAllPlugins(): BlacPlugin[];
+    /**
+     * Check if plugin is installed
+     */
+    hasPlugin(pluginName: string): boolean;
+    /**
+     * Clear all plugins (for testing)
+     */
+    clear(): void;
+    /**
+     * Setup lifecycle hooks to notify plugins
+     */
+    private setupLifecycleHooks;
+    /**
+     * Notify all plugins of a lifecycle event
+     */
+    private notifyPlugins;
+    /**
+     * Create plugin context with safe API access
+     */
+    private createPluginContext;
+    /**
+     * Check if plugin should be enabled based on environment
+     */
+    private shouldEnablePlugin;
+    /**
+     * Get current environment
+     */
+    private getCurrentEnvironment;
+}
+/**
+ * Create a plugin manager instance
+ */
+export declare function createPluginManager(registry: StateContainerRegistry): PluginManager;
+//# sourceMappingURL=PluginManager.d.ts.map

package/dist/plugin/PluginManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PluginManager.d.ts","sourceRoot":"","sources":["../../src/plugin/PluginManager.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAC7E,OAAO,KAAK,EACV,UAAU,EAEV,YAAY,EAEb,MAAM,cAAc,CAAC;AAQtB;;GAEG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,OAAO,CAAsC;IACrD,OAAO,CAAC,QAAQ,CAAyB;gBAE7B,QAAQ,EAAE,sBAAsB;IAK5C;;OAEG;IACH,OAAO,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,GAAE,YAAiB,GAAG,IAAI;IA8C5D;;OAEG;IACH,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAsBnC;;OAEG;IACH,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS;IAIrD;;OAEG;IACH,aAAa,IAAI,UAAU,EAAE;IAI7B;;OAEG;IACH,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO;IAItC;;OAEG;IACH,KAAK,IAAI,IAAI;IAMb;;OAEG;IACH,OAAO,CAAC,mBAAmB;IA+B3B;;OAEG;IACH,OAAO,CAAC,aAAa;IAkBrB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IA+C3B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAQ1B;;OAEG;IACH,OAAO,CAAC,qBAAqB;CAQ9B;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,sBAAsB,GAC/B,aAAa,CAEf"}

package/dist/proxy/ProxyTracker.d.ts

@@ -0,0 +1,71 @@
+/**
+ * ProxyTracker - Automatic dependency tracking through Proxies
+ *
+ * Tracks property access on state objects to automatically determine
+ * which parts of the state a component depends on.
+ */
+/**
+ * Tracks property access on state objects
+ */
+export declare class ProxyTracker<T> {
+    private trackedPaths;
+    private isTracking;
+    private proxyCache;
+    private maxDepth;
+    /**
+     * Create a proxy that tracks property access
+     */
+    createProxy(target: T, path?: string, depth?: number): T;
+    /**
+     * Create a proxy for arrays with special handling
+     */
+    private createArrayProxy;
+    /**
+     * Start tracking property access
+     */
+    startTracking(): void;
+    /**
+     * Stop tracking and return tracked paths
+     */
+    stopTracking(): Set<string>;
+    /**
+     * Get currently tracked paths
+     */
+    getTrackedPaths(): ReadonlySet<string>;
+    /**
+     * Check if currently tracking
+     */
+    isCurrentlyTracking(): boolean;
+    /**
+     * Clear proxy cache (useful for memory management)
+     */
+    clearCache(): void;
+    /**
+     * Set maximum tracking depth
+     */
+    setMaxDepth(depth: number): void;
+    /**
+     * Add a path manually (useful for forcing dependencies)
+     */
+    addPath(path: string): void;
+    /**
+     * Remove a path manually
+     */
+    removePath(path: string): void;
+    /**
+     * Clear all tracked paths
+     */
+    clearPaths(): void;
+}
+/**
+ * Global proxy tracker instance for convenience
+ */
+export declare const globalProxyTracker: ProxyTracker<unknown>;
+/**
+ * Utility function to track property access in a callback
+ */
+export declare function trackAccess<T, R>(state: T, callback: (proxiedState: T) => R): {
+    result: R;
+    trackedPaths: Set<string>;
+};
+//# sourceMappingURL=ProxyTracker.d.ts.map

package/dist/proxy/ProxyTracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProxyTracker.d.ts","sourceRoot":"","sources":["../../src/proxy/ProxyTracker.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAqBH;;GAEG;AACH,qBAAa,YAAY,CAAC,CAAC;IACzB,OAAO,CAAC,YAAY,CAAqB;IACzC,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,UAAU,CAA8B;IAChD,OAAO,CAAC,QAAQ,CAAM;IAEtB;;OAEG;IACH,WAAW,CAAC,MAAM,EAAE,CAAC,EAAE,IAAI,GAAE,MAAW,EAAE,KAAK,GAAE,MAAU,GAAG,CAAC;IA6F/D;;OAEG;IACH,OAAO,CAAC,gBAAgB;IA8DxB;;OAEG;IACH,aAAa,IAAI,IAAI;IAMrB;;OAEG;IACH,YAAY,IAAI,GAAG,CAAC,MAAM,CAAC;IAS3B;;OAEG;IACH,eAAe,IAAI,WAAW,CAAC,MAAM,CAAC;IAItC;;OAEG;IACH,mBAAmB,IAAI,OAAO;IAI9B;;OAEG;IACH,UAAU,IAAI,IAAI;IAIlB;;OAEG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAIhC;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAI3B;;OAEG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAI9B;;OAEG;IACH,UAAU,IAAI,IAAI;CAGnB;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,uBAAqB,CAAC;AAErD;;GAEG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,CAAC,EAC9B,KAAK,EAAE,CAAC,EACR,QAAQ,EAAE,CAAC,YAAY,EAAE,CAAC,KAAK,CAAC,GAC/B;IAAE,MAAM,EAAE,CAAC,CAAC;IAAC,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;CAAE,CAS1C"}

package/dist/registry/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Registry module (deprecated)
+ *
+ * Registry functionality has been consolidated into StateContainer.
+ * Use StateContainer static methods instead:
+ *
+ * - StateContainer.register() - Register a type
+ * - StateContainer.getOrCreate() - Get or create instance
+ * - StateContainer.isRegistered() - Check if type is registered
+ * - StateContainer.hasInstance() - Check if instance exists
+ * - StateContainer.removeInstance() - Remove instance
+ * - StateContainer.getAll() - Get all instances of a type
+ * - StateContainer.clear() - Clear all instances of a type
+ * - StateContainer.clearAllInstances() - Clear all instances
+ * - StateContainer.unregister() - Unregister a type
+ * - StateContainer.getStats() - Get statistics
+ */
+export { type BlocConstructor } from '../types/utilities';
+export { type InstanceId, instanceId as createInstanceId, } from '../types/branded';
+//# sourceMappingURL=index.d.ts.map

package/dist/registry/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/registry/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,EACL,KAAK,UAAU,EACf,UAAU,IAAI,gBAAgB,GAC/B,MAAM,kBAAkB,CAAC"}

package/dist/test-utils/index.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Test utilities and fixtures
+ */
+/**
+ * Create a test state object
+ */
+export declare function createTestState<T extends Record<string, unknown>>(overrides?: Partial<T>): T;
+/**
+ * Wait for a condition to be true
+ */
+export declare function waitFor(condition: () => boolean, timeout?: number, interval?: number): Promise<void>;
+/**
+ * Create a mock subscription notify function
+ */
+export declare function createMockNotify<T = unknown>(): {
+    fn: import("vitest").Mock<(state: T) => void>;
+    calls: T[];
+    callCount: () => number;
+    lastCall: () => T;
+    reset: () => void;
+};
+/**
+ * Memory usage tracker for tests
+ */
+export declare class MemoryTracker {
+    private baseline;
+    start(): void;
+    getUsage(): number;
+    getMB(): number;
+}
+/**
+ * Performance timer for benchmarking
+ */
+export declare class PerfTimer {
+    private start;
+    private marks;
+    begin(): void;
+    mark(label: string): void;
+    end(): number;
+    getMark(label: string): number | undefined;
+    getAllMarks(): Record<string, number>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/test-utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/test-utils/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH;;GAEG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/D,SAAS,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,GACrB,CAAC,CAUH;AAED;;GAEG;AACH,wBAAsB,OAAO,CAC3B,SAAS,EAAE,MAAM,OAAO,EACxB,OAAO,SAAO,EACd,QAAQ,SAAK,GACZ,OAAO,CAAC,IAAI,CAAC,CAQf;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,GAAG,OAAO;sCAEjB,CAAC;;;;;EAa3B;AAED;;GAEG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAa;IAE7B,KAAK,IAAI,IAAI;IAOb,QAAQ,IAAI,MAAM;IAOlB,KAAK,IAAI,MAAM;CAGhB;AAED;;GAEG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,KAAK,CAAa;IAC1B,OAAO,CAAC,KAAK,CAAkC;IAE/C,KAAK,IAAI,IAAI;IAIb,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAIzB,GAAG,IAAI,MAAM;IAIb,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAK1C,WAAW,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;CAOtC"}

package/dist/tracking/dependency-tracker.d.ts

@@ -0,0 +1,21 @@
+import { type ProxyTrackerState } from './proxy-tracker';
+export interface PathInfo {
+    segments: string[];
+    value: any;
+}
+export interface TrackerState<T> {
+    proxyTrackerState: ProxyTrackerState<T>;
+    previousRenderPaths: Set<string>;
+    currentRenderPaths: Set<string>;
+    pathCache: Map<string, PathInfo>;
+    lastCheckedState: T | null;
+    lastCheckedValues: Map<string, any>;
+}
+export declare function optimizeTrackedPaths(paths: Set<string>): Set<string>;
+export declare function createTrackerState<T>(): TrackerState<T>;
+export declare function startTracking<T>(tracker: TrackerState<T>): void;
+export declare function createProxy<T>(tracker: TrackerState<T>, state: T): T;
+export declare function captureTrackedPaths<T>(tracker: TrackerState<T>, state: T): void;
+export declare function hasChanges<T>(tracker: TrackerState<T>, state: T): boolean;
+export declare function hasTrackedData<T>(tracker: TrackerState<T>): boolean;
+//# sourceMappingURL=dependency-tracker.d.ts.map

package/dist/tracking/dependency-tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependency-tracker.d.ts","sourceRoot":"","sources":["../../src/tracking/dependency-tracker.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EAKvB,MAAM,iBAAiB,CAAC;AAGzB,MAAM,WAAW,QAAQ;IACvB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,KAAK,EAAE,GAAG,CAAC;CACZ;AAED,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,iBAAiB,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC;IACxC,mBAAmB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACjC,kBAAkB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAChC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IACjC,gBAAgB,EAAE,CAAC,GAAG,IAAI,CAAC;IAC3B,iBAAiB,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CACrC;AA8BD,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAkDpE;AAED,wBAAgB,kBAAkB,CAAC,CAAC,KAAK,YAAY,CAAC,CAAC,CAAC,CASvD;AAED,wBAAgB,aAAa,CAAC,CAAC,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,CAE/D;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAEpE;AAED,wBAAgB,mBAAmB,CAAC,CAAC,EACnC,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC,EACxB,KAAK,EAAE,CAAC,GACP,IAAI,CAwCN;AAED,wBAAgB,UAAU,CAAC,CAAC,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAmBzE;AAED,wBAAgB,cAAc,CAAC,CAAC,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,OAAO,CAMnE"}

package/dist/tracking/getter-tracker.d.ts

@@ -0,0 +1,31 @@
+import type { StateContainer } from '../core/StateContainer';
+export interface GetterTrackerState {
+    trackedValues: Map<string | symbol, unknown>;
+    currentlyAccessing: Set<string | symbol>;
+    trackedGetters: Set<string | symbol>;
+    isTracking: boolean;
+    renderCache: Map<string | symbol, unknown>;
+    cacheValid: boolean;
+    externalDependencies: Set<StateContainer<any>>;
+}
+interface GetterExecutionContext {
+    tracker: GetterTrackerState | null;
+    currentBloc: StateContainer<any> | null;
+    depth: number;
+    visitedBlocs: Set<StateContainer<any>>;
+}
+export declare function getGetterExecutionContext(): GetterExecutionContext;
+export declare function getDescriptor(obj: any, prop: string | symbol): PropertyDescriptor | undefined;
+export declare function isGetter(obj: any, prop: string | symbol): boolean;
+export declare function createGetterTracker(): GetterTrackerState;
+export declare function setActiveTracker<TBloc extends StateContainer<any>>(bloc: TBloc, tracker: GetterTrackerState): void;
+export declare function clearActiveTracker<TBloc extends StateContainer<any>>(bloc: TBloc): void;
+export declare function getActiveTracker<TBloc extends StateContainer<any>>(bloc: TBloc): GetterTrackerState | undefined;
+export declare function commitTrackedGetters(tracker: GetterTrackerState): void;
+export declare function createBlocProxy<TBloc extends StateContainer<any>>(bloc: TBloc): TBloc;
+export declare function hasGetterChanges<TBloc extends StateContainer<any>>(bloc: TBloc, tracker: GetterTrackerState | null): boolean;
+export declare function invalidateRenderCache(tracker: GetterTrackerState): void;
+export declare function clearExternalDependencies(tracker: GetterTrackerState): void;
+export declare function resetGetterTracker(tracker: GetterTrackerState): void;
+export {};
+//# sourceMappingURL=getter-tracker.d.ts.map

package/dist/tracking/getter-tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getter-tracker.d.ts","sourceRoot":"","sources":["../../src/tracking/getter-tracker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAG7D,MAAM,WAAW,kBAAkB;IACjC,aAAa,EAAE,GAAG,CAAC,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,CAAC;IAC7C,kBAAkB,EAAE,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC;IACzC,cAAc,EAAE,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC;IACrC,UAAU,EAAE,OAAO,CAAC;IACpB,WAAW,EAAE,GAAG,CAAC,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,CAAC;IAC3C,UAAU,EAAE,OAAO,CAAC;IACpB,oBAAoB,EAAE,GAAG,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC;CAChD;AAaD,UAAU,sBAAsB;IAC9B,OAAO,EAAE,kBAAkB,GAAG,IAAI,CAAC;IACnC,WAAW,EAAE,cAAc,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC;IACxC,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,GAAG,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC;CACxC;AAaD,wBAAgB,yBAAyB,IAAI,sBAAsB,CAElE;AAED,wBAAgB,aAAa,CAC3B,GAAG,EAAE,GAAG,EACR,IAAI,EAAE,MAAM,GAAG,MAAM,GACpB,kBAAkB,GAAG,SAAS,CA6BhC;AAED,wBAAgB,QAAQ,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAGjE;AAED,wBAAgB,mBAAmB,IAAI,kBAAkB,CAUxD;AAED,wBAAgB,gBAAgB,CAAC,KAAK,SAAS,cAAc,CAAC,GAAG,CAAC,EAChE,IAAI,EAAE,KAAK,EACX,OAAO,EAAE,kBAAkB,GAC1B,IAAI,CAEN;AAED,wBAAgB,kBAAkB,CAAC,KAAK,SAAS,cAAc,CAAC,GAAG,CAAC,EAClE,IAAI,EAAE,KAAK,GACV,IAAI,CAEN;AAED,wBAAgB,gBAAgB,CAAC,KAAK,SAAS,cAAc,CAAC,GAAG,CAAC,EAChE,IAAI,EAAE,KAAK,GACV,kBAAkB,GAAG,SAAS,CAEhC;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI,CAKtE;AAED,wBAAgB,eAAe,CAAC,KAAK,SAAS,cAAc,CAAC,GAAG,CAAC,EAC/D,IAAI,EAAE,KAAK,GACV,KAAK,CA+EP;AAED,wBAAgB,gBAAgB,CAAC,KAAK,SAAS,cAAc,CAAC,GAAG,CAAC,EAChE,IAAI,EAAE,KAAK,EACX,OAAO,EAAE,kBAAkB,GAAG,IAAI,GACjC,OAAO,CAwDT;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI,CAEvE;AAED,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI,CAE3E;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI,CAQpE"}

package/dist/tracking/index.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Dependency Tracking
+ *
+ * Framework-agnostic dependency tracking utilities for automatic reactivity.
+ * These utilities can be used by any framework integration (React, Vue, Angular, etc.)
+ * to track property accesses and detect changes.
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * import {
+ *   createTrackerState,
+ *   startTracking,
+ *   createProxy,
+ *   captureTrackedPaths,
+ *   hasChanges
+ * } from '@blac/core';
+ *
+ * // Create tracker state
+ * const tracker = createTrackerState<MyState>();
+ *
+ * // During render:
+ * startTracking(tracker);
+ * const proxy = createProxy(tracker, state);
+ * // ... render with proxy ...
+ * captureTrackedPaths(tracker, state);
+ *
+ * // On state change:
+ * if (hasChanges(tracker, newState)) {
+ *   // Trigger re-render
+ * }
+ * ```
+ */
+export { type TrackerState, type PathInfo, createTrackerState, startTracking, createProxy, captureTrackedPaths, hasChanges, hasTrackedData, } from './dependency-tracker';
+export { type ProxyTrackerState, createProxyTrackerState, startProxyTracking, stopProxyTracking, createProxyInternal, createArrayProxy, createProxyForTarget, isProxyable, } from './proxy-tracker';
+export { parsePath, getValueAtPath, shallowEqual } from './path-utils';
+export { type GetterTrackerState, createGetterTracker, createBlocProxy, hasGetterChanges, isGetter, getDescriptor, setActiveTracker, clearActiveTracker, getActiveTracker, commitTrackedGetters, invalidateRenderCache, resetGetterTracker, clearExternalDependencies, getGetterExecutionContext, } from './getter-tracker';
+//# sourceMappingURL=index.d.ts.map

package/dist/tracking/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tracking/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAGH,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,QAAQ,EACb,kBAAkB,EAClB,aAAa,EACb,WAAW,EACX,mBAAmB,EACnB,UAAU,EACV,cAAc,GACf,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EACL,KAAK,iBAAiB,EACtB,uBAAuB,EACvB,kBAAkB,EAClB,iBAAiB,EACjB,mBAAmB,EACnB,gBAAgB,EAChB,oBAAoB,EACpB,WAAW,GACZ,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAGvE,OAAO,EACL,KAAK,kBAAkB,EACvB,mBAAmB,EACnB,eAAe,EACf,gBAAgB,EAChB,QAAQ,EACR,aAAa,EACb,gBAAgB,EAChB,kBAAkB,EAClB,gBAAgB,EAChB,oBAAoB,EACpB,qBAAqB,EACrB,kBAAkB,EAClB,yBAAyB,EACzB,yBAAyB,GAC1B,MAAM,kBAAkB,CAAC"}

package/dist/tracking/path-utils.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Path utilities for dependency tracking
+ *
+ * Provides utilities for parsing property paths and extracting values
+ * from nested objects using path strings.
+ */
+/**
+ * Parse a property path string into an array of segments
+ *
+ * Handles both dot notation (a.b.c) and bracket notation (a[0].b)
+ *
+ * @example
+ * parsePath('user.name') // ['user', 'name']
+ * parsePath('items[0].name') // ['items', '0', 'name']
+ * parsePath('data.users[2].address.city') // ['data', 'users', '2', 'address', 'city']
+ */
+export declare function parsePath(path: string): string[];
+/**
+ * Get a value from an object using a path of segments
+ *
+ * @example
+ * const obj = { user: { name: 'Alice', age: 30 } }
+ * getValueAtPath(obj, ['user', 'name']) // 'Alice'
+ * getValueAtPath(obj, ['user', 'age']) // 30
+ * getValueAtPath(obj, ['user', 'missing']) // undefined
+ */
+export declare function getValueAtPath(obj: any, segments: string[]): any;
+/**
+ * Shallow equality comparison for arrays
+ *
+ * Compares two arrays element-by-element using Object.is
+ *
+ * @example
+ * shallowEqual([1, 2, 3], [1, 2, 3]) // true
+ * shallowEqual([1, 2, 3], [1, 2, 4]) // false
+ * shallowEqual([1, 2], [1, 2, 3]) // false
+ */
+export declare function shallowEqual(arr1: unknown[], arr2: unknown[]): boolean;
+//# sourceMappingURL=path-utils.d.ts.map

package/dist/tracking/path-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-utils.d.ts","sourceRoot":"","sources":["../../src/tracking/path-utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CA6BhD;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,GAAG,CAShE;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,OAAO,CAMtE"}

package/dist/tracking/proxy-tracker.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Functional proxy tracker for automatic dependency tracking
+ *
+ * This module provides a functional approach to proxy-based dependency tracking.
+ * Unlike the class-based ProxyTracker, this uses a state object pattern that's
+ * easier to integrate with functional programming patterns and framework hooks.
+ */
+/**
+ * Check if a value can be proxied
+ *
+ * Returns true for plain objects and arrays only.
+ * Excludes built-in objects like Date, Map, Set, etc.
+ */
+export declare function isProxyable(value: unknown): value is object;
+/**
+ * State container for proxy tracking
+ */
+export interface ProxyTrackerState<T> {
+    /** Set of all tracked property paths */
+    trackedPaths: Set<string>;
+    /** Whether tracking is currently active */
+    isTracking: boolean;
+    /** Cache of created proxies to avoid duplicates */
+    proxyCache: WeakMap<object, any>;
+    /** Cache of bound functions to maintain referential equality */
+    boundFunctionsCache: WeakMap<Function, Function> | null;
+    /** Last state object that was proxied (for cache invalidation) */
+    lastProxiedState: T | null;
+    /** Last proxy created (for cache reuse) */
+    lastProxy: T | null;
+    /** Maximum depth for nested proxy creation */
+    maxDepth: number;
+}
+/**
+ * Create a new proxy tracker state
+ *
+ * @example
+ * const state = createProxyTrackerState<MyState>();
+ * startProxyTracking(state);
+ * const proxy = createProxyForTarget(state, myObject);
+ * // ... use proxy ...
+ * const paths = stopProxyTracking(state);
+ */
+export declare function createProxyTrackerState<T>(): ProxyTrackerState<T>;
+/**
+ * Start tracking property accesses
+ *
+ * Clears previous tracked paths and enables tracking mode.
+ */
+export declare function startProxyTracking<T>(state: ProxyTrackerState<T>): void;
+/**
+ * Stop tracking and return the tracked paths
+ *
+ * Returns a new Set containing all tracked paths.
+ */
+export declare function stopProxyTracking<T>(state: ProxyTrackerState<T>): Set<string>;
+/**
+ * Create a proxy for an array with property access tracking
+ *
+ * Tracks:
+ * - Array element access (arr[0])
+ * - Length access (arr.length)
+ * - Array method calls (arr.map, arr.filter, etc.)
+ */
+export declare function createArrayProxy<T, U>(state: ProxyTrackerState<T>, target: U[], path: string, depth?: number): U[];
+/**
+ * Create a proxy for an object with property access tracking
+ *
+ * This is the core proxy creation function that recursively creates proxies
+ * for nested objects and arrays.
+ *
+ * Tracks:
+ * - Property access (obj.prop)
+ * - Nested property access (obj.nested.prop)
+ * - 'in' operator usage ('prop' in obj)
+ * - Object.keys, Object.entries, etc.
+ */
+export declare function createProxyInternal<T>(state: ProxyTrackerState<T>, target: T, path?: string, depth?: number): T;
+/**
+ * Create a proxy for a target with caching
+ *
+ * If the target hasn't changed since the last call, returns the cached proxy.
+ * Otherwise, creates a new proxy and caches it.
+ *
+ * This is the main entry point for creating tracked proxies.
+ */
+export declare function createProxyForTarget<T>(state: ProxyTrackerState<T>, target: T): T;
+//# sourceMappingURL=proxy-tracker.d.ts.map

package/dist/tracking/proxy-tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxy-tracker.d.ts","sourceRoot":"","sources":["../../src/tracking/proxy-tracker.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAeH;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAI3D;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB,CAAC,CAAC;IAClC,wCAAwC;IACxC,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC1B,2CAA2C;IAC3C,UAAU,EAAE,OAAO,CAAC;IACpB,mDAAmD;IACnD,UAAU,EAAE,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACjC,gEAAgE;IAEhE,mBAAmB,EAAE,OAAO,CAAC,QAAQ,EAAE,QAAQ,CAAC,GAAG,IAAI,CAAC;IACxD,kEAAkE;IAClE,gBAAgB,EAAE,CAAC,GAAG,IAAI,CAAC;IAC3B,2CAA2C;IAC3C,SAAS,EAAE,CAAC,GAAG,IAAI,CAAC;IACpB,8CAA8C;IAC9C,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,KAAK,iBAAiB,CAAC,CAAC,CAAC,CAUjE;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,KAAK,EAAE,iBAAiB,CAAC,CAAC,CAAC,GAAG,IAAI,CAGvE;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,KAAK,EAAE,iBAAiB,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAG7E;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,CAAC,EACnC,KAAK,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAC3B,MAAM,EAAE,CAAC,EAAE,EACX,IAAI,EAAE,MAAM,EACZ,KAAK,GAAE,MAAU,GAChB,CAAC,EAAE,CA4DL;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EACnC,KAAK,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAC3B,MAAM,EAAE,CAAC,EACT,IAAI,GAAE,MAAW,EACjB,KAAK,GAAE,MAAU,GAChB,CAAC,CAsFH;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EACpC,KAAK,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAC3B,MAAM,EAAE,CAAC,GACR,CAAC,CAcH"}

package/dist/types/branded.d.ts

@@ -0,0 +1,9 @@
+declare const brand: unique symbol;
+export type Brand<T, B> = T & {
+    [brand]: B;
+};
+export type BrandedId<B> = Brand<string, B>;
+export type InstanceId = Brand<string, 'InstanceId'>;
+export declare function instanceId(id: string): InstanceId;
+export {};
+//# sourceMappingURL=branded.d.ts.map

package/dist/types/branded.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"branded.d.ts","sourceRoot":"","sources":["../../src/types/branded.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,EAAE,OAAO,MAAM,CAAC;AAEnC,MAAM,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IAAE,CAAC,KAAK,CAAC,EAAE,CAAC,CAAA;CAAE,CAAC;AAC7C,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;AAC5C,MAAM,MAAM,UAAU,GAAG,KAAK,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;AAErD,wBAAgB,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU,CAEjD"}

package/dist/types/events.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Base event interface for type-safe event system
+ */
+/**
+ * Base event interface
+ * Used by Vertex for event-driven state management
+ */
+export interface BaseEvent {
+    readonly type: string;
+    readonly timestamp: number;
+    readonly source?: string;
+}
+//# sourceMappingURL=events.d.ts.map

package/dist/types/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../src/types/events.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B"}

package/dist/types/utilities.d.ts

@@ -0,0 +1,18 @@
+import type { StateContainer } from '../core/StateContainer';
+export type ExtractState<T> = T extends StateContainer<infer S> ? S : never;
+export type ExtractConstructorArgs<T> = T extends new (...args: infer P) => any ? P : never[];
+export type BlocConstructor<TBloc extends StateContainer<any>> = (new (...args: any[]) => TBloc) & {
+    resolve(instanceKey?: string, ...args: any[]): TBloc;
+    get(instanceKey?: string): TBloc;
+    getSafe(instanceKey?: string): {
+        error: Error;
+        instance: null;
+    } | {
+        error: null;
+        instance: TBloc;
+    };
+    release(instanceKey?: string): void;
+    isolated?: boolean;
+    keepAlive?: boolean;
+};
+//# sourceMappingURL=utilities.d.ts.map

package/dist/types/utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utilities.d.ts","sourceRoot":"","sources":["../../src/types/utilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAE7D,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,SAAS,cAAc,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAE5E,MAAM,MAAM,sBAAsB,CAAC,CAAC,IAAI,CAAC,SAAS,KAAK,GAAG,IAAI,EAAE,MAAM,CAAC,KAAK,GAAG,GAC3E,CAAC,GACD,KAAK,EAAE,CAAC;AAEZ,MAAM,MAAM,eAAe,CAAC,KAAK,SAAS,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,KAChE,GAAG,IAAI,EAAE,GAAG,EAAE,KACX,KAAK,CAAC,GAAG;IACZ,OAAO,CAAC,WAAW,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,KAAK,CAAC;IACrD,GAAG,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACjC,OAAO,CACL,WAAW,CAAC,EAAE,MAAM,GACnB;QAAE,KAAK,EAAE,KAAK,CAAC;QAAC,QAAQ,EAAE,IAAI,CAAA;KAAE,GAAG;QAAE,KAAK,EAAE,IAAI,CAAC;QAAC,QAAQ,EAAE,KAAK,CAAA;KAAE,CAAC;IACvE,OAAO,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC"}

package/dist/utils/equality.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Deep equality check with circular reference handling
+ */
+export declare function deepEqual<T>(a: T, b: T, seen?: WeakMap<WeakKey, any>): boolean;
+/**
+ * Shallow equality check (more performant for simple cases)
+ */
+export declare function shallowEqual<T>(a: T, b: T): boolean;
+//# sourceMappingURL=equality.d.ts.map

package/dist/utils/equality.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equality.d.ts","sourceRoot":"","sources":["../../src/utils/equality.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,wBAAgB,GAAG,OAAO,CA4DtE;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,OAAO,CAWnD"}