@blac/core 2.0.0-rc.1 → 2.0.0-rc.3

package/dist/index.d.ts

@@ -1,17 +1,868 @@
-export * from './Blac';
-export * from './Bloc';
-export * from './BlocBase';
-export * from './Cubit';
-export * from './types';
-export * from './events';
-export * from './subscription';
-export * from './lifecycle';
-export * from './utils/uuid';
-export * from './utils/shallowEqual';
-export * from './utils/generateInstanceId';
-export * from './utils/RerenderLogger';
-export * from './testing';
-export * from './adapter';
-export * from './plugins';
-export * from './errors';
+//#region src/core/StateContainerRegistry.d.ts
+
+/**
+ * Registry for managing StateContainer instances
+ */
+declare class StateContainerRegistry {
+  private readonly instances;
+  private readonly types;
+  /**
+   * Register a type with isolation mode
+   */
+  register<T extends StateContainer<any>>(constructor: new (...args: any[]) => T, isolated?: boolean): void;
+  /**
+   * Get or create a StateContainer instance
+   * For isolated: always creates new
+   * For shared: singleton per key
+   */
+  getOrCreate<T extends StateContainer<any>>(constructor: new (...args: any[]) => T, key?: string, ...args: any[]): T;
+  /**
+   * Release a reference to an instance
+   * Disposes when ref count reaches zero (unless keepAlive)
+   */
+  release<T extends StateContainer<any>>(constructor: new (...args: any[]) => T, key?: string, forceDispose?: boolean): void;
+  /**
+   * Get all instances of a type (shared only, isolated aren't tracked)
+   */
+  getAll<T extends StateContainer<any>>(constructor: new (...args: any[]) => T): T[];
+  /**
+   * Clear all instances of a type
+   */
+  clear<T extends StateContainer<any>>(constructor: new (...args: any[]) => T): void;
+  /**
+   * Clear all instances from all types (for testing)
+   */
+  clearAll(): void;
+  /**
+   * Get registry statistics (for debugging)
+   */
+  getStats(): {
+    registeredTypes: number;
+    totalInstances: number;
+    typeBreakdown: Record<string, number>;
+  };
+  /**
+   * Get reference count for an instance
+   */
+  getRefCount<T extends StateContainer<any>>(constructor: new (...args: any[]) => T, key?: string): number;
+  /**
+   * Check if an instance exists
+   */
+  hasInstance<T extends StateContainer<any>>(constructor: new (...args: any[]) => T, key?: string): boolean;
+}
+/**
+ * Global default registry instance
+ */
+declare const globalRegistry: StateContainerRegistry;
+//#endregion
+//#region src/core/StateContainer.d.ts
+/**
+ * Configuration options for StateContainer
+ */
+interface StateContainerConfig {
+  /** Container name for debugging */
+  name?: string;
+  /** Whether to keep container alive when no consumers */
+  keepAlive?: boolean;
+  /** Enable debug logging */
+  debug?: boolean;
+  /** Custom instance identifier */
+  instanceId?: string;
+  /** Whether this instance should be isolated (not shared) */
+  isolated?: boolean;
+}
+/**
+ * Listener function for state changes
+ */
+type StateListener<S$1> = (state: S$1) => void;
+/**
+ * Base abstract class for all state containers
+ */
+declare abstract class StateContainer<S$1> {
+  private static _registry;
+  /**
+   * Set a custom registry (mainly for testing)
+   */
+  static setRegistry(registry: StateContainerRegistry): void;
+  /**
+   * Register a type as isolated or shared
+   */
+  static register<T extends StateContainer<any>>(this: new (...args: any[]) => T, isolated?: boolean): void;
+  /**
+   * Get or create an instance
+   * @param key - Optional instance key for shared instances
+   * @param args - Constructor arguments
+   */
+  static getOrCreate<T extends StateContainer<any>>(this: new (...args: any[]) => T, key?: string, ...args: any[]): T;
+  /**
+   * Release a reference to an instance
+   * @param key - Optional instance key
+   * @param forceDispose - Force dispose regardless of ref count or keepAlive
+   */
+  static release<T extends StateContainer<any>>(this: new (...args: any[]) => T, key?: string, forceDispose?: boolean): void;
+  /**
+   * Get all instances of this type
+   */
+  static getAll<T extends StateContainer<any>>(this: new (...args: any[]) => T): T[];
+  /**
+   * Clear all instances of this type
+   */
+  static clear<T extends StateContainer<any>>(this: new (...args: any[]) => T): void;
+  /**
+   * Clear all instances from all types (for testing)
+   */
+  static clearAllInstances(): void;
+  /**
+   * Get registry statistics (for debugging)
+   */
+  static getStats(): {
+    registeredTypes: number;
+    totalInstances: number;
+    typeBreakdown: Record<string, number>;
+  };
+  /**
+   * Get reference count for an instance
+   * @param key - Optional instance key
+   */
+  static getRefCount<T extends StateContainer<any>>(this: new (...args: any[]) => T, key?: string): number;
+  /**
+   * Check if an instance exists
+   * @param key - Optional instance key
+   */
+  static hasInstance<T extends StateContainer<any>>(this: new (...args: any[]) => T, key?: string): boolean;
+  private _state;
+  private readonly listeners;
+  private _disposed;
+  private readonly config;
+  readonly name: string;
+  readonly keepAlive: boolean;
+  readonly debug: boolean;
+  readonly instanceId: string;
+  /**
+   * Create a new StateContainer
+   */
+  constructor(initialState: S$1, config?: StateContainerConfig);
+  /**
+   * Get the current state
+   */
+  get state(): S$1;
+  /**
+   * Check if disposed
+   */
+  get isDisposed(): boolean;
+  /**
+   * Subscribe to state changes
+   * @returns Unsubscribe function
+   */
+  subscribe(listener: StateListener<S$1>): () => void;
+  /**
+   * Dispose the container
+   */
+  dispose(): void;
+  /**
+   * Emit a new state (with change detection)
+   */
+  protected emit(newState: S$1): void;
+  /**
+   * Update state using a function
+   */
+  protected update(updater: (current: S$1) => S$1): void;
+  /**
+   * Optional disposal hook for subclasses
+   */
+  protected onDispose?(): void;
+  /**
+   * Optional state change hook for subclasses
+   */
+  protected onStateChange?(newState: S$1, previousState: S$1): void;
+}
+//#endregion
+//#region src/core/Cubit.d.ts
+/**
+ * Cubit is a simple state container that allows direct state emission
+ *
+ * Unlike StateContainer (where emit is protected), Cubit exposes emit and update
+ * as public methods to allow direct state management.
+ */
+declare abstract class Cubit<S$1> extends StateContainer<S$1> {
+  /**
+   * Create a new Cubit
+   * @param initialState Initial state value
+   * @param config Configuration options
+   */
+  constructor(initialState: S$1, config?: StateContainerConfig);
+  /**
+   * Emit a new state (public override of protected parent method)
+   */
+  emit(newState: S$1): void;
+  /**
+   * Update state using a function (public override of protected parent method)
+   */
+  update(updater: (current: S$1) => S$1): void;
+  /**
+   * Patch state with partial updates (shallow merge)
+   * Only available when state is an object type
+   * Arrow function to maintain correct 'this' binding in React
+   *
+   * @example
+   * ```typescript
+   * // Update single field
+   * this.patch({ count: 5 });
+   *
+   * // Update multiple fields
+   * this.patch({ count: 5, name: 'Updated' });
+   * ```
+   */
+  patch: S$1 extends object ? (partial: Partial<S$1>) => void : never;
+}
+/**
+ * Example: Counter Cubit
+ */
+declare class CounterCubit extends Cubit<number> {
+  constructor();
+  increment: () => void;
+  decrement: () => void;
+  reset: () => void;
+  addAmount: (amount: number) => void;
+}
+/**
+ * Example: Complex State Cubit
+ */
+interface TodoState {
+  todos: Array<{
+    id: string;
+    text: string;
+    done: boolean;
+  }>;
+  filter: 'all' | 'active' | 'completed';
+  isLoading: boolean;
+}
+declare class TodoCubit extends Cubit<TodoState> {
+  private nextId;
+  constructor();
+  addTodo: (text: string) => void;
+  toggleTodo: (id: string) => void;
+  removeTodo: (id: string) => void;
+  setFilter: (filter: TodoState["filter"]) => void;
+  setLoading: (isLoading: boolean) => void;
+  get visibleTodos(): {
+    id: string;
+    text: string;
+    done: boolean;
+  }[];
+  get activeTodoCount(): number;
+}
+//#endregion
+//#region src/types/events.d.ts
+/**
+ * Base event interface for type-safe event system
+ */
+/**
+ * Base event interface
+ * Used by Vertex for event-driven state management
+ */
+interface BaseEvent {
+  readonly type: string;
+  readonly timestamp: number;
+  readonly source?: string;
+}
+//#endregion
+//#region src/core/Vertex.d.ts
+/**
+ * Event handler signature (synchronous only)
+ */
+type EventHandler<E extends BaseEvent, S$1> = (event: E, emit: (state: S$1) => void) => void;
+/**
+ * Type-safe event constructor
+ */
+type EventConstructor<T$1 extends BaseEvent = BaseEvent> = new (...args: never[]) => T$1;
+/**
+ * Vertex is an event-driven state container (Bloc pattern)
+ *
+ * Includes its own simple event system since events are only needed
+ * for the Vertex pattern, not for the base StateContainer.
+ */
+declare abstract class Vertex<S$1, E extends BaseEvent = BaseEvent> extends StateContainer<S$1> {
+  private eventHandlers;
+  private isProcessing;
+  private eventQueue;
+  /**
+   * Create a new Vertex
+   * @param initialState Initial state value
+   * @param config Configuration options
+   */
+  constructor(initialState: S$1, config?: StateContainerConfig);
+  /**
+   * Register an event handler
+   * Arrow function to maintain correct 'this' binding
+   */
+  protected on: <T extends E>(EventClass: EventConstructor<T>, handler: EventHandler<T, S$1>) => void;
+  /**
+   * Add an event to be processed
+   * Arrow function to maintain correct 'this' binding in React
+   */
+  add: (event: E) => void;
+  /**
+   * Process an event (synchronously)
+   */
+  private processEvent;
+  /**
+   * Handle a single event (synchronously)
+   */
+  private handleEvent;
+  /**
+   * Hook for handling event processing errors
+   */
+  protected onEventError(event: E, error: Error): void;
+}
+/**
+ * Example: Counter Events
+ */
+declare class IncrementEvent implements BaseEvent {
+  readonly amount: number;
+  readonly type = "increment";
+  readonly timestamp: number;
+  constructor(amount?: number);
+}
+declare class DecrementEvent implements BaseEvent {
+  readonly amount: number;
+  readonly type = "decrement";
+  readonly timestamp: number;
+  constructor(amount?: number);
+}
+declare class ResetEvent implements BaseEvent {
+  readonly type = "reset";
+  readonly timestamp: number;
+}
+/**
+ * Example: Counter Vertex
+ * Demonstrates proper typing and event handling
+ */
+declare class CounterVertex extends Vertex<number> {
+  constructor();
+  increment: (amount?: number) => void;
+  decrement: (amount?: number) => void;
+  reset: () => void;
+}
+/**
+ * Auth State and Events for testing async handlers
+ */
+interface AuthState {
+  isAuthenticated: boolean;
+  isLoading: boolean;
+  user: {
+    id: string;
+    name: string;
+    email: string;
+  } | null;
+  error: string | null;
+}
+declare class LoginEvent implements BaseEvent {
+  readonly email: string;
+  readonly password: string;
+  readonly type = "login";
+  readonly timestamp: number;
+  constructor(email: string, password: string);
+}
+declare class LogoutEvent implements BaseEvent {
+  readonly type = "logout";
+  readonly timestamp: number;
+}
+declare class AuthVertex extends Vertex<AuthState> {
+  constructor();
+  login: (email: string, password: string) => void;
+  logout: () => void;
+}
+//#endregion
+//#region src/types/branded.d.ts
+/**
+ * Branded types for type-safe IDs
+ * These types ensure that IDs can't be accidentally mixed up
+ */
+/**
+ * Helper type for cases where any object type is acceptable
+ * Used sparingly only where type cannot be more specific
+ * eslint-disable-next-line @typescript-eslint/no-explicit-any
+ */
+type AnyObject = any;
+/** Unique symbol for branding */
+declare const brand: unique symbol;
+/** Type branding utility */
+type Brand<T$1, B> = T$1 & {
+  [brand]: B;
+};
+/** Generic branded ID type */
+type BrandedId<B> = Brand<string, B>;
+/** Branded instance ID type */
+type InstanceId = Brand<string, 'InstanceId'>;
+//#endregion
+//#region src/tracking/proxy-tracker.d.ts
+/**
+ * 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.
+ */
+declare function isProxyable(value: unknown): value is object;
+/**
+ * State container for proxy tracking
+ */
+interface ProxyTrackerState<T$1> {
+  /** 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$1 | null;
+  /** Last proxy created (for cache reuse) */
+  lastProxy: T$1 | 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);
+ */
+declare function createProxyTrackerState<T$1>(): ProxyTrackerState<T$1>;
+/**
+ * Start tracking property accesses
+ *
+ * Clears previous tracked paths and enables tracking mode.
+ */
+declare function startProxyTracking<T$1>(state: ProxyTrackerState<T$1>): void;
+/**
+ * Stop tracking and return the tracked paths
+ *
+ * Returns a new Set containing all tracked paths.
+ */
+declare function stopProxyTracking<T$1>(state: ProxyTrackerState<T$1>): 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.)
+ */
+declare function createArrayProxy<T$1, U>(state: ProxyTrackerState<T$1>, 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.
+ */
+declare function createProxyInternal<T$1>(state: ProxyTrackerState<T$1>, target: T$1, path?: string, depth?: number): T$1;
+/**
+ * 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.
+ */
+declare function createProxyForTarget<T$1>(state: ProxyTrackerState<T$1>, target: T$1): T$1;
+//#endregion
+//#region src/tracking/dependency-tracker.d.ts
+/**
+ * Information about a tracked path
+ */
+interface PathInfo {
+  /** Parsed path segments */
+  segments: string[];
+  /** Last known value at this path */
+  value: any;
+}
+/**
+ * State for dependency tracking
+ */
+interface TrackerState<T$1 extends AnyObject> {
+  /** Internal proxy tracker state */
+  proxyTrackerState: ProxyTrackerState<T$1>;
+  /** Paths tracked in the previous render */
+  previousRenderPaths: Set<string>;
+  /** Paths tracked in the current render */
+  currentRenderPaths: Set<string>;
+  /** Cache of parsed paths and their values */
+  pathCache: Map<string, PathInfo>;
+  /** Last state object that was checked for changes */
+  lastCheckedState: T$1 | null;
+  /** Values from the last change check (optimization) */
+  lastCheckedValues: Map<string, any>;
+  /** Counter for periodic cleanup of unused paths */
+  cleanupCounter: number;
+}
+/**
+ * Create a new tracker state
+ */
+declare function createTrackerState<T$1 extends AnyObject>(): TrackerState<T$1>;
+/**
+ * Start tracking property accesses
+ */
+declare function startTracking<T$1 extends AnyObject>(tracker: TrackerState<T$1>): void;
+/**
+ * Create a proxy for the given state
+ */
+declare function createProxy<T$1 extends AnyObject>(tracker: TrackerState<T$1>, state: T$1): T$1;
+/**
+ * Capture the paths that were tracked during a render
+ *
+ * This should be called after each render to record which paths were accessed.
+ * It also performs periodic cleanup of unused paths to prevent memory leaks.
+ */
+declare function captureTrackedPaths<T$1 extends AnyObject>(tracker: TrackerState<T$1>, state: T$1): void;
+/**
+ * Check if any tracked paths have changed
+ *
+ * This is called when state changes to determine if a re-render is needed.
+ * Returns true if any tracked path has a different value than before.
+ */
+declare function hasChanges<T$1 extends AnyObject>(tracker: TrackerState<T$1>, state: T$1): boolean;
+/**
+ * Check if tracker has any tracked data
+ *
+ * Returns true if there are any tracked paths or cached paths.
+ */
+declare function hasTrackedData<T$1 extends AnyObject>(tracker: TrackerState<T$1>): boolean;
+//#endregion
+//#region src/tracking/path-utils.d.ts
+/**
+ * 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']
+ */
+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
+ */
+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
+ */
+declare function shallowEqual(arr1: unknown[], arr2: unknown[]): boolean;
+//#endregion
+//#region src/proxy/ProxyTracker.d.ts
+/**
+ * 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
+ */
+declare class ProxyTracker<T$1> {
+  private trackedPaths;
+  private isTracking;
+  private proxyCache;
+  private maxDepth;
+  /**
+   * Create a proxy that tracks property access
+   */
+  createProxy(target: T$1, path?: string, depth?: number): T$1;
+  /**
+   * 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
+ */
+declare const globalProxyTracker: ProxyTracker<unknown>;
+/**
+ * Utility function to track property access in a callback
+ */
+declare function trackAccess<T$1, R>(state: T$1, callback: (proxiedState: T$1) => R): {
+  result: R;
+  trackedPaths: Set<string>;
+};
+//#endregion
+//#region src/types/utilities.d.ts
+/**
+ * Extract state type from StateContainer
+ *
+ * @example
+ * ```ts
+ * class CounterBloc extends Cubit<number> { ... }
+ * type State = ExtractState<CounterBloc>; // number
+ * ```
+ */
+type ExtractState<T$1> = T$1 extends StateContainer<infer S> ? S : never;
+/**
+ * Extract constructor parameter types from a Bloc class
+ *
+ * @example
+ * ```ts
+ * class UserBloc extends Cubit<UserState> {
+ *   constructor(userId: string, config: Config) { ... }
+ * }
+ * type Args = ExtractConstructorArgs<typeof UserBloc>; // [string, Config]
+ * ```
+ */
+type ExtractConstructorArgs<T$1> = T$1 extends (new (...args: infer P) => AnyObject) ? P : never[];
+/**
+ * Bloc constructor type - represents a class constructor for StateContainer subclasses
+ * Includes static methods from StateContainer for instance management
+ *
+ * Note: Uses `any` for state type to support variance - the actual Bloc instance
+ * will have the correct specific types inferred at usage sites.
+ *
+ * @example
+ * ```ts
+ * function createBloc<TBloc extends StateContainer<any>>(
+ *   BlocClass: BlocConstructor<TBloc>
+ * ): TBloc {
+ *   return BlocClass.getOrCreate();
+ * }
+ * ```
+ */
+type BlocConstructor<TBloc extends StateContainer<any>> = (new (...args: any[]) => TBloc) & {
+  getOrCreate?(instanceKey?: string, ...args: any[]): TBloc;
+  release?(instanceKey?: string): void;
+  isolated?: boolean;
+  keepAlive?: boolean;
+};
+//#endregion
+//#region src/logging/Logger.d.ts
+declare enum LogLevel {
+  ERROR = 0,
+  WARN = 1,
+  INFO = 2,
+  DEBUG = 3,
+}
+interface LogEntry {
+  level: string;
+  context: string;
+  message: string;
+  data?: any;
+  timestamp: number;
+}
+interface LogConfig {
+  enabled: boolean;
+  level: LogLevel;
+  output: (entry: LogEntry) => void;
+}
+/**
+ * Creates a logger instance with given configuration
+ *
+ * @param config - Logger configuration
+ * @returns Logger instance with debug, info, warn, error, and configure methods
+ *
+ * @example
+ * ```ts
+ * const logger = createLogger({
+ *   enabled: true,
+ *   level: LogLevel.DEBUG,
+ *   output: (entry) => console.log(JSON.stringify(entry))
+ * });
+ * logger.debug('MyComponent', 'Rendering', { props: { foo: 'bar' } });
+ * ```
+ */
+declare function createLogger(config: LogConfig): {
+  debug: (context: string, message: string, data?: any) => void;
+  info: (context: string, message: string, data?: any) => void;
+  warn: (context: string, message: string, data?: any) => void;
+  error: (context: string, message: string, data?: any) => void;
+  configure: (opts: Partial<LogConfig>) => void;
+};
+declare const debug: (context: string, message: string, data?: any) => void;
+declare const info: (context: string, message: string, data?: any) => void;
+declare const warn: (context: string, message: string, data?: any) => void;
+declare const error: (context: string, message: string, data?: any) => void;
+/**
+ * Configuration function that recreates the default logger
+ *
+ * @param opts - Partial logger configuration
+ *
+ * @example
+ * ```ts
+ * configureLogger({ enabled: true, level: LogLevel.DEBUG });
+ * ```
+ */
+declare function configureLogger(opts: Partial<LogConfig>): void;
+//#endregion
+//#region src/constants.d.ts
+/**
+ * Default configuration constants for BlaC
+ *
+ * Centralized location for all magic numbers and default values.
+ */
+/**
+ * Default configuration constants for BlaC
+ */
+declare const BLAC_DEFAULTS: {
+  /**
+   * Default cleanup interval for subscriptions (30 seconds)
+   */
+  readonly CLEANUP_INTERVAL_MS: 30000;
+  /**
+   * Cleanup interval for weak reference stage (10 seconds)
+   */
+  readonly WEAKREF_CLEANUP_INTERVAL_MS: 10000;
+  /**
+   * Default maximum subscriptions per container
+   */
+  readonly MAX_SUBSCRIPTIONS: 1000;
+  /**
+   * Maximum subscriptions for high-performance mode
+   */
+  readonly MAX_SUBSCRIPTIONS_HIGH_PERF: 10000;
+  /**
+   * Default timeout for pipeline execution (5 seconds)
+   */
+  readonly PIPELINE_TIMEOUT_MS: 5000;
+  /**
+   * Cleanup interval for high-performance mode (5 seconds)
+   */
+  readonly CLEANUP_INTERVAL_HIGH_PERF_MS: 5000;
+  /**
+   * Maximum number of stages in a pipeline
+   */
+  readonly MAX_PIPELINE_STAGES: 30;
+};
+//#endregion
+//#region src/utils/idGenerator.d.ts
+/**
+ * Centralized ID Generation
+ *
+ * Provides consistent, collision-resistant ID generation for all BlaC subsystems.
+ * Uses timestamp + counter + random suffix for uniqueness.
+ */
+/**
+ * Creates an ID generator with isolated counter state
+ *
+ * @param prefix - Prefix for generated IDs
+ * @returns Object with next(), nextSimple(), and reset() methods
+ *
+ * @example
+ * ```ts
+ * const generator = createIdGenerator('sub');
+ * const id1 = generator.next(); // "sub_1698765432100_1_a3k9d7f2q"
+ * const id2 = generator.next(); // "sub_1698765432101_2_b4n8e9g3r"
+ * ```
+ */
+declare function createIdGenerator(prefix: string): {
+  next: () => string;
+  nextSimple: () => string;
+  reset: () => void;
+};
+/**
+ * Generate ID with timestamp, counter, and random suffix (tree-shakeable)
+ *
+ * Format: `${prefix}_${timestamp}_${counter}_${random}`
+ *
+ * @param prefix - Prefix for the ID (e.g., 'sub', 'consumer', 'stage')
+ * @returns Branded ID string
+ *
+ * @example
+ * ```ts
+ * const id = generateId('sub');
+ * // Returns: "sub_1698765432100_1_a3k9d7f2q"
+ * ```
+ */
+declare function generateId(prefix: string): string;
+/**
+ * Generate simple ID with timestamp and random (no counter tracking)
+ *
+ * Format: `${prefix}_${timestamp}_${random}`
+ *
+ * @param prefix - Prefix for the ID
+ * @returns Branded ID string
+ *
+ * @example
+ * ```ts
+ * const id = generateSimpleId('CounterBloc');
+ * // Returns: "CounterBloc_1698765432100_a3k9d7f2q"
+ * ```
+ */
+declare function generateSimpleId(prefix: string): string;
+/**
+ * Reset all counters for testing purposes
+ * @internal
+ */
+declare function __resetIdCounters(): void;
+//#endregion
+export { type AnyObject, AuthState, AuthVertex, BLAC_DEFAULTS, type BaseEvent, BlocConstructor, type Brand, type BrandedId, CounterCubit, CounterVertex, Cubit, DecrementEvent, EventConstructor, EventHandler, ExtractConstructorArgs, ExtractState, IncrementEvent, type InstanceId, type LogConfig, type LogEntry, LogLevel, LoginEvent, LogoutEvent, PathInfo, ProxyTracker, ProxyTrackerState, ResetEvent, StateContainer, StateContainerConfig, StateContainerRegistry, TodoCubit, TodoState, TrackerState, Vertex, __resetIdCounters, captureTrackedPaths, configureLogger, createArrayProxy, createIdGenerator, createLogger, createProxy, createProxyForTarget, createProxyInternal, createProxyTrackerState, createTrackerState, debug, error, generateId, generateSimpleId, getValueAtPath, globalProxyTracker, globalRegistry, hasChanges, hasTrackedData, info, isProxyable, parsePath, shallowEqual, startProxyTracking, startTracking, stopProxyTracking, trackAccess, warn };
 //# sourceMappingURL=index.d.ts.map