@blac/core 2.0.1 → 2.0.3

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["error","instance","MAX_GETTER_DEPTH","error","instance","error","error","url","lineNum","col","error","error","fullPath","info","error","instance","error","instance"],"sources":["../src/utils/idGenerator.ts","../src/plugin/PluginManager.ts","../src/constants.ts","../src/tracking/getter-tracker.ts","../src/core/markers.ts","../src/utils/static-props.ts","../src/core/StateContainerRegistry.ts","../src/core/StateContainer.ts","../src/core/Cubit.ts","../src/core/Vertex.ts","../src/core/StatelessCubit.ts","../src/core/StatelessVertex.ts","../src/plugin/BlacPlugin.ts","../src/tracking/proxy-tracker.ts","../src/tracking/path-utils.ts","../src/tracking/dependency-tracker.ts","../src/tracking/tracking-proxy.ts","../src/tracking/dependency-manager.ts","../src/tracking/tracked.ts","../src/adapter/framework-adapter.ts","../src/logging/Logger.ts","../src/config.ts","../src/decorators/blac.ts","../src/registry/acquire.ts","../src/registry/borrow.ts","../src/registry/ensure.ts","../src/registry/release.ts","../src/registry/queries.ts","../src/registry/management.ts","../src/registry/config.ts","../src/waitUntil/errors.ts","../src/waitUntil/waitUntil.ts","../src/watch/watch.ts"],"sourcesContent":["/**\n * Centralized ID Generation\n *\n * Provides consistent, collision-resistant ID generation for all BlaC subsystems.\n * Uses timestamp + counter + random suffix for uniqueness.\n */\n\n// Global counter map for ID generation\nconst globalCounters = new Map<string, number>();\n\n/**\n * Creates an ID generator with isolated counter state\n *\n * @param prefix - Prefix for generated IDs\n * @returns Object with next(), nextSimple(), and reset() methods\n *\n * @example\n * ```ts\n * const generator = createIdGenerator('sub');\n * const id1 = generator.next(); // \"sub:1698765432100_1_a3k9d7f2q\"\n * const id2 = generator.next(); // \"sub:1698765432101_2_b4n8e9g3r\"\n * ```\n */\nexport function createIdGenerator(prefix: string) {\n  let counter = 0;\n  return {\n    next: () =>\n      `${prefix}:${Date.now()}_${++counter}_${Math.random().toString(36).substring(2, 11)}`,\n    nextSimple: () => `${prefix}:${++counter}`,\n    reset: () => {\n      counter = 0;\n    },\n  };\n}\n\n/**\n * Generate ID with timestamp, counter, and random suffix (tree-shakeable)\n *\n * Format: `${prefix}:${timestamp}_${counter}_${random}`\n *\n * @param prefix - Prefix for the ID (e.g., 'sub', 'consumer', 'stage')\n * @returns Branded ID string\n *\n * @example\n * const id = generateId('sub');\n * // Returns: \"sub:1698765432100_1_a3k9d7f2q\"\n */\nexport function generateId(prefix: string): string {\n  const counter = (globalCounters.get(prefix) ?? 0) + 1;\n  globalCounters.set(prefix, counter);\n  const timestamp = Date.now();\n  const random = Math.random().toString(36).substring(2, 11);\n  return `${prefix}:${timestamp}_${counter}_${random}`;\n}\n\n/**\n * Generate simple ID with timestamp and random (no counter tracking)\n *\n * Format: `${prefix}:${timestamp}_${random}`\n *\n * @param prefix - Prefix for the ID\n * @returns Branded ID string\n *\n * @example\n * ```ts\n * const id = generateSimpleId('CounterBloc');\n * // Returns: \"CounterBloc:1698765432100_a3k9d7f2q\"\n * ```\n */\nexport function generateSimpleId(prefix: string, affix?: string): string {\n  if (affix) {\n    return `${prefix}:${affix}`;\n  }\n  const timestamp = Date.now();\n  const random = Math.random().toString(36).substring(2, 11);\n  return `${prefix}:${timestamp}_${random}`;\n}\n\n/**\n * Reset all counters for testing purposes\n * @internal\n */\nexport function __resetIdCounters(): void {\n  globalCounters.clear();\n}\n\n/**\n * Generate a unique isolated instance key\n * Uses base36 encoding for compact, URL-safe identifiers\n *\n * Format: \"isolated-{9-char-random-string}\"\n * Example: \"isolated-k7x2m9p4q\"\n *\n * @returns A unique isolated instance key\n */\nexport function generateIsolatedKey(): string {\n  const randomPart = Math.random().toString(36).slice(2, 11);\n  return `isolated-${randomPart}`;\n}\n\n/**\n * Check if a key is an isolated instance key\n * @param key - The instance key to check\n * @returns true if the key is an isolated instance key\n */\nexport function isIsolatedKey(key: string): boolean {\n  return key.startsWith('isolated-');\n}\n","import type { StateContainer } from '../core/StateContainer';\nimport type { StateContainerRegistry } from '../core/StateContainerRegistry';\nimport type {\n  BlacPlugin,\n  PluginContext,\n  PluginConfig,\n  InstanceMetadata,\n} from './BlacPlugin';\n\n/**\n * Internal structure for tracking installed plugins\n * @internal\n */\ninterface InstalledPlugin {\n  plugin: BlacPlugin;\n  config: PluginConfig;\n  context: PluginContext;\n}\n\n/**\n * Manages plugin lifecycle for the BlaC state management system.\n * Plugins receive notifications about state container lifecycle events.\n *\n * @example\n * ```ts\n * const manager = createPluginManager(registry);\n * manager.install(myPlugin, { environment: 'development' });\n * ```\n */\nexport class PluginManager {\n  private plugins = new Map<string, InstalledPlugin>();\n  private registry: StateContainerRegistry;\n\n  /**\n   * Create a new PluginManager\n   * @param registry - The StateContainerRegistry to monitor for lifecycle events\n   */\n  constructor(registry: StateContainerRegistry) {\n    this.registry = registry;\n    this.setupLifecycleHooks();\n  }\n\n  /**\n   * Install a plugin with optional configuration\n   * @param plugin - The plugin to install\n   * @param config - Optional plugin configuration\n   * @throws Error if plugin is already installed\n   */\n  install(plugin: BlacPlugin, config: PluginConfig = {}): void {\n    const effectiveConfig: PluginConfig = {\n      enabled: true,\n      environment: 'all',\n      ...config,\n    };\n\n    if (!this.shouldEnablePlugin(effectiveConfig)) {\n      console.log(\n        `[BlaC] Plugin \"${plugin.name}\" skipped (environment mismatch)`,\n      );\n      return;\n    }\n\n    if (this.plugins.has(plugin.name)) {\n      throw new Error(`Plugin \"${plugin.name}\" is already installed`);\n    }\n\n    const context = this.createPluginContext();\n\n    this.plugins.set(plugin.name, {\n      plugin,\n      config: effectiveConfig,\n      context,\n    });\n\n    if (plugin.onInstall) {\n      try {\n        plugin.onInstall(context);\n      } catch (error) {\n        console.error(\n          `[BlaC] Error installing plugin \"${plugin.name}\":`,\n          error,\n        );\n        this.plugins.delete(plugin.name);\n        throw error;\n      }\n    }\n\n    console.log(`[BlaC] Plugin \"${plugin.name}\" v${plugin.version} installed`);\n  }\n\n  /**\n   * Uninstall a plugin by name\n   * @param pluginName - The name of the plugin to uninstall\n   * @throws Error if plugin is not installed\n   */\n  uninstall(pluginName: string): void {\n    const installed = this.plugins.get(pluginName);\n    if (!installed) {\n      throw new Error(`Plugin \"${pluginName}\" is not installed`);\n    }\n\n    if (installed.plugin.onUninstall) {\n      try {\n        installed.plugin.onUninstall();\n      } catch (error) {\n        console.error(\n          `[BlaC] Error uninstalling plugin \"${pluginName}\":`,\n          error,\n        );\n      }\n    }\n\n    this.plugins.delete(pluginName);\n    console.log(`[BlaC] Plugin \"${pluginName}\" uninstalled`);\n  }\n\n  /**\n   * Get an installed plugin by name\n   * @param pluginName - The name of the plugin to retrieve\n   * @returns The plugin instance or undefined if not found\n   */\n  getPlugin(pluginName: string): BlacPlugin | undefined {\n    return this.plugins.get(pluginName)?.plugin;\n  }\n\n  /**\n   * Get all installed plugins\n   * @returns Array of all installed plugins\n   */\n  getAllPlugins(): BlacPlugin[] {\n    return Array.from(this.plugins.values()).map((p) => p.plugin);\n  }\n\n  /**\n   * Check if a plugin is installed\n   * @param pluginName - The name of the plugin to check\n   * @returns true if the plugin is installed\n   */\n  hasPlugin(pluginName: string): boolean {\n    return this.plugins.has(pluginName);\n  }\n\n  /**\n   * Uninstall all plugins\n   */\n  clear(): void {\n    for (const name of this.plugins.keys()) {\n      this.uninstall(name);\n    }\n  }\n\n  /**\n   * Setup lifecycle hooks to notify plugins\n   */\n  private setupLifecycleHooks(): void {\n    // Instance created\n    this.registry.on('created', (instance) => {\n      this.notifyPlugins('onInstanceCreated', instance);\n    });\n\n    // State changed\n    this.registry.on(\n      'stateChanged',\n      (instance, previousState, currentState, callstack) => {\n        this.notifyPlugins(\n          'onStateChanged',\n          instance,\n          previousState,\n          currentState,\n          callstack,\n        );\n      },\n    );\n\n    // Event added\n    this.registry.on('eventAdded', (vertex, event) => {\n      this.notifyPlugins('onEventAdded', vertex, event);\n    });\n\n    // Instance disposed\n    this.registry.on('disposed', (instance) => {\n      this.notifyPlugins('onInstanceDisposed', instance);\n    });\n  }\n\n  /**\n   * Notify all plugins of a lifecycle event\n   */\n  private notifyPlugins(hookName: keyof BlacPlugin, ...args: any[]): void {\n    for (const { plugin, config, context } of this.plugins.values()) {\n      if (!config.enabled) continue;\n\n      const hook = plugin[hookName];\n      if (typeof hook === 'function') {\n        try {\n          (hook as any).apply(plugin, [...args, context]);\n        } catch (error) {\n          console.error(\n            `[BlaC] Error in plugin \"${plugin.name}\" ${hookName}:`,\n            error,\n          );\n        }\n      }\n    }\n  }\n\n  /**\n   * Create plugin context with safe API access\n   */\n  private createPluginContext(): PluginContext {\n    return {\n      getInstanceMetadata: (\n        instance: StateContainer<any>,\n      ): InstanceMetadata => {\n        // const TypeClass = instance.constructor as any;\n\n        // if (TypeClass.instances) {\n        //   for (const [key, entry] of TypeClass.instances) {\n        //     if (entry.instance === instance) {\n        //       break;\n        //     }\n        //   }\n        // }\n\n        return {\n          id: instance.instanceId,\n          className: instance.constructor.name,\n          isDisposed: instance.isDisposed,\n          name: instance.name,\n          lastStateChangeTimestamp: instance.lastUpdateTimestamp,\n          createdAt: instance.createdAt,\n          state: instance.state,\n          isIsolated: instance.instanceId.startsWith('isolated-'),\n        };\n      },\n\n      getState: <S extends object = any>(instance: StateContainer<S>): S => {\n        return instance.state;\n      },\n\n      queryInstances: <T extends StateContainer<any>>(\n        typeClass: new (...args: any[]) => T,\n      ): T[] => {\n        return this.registry.getAll(typeClass as any);\n      },\n\n      getAllTypes: () => {\n        return this.registry.getTypes();\n      },\n\n      getStats: () => {\n        return this.registry.getStats();\n      },\n    };\n  }\n\n  /**\n   * Check if plugin should be enabled based on environment\n   */\n  private shouldEnablePlugin(config: PluginConfig): boolean {\n    if (!config.enabled) return false;\n    if (config.environment === 'all') return true;\n\n    const currentEnv = this.getCurrentEnvironment();\n    return currentEnv === config.environment;\n  }\n\n  /**\n   * Get current environment\n   */\n  private getCurrentEnvironment(): 'development' | 'production' | 'test' {\n    if (typeof process !== 'undefined') {\n      if (process.env.NODE_ENV === 'test') return 'test';\n      if (process.env.NODE_ENV === 'production') return 'production';\n      return 'development';\n    }\n    return 'development';\n  }\n}\n\n/**\n * Create a plugin manager instance\n * @param registry - The StateContainerRegistry to monitor for lifecycle events\n * @returns A new PluginManager instance\n */\nexport function createPluginManager(\n  registry: StateContainerRegistry,\n): PluginManager {\n  return new PluginManager(registry);\n}\n","/**\n * Default configuration constants for BlaC\n *\n * Centralized location for all magic numbers and default values.\n */\n\n/**\n * Default configuration constants for BlaC\n */\nexport const BLAC_DEFAULTS = {\n  /**\n   * Default instance key for shared instances\n   */\n  DEFAULT_INSTANCE_KEY: 'default',\n\n  /**\n   * Maximum getter nesting depth (prevents infinite recursion)\n   */\n  MAX_GETTER_DEPTH: 10,\n\n  /**\n   * Default cleanup interval for subscriptions (30 seconds)\n   */\n  CLEANUP_INTERVAL_MS: 30_000,\n\n  /**\n   * Cleanup interval for weak reference stage (10 seconds)\n   */\n  WEAKREF_CLEANUP_INTERVAL_MS: 10_000,\n\n  /**\n   * Default maximum subscriptions per container\n   */\n  MAX_SUBSCRIPTIONS: 1_000,\n\n  /**\n   * Maximum subscriptions for high-performance mode\n   */\n  MAX_SUBSCRIPTIONS_HIGH_PERF: 10_000,\n\n  /**\n   * Default timeout for pipeline execution (5 seconds)\n   */\n  PIPELINE_TIMEOUT_MS: 5_000,\n\n  /**\n   * Cleanup interval for high-performance mode (5 seconds)\n   */\n  CLEANUP_INTERVAL_HIGH_PERF_MS: 5_000,\n\n  /**\n   * Maximum number of stages in a pipeline\n   */\n  MAX_PIPELINE_STAGES: 30,\n} as const;\n\n/**\n * Static property names for StateContainer classes\n * Used for feature flags and configuration on bloc classes\n */\nexport const BLAC_STATIC_PROPS = {\n  /**\n   * Mark a bloc as isolated (each component gets its own instance)\n   */\n  ISOLATED: 'isolated',\n\n  /**\n   * Mark a bloc to never be auto-disposed (kept alive permanently)\n   */\n  KEEP_ALIVE: 'keepAlive',\n\n  /**\n   * Exclude a bloc from DevTools reporting (prevents infinite loops)\n   */\n  EXCLUDE_FROM_DEVTOOLS: '__excludeFromDevTools',\n} as const;\n\n/**\n * ID generation patterns and constants\n */\nexport const BLAC_ID_PATTERNS = {\n  /**\n   * Prefix for isolated instance keys\n   */\n  ISOLATED_PREFIX: 'isolated-',\n\n  /**\n   * Length of generated ID portion (9 characters from base36)\n   */\n  ID_LENGTH: 9,\n} as const;\n\n/**\n * Standard error message prefix\n */\nexport const BLAC_ERROR_PREFIX = '[BlaC]' as const;\n","import { BLAC_DEFAULTS, BLAC_ERROR_PREFIX } from '../constants';\nimport { StateContainerInstance } from '../types/utilities';\n\n/**\n * @internal\n */\nexport interface GetterState {\n  trackedValues: Map<string | symbol, unknown>;\n  currentlyAccessing: Set<string | symbol>;\n  trackedGetters: Set<string | symbol>;\n  isTracking: boolean;\n  renderCache: Map<string | symbol, unknown>;\n  cacheValid: boolean;\n  externalDependencies: Set<StateContainerInstance>; // Track external blocs accessed in getters\n}\n\nconst descriptorCache = new WeakMap<\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n  Function,\n  Map<string | symbol, PropertyDescriptor | undefined>\n>();\n\nconst blocProxyCache = new WeakMap<StateContainerInstance>();\n\nconst activeTrackerMap = new WeakMap<StateContainerInstance, GetterState>();\n\n// Global execution context for tracking getter execution\ninterface GetterExecutionContext {\n  tracker: GetterState | null;\n  currentBloc: StateContainerInstance | null;\n  depth: number; // Track nesting depth to detect circular dependencies\n  visitedBlocs: Set<StateContainerInstance>; // Track visited blocs in current call stack\n}\n\nconst getterExecutionContext: GetterExecutionContext = {\n  tracker: null,\n  currentBloc: null,\n  depth: 0,\n  visitedBlocs: new Set(),\n};\n\n// Maximum allowed getter nesting depth to prevent infinite recursion\nconst MAX_GETTER_DEPTH = BLAC_DEFAULTS.MAX_GETTER_DEPTH;\n\n/**\n * @internal\n */\nexport function getGetterExecutionContext(): GetterExecutionContext {\n  return getterExecutionContext;\n}\n\n/**\n * @internal\n */\nexport function getDescriptor(\n  obj: any,\n  prop: string | symbol,\n): PropertyDescriptor | undefined {\n  const constructor = obj.constructor;\n\n  // Try to get from cache\n  let constructorCache = descriptorCache.get(constructor);\n  if (constructorCache?.has(prop)) {\n    return constructorCache.get(prop);\n  }\n\n  // Walk prototype chain to find descriptor\n  let current = obj;\n  let descriptor: PropertyDescriptor | undefined;\n\n  while (current && current !== Object.prototype) {\n    descriptor = Object.getOwnPropertyDescriptor(current, prop);\n    if (descriptor) {\n      break;\n    }\n    current = Object.getPrototypeOf(current);\n  }\n\n  // Cache the result\n  if (!constructorCache) {\n    constructorCache = new Map();\n    descriptorCache.set(constructor, constructorCache);\n  }\n  constructorCache.set(prop, descriptor);\n\n  return descriptor;\n}\n\n/**\n * @internal\n */\nexport function isGetter(obj: any, prop: string | symbol): boolean {\n  const descriptor = getDescriptor(obj, prop);\n  return descriptor?.get !== undefined;\n}\n\n/**\n * @internal\n */\nexport function createGetterState(): GetterState {\n  return {\n    trackedValues: new Map(),\n    currentlyAccessing: new Set(),\n    trackedGetters: new Set(),\n    isTracking: false,\n    renderCache: new Map(),\n    cacheValid: false,\n    externalDependencies: new Set(), // Initialize external dependencies set\n  };\n}\n\n/**\n * @internal\n */\nexport function setActiveTracker<TBloc extends StateContainerInstance>(\n  bloc: TBloc,\n  tracker: GetterState,\n): void {\n  activeTrackerMap.set(bloc, tracker);\n}\n\n/**\n * @internal\n */\nexport function clearActiveTracker<TBloc extends StateContainerInstance>(\n  bloc: TBloc,\n): void {\n  activeTrackerMap.delete(bloc);\n}\n\n/**\n * @internal\n */\nexport function getActiveTracker<TBloc extends StateContainerInstance>(\n  bloc: TBloc,\n): GetterState | undefined {\n  return activeTrackerMap.get(bloc);\n}\n\n/**\n * @internal\n */\nexport function commitTrackedGetters(tracker: GetterState): void {\n  if (tracker.currentlyAccessing.size > 0) {\n    tracker.trackedGetters = new Set(tracker.currentlyAccessing);\n  }\n  tracker.currentlyAccessing.clear();\n}\n\n/**\n * @internal\n */\nexport function createBlocProxy<TBloc extends StateContainerInstance>(\n  bloc: TBloc,\n): TBloc {\n  // Check cache first - return existing proxy if available\n  const cached = blocProxyCache.get(bloc);\n  if (cached) {\n    return cached;\n  }\n\n  const proxy = new Proxy(bloc, {\n    get(target, prop, receiver) {\n      // Get the active tracker for this bloc (set by the framework adapter)\n      const tracker = activeTrackerMap.get(target);\n\n      // Only track during render phase (when tracker is active and tracking enabled)\n      if (tracker?.isTracking && isGetter(target, prop)) {\n        // Record that this getter was accessed during current render\n        tracker.currentlyAccessing.add(prop);\n\n        // Use cached value if available from previous change detection\n        if (tracker.cacheValid && tracker.renderCache.has(prop)) {\n          const cachedValue = tracker.renderCache.get(prop);\n          // Also store in trackedValues for consistency\n          tracker.trackedValues.set(prop, cachedValue);\n          return cachedValue;\n        }\n\n        // Check for circular dependencies\n        if (getterExecutionContext.depth >= MAX_GETTER_DEPTH) {\n          console.warn(\n            `${BLAC_ERROR_PREFIX} Maximum getter depth (${MAX_GETTER_DEPTH}) exceeded. ` +\n              `Possible circular dependency in getter \"${String(prop)}\" on ${target.constructor.name}. ` +\n              `Returning undefined to prevent stack overflow.`,\n          );\n          return undefined;\n        }\n\n        // Check if we're revisiting a bloc in the current call stack (direct circular dependency)\n        if (getterExecutionContext.visitedBlocs.has(target)) {\n          console.warn(\n            `${BLAC_ERROR_PREFIX} Circular dependency detected: getter \"${String(prop)}\" on ${target.constructor.name} ` +\n              `is calling back into itself. Returning undefined to prevent infinite recursion.`,\n          );\n          return undefined;\n        }\n\n        // Set execution context before calling getter\n        const prevContext = {\n          tracker: getterExecutionContext.tracker,\n          currentBloc: getterExecutionContext.currentBloc,\n          depth: getterExecutionContext.depth,\n          visitedBlocs: new Set(getterExecutionContext.visitedBlocs), // Copy set\n        };\n\n        getterExecutionContext.tracker = tracker;\n        getterExecutionContext.currentBloc = target;\n        getterExecutionContext.depth++;\n        getterExecutionContext.visitedBlocs.add(target);\n\n        try {\n          // Compute getter if no cache available (first access or cache invalidated)\n          const descriptor = getDescriptor(target, prop);\n          const value = descriptor!.get!.call(target);\n          tracker.trackedValues.set(prop, value);\n          return value;\n        } catch (error) {\n          // Remove from pending tracking since we failed to get a value\n          tracker.currentlyAccessing.delete(prop);\n          throw error;\n        } finally {\n          // Restore previous context\n          getterExecutionContext.tracker = prevContext.tracker;\n          getterExecutionContext.currentBloc = prevContext.currentBloc;\n          getterExecutionContext.depth = prevContext.depth;\n          getterExecutionContext.visitedBlocs = prevContext.visitedBlocs;\n        }\n      }\n\n      // Default behavior for non-getters or when tracking disabled\n      return Reflect.get(target, prop, receiver);\n    },\n  });\n\n  blocProxyCache.set(bloc, proxy);\n  return proxy;\n}\n\n/**\n * @internal\n */\nexport function hasGetterChanges<TBloc extends StateContainerInstance>(\n  bloc: TBloc,\n  tracker: GetterState | null,\n): boolean {\n  // Early return if no tracker or no getters tracked\n  if (!tracker || tracker.trackedGetters.size === 0) {\n    return false;\n  }\n\n  // Clear previous render cache\n  tracker.renderCache.clear();\n\n  let hasAnyChange = false;\n\n  // Compute all getters to populate render cache (no early exit)\n  for (const prop of tracker.trackedGetters) {\n    try {\n      const descriptor = getDescriptor(bloc, prop);\n      if (!descriptor?.get) {\n        // Getter no longer exists (shouldn't happen, but be defensive)\n        continue;\n      }\n\n      const newValue = descriptor.get.call(bloc);\n      const oldValue = tracker.trackedValues.get(prop);\n\n      // Store in render cache for upcoming render (even if unchanged)\n      tracker.renderCache.set(prop, newValue);\n\n      // Update tracked values for next comparison\n      tracker.trackedValues.set(prop, newValue);\n\n      // Use Object.is for reference equality comparison\n      if (!Object.is(newValue, oldValue)) {\n        hasAnyChange = true;\n        // Don't return early - continue computing and caching remaining getters\n      }\n    } catch (error) {\n      // Getter threw an error during comparison\n      console.warn(\n        `${BLAC_ERROR_PREFIX} Getter \"${String(prop)}\" threw error during change detection. Stopping tracking for this getter.`,\n        error,\n      );\n\n      // Stop tracking this getter\n      tracker.trackedGetters.delete(prop);\n      tracker.trackedValues.delete(prop);\n\n      // Treat as \"changed\" to trigger re-render\n      // Still return early on error to avoid cascading failures\n      tracker.cacheValid = false; // Invalidate cache due to error\n      return true;\n    }\n  }\n\n  // Mark cache as valid for the upcoming render\n  tracker.cacheValid = true;\n\n  return hasAnyChange;\n}\n\n/**\n * @internal\n */\nexport function invalidateRenderCache(tracker: GetterState): void {\n  tracker.cacheValid = false;\n}\n\n/**\n * @internal\n */\nexport function clearExternalDependencies(tracker: GetterState): void {\n  tracker.externalDependencies.clear();\n}\n\n/**\n * @internal\n */\nexport function resetGetterState(tracker: GetterState): void {\n  tracker.trackedValues.clear();\n  tracker.currentlyAccessing.clear();\n  tracker.trackedGetters.clear();\n  tracker.renderCache.clear();\n  tracker.cacheValid = false;\n  tracker.isTracking = false;\n  tracker.externalDependencies.clear();\n}\n","/**\n * Marker symbols for identifying container types.\n * These are in a separate file to avoid circular dependencies.\n * @internal\n */\n\n/**\n * Marker symbol to identify stateless containers at the type level.\n * Used by React hooks to prevent `useBloc` from accepting stateless containers.\n */\nexport const STATELESS_MARKER = Symbol('STATELESS_CONTAINER');\n","/**\n * Utility functions for accessing static properties on StateContainer classes\n */\n\nimport { BLAC_STATIC_PROPS } from '../constants';\nimport { STATELESS_MARKER } from '../core/markers';\nimport { StateContainerConstructor } from '../types/utilities';\n\n/**\n * Get a static property from a class constructor\n * Type-safe helper that avoids (Type as any) casts\n *\n * @param Type - The class constructor\n * @param propName - The property name to access\n * @param defaultValue - Optional default value if property is undefined\n * @returns The property value or default\n */\nexport function getStaticProp<\n  V,\n  T extends StateContainerConstructor = StateContainerConstructor,\n>(Type: T, propName: string, defaultValue?: V): V | undefined {\n  return (Type as any)[propName] ?? defaultValue;\n}\n\n/**\n * Check if a class is marked as isolated.\n * Isolated classes create separate instances per component.\n * @param Type - The class constructor to check\n * @returns true if the class has `static isolated = true`\n */\nexport function isIsolatedClass<T extends StateContainerConstructor>(\n  Type: T,\n): boolean {\n  return getStaticProp<boolean>(Type, BLAC_STATIC_PROPS.ISOLATED) === true;\n}\n\n/**\n * Check if a class is marked as keepAlive.\n * KeepAlive classes are never auto-disposed when ref count reaches 0.\n * @param Type - The class constructor to check\n * @returns true if the class has `static keepAlive = true`\n */\nexport function isKeepAliveClass<T extends StateContainerConstructor>(\n  Type: T,\n): boolean {\n  return getStaticProp<boolean>(Type, BLAC_STATIC_PROPS.KEEP_ALIVE) === true;\n}\n\n/**\n * Check if a class should be excluded from DevTools.\n * Used to prevent infinite loops when DevTools tracks itself.\n * @param Type - The class constructor to check\n * @returns true if the class has `static __excludeFromDevTools = true`\n */\nexport function isExcludedFromDevTools<T extends StateContainerConstructor>(\n  Type: T,\n): boolean {\n  return (\n    getStaticProp<boolean>(Type, BLAC_STATIC_PROPS.EXCLUDE_FROM_DEVTOOLS) ===\n    true\n  );\n}\n\n/**\n * Check if a class is a stateless container (StatelessCubit or StatelessVertex).\n * Stateless containers don't have state, emit, update, or subscribe methods.\n * @param Type - The class constructor to check\n * @returns true if the class is a stateless container\n */\nexport function isStatelessClass<T extends StateContainerConstructor>(\n  Type: T,\n): boolean {\n  return (Type as any)[STATELESS_MARKER] === true;\n}\n","import type { StateContainer, StateContainerConfig } from './StateContainer';\nimport type { Vertex } from './Vertex';\nimport { createPluginManager } from '../plugin/PluginManager';\nimport { getGetterExecutionContext } from '../tracking/getter-tracker';\nimport { BLAC_DEFAULTS, BLAC_ERROR_PREFIX } from '../constants';\nimport { isIsolatedClass, isKeepAliveClass } from '../utils/static-props';\nimport {\n  ExtractProps,\n  InstanceReadonlyState,\n  StateContainerConstructor,\n} from '../types/utilities';\n\n/**\n * Internal configuration for registered types\n * @internal\n */\ninterface TypeConfig {\n  isolated: boolean;\n}\n\n/**\n * Entry in the instance registry, tracking the instance and its reference count\n * @template T - Instance type\n */\nexport interface InstanceEntry<T = any> {\n  /** The state container instance */\n  instance: T;\n  /** Number of active references to this instance */\n  refCount: number;\n}\n\n/**\n * Lifecycle events emitted by the registry\n */\nexport type LifecycleEvent =\n  | 'created'\n  | 'stateChanged'\n  | 'eventAdded'\n  | 'disposed';\n\n/**\n * Listener function type for each lifecycle event\n * @template E - The lifecycle event type\n */\nexport type LifecycleListener<E extends LifecycleEvent> = E extends 'created'\n  ? (container: StateContainer<any>) => void\n  : E extends 'stateChanged'\n    ? (\n        container: StateContainer<any>,\n        previousState: any,\n        currentState: any,\n        callstack?: string,\n      ) => void\n    : E extends 'eventAdded'\n      ? (container: Vertex<any, any>, event: any) => void\n      : E extends 'disposed'\n        ? (container: StateContainer<any>) => void\n        : never;\n\n/**\n * Central registry for managing StateContainer instances.\n * Handles instance lifecycle, ref counting, and lifecycle event emission.\n *\n * @example\n * ```ts\n * const registry = new StateContainerRegistry();\n * const instance = registry.acquire(MyBloc);  // ownership, must release\n * const other = registry.ensure(OtherBloc);   // no ownership, bloc-to-bloc\n * registry.on('stateChanged', (container, prev, next) => {\n *   console.log('State changed:', prev, '->', next);\n * });\n * ```\n */\nexport class StateContainerRegistry {\n  private readonly instancesByConstructor = new WeakMap<\n    StateContainerConstructor,\n    Map<string, InstanceEntry>\n  >();\n\n  private readonly types = new Set<StateContainerConstructor>();\n\n  private readonly typeConfigs = new Map<string, TypeConfig>();\n\n  private readonly listeners = new Map<\n    LifecycleEvent,\n    Set<(...args: any[]) => void>\n  >();\n\n  /**\n   * Register a type for lifecycle event tracking\n   * @param constructor - The StateContainer class constructor\n   */\n  registerType<T extends StateContainerConstructor>(constructor: T): void {\n    this.types.add(constructor);\n  }\n\n  /**\n   * Register a StateContainer class with configuration\n   * @param constructor - The StateContainer class constructor\n   * @param isolated - Whether instances should be isolated (component-scoped)\n   * @throws Error if type is already registered\n   */\n  register<T extends StateContainerConstructor>(\n    constructor: T,\n    isolated = false,\n  ): void {\n    const className = constructor.name;\n\n    if (!isolated && isIsolatedClass(constructor)) {\n      isolated = true;\n    }\n\n    if (this.typeConfigs.has(className)) {\n      throw new Error(\n        `${BLAC_ERROR_PREFIX} Type \"${className}\" is already registered`,\n      );\n    }\n\n    this.typeConfigs.set(className, { isolated });\n    this.registerType(constructor);\n  }\n\n  private ensureInstancesMap<T extends StateContainerConstructor>(\n    Type: T,\n  ): Map<string, InstanceEntry> {\n    let instances = this.instancesByConstructor.get(Type);\n    if (!instances) {\n      instances = new Map<string, InstanceEntry>();\n      this.instancesByConstructor.set(Type, instances);\n    }\n    return instances;\n  }\n\n  /**\n   * Get the instances Map for a specific class (public API for stats/debugging)\n   */\n  getInstancesMap<T extends StateContainerConstructor>(\n    Type: T,\n  ): Map<string, InstanceEntry> {\n    return this.instancesByConstructor.get(Type) || new Map();\n  }\n\n  private trackExecutionContext(instance: StateContainer<any>): void {\n    // Track cross-bloc dependency if we're inside a getter execution\n    const context = getGetterExecutionContext();\n    if (\n      context.tracker &&\n      context.currentBloc &&\n      context.currentBloc !== instance\n    ) {\n      // Add this bloc as an external dependency\n      context.tracker.externalDependencies.add(instance);\n    }\n  }\n\n  /**\n   * Acquire an instance with ref counting (ownership semantics).\n   * Creates a new instance if one doesn't exist, or returns existing and increments ref count.\n   * You must call `release()` when done to decrement the ref count.\n   * @param Type - The StateContainer class constructor\n   * @param instanceKey - Instance key (defaults to 'default')\n   * @param options - Acquisition options\n   * @param options.canCreate - Whether to create new instance if not found (default: true)\n   * @param options.countRef - Whether to increment ref count (default: true)\n   * @param options.props - Props to pass to constructor if creating new instance\n   * @param options.trackExecutionContext - Whether to track cross-bloc dependency (default: false)\n   * @returns The state container instance\n   */\n  acquire<T extends StateContainerConstructor = StateContainerConstructor>(\n    Type: T,\n    instanceKey: string = BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY,\n    options: {\n      canCreate?: boolean;\n      countRef?: boolean;\n      props?: ExtractProps<T>;\n      trackExecutionContext?: boolean;\n    } = {},\n  ): InstanceType<T> {\n    const {\n      canCreate = true,\n      countRef = true,\n      props,\n      trackExecutionContext = false,\n    } = options;\n    // Check if this is an isolated type\n    const registryConfig = this.typeConfigs.get(Type.name);\n    const isolated = isIsolatedClass(Type) || registryConfig?.isolated === true;\n\n    const config: StateContainerConfig = {\n      instanceId: instanceKey,\n    };\n\n    if (isolated && !canCreate) {\n      throw new Error(\n        `${BLAC_ERROR_PREFIX} Cannot get isolated instance \"${instanceKey}\" of ${Type.name} when creation is disabled.`,\n      );\n    }\n\n    // Isolated: always create new instance (not tracked)\n    if (isolated) {\n      const instance = new Type(props) as InstanceType<T>;\n      instance.initConfig(config);\n      // Register type for lifecycle coordination\n      this.registerType(Type);\n      if (trackExecutionContext) {\n        this.trackExecutionContext(instance);\n      }\n      return instance;\n    }\n\n    // Shared: singleton pattern with ref counting\n    const instances = this.ensureInstancesMap(Type);\n    const entry = instances.get(instanceKey);\n\n    // Increment ref count if found, only if counting is enabled or refCount is 0\n    if (entry && (countRef || entry.refCount === 0)) {\n      entry.refCount++;\n    }\n\n    if (entry) {\n      if (trackExecutionContext) {\n        this.trackExecutionContext(entry.instance);\n      }\n      return entry.instance;\n    }\n\n    if (!canCreate) {\n      throw new Error(\n        `${BLAC_ERROR_PREFIX} ${Type.name} instance \"${instanceKey}\" not found and creation is disabled.`,\n      );\n    }\n\n    // Create new shared instance\n    const instance = new Type(props) as InstanceType<T>;\n    instance.initConfig(config);\n    instances.set(instanceKey, { instance, refCount: 1 });\n\n    // Register type for lifecycle coordination\n    this.registerType(Type);\n\n    if (trackExecutionContext) {\n      this.trackExecutionContext(instance);\n    }\n    return instance;\n  }\n\n  /**\n   * Borrow an existing instance without incrementing ref count (borrowing semantics).\n   * Tracks cross-bloc dependency for reactive updates.\n   * @param Type - The StateContainer class constructor\n   * @param instanceKey - Instance key (defaults to 'default')\n   * @returns The state container instance\n   * @throws Error if instance doesn't exist\n   */\n  borrow<T extends StateContainerConstructor = StateContainerConstructor>(\n    Type: T,\n    instanceKey: string = BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY,\n  ): InstanceType<T> {\n    return this.acquire(Type, instanceKey, {\n      canCreate: false,\n      trackExecutionContext: true,\n    });\n  }\n\n  /**\n   * Safely borrow an existing instance (borrowing semantics with error handling).\n   * Returns discriminated union for type-safe conditional access.\n   * @param Type - The StateContainer class constructor\n   * @param instanceKey - Instance key (defaults to 'default')\n   * @returns Discriminated union with either the instance or an error\n   */\n  borrowSafe<T extends StateContainerConstructor = StateContainerConstructor>(\n    Type: T,\n    instanceKey: string = BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY,\n  ):\n    | { error: Error; instance: null }\n    | { error: null; instance: InstanceType<T> } {\n    try {\n      const instance = this.borrow(Type, instanceKey);\n      return { error: null, instance };\n    } catch (error: any) {\n      return { error, instance: null };\n    }\n  }\n\n  /**\n   * Ensure an instance exists without taking ownership (for bloc-to-bloc communication).\n   * Gets existing instance OR creates it if it doesn't exist, without incrementing ref count.\n   * Tracks cross-bloc dependency for reactive updates.\n   *\n   * Use this in bloc-to-bloc communication when you need to ensure an instance exists\n   * but don't want to claim ownership (no ref count increment).\n   * @param Type - The StateContainer class constructor\n   * @param instanceKey - Instance key (defaults to 'default')\n   * @returns The state container instance\n   */\n  ensure<T extends StateContainerConstructor = StateContainerConstructor>(\n    Type: T,\n    instanceKey: string = BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY,\n  ): InstanceType<T> {\n    return this.acquire(Type, instanceKey, {\n      canCreate: true,\n      countRef: false,\n      trackExecutionContext: true,\n    });\n  }\n\n  /**\n   * Release a reference to an instance.\n   * Decrements ref count and disposes when it reaches 0 (unless keepAlive).\n   * @param Type - The StateContainer class constructor\n   * @param instanceKey - Instance key (defaults to 'default')\n   * @param forceDispose - Force immediate disposal regardless of ref count\n   */\n  release<T extends StateContainerConstructor>(\n    Type: T,\n    instanceKey: string = BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY,\n    forceDispose = false,\n  ): void {\n    const instances = this.ensureInstancesMap(Type);\n    const entry = instances.get(instanceKey);\n\n    if (!entry) return;\n\n    // Force dispose immediately\n    if (forceDispose) {\n      if (!entry.instance.isDisposed) {\n        entry.instance.dispose();\n      }\n      instances.delete(instanceKey);\n      return;\n    }\n\n    // Decrement ref count\n    entry.refCount--;\n\n    // Check static keepAlive property\n    const keepAlive = isKeepAliveClass(Type);\n\n    // Auto-dispose when ref count reaches 0 (unless keepAlive)\n    if (entry.refCount <= 0 && !keepAlive) {\n      if (!entry.instance.isDisposed) {\n        entry.instance.dispose();\n      }\n      instances.delete(instanceKey);\n    }\n  }\n\n  /**\n   * Get all instances of a specific type.\n   * @param Type - The StateContainer class constructor\n   * @returns Array of all instances\n   */\n  getAll<T extends StateContainerConstructor>(\n    Type: T,\n  ): InstanceReadonlyState<T>[] {\n    const instances = this.ensureInstancesMap(Type);\n    const result: InstanceReadonlyState<T>[] = [];\n    for (const entry of instances.values()) {\n      result.push(entry.instance);\n    }\n    return result;\n  }\n\n  /**\n   * Safely iterate over all instances of a type.\n   * Skips disposed instances and catches callback errors.\n   * @param Type - The StateContainer class constructor\n   * @param callback - Function to call for each instance\n   */\n  forEach<T extends StateContainerConstructor>(\n    Type: T,\n    callback: (instance: InstanceReadonlyState<T>) => void,\n  ): void {\n    const instances = this.ensureInstancesMap(Type);\n    for (const entry of instances.values()) {\n      const instance = entry.instance;\n      if (!instance.isDisposed) {\n        try {\n          callback(instance);\n        } catch (error) {\n          console.error(\n            `${BLAC_ERROR_PREFIX} forEach callback error for ${Type.name}:`,\n            error,\n          );\n        }\n      }\n    }\n  }\n\n  /**\n   * Clear all instances of a specific type (disposes them).\n   * @param Type - The StateContainer class constructor\n   */\n  clear<T extends StateContainerConstructor>(Type: T): void {\n    const instances = this.ensureInstancesMap(Type);\n    // Dispose all instances\n    for (const entry of instances.values()) {\n      if (!entry.instance.isDisposed) {\n        entry.instance.dispose();\n      }\n    }\n    // Clear the Map\n    instances.clear();\n  }\n\n  /**\n   * Get reference count for an instance.\n   * @param Type - The StateContainer class constructor\n   * @param instanceKey - Instance key (defaults to 'default')\n   * @returns Current ref count (0 if instance doesn't exist)\n   */\n  getRefCount<T extends StateContainerConstructor>(\n    Type: T,\n    instanceKey: string = BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY,\n  ): number {\n    const instances = this.ensureInstancesMap(Type);\n    const entry = instances.get(instanceKey);\n    return entry?.refCount ?? 0;\n  }\n\n  /**\n   * Check if an instance exists.\n   * @param Type - The StateContainer class constructor\n   * @param instanceKey - Instance key (defaults to 'default')\n   * @returns true if instance exists\n   */\n  hasInstance<T extends StateContainerConstructor>(\n    Type: T,\n    instanceKey: string = BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY,\n  ): boolean {\n    const instances = this.ensureInstancesMap(Type);\n    return instances.has(instanceKey);\n  }\n\n  /**\n   * Clear all instances from all types (for testing)\n   *\n   * Iterates all registered types and clears their instances.\n   * Also clears type tracking to reset the registry state.\n   */\n  clearAll(): void {\n    // Step 1: Clear instances from each type (while we still have the types list)\n    for (const Type of this.types) {\n      this.clear(Type);\n    }\n    // Step 2: Now clear type tracking (resets registry state for tests)\n    this.types.clear();\n    this.typeConfigs.clear();\n  }\n\n  /**\n   * Get registry statistics for debugging.\n   * @returns Object with registeredTypes, totalInstances, and typeBreakdown\n   */\n  getStats(): {\n    registeredTypes: number;\n    totalInstances: number;\n    typeBreakdown: Record<string, number>;\n  } {\n    const typeBreakdown: Record<string, number> = {};\n    let totalInstances = 0;\n\n    // Collect stats from each registered type\n    for (const Type of this.types) {\n      const typeName = Type.name;\n      const instances = this.getInstancesMap(Type);\n      const count = instances.size;\n\n      typeBreakdown[typeName] = count;\n      totalInstances += count;\n    }\n\n    return {\n      registeredTypes: this.types.size,\n      totalInstances,\n      typeBreakdown,\n    };\n  }\n\n  /**\n   * Get all registered types (for plugin system).\n   * @returns Array of all registered StateContainer class constructors\n   */\n  getTypes(): StateContainerConstructor[] {\n    return Array.from(this.types);\n  }\n\n  /**\n   * Subscribe to lifecycle events\n   * @param event - The lifecycle event to listen for\n   * @param listener - The listener function to call when the event occurs\n   * @returns Unsubscribe function\n   */\n  on<E extends LifecycleEvent>(\n    event: E,\n    listener: LifecycleListener<E>,\n  ): () => void {\n    if (!this.listeners.has(event)) {\n      this.listeners.set(event, new Set());\n    }\n    const instance = this.listeners.get(event);\n    if (!instance) {\n      throw new Error(\n        `${BLAC_ERROR_PREFIX} Failed to register listener for event '${event}'`,\n      );\n    }\n\n    instance.add(listener as (...args: any[]) => void);\n\n    // Return unsubscribe function\n    return () => {\n      this.listeners.get(event)?.delete(listener as (...args: any[]) => void);\n    };\n  }\n\n  /**\n   * Emit lifecycle event to all listeners\n   * @internal - Called by StateContainer/Vertex lifecycle methods\n   */\n  emit(event: LifecycleEvent, ...args: any[]): void {\n    const listeners = this.listeners.get(event);\n    if (!listeners || listeners.size === 0) return; // Zero overhead when no listeners\n\n    for (const listener of listeners) {\n      try {\n        listener(...args);\n      } catch (error) {\n        console.error(\n          `${BLAC_ERROR_PREFIX} Listener error for '${event}':`,\n          error,\n        );\n      }\n    }\n  }\n}\n\n/**\n * Global default registry instance\n */\nexport const globalRegistry = new StateContainerRegistry();\n\n/**\n * Global plugin manager (initialized lazily)\n */\nlet _globalPluginManager: any = null;\n\n/**\n * Get the global plugin manager\n */\nexport function getPluginManager(): any {\n  if (!_globalPluginManager) {\n    _globalPluginManager = createPluginManager(globalRegistry);\n  }\n  return _globalPluginManager;\n}\n","import { generateSimpleId } from '../utils/idGenerator';\nimport { globalRegistry } from './StateContainerRegistry';\n\n/**\n * Configuration options for initializing a StateContainer instance\n */\nexport interface StateContainerConfig {\n  /** Display name for the instance (defaults to class name) */\n  name?: string;\n  /** Enable debug logging for this instance */\n  debug?: boolean;\n  /** Custom instance identifier */\n  instanceId?: string;\n}\n\n/**\n * Listener function for state changes\n * @internal\n */\ntype StateListener<S> = (state: S) => void;\n\n/**\n * System events emitted by StateContainer lifecycle\n */\nexport type SystemEvent = 'propsUpdated' | 'stateChanged' | 'dispose';\n\n/**\n * Payload types for each system event\n * @template S - State type\n * @template P - Props type\n */\nexport interface SystemEventPayloads<S, P> {\n  /** Emitted when props are updated via updateProps() */\n  propsUpdated: { props: P; previousProps: P | undefined };\n  /** Emitted when state changes via emit() or update() */\n  stateChanged: { state: S; previousState: S };\n  /** Emitted when the instance is disposed */\n  dispose: void;\n}\n\n/**\n * Handler function for system events\n * @internal\n */\ntype SystemEventHandler<S, P, E extends SystemEvent> = (\n  payload: SystemEventPayloads<S, P>[E],\n) => void;\n\n/**\n * Abstract base class for all state containers in BlaC.\n * Provides lifecycle management, subscription handling, ref counting,\n * and integration with the global registry.\n *\n * @template S - State type managed by this container\n * @template P - Props type passed to the container (optional)\n *\n * @example\n * ```ts\n * class CounterBloc extends StateContainer<{ count: number }> {\n *   constructor() {\n *     super({ count: 0 });\n *   }\n *   increment() {\n *     this.emit({ count: this.state.count + 1 });\n *   }\n * }\n * ```\n */\nexport abstract class StateContainer<S extends object = any, P = any> {\n  static __excludeFromDevTools = false;\n  static enableStackTrace = true;\n\n  private _state: S;\n  private readonly listeners = new Set<StateListener<S>>();\n  private _disposed = false;\n  private config: StateContainerConfig = {};\n  private _props: P | undefined = undefined;\n  private readonly systemEventHandlers = new Map<\n    SystemEvent,\n    Set<SystemEventHandler<S, P, any>>\n  >();\n\n  /** Display name for this instance */\n  name: string = this.constructor.name;\n  /** Whether debug logging is enabled */\n  debug: boolean = false;\n  /** Unique identifier for this instance */\n  instanceId: string = generateSimpleId(this.constructor.name, 'main');\n  /** Timestamp when this instance was created */\n  createdAt: number = Date.now();\n\n  /** Current props value passed to this container */\n  get props(): P | undefined {\n    return this._props;\n  }\n\n  constructor(initialState: S) {\n    this._state = initialState;\n  }\n\n  /**\n   * Initialize configuration for this instance.\n   * Called by the registry after construction.\n   * @param config - Configuration options\n   */\n  initConfig(config: StateContainerConfig): void {\n    this.config = { ...config };\n    this.name = this.config.name || this.constructor.name;\n    this.debug = this.config.debug ?? false;\n    this.instanceId = generateSimpleId(\n      this.constructor.name,\n      this.config.instanceId,\n    );\n\n    globalRegistry.emit('created', this);\n  }\n\n  /** Current state value */\n  get state(): Readonly<S> {\n    return this._state;\n  }\n\n  /** Whether this instance has been disposed */\n  get isDisposed(): boolean {\n    return this._disposed;\n  }\n\n  /**\n   * Subscribe to state changes\n   * @param listener - Function called when state changes\n   * @returns Unsubscribe function\n   */\n  subscribe(listener: StateListener<S>): () => void {\n    if (this._disposed) {\n      throw new Error(`Cannot subscribe to disposed container ${this.name}`);\n    }\n\n    this.listeners.add(listener);\n    return () => this.listeners.delete(listener);\n  }\n\n  /**\n   * Dispose this instance and clean up resources.\n   * Clears all listeners and emits the 'dispose' system event.\n   */\n  dispose(): void {\n    if (this._disposed) return;\n\n    if (this.debug) {\n      console.log(`[${this.name}] Disposing...`);\n    }\n\n    this._disposed = true;\n\n    this.emitSystemEvent('dispose', undefined as void);\n\n    this.listeners.clear();\n    this.systemEventHandlers.clear();\n\n    globalRegistry.emit('disposed', this);\n\n    if (this.debug) {\n      console.log(`[${this.name}] Disposed successfully`);\n    }\n  }\n\n  /**\n   * Emit a new state value and notify all listeners.\n   * @param newState - The new state value\n   * @protected\n   */\n  protected emit(newState: S): void {\n    if (this._disposed) {\n      throw new Error(`Cannot emit state from disposed container ${this.name}`);\n    }\n\n    if (this._state === newState) return;\n\n    const previousState = this._state;\n    this._state = newState;\n\n    this.emitSystemEvent('stateChanged', {\n      state: newState,\n      previousState,\n    });\n\n    for (const listener of this.listeners) {\n      try {\n        listener(newState);\n      } catch (error) {\n        console.error(`[${this.name}] Error in listener:`, error);\n      }\n    }\n\n    const stackTrace = this.captureStackTrace();\n\n    globalRegistry.emit(\n      'stateChanged',\n      this,\n      previousState,\n      newState,\n      stackTrace,\n    );\n    this.lastUpdateTimestamp = Date.now();\n  }\n\n  private captureStackTrace(): string {\n    if (\n      !StateContainer.enableStackTrace ||\n      (typeof process !== 'undefined' && process.env?.NODE_ENV === 'production')\n    ) {\n      return '';\n    }\n\n    try {\n      const error = new Error();\n      const stack = error.stack || '';\n      const lines = stack.split('\\n');\n      const relevantLines = lines.slice(1);\n      const formattedLines: string[] = [];\n\n      for (const line of relevantLines) {\n        if (!line.trim()) continue;\n\n        if (\n          line.includes('StateContainer.emit') ||\n          line.includes('StateContainer.update') ||\n          line.includes('StateContainer.captureStackTrace') ||\n          line.includes('Cubit.patch') ||\n          line.includes('Vertex.')\n        ) {\n          continue;\n        }\n\n        if (\n          line.includes('node_modules') ||\n          line.includes('react-dom') ||\n          line.includes('react_jsx') ||\n          line.includes('.vite/deps') ||\n          line.includes('executeDispatch') ||\n          line.includes('runWithFiber') ||\n          line.includes('invokeGuarded') ||\n          line.includes('callCallback') ||\n          line.includes('processDispatchQueue') ||\n          line.includes('dispatchEvent') ||\n          line.includes('batchedUpdates')\n        ) {\n          continue;\n        }\n\n        const formatted = this.formatStackLine(line);\n        if (formatted) {\n          formattedLines.push(formatted);\n        }\n      }\n\n      return formattedLines.join('\\n');\n    } catch {\n      return '';\n    }\n  }\n\n  private formatStackLine(line: string): string | null {\n    const match = line.match(/at\\s+(.+?)\\s+\\((.+?):(\\d+):(\\d+)\\)/);\n    if (!match) {\n      const simpleMatch = line.match(/at\\s+(.+?):(\\d+):(\\d+)/);\n      if (simpleMatch) {\n        const [, url, lineNum, col] = simpleMatch;\n        const cleanPath = this.cleanFilePath(url);\n        return `  at ${cleanPath}:${lineNum}:${col}`;\n      }\n      return null;\n    }\n\n    const [, functionName, url, lineNum, col] = match;\n    const cleanPath = this.cleanFilePath(url);\n\n    return `  at ${functionName} (${cleanPath}:${lineNum}:${col})`;\n  }\n\n  private cleanFilePath(url: string): string {\n    let path = url\n      .replace(/http:\\/\\/localhost:\\d+\\/@fs/, '')\n      .replace(/http:\\/\\/localhost:\\d+\\//, '')\n      .replace(/\\?t=\\d+/, '')\n      .replace(/\\?v=[a-f0-9]+/, '');\n\n    const projectMatch = path.match(/\\/Projects\\/blac\\/(.+)/);\n    if (projectMatch) {\n      path = projectMatch[1];\n    }\n\n    const segments = path.split('/');\n    if (segments.length > 3) {\n      path = segments.slice(-3).join('/');\n    }\n\n    return path;\n  }\n\n  /** Timestamp of the last state update */\n  lastUpdateTimestamp: number = Date.now();\n\n  /**\n   * Update state using a transform function.\n   * @param updater - Function that receives current state and returns new state\n   * @protected\n   */\n  protected update(updater: (current: S) => S): void {\n    if (this._disposed) {\n      throw new Error(\n        `Cannot update state from disposed container ${this.name}`,\n      );\n    }\n    this.emit(updater(this._state));\n  }\n\n  /**\n   * Subscribe to system lifecycle events.\n   * @param event - The event type to listen for\n   * @param handler - Handler function called when event occurs\n   * @returns Unsubscribe function\n   * @protected\n   */\n  protected onSystemEvent = <E extends SystemEvent>(\n    event: E,\n    handler: SystemEventHandler<S, P, E>,\n  ): (() => void) => {\n    let handlers = this.systemEventHandlers.get(event);\n    if (!handlers) {\n      handlers = new Set();\n      this.systemEventHandlers.set(event, handlers);\n    }\n    handlers.add(handler as SystemEventHandler<S, P, any>);\n\n    return () => {\n      handlers?.delete(handler as SystemEventHandler<S, P, any>);\n    };\n  };\n\n  private emitSystemEvent<E extends SystemEvent>(\n    event: E,\n    payload: SystemEventPayloads<S, P>[E],\n  ): void {\n    const handlers = this.systemEventHandlers.get(event);\n    if (!handlers) return;\n\n    for (const handler of handlers) {\n      try {\n        handler(payload);\n      } catch (error) {\n        console.error(`[${this.name}] Error in system event handler:`, error);\n      }\n    }\n  }\n\n  /**\n   * Update the props for this container.\n   * Emits the 'propsUpdated' system event.\n   * @param newProps - The new props value\n   */\n  updateProps(newProps: P): void {\n    if (this._disposed) {\n      throw new Error(`Cannot update props on disposed container ${this.name}`);\n    }\n\n    const previousProps = this._props;\n    this._props = newProps;\n\n    this.emitSystemEvent('propsUpdated', {\n      props: newProps,\n      previousProps,\n    });\n\n    if (this.debug) {\n      console.log(`[${this.name}] Props updated:`, { newProps, previousProps });\n    }\n  }\n}\n","import { StateContainer } from './StateContainer';\n\n/**\n * Simple state container with direct state emission.\n * Extends StateContainer with public methods for emitting and updating state.\n *\n * @template S - State type\n * @template P - Props type (optional)\n */\nexport abstract class Cubit<\n  S extends object = any,\n  P = undefined,\n> extends StateContainer<S, P> {\n  constructor(initialState: S) {\n    super(initialState);\n  }\n\n  /**\n   * Replace state with a new value and notify all listeners\n   * @param newState - The new state value\n   */\n  public emit(newState: S): void {\n    super['emit'](newState);\n  }\n\n  /**\n   * Transform current state using an updater function and emit the new state\n   * @param updater - Function that receives current state and returns new state\n   */\n  public update(updater: (current: S) => S): void {\n    super['update'](updater);\n  }\n\n  /**\n   * Merge partial state changes into current state (only for object states)\n   */\n  public patch = ((partial: S extends object ? Partial<S> : never): void => {\n    if (typeof this.state !== 'object' || this.state === null) {\n      throw new Error('patch() is only available for object state types');\n    }\n    this.update((current) => ({ ...current, ...partial }) as S);\n  }) as S extends object ? (partial: Partial<S>) => void : never;\n}\n","import { StateContainer } from './StateContainer';\nimport { globalRegistry } from './StateContainerRegistry';\nimport type {\n  DiscriminatedEvent,\n  EventWithMetadata,\n  EventHandlerMap,\n  VertexEventHandler,\n} from '../types/events';\n\n/**\n * Event-driven state container using discriminated union events.\n * Extends StateContainer with event-based state transitions and\n * compile-time exhaustive checking for event handlers.\n *\n * @template S - State type (must be an object)\n * @template E - Event union type (discriminated by 'type' property)\n * @template P - Props type (optional)\n *\n * @example\n * ```typescript\n * type CounterEvent =\n *   | { type: 'increment'; amount: number }\n *   | { type: 'decrement' }\n *   | { type: 'reset' };\n *\n * class CounterVertex extends Vertex<{ count: number }, CounterEvent> {\n *   constructor() {\n *     super({ count: 0 });\n *     this.createHandlers({\n *       increment: (event, emit) => {\n *         emit({ count: this.state.count + event.amount });\n *       },\n *       decrement: (_, emit) => {\n *         emit({ count: this.state.count - 1 });\n *       },\n *       reset: (_, emit) => {\n *         emit({ count: 0 });\n *       },\n *     });\n *   }\n *\n *   increment = (amount = 1) => this.add({ type: 'increment', amount });\n * }\n * ```\n */\nexport abstract class Vertex<\n  S extends object = object,\n  E extends DiscriminatedEvent = DiscriminatedEvent,\n  P = undefined,\n> extends StateContainer<S, P> {\n  /** @internal */\n  private handlers = new Map<\n    string,\n    VertexEventHandler<DiscriminatedEvent, S>\n  >();\n  /** @internal */\n  private isProcessing = false;\n  /** @internal */\n  private eventQueue: EventWithMetadata<E>[] = [];\n\n  constructor(initialState: S) {\n    super(initialState);\n  }\n\n  /**\n   * Register all event handlers with exhaustive type checking.\n   * TypeScript will error if any event type from the union is missing.\n   *\n   * @param handlers - Map of event type to handler function\n   */\n  protected createHandlers(handlers: EventHandlerMap<E, S>): void {\n    for (const [eventType, handler] of Object.entries(handlers)) {\n      this.handlers.set(\n        eventType,\n        handler as VertexEventHandler<DiscriminatedEvent, S>,\n      );\n    }\n  }\n\n  /**\n   * Dispatch an event for processing.\n   * Events are processed synchronously; if called during processing,\n   * the event is queued and processed after the current event completes.\n   *\n   * @param event - The event to process (must match the event union type)\n   */\n  public add = (event: E): void => {\n    const enrichedEvent = this.enrichEvent(event);\n    globalRegistry.emit('eventAdded', this, enrichedEvent);\n    this.processEvent(enrichedEvent);\n  };\n\n  /** @internal */\n  private enrichEvent(event: E): EventWithMetadata<E> {\n    return {\n      ...event,\n      timestamp: Date.now(),\n    };\n  }\n\n  /** @internal */\n  private processEvent(event: EventWithMetadata<E>): void {\n    if (this.isProcessing) {\n      this.eventQueue.push(event);\n      return;\n    }\n\n    this.isProcessing = true;\n\n    try {\n      this.handleEvent(event);\n\n      while (this.eventQueue.length > 0) {\n        const nextEvent = this.eventQueue.shift()!;\n        this.handleEvent(nextEvent);\n      }\n    } finally {\n      this.isProcessing = false;\n    }\n  }\n\n  /** @internal */\n  private handleEvent(event: EventWithMetadata<E>): void {\n    const handler = this.handlers.get(event.type);\n\n    if (!handler) {\n      if (this.debug) {\n        console.warn(`No handler registered for event type: ${event.type}`);\n      }\n      return;\n    }\n\n    const emitFn = (state: S) => {\n      this.emit(state);\n    };\n\n    try {\n      handler(event, emitFn);\n    } catch (error) {\n      if (this.debug) {\n        console.error(`Error handling event ${event.type}:`, error);\n      }\n      this.onEventError(event, error as Error);\n    }\n  }\n\n  /**\n   * Called when an error occurs during event processing.\n   * Override to implement custom error handling.\n   *\n   * @param _event - The event that caused the error\n   * @param _error - The error that occurred\n   */\n  protected onEventError(_event: EventWithMetadata<E>, _error: Error): void {}\n}\n","import { Cubit } from './Cubit';\nimport { STATELESS_MARKER } from './markers';\n\nexport { STATELESS_MARKER };\n\n/**\n * Empty state type used internally by stateless containers.\n * Using `Record<never, never>` ensures the state object has no accessible properties.\n * @internal\n */\ntype EmptyState = Record<never, never>;\n\n/**\n * A Cubit without state management capabilities.\n * Use this for action-only containers that don't need to manage or emit state.\n *\n * StatelessCubit:\n * - Has no `emit()`, `update()`, or `patch()` methods\n * - Has no accessible `state` property\n * - Cannot be subscribed to (throws error)\n * - Is rejected by `useBloc` hook (use `useBlocActions` instead)\n *\n * @template P - Props type (optional)\n *\n * @example\n * ```typescript\n * class AnalyticsService extends StatelessCubit {\n *   trackPageView(page: string) {\n *     analytics.track('page_view', { page });\n *   }\n *\n *   trackClick(element: string) {\n *     analytics.track('click', { element });\n *   }\n * }\n *\n * // In React component:\n * const analytics = useBlocActions(AnalyticsService);\n * analytics.trackPageView('/home');\n * ```\n */\nexport abstract class StatelessCubit<P = undefined> extends Cubit<\n  EmptyState,\n  P\n> {\n  /**\n   * Marker property to identify stateless containers.\n   * @internal\n   */\n  static readonly [STATELESS_MARKER] = true as const;\n\n  constructor() {\n    super({});\n  }\n\n  /**\n   * State is not available on StatelessCubit.\n   * @throws Always throws an error when accessed.\n   */\n  override get state(): never {\n    throw new Error(\n      `${this.name} is a StatelessCubit and does not have state. ` +\n        'Use a regular Cubit if you need state management.',\n    );\n  }\n\n  /**\n   * Subscriptions are not available on StatelessCubit.\n   * @throws Always throws an error when called.\n   */\n  override subscribe(_listener: (state: EmptyState) => void): never {\n    throw new Error(\n      `${this.name} is a StatelessCubit and does not support subscriptions. ` +\n        'Use useBlocActions() instead of useBloc() in React.',\n    );\n  }\n\n  /**\n   * emit() is not available on StatelessCubit.\n   * TypeScript will show an error if you try to call this method.\n   */\n  public override emit(_newState: never): never {\n    throw new Error(\n      `${this.name} is a StatelessCubit and does not support emit(). ` +\n        'Use a regular Cubit if you need state management.',\n    );\n  }\n\n  /**\n   * update() is not available on StatelessCubit.\n   * TypeScript will show an error if you try to call this method.\n   */\n  public override update(_updater: never): never {\n    throw new Error(\n      `${this.name} is a StatelessCubit and does not support update(). ` +\n        'Use a regular Cubit if you need state management.',\n    );\n  }\n\n  /**\n   * patch() is not available on StatelessCubit.\n   * @throws Error always - StatelessCubit does not support state changes\n   */\n  public override patch = (_partial: Partial<EmptyState>): void => {\n    throw new Error(\n      `${this.name} is a StatelessCubit and does not support patch(). ` +\n        'Use a regular Cubit if you need state management.',\n    );\n  };\n}\n","import { StateContainer } from './StateContainer';\nimport { globalRegistry } from './StateContainerRegistry';\nimport { STATELESS_MARKER } from './StatelessCubit';\nimport type { DiscriminatedEvent, EventWithMetadata } from '../types/events';\n\n/**\n * Empty state type used internally by stateless containers.\n * @internal\n */\ntype EmptyState = Record<never, never>;\n\n/**\n * Event handler for StatelessVertex that receives only the event (no emit function).\n * Use for side-effect-only event processing.\n */\nexport type StatelessEventHandler<E extends DiscriminatedEvent> = (\n  event: EventWithMetadata<E>,\n) => void;\n\n/**\n * Map of event types to their handlers for StatelessVertex.\n * Enforces exhaustive handling of all event types in the union.\n */\nexport type StatelessEventHandlerMap<E extends DiscriminatedEvent> = {\n  [K in E['type']]: StatelessEventHandler<Extract<E, { type: K }>>;\n};\n\n/**\n * An event-driven container without state management capabilities.\n * Use this for event processing that only produces side effects (logging, analytics, etc).\n *\n * StatelessVertex:\n * - Processes events via `add()` method\n * - Handlers receive only the event (no `emit` function)\n * - Has no accessible `state` property\n * - Cannot be subscribed to (throws error)\n * - Is rejected by `useBloc` hook (use `useBlocActions` instead)\n *\n * @template E - Event union type (discriminated by 'type' property)\n * @template P - Props type (optional)\n *\n * @example\n * ```typescript\n * type LogEvent =\n *   | { type: 'info'; message: string }\n *   | { type: 'error'; message: string; error: Error }\n *   | { type: 'warn'; message: string };\n *\n * class LoggingVertex extends StatelessVertex<LogEvent> {\n *   constructor() {\n *     super();\n *     this.createHandlers({\n *       info: (event) => console.log('[INFO]', event.message),\n *       error: (event) => console.error('[ERROR]', event.message, event.error),\n *       warn: (event) => console.warn('[WARN]', event.message),\n *     });\n *   }\n *\n *   info = (message: string) => this.add({ type: 'info', message });\n *   error = (message: string, error: Error) => this.add({ type: 'error', message, error });\n *   warn = (message: string) => this.add({ type: 'warn', message });\n * }\n *\n * // In React component:\n * const logger = useBlocActions(LoggingVertex);\n * logger.info('Page loaded');\n * ```\n */\nexport abstract class StatelessVertex<\n  E extends DiscriminatedEvent = DiscriminatedEvent,\n  P = undefined,\n> extends StateContainer<EmptyState, P> {\n  /**\n   * Marker property to identify stateless containers.\n   * @internal\n   */\n  static readonly [STATELESS_MARKER] = true as const;\n\n  /** @internal */\n  private handlers = new Map<\n    string,\n    StatelessEventHandler<DiscriminatedEvent>\n  >();\n  /** @internal */\n  private isProcessing = false;\n  /** @internal */\n  private eventQueue: EventWithMetadata<E>[] = [];\n\n  constructor() {\n    super({});\n  }\n\n  /**\n   * State is not available on StatelessVertex.\n   * @throws Always throws an error when accessed.\n   */\n  override get state(): never {\n    throw new Error(\n      `${this.name} is a StatelessVertex and does not have state. ` +\n        'Use a regular Vertex if you need state management.',\n    );\n  }\n\n  /**\n   * Subscriptions are not available on StatelessVertex.\n   * @throws Always throws an error when called.\n   */\n  override subscribe(_listener: (state: EmptyState) => void): never {\n    throw new Error(\n      `${this.name} is a StatelessVertex and does not support subscriptions. ` +\n        'Use useBlocActions() instead of useBloc() in React.',\n    );\n  }\n\n  /**\n   * Register all event handlers with exhaustive type checking.\n   * TypeScript will error if any event type from the union is missing.\n   *\n   * Unlike regular Vertex, handlers do NOT receive an emit function\n   * since StatelessVertex cannot emit state.\n   *\n   * @param handlers - Map of event type to handler function\n   */\n  protected createHandlers(handlers: StatelessEventHandlerMap<E>): void {\n    for (const [eventType, handler] of Object.entries(handlers)) {\n      this.handlers.set(\n        eventType,\n        handler as StatelessEventHandler<DiscriminatedEvent>,\n      );\n    }\n  }\n\n  /**\n   * Dispatch an event for processing.\n   * Events are processed synchronously; if called during processing,\n   * the event is queued and processed after the current event completes.\n   *\n   * @param event - The event to process (must match the event union type)\n   */\n  public add = (event: E): void => {\n    const enrichedEvent = this.enrichEvent(event);\n    globalRegistry.emit('eventAdded', this, enrichedEvent);\n    this.processEvent(enrichedEvent);\n  };\n\n  /** @internal */\n  private enrichEvent(event: E): EventWithMetadata<E> {\n    return {\n      ...event,\n      timestamp: Date.now(),\n    };\n  }\n\n  /** @internal */\n  private processEvent(event: EventWithMetadata<E>): void {\n    if (this.isProcessing) {\n      this.eventQueue.push(event);\n      return;\n    }\n\n    this.isProcessing = true;\n\n    try {\n      this.handleEvent(event);\n\n      while (this.eventQueue.length > 0) {\n        const nextEvent = this.eventQueue.shift()!;\n        this.handleEvent(nextEvent);\n      }\n    } finally {\n      this.isProcessing = false;\n    }\n  }\n\n  /** @internal */\n  private handleEvent(event: EventWithMetadata<E>): void {\n    const handler = this.handlers.get(event.type);\n\n    if (!handler) {\n      if (this.debug) {\n        console.warn(`No handler registered for event type: ${event.type}`);\n      }\n      return;\n    }\n\n    try {\n      handler(event);\n    } catch (error) {\n      if (this.debug) {\n        console.error(`Error handling event ${event.type}:`, error);\n      }\n      this.onEventError(event, error as Error);\n    }\n  }\n\n  /**\n   * Called when an error occurs during event processing.\n   * Override to implement custom error handling.\n   *\n   * @param _event - The event that caused the error\n   * @param _error - The error that occurred\n   */\n  protected onEventError(_event: EventWithMetadata<E>, _error: Error): void {}\n\n  /**\n   * emit() is not available on StatelessVertex.\n   * @internal\n   */\n  protected override emit(_newState: never): never {\n    throw new Error(\n      `${this.name} is a StatelessVertex and does not support emit(). ` +\n        'Use a regular Vertex if you need state management.',\n    );\n  }\n\n  /**\n   * update() is not available on StatelessVertex.\n   * @internal\n   */\n  protected override update(_updater: never): never {\n    throw new Error(\n      `${this.name} is a StatelessVertex and does not support update(). ` +\n        'Use a regular Vertex if you need state management.',\n    );\n  }\n}\n","import type { StateContainer } from '../core/StateContainer';\nimport type { Vertex } from '../core/Vertex';\nimport type { DiscriminatedEvent, EventWithMetadata } from '../types/events';\n\n/**\n * Metadata information about a state container instance for debugging and inspection\n */\nexport interface InstanceMetadata {\n  /** Unique instance identifier */\n  id: string;\n  /** Name of the state container class */\n  className: string;\n  /** Whether the instance has been disposed */\n  isDisposed: boolean;\n  /** Display name for the instance */\n  name: string;\n  /** When state last changed (milliseconds) */\n  lastStateChangeTimestamp: number;\n  /** Current state value */\n  state: any;\n  /** Timestamp when instance was created (milliseconds) */\n  createdAt: number;\n  /** Whether this is an isolated (component-scoped) instance */\n  isIsolated: boolean;\n  /** Stack trace from when instance was created (for debugging) */\n  callstack?: string;\n  /** Previous state value */\n  previousState?: any;\n  /** Current state value */\n  currentState?: any;\n}\n\n/**\n * Safe context API provided to plugins for accessing registry data\n */\nexport interface PluginContext {\n  /**\n   * Get metadata for a specific instance\n   */\n  getInstanceMetadata(instance: StateContainer<any>): InstanceMetadata;\n\n  /**\n   * Get current state from a container\n   */\n  getState<S extends object = any>(instance: StateContainer<S>): S;\n\n  /**\n   * Get all instances of a specific type\n   */\n  queryInstances<T extends StateContainer<any>>(\n    typeClass: new (...args: any[]) => T,\n  ): T[];\n\n  /**\n   * Get all registered state container types\n   */\n  getAllTypes(): Array<new (...args: any[]) => StateContainer<any>>;\n\n  /**\n   * Get registry statistics\n   */\n  getStats(): {\n    registeredTypes: number;\n    totalInstances: number;\n    typeBreakdown: Record<string, number>;\n  };\n}\n\n/**\n * Interface for plugins that extend BlaC functionality\n */\nexport interface BlacPlugin {\n  /** Unique plugin identifier */\n  readonly name: string;\n  /** Plugin version identifier */\n  readonly version: string;\n\n  /**\n   * Called when the plugin is installed (optional)\n   */\n  onInstall?(context: PluginContext): void;\n\n  /**\n   * Called when the plugin is uninstalled\n   */\n  onUninstall?(): void;\n\n  /**\n   * Called when a state container instance is created\n   */\n  onInstanceCreated?(\n    instance: StateContainer<any>,\n    context: PluginContext,\n  ): void;\n\n  /**\n   * Called when state changes in a container instance\n   */\n  onStateChanged?<S extends object = any>(\n    instance: StateContainer<S>,\n    previousState: S,\n    currentState: S,\n    callstack: string | undefined,\n    context: PluginContext,\n  ): void;\n\n  /**\n   * Called when an event is added to a Vertex instance\n   */\n  onEventAdded?<E extends DiscriminatedEvent>(\n    vertex: Vertex<any, E>,\n    event: EventWithMetadata<E>,\n    context: PluginContext,\n  ): void;\n\n  /**\n   * Called when a state container instance is disposed\n   */\n  onInstanceDisposed?(\n    instance: StateContainer<any>,\n    context: PluginContext,\n  ): void;\n}\n\n/**\n * Plugin interface variant that requires mandatory onInstall hook\n */\nexport interface BlacPluginWithInit extends BlacPlugin {\n  /**\n   * Required initialization hook called when plugin is installed\n   */\n  onInstall(context: PluginContext): void;\n}\n\n/**\n * Configuration options for plugin installation\n */\nexport interface PluginConfig {\n  /** Enable or disable the plugin */\n  enabled?: boolean;\n  /** Environments where plugin runs */\n  environment?: 'development' | 'production' | 'test' | 'all';\n}\n\n/**\n * Type guard to check if a plugin has a required onInstall hook\n * @param plugin - The plugin to check\n * @returns true if the plugin implements BlacPluginWithInit\n */\nexport function hasInitHook(plugin: BlacPlugin): plugin is BlacPluginWithInit {\n  return typeof plugin.onInstall === 'function';\n}\n","/**\n * Functional proxy tracker for automatic dependency tracking\n *\n * This module provides a functional approach to proxy-based dependency tracking.\n * Unlike the class-based ProxyTracker, this uses a state object pattern that's\n * easier to integrate with functional programming patterns and framework hooks.\n *\n * @internal\n */\n\n/**\n * Check if a value can be proxied\n *\n * Returns true for plain objects and arrays only.\n * Excludes built-in objects like Date, Map, Set, etc.\n *\n * @internal\n */\nexport function isProxyable(value: unknown): value is object {\n  if (typeof value !== 'object' || value === null) return false;\n  const proto = Object.getPrototypeOf(value);\n  return proto === Object.prototype || proto === Array.prototype;\n}\n\n/**\n * State container for proxy tracking\n * @internal\n */\nexport interface ProxyState<T> {\n  /** Set of all tracked property paths */\n  trackedPaths: Set<string>;\n  /** Whether tracking is currently active */\n  isTracking: boolean;\n  /** Cache of created proxies to avoid duplicates */\n  proxyCache: WeakMap<object, any>;\n  /** Cache of bound functions to maintain referential equality */\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n  boundFunctionsCache: WeakMap<Function, Function> | null;\n  /** Last state object that was proxied (for cache invalidation) */\n  lastProxiedState: T | null;\n  /** Last proxy created (for cache reuse) */\n  lastProxy: T | null;\n  /** Maximum depth for nested proxy creation */\n  maxDepth: number;\n}\n\n/**\n * Create a new proxy tracker state\n *\n * @example\n * const state = createProxyTrackerState<MyState>();\n * startProxyTracking(state);\n * const proxy = createProxyForTarget(state, myObject);\n * // ... use proxy ...\n * const paths = stopProxyTracking(state);\n *\n * @internal\n */\nexport function createProxyState<T>(): ProxyState<T> {\n  return {\n    trackedPaths: new Set<string>(),\n    isTracking: false,\n    proxyCache: new WeakMap<object, any>(),\n    boundFunctionsCache: null,\n    lastProxiedState: null,\n    lastProxy: null,\n    maxDepth: 10,\n  };\n}\n\n/**\n * Start tracking property accesses\n *\n * Clears previous tracked paths and enables tracking mode.\n *\n * @internal\n */\nexport function startProxy<T>(state: ProxyState<T>): void {\n  state.isTracking = true;\n  state.trackedPaths.clear();\n}\n\n/**\n * Stop tracking and return the tracked paths\n *\n * Returns a new Set containing all tracked paths.\n *\n * @internal\n */\nexport function stopProxy<T>(state: ProxyState<T>): Set<string> {\n  state.isTracking = false;\n  return new Set(state.trackedPaths);\n}\n\n/**\n * Create a proxy for an array with property access tracking\n *\n * Tracks:\n * - Array element access (arr[0])\n * - Length access (arr.length)\n * - Array method calls (arr.map, arr.filter, etc.)\n *\n * @internal\n */\nexport function createArrayProxy<T, U>(\n  state: ProxyState<T>,\n  target: U[],\n  path: string,\n  depth: number = 0,\n): U[] {\n  const proxy = new Proxy(target, {\n    get: (arr, prop: string | symbol) => {\n      if (typeof prop === 'symbol') {\n        return Reflect.get(arr, prop);\n      }\n\n      const value = Reflect.get(arr, prop);\n\n      if (typeof value === 'function') {\n        // Don't track array methods - the array itself is already tracked\n        if (!state.boundFunctionsCache) {\n          // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n          state.boundFunctionsCache = new WeakMap<Function, Function>();\n        }\n        const cached = state.boundFunctionsCache.get(value);\n        if (cached) {\n          return cached;\n        }\n        const bound = value.bind(arr);\n        state.boundFunctionsCache.set(value, bound);\n        return bound;\n      }\n\n      // Track array length access\n      if (prop === 'length') {\n        if (state.isTracking) {\n          const fullPath = path ? `${path}.length` : 'length';\n          state.trackedPaths.add(fullPath);\n        }\n        return value;\n      }\n\n      // Track array index access\n      let fullPath: string;\n      if (typeof prop === 'string') {\n        const index = Number(prop);\n        if (!isNaN(index) && index >= 0) {\n          fullPath = path ? `${path}[${index}]` : `[${index}]`;\n        } else {\n          fullPath = path ? `${path}.${prop}` : prop;\n        }\n      } else {\n        return value;\n      }\n\n      if (isProxyable(value)) {\n        return createInternal(state, value as T, fullPath, depth + 1);\n      }\n\n      if (state.isTracking) {\n        state.trackedPaths.add(fullPath);\n      }\n\n      return value;\n    },\n  });\n\n  state.proxyCache.set(target, proxy);\n  return proxy;\n}\n\n/**\n * Create a proxy for an object with property access tracking\n *\n * This is the core proxy creation function that recursively creates proxies\n * for nested objects and arrays.\n *\n * Tracks:\n * - Property access (obj.prop)\n * - Nested property access (obj.nested.prop)\n * - 'in' operator usage ('prop' in obj)\n * - Object.keys, Object.entries, etc.\n *\n * @internal\n */\nexport function createInternal<T>(\n  state: ProxyState<T>,\n  target: T,\n  path: string = '',\n  depth: number = 0,\n): T {\n  if (!state.isTracking || !isProxyable(target)) {\n    return target;\n  }\n\n  if (depth >= state.maxDepth) {\n    return target;\n  }\n\n  if (state.proxyCache.has(target)) {\n    return state.proxyCache.get(target);\n  }\n\n  if (Array.isArray(target)) {\n    return createArrayProxy(\n      state,\n      target as unknown as any[],\n      path,\n      depth,\n    ) as unknown as T;\n  }\n\n  const proxy = new Proxy(target, {\n    get: (obj, prop: string | symbol) => {\n      if (typeof prop === 'symbol') {\n        return Reflect.get(obj, prop);\n      }\n\n      const value = Reflect.get(obj, prop);\n\n      if (typeof value === 'function') {\n        if (!state.boundFunctionsCache) {\n          // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n          state.boundFunctionsCache = new WeakMap<Function, Function>();\n        }\n        const cached = state.boundFunctionsCache.get(value);\n        if (cached) {\n          return cached;\n        }\n        const bound = value.bind(obj);\n        state.boundFunctionsCache.set(value, bound);\n        return bound;\n      }\n\n      const fullPath = path ? `${path}.${String(prop)}` : String(prop);\n\n      // Track ALL property accesses (objects, arrays, primitives)\n      // This ensures accessing state.items or state.user tracks those paths\n      if (typeof prop === 'string' && state.isTracking) {\n        if (!prop.startsWith('_') && !prop.startsWith('$$')) {\n          state.trackedPaths.add(fullPath);\n        }\n      }\n\n      // If the value is an object/array, create a nested proxy for deeper tracking\n      if (isProxyable(value)) {\n        const proxiedValue = createInternal(\n          state,\n          value as T,\n          fullPath,\n          depth + 1,\n        );\n        return proxiedValue;\n      }\n\n      return value;\n    },\n\n    has: (obj, prop: string | symbol) => {\n      if (typeof prop === 'string' && state.isTracking) {\n        const fullPath = path ? `${path}.${prop}` : prop;\n        state.trackedPaths.add(fullPath);\n      }\n      return Reflect.has(obj, prop);\n    },\n\n    ownKeys: (obj) => {\n      if (state.isTracking && path) {\n        state.trackedPaths.add(path);\n      }\n      return Reflect.ownKeys(obj);\n    },\n  });\n\n  state.proxyCache.set(target, proxy);\n  return proxy as T;\n}\n\n/**\n * Create a proxy for a target with caching\n *\n * If the target hasn't changed since the last call, returns the cached proxy.\n * Otherwise, creates a new proxy and caches it.\n *\n * This is the main entry point for creating tracked proxies.\n *\n * @internal\n */\nexport function createForTarget<T>(state: ProxyState<T>, target: T): T {\n  if (state.lastProxiedState === target && state.lastProxy) {\n    return state.lastProxy;\n  }\n\n  // Clear caches when state changes to prevent stale bound functions\n  // This is critical for array methods like .map() which get bound to the target\n  state.proxyCache = new WeakMap<object, any>();\n  state.boundFunctionsCache = null;\n\n  const proxy = createInternal(state, target, '', 0);\n  state.lastProxiedState = target;\n  state.lastProxy = proxy;\n  return proxy;\n}\n","/**\n * Path utilities for dependency tracking\n *\n * Provides utilities for parsing property paths and extracting values\n * from nested objects using path strings.\n *\n * @internal\n */\n\n/**\n * Parse a property path string into an array of segments\n *\n * @internal\n *\n * Handles both dot notation (a.b.c) and bracket notation (a[0].b)\n *\n * @example\n * ```ts\n * parsePath('user.name') // ['user', 'name']\n * parsePath('items[0].name') // ['items', '0', 'name']\n * parsePath('data.users[2].address.city') // ['data', 'users', '2', 'address', 'city']\n * ```\n */\nexport function parsePath(path: string): string[] {\n  const segments: string[] = [];\n  let current = '';\n  let i = 0;\n\n  while (i < path.length) {\n    const char = path[i];\n    if (char === '.') {\n      if (current) segments.push(current);\n      current = '';\n    } else if (char === '[') {\n      if (current) segments.push(current);\n      current = '';\n      // Skip bracket\n      i++;\n      // Read until ]\n      while (i < path.length && path[i] !== ']') {\n        current += path[i++];\n      }\n      if (current) segments.push(current);\n      current = '';\n    } else {\n      current += char;\n    }\n    i++;\n  }\n\n  if (current) segments.push(current);\n  return segments;\n}\n\n/**\n * Get a value from an object using a path of segments\n *\n * @example\n * ```ts\n * const obj = { user: { name: 'Alice', age: 30 } }\n * getValueAtPath(obj, ['user', 'name']) // 'Alice'\n * getValueAtPath(obj, ['user', 'age']) // 30\n * getValueAtPath(obj, ['user', 'missing']) // undefined\n * ```\n *\n * @internal\n */\nexport function getValueAtPath(obj: any, segments: string[]): any {\n  if (obj == null) return undefined;\n\n  let current = obj;\n  for (let i = 0; i < segments.length; i++) {\n    current = current[segments[i]];\n    if (current == null) return undefined;\n  }\n  return current;\n}\n\n/**\n * Shallow equality comparison for arrays\n *\n * Compares two arrays element-by-element using Object.is\n *\n * @example\n * ```ts\n * shallowEqual([1, 2, 3], [1, 2, 3]) // true\n * shallowEqual([1, 2, 3], [1, 2, 4]) // false\n * shallowEqual([1, 2], [1, 2, 3]) // false\n * ```\n *\n * @internal\n */\nexport function shallowEqual(arr1: unknown[], arr2: unknown[]): boolean {\n  if (arr1.length !== arr2.length) return false;\n  for (let i = 0; i < arr1.length; i++) {\n    if (!Object.is(arr1[i], arr2[i])) return false;\n  }\n  return true;\n}\n","import {\n  type ProxyState,\n  createProxyState,\n  startProxy,\n  stopProxy,\n  createForTarget,\n} from './proxy-tracker';\nimport { parsePath, getValueAtPath } from './path-utils';\n\n/**\n * @internal\n */\nexport interface PathInfo {\n  segments: string[];\n  value: any;\n}\n\n/**\n * @internal\n */\nexport interface DependencyState<T> {\n  proxyState: ProxyState<T>;\n  previousRenderPaths: Set<string>;\n  currentRenderPaths: Set<string>;\n  pathCache: Map<string, PathInfo>;\n  lastCheckedState: T | null;\n  lastCheckedValues: Map<string, any>;\n}\n\nfunction isChildPath(child: string, parent: string): boolean {\n  if (child === parent) return false;\n  return child.startsWith(parent + '.') || child.startsWith(parent + '[');\n}\n\n/**\n * Extract the parent array path from an array child path\n * Examples:\n *   'messages.length' -> 'messages'\n *   'messages[0]' -> 'messages'\n *   'messages[0].text' -> 'messages'\n *   'data.items[0]' -> 'data.items'\n */\nfunction getArrayParentPath(path: string): string | null {\n  // Check if path ends with .length\n  if (path.endsWith('.length')) {\n    return path.slice(0, -7); // Remove '.length'\n  }\n\n  // Check if path contains array indexing [n]\n  const arrayIndexMatch = path.match(/^(.+?)\\[\\d+\\]/);\n  if (arrayIndexMatch) {\n    return arrayIndexMatch[1];\n  }\n\n  return null;\n}\n\n/**\n * @internal\n */\nexport function optimizeTrackedPaths(paths: Set<string>): Set<string> {\n  if (paths.size === 0) {\n    return new Set();\n  }\n\n  if (paths.size === 1) {\n    return new Set(paths);\n  }\n\n  // Sort paths by length descending (longest/most specific first)\n  const sortedPaths = Array.from(paths).sort((a, b) => b.length - a.length);\n  const optimized = new Set<string>();\n\n  for (const path of sortedPaths) {\n    // Check if we already have a more specific child path\n    let hasMoreSpecificChild = false;\n\n    for (const optimizedPath of optimized) {\n      if (isChildPath(optimizedPath, path)) {\n        hasMoreSpecificChild = true;\n        break;\n      }\n    }\n\n    // Only add this path if we don't have a more specific version\n    if (!hasMoreSpecificChild) {\n      optimized.add(path);\n    }\n  }\n\n  // IMPORTANT: Add array parent paths back to track array reference changes\n  // When we track array children (e.g., 'messages.length' or 'messages[0]'),\n  // we must also track the array itself because:\n  // 1. Array methods like .map() track the array path\n  // 2. The array reference can change even when length/elements stay the same\n  // 3. Callback parameters in .map() receive raw elements (not proxies)\n  const arrayParents = new Set<string>();\n  for (const path of optimized) {\n    const arrayParent = getArrayParentPath(path);\n    if (arrayParent) {\n      arrayParents.add(arrayParent);\n    }\n  }\n\n  // Add array parent paths to the optimized set\n  for (const arrayParent of arrayParents) {\n    optimized.add(arrayParent);\n  }\n\n  return optimized;\n}\n\n/**\n * @internal\n */\nexport function createDependencyState<T>(): DependencyState<T> {\n  return {\n    proxyState: createProxyState<T>(),\n    previousRenderPaths: new Set<string>(),\n    currentRenderPaths: new Set<string>(),\n    pathCache: new Map<string, PathInfo>(),\n    lastCheckedState: null,\n    lastCheckedValues: new Map<string, any>(),\n  };\n}\n\n/**\n * @internal\n */\nexport function startDependency<T>(tracker: DependencyState<T>): void {\n  startProxy(tracker.proxyState);\n}\n\n/**\n * @internal\n */\nexport function createDependencyProxy<T>(\n  tracker: DependencyState<T>,\n  state: T,\n): T {\n  return createForTarget(tracker.proxyState, state);\n}\n\n/**\n * @internal\n */\nexport function capturePaths<T>(tracker: DependencyState<T>, state: T): void {\n  tracker.previousRenderPaths = tracker.currentRenderPaths;\n\n  // Get raw tracked paths and optimize them (remove redundant parents)\n  const rawPaths = stopProxy(tracker.proxyState);\n  tracker.currentRenderPaths = optimizeTrackedPaths(rawPaths);\n\n  if (\n    tracker.previousRenderPaths.size === 0 &&\n    tracker.currentRenderPaths.size === 0\n  ) {\n    return;\n  }\n\n  const trackedPathsUnion = new Set(tracker.previousRenderPaths);\n  for (const path of tracker.currentRenderPaths) {\n    trackedPathsUnion.add(path);\n  }\n\n  const canReuseCache = tracker.lastCheckedState === state;\n\n  for (const path of trackedPathsUnion) {\n    if (!tracker.pathCache.has(path)) {\n      const segments = parsePath(path);\n      const value =\n        canReuseCache && tracker.lastCheckedValues.has(path)\n          ? tracker.lastCheckedValues.get(path)\n          : getValueAtPath(state, segments);\n\n      tracker.pathCache.set(path, { segments, value });\n    } else {\n      const info = tracker.pathCache.get(path)!;\n      info.value =\n        canReuseCache && tracker.lastCheckedValues.has(path)\n          ? tracker.lastCheckedValues.get(path)\n          : getValueAtPath(state, info.segments);\n    }\n  }\n\n  tracker.lastCheckedValues.clear();\n}\n\n/**\n * @internal\n */\nexport function hasDependencyChanges<T>(\n  tracker: DependencyState<T>,\n  state: T,\n): boolean {\n  if (tracker.pathCache.size === 0) {\n    return true;\n  }\n\n  tracker.lastCheckedValues.clear();\n\n  for (const [path, info] of tracker.pathCache.entries()) {\n    const currentValue = getValueAtPath(state, info.segments);\n    tracker.lastCheckedValues.set(path, currentValue);\n\n    if (!Object.is(currentValue, info.value)) {\n      tracker.lastCheckedState = state;\n      return true;\n    }\n  }\n\n  tracker.lastCheckedState = state;\n  return false;\n}\n\n/**\n * @internal\n */\nexport function hasTrackedData<T>(tracker: DependencyState<T>): boolean {\n  return (\n    tracker.proxyState.trackedPaths.size > 0 ||\n    tracker.pathCache.size > 0 ||\n    tracker.previousRenderPaths.size > 0\n  );\n}\n","import type { StateContainerInstance } from '../types/utilities';\nimport type { DependencyState } from './dependency-tracker';\nimport type { GetterState } from './getter-tracker';\nimport {\n  createDependencyState,\n  startDependency,\n  createDependencyProxy,\n  capturePaths,\n  hasDependencyChanges,\n} from './dependency-tracker';\nimport {\n  createGetterState,\n  isGetter,\n  getDescriptor,\n  hasGetterChanges,\n  invalidateRenderCache,\n  commitTrackedGetters,\n  getGetterExecutionContext,\n} from './getter-tracker';\nimport { BLAC_DEFAULTS, BLAC_ERROR_PREFIX } from '../constants';\n\n/**\n * State for tracking both state property access and getter access.\n */\nexport interface TrackingProxyState {\n  dependencyState: DependencyState<any>;\n  getterState: GetterState;\n  dependencies: Set<StateContainerInstance>;\n  isTracking: boolean;\n}\n\n/**\n * Create a new tracking proxy state.\n */\nexport function createState(): TrackingProxyState {\n  return {\n    dependencyState: createDependencyState(),\n    getterState: createGetterState(),\n    dependencies: new Set(),\n    isTracking: false,\n  };\n}\n\n/**\n * Start tracking on a tracking proxy.\n */\nexport function startTracking(tracker: TrackingProxyState): void {\n  tracker.isTracking = true;\n  tracker.dependencies.clear();\n  tracker.getterState.isTracking = true;\n  tracker.getterState.externalDependencies.clear();\n  startDependency(tracker.dependencyState);\n}\n\n/**\n * Stop tracking and collect all dependencies.\n */\nexport function stopTracking(\n  tracker: TrackingProxyState,\n  bloc: StateContainerInstance,\n): Set<StateContainerInstance> {\n  tracker.isTracking = false;\n  tracker.getterState.isTracking = false;\n\n  capturePaths(tracker.dependencyState, bloc.state);\n  commitTrackedGetters(tracker.getterState);\n\n  const allDeps = new Set(tracker.dependencies);\n  for (const dep of tracker.getterState.externalDependencies) {\n    allDeps.add(dep);\n  }\n\n  tracker.getterState.externalDependencies.clear();\n\n  return allDeps;\n}\n\n/**\n * Check if tracked state or getters have changed.\n */\nexport function hasChanges(\n  tracker: TrackingProxyState,\n  bloc: StateContainerInstance,\n): boolean {\n  invalidateRenderCache(tracker.getterState);\n\n  const stateChanged = hasDependencyChanges(\n    tracker.dependencyState,\n    bloc.state,\n  );\n  const getterChanged = hasGetterChanges(bloc, tracker.getterState);\n\n  return stateChanged || getterChanged;\n}\n\nconst MAX_GETTER_DEPTH = BLAC_DEFAULTS.MAX_GETTER_DEPTH;\n\n/**\n * Create a tracking proxy for a bloc instance.\n * Tracks both state property access and getter access.\n */\nexport function createTrackingProxy<T extends StateContainerInstance>(\n  bloc: T,\n  tracker: TrackingProxyState,\n): T {\n  tracker.dependencies.add(bloc);\n\n  const stateProxyCache = new WeakMap<object, any>();\n\n  const proxy = new Proxy(bloc, {\n    get(target, prop, receiver) {\n      if (prop === 'state') {\n        if (!tracker.isTracking) {\n          return target.state;\n        }\n\n        const rawState = target.state;\n        if (rawState === null || typeof rawState !== 'object') {\n          return rawState;\n        }\n\n        if (stateProxyCache.has(rawState)) {\n          return stateProxyCache.get(rawState);\n        }\n\n        const stateProxy = createDependencyProxy(\n          tracker.dependencyState,\n          rawState,\n        );\n        stateProxyCache.set(rawState, stateProxy);\n        return stateProxy;\n      }\n\n      if (typeof prop === 'symbol') {\n        return Reflect.get(target, prop, receiver);\n      }\n\n      const value = Reflect.get(target, prop, receiver);\n\n      if (typeof value === 'function') {\n        return value.bind(target);\n      }\n\n      if (tracker.isTracking && isGetter(target, prop)) {\n        tracker.getterState.currentlyAccessing.add(prop);\n\n        if (\n          tracker.getterState.cacheValid &&\n          tracker.getterState.renderCache.has(prop)\n        ) {\n          const cachedValue = tracker.getterState.renderCache.get(prop);\n          tracker.getterState.trackedValues.set(prop, cachedValue);\n          return cachedValue;\n        }\n\n        const context = getGetterExecutionContext();\n        if (context.depth >= MAX_GETTER_DEPTH) {\n          console.warn(\n            `${BLAC_ERROR_PREFIX} Maximum getter depth (${MAX_GETTER_DEPTH}) exceeded. ` +\n              `Possible circular dependency in getter \"${String(prop)}\" on ${target.constructor.name}.`,\n          );\n          return undefined;\n        }\n\n        if (context.visitedBlocs.has(target)) {\n          console.warn(\n            `${BLAC_ERROR_PREFIX} Circular dependency detected: getter \"${String(prop)}\" on ${target.constructor.name}.`,\n          );\n          return undefined;\n        }\n\n        const prevContext = {\n          tracker: context.tracker,\n          currentBloc: context.currentBloc,\n          depth: context.depth,\n          visitedBlocs: new Set(context.visitedBlocs),\n        };\n\n        context.tracker = tracker.getterState;\n        context.currentBloc = target;\n        context.depth++;\n        context.visitedBlocs.add(target);\n\n        try {\n          const descriptor = getDescriptor(target, prop);\n          const getterValue = descriptor!.get!.call(target);\n          tracker.getterState.trackedValues.set(prop, getterValue);\n          return getterValue;\n        } catch (error) {\n          tracker.getterState.currentlyAccessing.delete(prop);\n          throw error;\n        } finally {\n          context.tracker = prevContext.tracker;\n          context.currentBloc = prevContext.currentBloc;\n          context.depth = prevContext.depth;\n          context.visitedBlocs = prevContext.visitedBlocs;\n        }\n      }\n\n      return value;\n    },\n  });\n\n  return proxy as T;\n}\n","import type { StateContainerInstance } from '../types/utilities';\n\n/**\n * Manages subscriptions to state container dependencies.\n * Provides efficient sync mechanism to add/remove subscriptions\n * as dependencies change between callback invocations.\n */\nexport class DependencyManager {\n  private subscriptions = new Map<StateContainerInstance, () => void>();\n  private currentDeps = new Set<StateContainerInstance>();\n\n  /**\n   * Sync subscriptions with a new set of dependencies.\n   * Adds subscriptions for new deps, removes subscriptions for stale deps.\n   *\n   * @param newDeps - The new set of dependencies to subscribe to\n   * @param onChange - Callback to invoke when any dependency changes\n   * @param exclude - Optional instance to exclude from subscriptions (e.g., primary bloc)\n   * @returns true if the dependency set changed, false if unchanged\n   */\n  sync(\n    newDeps: Set<StateContainerInstance>,\n    onChange: () => void,\n    exclude?: StateContainerInstance,\n  ): boolean {\n    const filteredNewDeps = new Set<StateContainerInstance>();\n    for (const dep of newDeps) {\n      if (dep !== exclude && !dep.isDisposed) {\n        filteredNewDeps.add(dep);\n      }\n    }\n\n    if (this.areSetsEqual(this.currentDeps, filteredNewDeps)) {\n      return false;\n    }\n\n    for (const dep of this.currentDeps) {\n      if (!filteredNewDeps.has(dep)) {\n        const unsub = this.subscriptions.get(dep);\n        if (unsub) {\n          unsub();\n          this.subscriptions.delete(dep);\n        }\n      }\n    }\n\n    for (const dep of filteredNewDeps) {\n      if (!this.currentDeps.has(dep) && !this.subscriptions.has(dep)) {\n        const unsub = dep.subscribe(onChange);\n        this.subscriptions.set(dep, unsub);\n      }\n    }\n\n    this.currentDeps = filteredNewDeps;\n    return true;\n  }\n\n  /**\n   * Add a single dependency subscription.\n   */\n  add(dep: StateContainerInstance, onChange: () => void): void {\n    if (this.subscriptions.has(dep) || dep.isDisposed) {\n      return;\n    }\n    const unsub = dep.subscribe(onChange);\n    this.subscriptions.set(dep, unsub);\n    this.currentDeps.add(dep);\n  }\n\n  /**\n   * Check if a dependency is currently subscribed.\n   */\n  has(dep: StateContainerInstance): boolean {\n    return this.currentDeps.has(dep);\n  }\n\n  /**\n   * Get the current set of dependencies.\n   */\n  getDependencies(): Set<StateContainerInstance> {\n    return new Set(this.currentDeps);\n  }\n\n  /**\n   * Clean up all active subscriptions.\n   */\n  cleanup(): void {\n    for (const unsub of this.subscriptions.values()) {\n      unsub();\n    }\n    this.subscriptions.clear();\n    this.currentDeps.clear();\n  }\n\n  private areSetsEqual(\n    a: Set<StateContainerInstance>,\n    b: Set<StateContainerInstance>,\n  ): boolean {\n    if (a.size !== b.size) return false;\n    for (const item of a) {\n      if (!b.has(item)) return false;\n    }\n    return true;\n  }\n}\n","import type { StateContainerInstance } from '../types/utilities';\nimport {\n  createState,\n  startTracking,\n  stopTracking,\n  createTrackingProxy,\n  hasChanges,\n  type TrackingProxyState,\n} from './tracking-proxy';\nimport { DependencyManager } from './dependency-manager';\n\n/**\n * Result of running a tracked callback.\n */\nexport interface TrackedResult<T> {\n  result: T;\n  dependencies: Set<StateContainerInstance>;\n}\n\n/**\n * Options for the tracked() function.\n */\nexport interface TrackedOptions {\n  exclude?: StateContainerInstance;\n}\n\n/**\n * Run a callback while tracking all bloc dependencies accessed.\n * Returns both the result and the set of discovered dependencies.\n *\n * @example\n * ```ts\n * const { result, dependencies } = tracked(() => {\n *   const user = ensure(UserBloc);\n *   return user.fullName; // getter that may access other blocs\n * });\n * // dependencies contains UserBloc + any blocs accessed in fullName getter\n * ```\n */\nexport function tracked<T>(\n  callback: () => T,\n  options?: TrackedOptions,\n): TrackedResult<T> {\n  const tracker = createState();\n  startTracking(tracker);\n\n  let result: T;\n  try {\n    result = callback();\n  } finally {\n    stopTracking(tracker, { state: null } as any);\n  }\n\n  const dependencies = new Set(tracker.dependencies);\n  for (const dep of tracker.getterState.externalDependencies) {\n    dependencies.add(dep);\n  }\n\n  if (options?.exclude) {\n    dependencies.delete(options.exclude);\n  }\n\n  return { result, dependencies };\n}\n\n/**\n * Context for running tracked callbacks with bloc proxies.\n * Provides methods to create proxies and check for changes.\n */\nexport class TrackedContext {\n  private tracker: TrackingProxyState;\n  private proxiedBlocs = new WeakMap<\n    StateContainerInstance,\n    StateContainerInstance\n  >();\n  private primaryBlocs = new Set<StateContainerInstance>();\n\n  constructor() {\n    this.tracker = createState();\n  }\n\n  /**\n   * Get a tracking proxy for a bloc instance.\n   * The proxy will track state and getter accesses.\n   */\n  proxy<T extends StateContainerInstance>(bloc: T): T {\n    const cached = this.proxiedBlocs.get(bloc);\n    if (cached) {\n      return cached as T;\n    }\n\n    const proxied = createTrackingProxy(bloc, this.tracker);\n    this.proxiedBlocs.set(bloc, proxied);\n    this.primaryBlocs.add(bloc);\n    return proxied;\n  }\n\n  /**\n   * Start tracking for a new callback execution.\n   */\n  start(): void {\n    startTracking(this.tracker);\n  }\n\n  /**\n   * Stop tracking and get discovered dependencies.\n   * Excludes primary blocs (those explicitly proxied via proxy()).\n   */\n  stop(): Set<StateContainerInstance> {\n    const allDeps = new Set<StateContainerInstance>();\n\n    for (const bloc of this.primaryBlocs) {\n      const deps = stopTracking(this.tracker, bloc);\n      for (const dep of deps) {\n        if (!this.primaryBlocs.has(dep)) {\n          allDeps.add(dep);\n        }\n      }\n    }\n\n    for (const dep of this.tracker.getterState.externalDependencies) {\n      if (!this.primaryBlocs.has(dep)) {\n        allDeps.add(dep);\n      }\n    }\n\n    return allDeps;\n  }\n\n  /**\n   * Check if any tracked state or getters have changed.\n   */\n  changed(): boolean {\n    for (const bloc of this.primaryBlocs) {\n      if (hasChanges(this.tracker, bloc)) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Get all primary blocs (those explicitly proxied).\n   */\n  getPrimaryBlocs(): Set<StateContainerInstance> {\n    return new Set(this.primaryBlocs);\n  }\n\n  /**\n   * Reset the context for reuse.\n   */\n  reset(): void {\n    this.tracker = createState();\n    this.proxiedBlocs = new WeakMap();\n    this.primaryBlocs.clear();\n  }\n}\n\n/**\n * Create a new tracked context for manual control over tracking.\n */\nexport function createTrackedContext(): TrackedContext {\n  return new TrackedContext();\n}\n\nexport { DependencyManager };\n","/**\n * Framework Adapter\n *\n * Reusable utilities for integrating BlaC with any reactive framework.\n * Provides subscription and snapshot functions for different tracking modes.\n */\nimport type { DependencyState, GetterState } from '../tracking';\nimport type {\n  ExtractState,\n  InstanceReadonlyState,\n  InstanceState,\n  StateContainerConstructor,\n  StateContainerInstance,\n} from '../types/utilities';\nimport {\n  createDependencyState,\n  startDependency,\n  createDependencyProxy,\n  capturePaths,\n  hasDependencyChanges,\n  hasTrackedData,\n  shallowEqual,\n  createGetterState,\n  createBlocProxy,\n  hasGetterChanges,\n  setActiveTracker,\n  clearActiveTracker,\n  commitTrackedGetters,\n  invalidateRenderCache,\n  clearExternalDependencies,\n} from '../tracking';\n\n/**\n * Internal state for framework adapters, holding tracking and caching data.\n * @template TBloc - The state container type\n */\nexport interface AdapterState<TBloc extends StateContainerConstructor> {\n  /** Dependency tracker for state property access tracking */\n  dependencyState: DependencyState<ExtractState<TBloc>> | null;\n  /** Cached manual dependencies for comparison */\n  manualDepsCache: unknown[] | null;\n  /** Getter state for computed property tracking */\n  getterState: GetterState | null;\n  /** Proxied bloc instance for auto-tracking */\n  proxiedBloc: InstanceState<TBloc> | null;\n}\n\n/**\n * Configuration for manual dependency tracking mode\n * @template TBloc - The state container type\n */\nexport interface ManualDepsConfig<TBloc extends StateContainerConstructor> {\n  /** Function that returns dependency array from state and bloc */\n  dependencies: (\n    state: ExtractState<TBloc>,\n    bloc: InstanceState<TBloc>,\n  ) => any[];\n}\n\n/**\n * Callback function invoked when subscribed state changes\n */\nexport type SubscriptionCallback = () => void;\n\n/**\n * Function that subscribes to state changes and returns an unsubscribe function\n */\nexport type SubscribeFunction = (callback: SubscriptionCallback) => () => void;\n\n/**\n * Function that returns a snapshot of the current state\n * @template TState - The state type\n */\nexport type SnapshotFunction<TState> = () => TState;\n\nimport { DependencyManager } from '../tracking/dependency-manager';\n\n/**\n * Manages subscriptions to external bloc dependencies for getter tracking.\n * When a getter accesses another bloc's state, this manager ensures\n * re-renders occur when those external dependencies change.\n *\n * @deprecated Use DependencyManager from tracking module instead.\n * This class is kept for backward compatibility.\n */\nexport class ExternalDepsManager {\n  private manager = new DependencyManager();\n\n  /**\n   * Update subscriptions to external bloc dependencies.\n   * Creates subscriptions to blocs accessed via getters.\n   * @param getterTracker - The getter tracker state with external dependencies\n   * @param rawInstance - The primary bloc instance (excluded from subscriptions)\n   * @param onGetterChange - Callback to invoke when external dependency changes\n   * @returns true if subscriptions were updated, false if unchanged\n   */\n  updateSubscriptions(\n    getterState: GetterState | null,\n    rawInstance: StateContainerInstance,\n    onGetterChange: () => void,\n  ): boolean {\n    if (!getterState?.externalDependencies) {\n      return false;\n    }\n\n    const currentDeps = getterState.externalDependencies;\n\n    const onExternalChange = () => {\n      invalidateRenderCache(getterState);\n\n      if (hasGetterChanges(rawInstance, getterState)) {\n        onGetterChange();\n      }\n    };\n\n    const changed = this.manager.sync(\n      currentDeps,\n      onExternalChange,\n      rawInstance,\n    );\n\n    clearExternalDependencies(getterState);\n\n    return changed;\n  }\n\n  /**\n   * Clean up all active subscriptions\n   */\n  cleanup(): void {\n    this.manager.cleanup();\n  }\n}\n\nexport { DependencyManager };\n\n/**\n * Create a subscribe function for auto-tracking mode.\n * Only triggers callback when tracked properties change.\n * @param instance - The state container instance\n * @param adapterState - The adapter state for tracking\n * @returns Subscribe function for use with useSyncExternalStore\n */\nexport function autoTrackSubscribe<TBloc extends StateContainerConstructor>(\n  instance: InstanceReadonlyState<TBloc>,\n  adapterState: AdapterState<TBloc>,\n): SubscribeFunction {\n  return (callback: SubscriptionCallback) => {\n    return instance.subscribe(() => {\n      const depState =\n        adapterState.dependencyState ||\n        (adapterState.dependencyState = createDependencyState<any>());\n\n      const hasStateDeps = depState.pathCache && depState.pathCache.size > 0;\n      const hasGetterDeps =\n        adapterState.getterState &&\n        adapterState.getterState.trackedGetters.size > 0;\n\n      const isPrimitiveState =\n        instance.state !== null &&\n        typeof instance.state !== 'object' &&\n        typeof instance.state !== 'function';\n\n      if (!hasStateDeps && !hasGetterDeps && !isPrimitiveState) {\n        return;\n      }\n\n      let stateChanged = hasDependencyChanges(depState, instance.state);\n\n      if (!hasStateDeps && hasGetterDeps) {\n        stateChanged = false;\n      }\n\n      if (stateChanged) {\n        callback();\n        return;\n      }\n\n      const getterChanged = hasGetterChanges(\n        instance,\n        adapterState.getterState,\n      );\n\n      if (getterChanged) {\n        callback();\n      }\n    });\n  };\n}\n\n/**\n * Create a subscribe function for manual dependency tracking mode.\n * Only triggers callback when dependencies array changes.\n * @param instance - The state container instance\n * @param adapterState - The adapter state for caching\n * @param config - Configuration with dependencies function\n * @returns Subscribe function for use with useSyncExternalStore\n */\nexport function manualDepsSubscribe<TBloc extends StateContainerConstructor>(\n  instance: InstanceState<TBloc>,\n  adapterState: AdapterState<TBloc>,\n  config: ManualDepsConfig<TBloc>,\n): SubscribeFunction {\n  return (callback: SubscriptionCallback) => {\n    return instance.subscribe(() => {\n      const newDeps = config.dependencies(instance.state, instance);\n      if (\n        !adapterState.manualDepsCache ||\n        !shallowEqual(adapterState.manualDepsCache, newDeps)\n      ) {\n        adapterState.manualDepsCache = newDeps;\n        callback();\n      }\n    });\n  };\n}\n\n/**\n * Create a subscribe function for no-tracking mode.\n * Triggers callback on every state change.\n * @param instance - The state container instance\n * @returns Subscribe function for use with useSyncExternalStore\n */\nexport function noTrackSubscribe<TBloc extends StateContainerInstance>(\n  instance: TBloc,\n): SubscribeFunction {\n  return (callback: SubscriptionCallback) => instance.subscribe(callback);\n}\n\n/**\n * Create a snapshot function for auto-tracking mode.\n * Returns a proxied state that tracks property access.\n * @param instance - The state container instance\n * @param adapterState - The adapter state for tracking\n * @returns Snapshot function for use with useSyncExternalStore\n */\nexport function autoTrackSnapshot<TBloc extends StateContainerConstructor>(\n  instance: InstanceReadonlyState<TBloc>,\n  adapterState: AdapterState<TBloc>,\n): SnapshotFunction<ExtractState<TBloc>> {\n  return () => {\n    const depState =\n      adapterState.dependencyState ||\n      (adapterState.dependencyState = createDependencyState<any>());\n\n    if (hasTrackedData(depState)) {\n      capturePaths(depState, instance.state);\n    }\n\n    if (adapterState.getterState) {\n      invalidateRenderCache(adapterState.getterState);\n\n      commitTrackedGetters(adapterState.getterState);\n\n      adapterState.getterState.isTracking = true;\n\n      setActiveTracker(instance, adapterState.getterState);\n    }\n\n    startDependency(depState);\n    return createDependencyProxy(depState, instance.state);\n  };\n}\n\n/**\n * Create a snapshot function for manual dependency tracking mode.\n * Caches dependencies for comparison on next render.\n * @param instance - The state container instance\n * @param adapterState - The adapter state for caching\n * @param config - Configuration with dependencies function\n * @returns Snapshot function for use with useSyncExternalStore\n */\nexport function manualDepsSnapshot<TBloc extends StateContainerConstructor>(\n  instance: InstanceState<TBloc>,\n  adapterState: AdapterState<TBloc>,\n  config: ManualDepsConfig<TBloc>,\n): SnapshotFunction<ExtractState<TBloc>> {\n  return () => {\n    adapterState.manualDepsCache = config.dependencies(\n      instance.state,\n      instance,\n    );\n    return instance.state;\n  };\n}\n\n/**\n * Create a snapshot function for no-tracking mode.\n * Returns the raw state directly.\n * @param instance - The state container instance\n * @returns Snapshot function for use with useSyncExternalStore\n */\nexport function noTrackSnapshot<TBloc extends StateContainerConstructor>(\n  instance: InstanceReadonlyState<TBloc>,\n): SnapshotFunction<ExtractState<TBloc>> {\n  return () => instance.state;\n}\n\n/**\n * Initialize adapter state for auto-tracking mode.\n * Creates getter tracker and proxied bloc instance.\n * @param instance - The state container instance\n * @returns Initialized adapter state\n */\nexport function autoTrackInit<TBloc extends StateContainerConstructor>(\n  instance: InstanceState<TBloc>,\n): AdapterState<TBloc> {\n  return {\n    dependencyState: null,\n    manualDepsCache: null,\n    getterState: createGetterState(),\n    proxiedBloc: createBlocProxy(instance),\n  };\n}\n\n/**\n * Initialize adapter state for manual dependency tracking mode.\n * No proxy is created; bloc is used directly.\n * @param instance - The state container instance\n * @returns Initialized adapter state\n */\nexport function manualDepsInit<TBloc extends StateContainerConstructor>(\n  instance: InstanceState<TBloc>,\n): AdapterState<TBloc> {\n  return {\n    dependencyState: null,\n    manualDepsCache: null,\n    getterState: null,\n    proxiedBloc: instance,\n  };\n}\n\n/**\n * Initialize adapter state for no-tracking mode.\n * No tracking or proxy is created.\n * @param instance - The state container instance\n * @returns Initialized adapter state\n */\nexport function noTrackInit<TBloc extends StateContainerConstructor>(\n  instance: InstanceState<TBloc>,\n): AdapterState<TBloc> {\n  return {\n    dependencyState: null,\n    manualDepsCache: null,\n    getterState: null,\n    proxiedBloc: instance,\n  };\n}\n\n/**\n * Disable getter tracking after render phase completes.\n * Clears the active tracker to prevent tracking outside of render.\n * @param adapterState - The adapter state\n * @param rawInstance - The raw bloc instance\n */\nexport function disableGetterTracking<TBloc extends StateContainerConstructor>(\n  adapterState: AdapterState<TBloc>,\n  rawInstance: InstanceState<TBloc>,\n): void {\n  if (adapterState.getterState) {\n    adapterState.getterState.isTracking = false;\n    clearActiveTracker(rawInstance);\n  }\n}\n","/**\n * Log severity levels (lower number = higher severity)\n */\nexport enum LogLevel {\n  /** Critical errors that may cause application failure */\n  ERROR = 0,\n  /** Warning conditions that should be addressed */\n  WARN = 1,\n  /** Informational messages about application state */\n  INFO = 2,\n  /** Detailed debugging information */\n  DEBUG = 3,\n}\n\n/**\n * Structure of a log entry passed to output handlers\n */\nexport interface LogEntry {\n  /** Log level as string (DEBUG, INFO, WARN, ERROR) */\n  level: string;\n  /** Context identifier (typically component or module name) */\n  context: string;\n  /** Log message */\n  message: string;\n  /** Optional structured data */\n  data?: any;\n  /** Unix timestamp in milliseconds */\n  timestamp: number;\n}\n\n/**\n * Configuration for the logger\n */\nexport interface LogConfig {\n  /** Whether logging is enabled */\n  enabled: boolean;\n  /** Minimum log level to output */\n  level: LogLevel;\n  /** Function called to output log entries */\n  output: (entry: LogEntry) => void;\n}\n\n/**\n * Creates a logger instance with given configuration\n *\n * @param config - Logger configuration\n * @returns Logger instance with debug, info, warn, error, and configure methods\n *\n * @example\n * ```ts\n * const logger = createLogger({\n *   enabled: true,\n *   level: LogLevel.DEBUG,\n *   output: (entry) => console.log(JSON.stringify(entry))\n * });\n * logger.debug('MyComponent', 'Rendering', { props: { foo: 'bar' } });\n * ```\n */\nexport function createLogger(config: LogConfig) {\n  const shouldLog = (level: LogLevel): boolean => {\n    return config.enabled && config.level >= level;\n  };\n\n  const log = (\n    level: string,\n    context: string,\n    message: string,\n    data?: any,\n  ): void => {\n    try {\n      const entry: LogEntry = {\n        level,\n        context,\n        message,\n        timestamp: Date.now(),\n        ...(data !== undefined && { data: serialize(data) }),\n      };\n      config.output(entry);\n    } catch (e) {\n      console.error('[BlacLogger] Error logging:', e);\n    }\n  };\n\n  const serialize = (data: any): any => {\n    try {\n      return JSON.parse(JSON.stringify(data));\n    } catch {\n      return String(data);\n    }\n  };\n\n  return {\n    debug: (context: string, message: string, data?: any) => {\n      if (shouldLog(LogLevel.DEBUG)) {\n        log('DEBUG', context, message, data);\n      }\n    },\n    info: (context: string, message: string, data?: any) => {\n      if (shouldLog(LogLevel.INFO)) {\n        log('INFO', context, message, data);\n      }\n    },\n    warn: (context: string, message: string, data?: any) => {\n      if (shouldLog(LogLevel.WARN)) {\n        log('WARN', context, message, data);\n      }\n    },\n    error: (context: string, message: string, data?: any) => {\n      if (shouldLog(LogLevel.ERROR)) {\n        log('ERROR', context, message, data);\n      }\n    },\n    configure: (opts: Partial<LogConfig>) => {\n      Object.assign(config, opts);\n    },\n  };\n}\n\n// Track current configuration for proper merging\nlet currentConfig: LogConfig = {\n  enabled: false, // Off by default (matches current implementation)\n  level: LogLevel.INFO,\n  output: (entry) => console.log(JSON.stringify(entry)),\n};\n\n// Default logger instance\nlet defaultLogger = createLogger(currentConfig);\n\n/**\n * Log a debug message (tree-shakeable export)\n * @param context - Context identifier (module or component name)\n * @param message - Log message\n * @param data - Optional structured data\n */\nexport const debug = (context: string, message: string, data?: any) =>\n  defaultLogger.debug(context, message, data);\n\n/**\n * Log an info message (tree-shakeable export)\n * @param context - Context identifier (module or component name)\n * @param message - Log message\n * @param data - Optional structured data\n */\nexport const info = (context: string, message: string, data?: any) =>\n  defaultLogger.info(context, message, data);\n\n/**\n * Log a warning message (tree-shakeable export)\n * @param context - Context identifier (module or component name)\n * @param message - Log message\n * @param data - Optional structured data\n */\nexport const warn = (context: string, message: string, data?: any) =>\n  defaultLogger.warn(context, message, data);\n\n/**\n * Log an error message (tree-shakeable export)\n * @param context - Context identifier (module or component name)\n * @param message - Log message\n * @param data - Optional structured data\n */\nexport const error = (context: string, message: string, data?: any) =>\n  defaultLogger.error(context, message, data);\n\n/**\n * Configuration function that recreates the default logger\n *\n * @param opts - Partial logger configuration\n *\n * @example\n * ```ts\n * configureLogger({ enabled: true, level: LogLevel.DEBUG });\n * ```\n */\nexport function configureLogger(opts: Partial<LogConfig>): void {\n  // Merge with existing config\n  currentConfig = {\n    ...currentConfig,\n    ...opts,\n  };\n  defaultLogger = createLogger(currentConfig);\n}\n","import { configureLogger, LogLevel, type LogConfig } from './logging/Logger';\n\n/**\n * Global configuration for @blac/core\n */\nexport interface BlacConfig {\n  /** Enable development mode (enables additional warnings and checks) */\n  devMode: boolean;\n  /** Logger configuration */\n  logger: Partial<LogConfig>;\n}\n\nconst defaultConfig: BlacConfig = {\n  devMode: process.env.NODE_ENV !== 'production',\n  logger: {\n    enabled: false,\n    level: LogLevel.INFO,\n  },\n};\n\nlet globalConfig: BlacConfig = { ...defaultConfig };\n\n/**\n * Configure global defaults for @blac/core.\n *\n * @example\n * ```ts\n * import { configureBlac, LogLevel } from '@blac/core';\n *\n * configureBlac({\n *   devMode: true,\n *   logger: {\n *     enabled: true,\n *     level: LogLevel.DEBUG\n *   }\n * });\n * ```\n *\n * @param config - Partial configuration to merge with defaults\n */\nexport function configureBlac(config: Partial<BlacConfig>): void {\n  globalConfig = {\n    ...globalConfig,\n    ...config,\n    logger: {\n      ...globalConfig.logger,\n      ...config.logger,\n    },\n  };\n\n  // Apply logger configuration\n  if (config.logger) {\n    configureLogger(config.logger);\n  }\n}\n\n/**\n * Get the current global configuration.\n * @internal\n */\nexport function getBlacConfig(): BlacConfig {\n  return globalConfig;\n}\n\n/**\n * Check if development mode is enabled.\n */\nexport function isDevMode(): boolean {\n  return globalConfig.devMode;\n}\n\n/**\n * Reset configuration to defaults (useful for testing).\n * @internal\n */\nexport function resetBlacConfig(): void {\n  globalConfig = { ...defaultConfig };\n  configureLogger(defaultConfig.logger);\n}\n","import { BLAC_STATIC_PROPS } from '../constants';\n\n/**\n * Configuration options for the @blac decorator.\n * Only one option can be specified at a time (union type).\n */\nexport type BlacOptions =\n  /** Mark bloc as isolated (each component gets its own instance) */\n  | { isolated: true }\n  /** Mark bloc to never be auto-disposed when ref count reaches 0 */\n  | { keepAlive: true }\n  /** Exclude bloc from DevTools tracking (prevents infinite loops) */\n  | { excludeFromDevTools: true };\n\n/**\n * Decorator to configure StateContainer classes.\n *\n * @example Decorator syntax (requires experimentalDecorators or TC39 decorators)\n * ```ts\n * @blac({ isolated: true })\n * class FormBloc extends Cubit<FormState> {}\n *\n * @blac({ keepAlive: true })\n * class AuthBloc extends Cubit<AuthState> {}\n *\n * @blac({ excludeFromDevTools: true })\n * class InternalBloc extends Cubit<InternalState> {}\n * ```\n *\n * @example Function syntax (no decorator support needed)\n * ```ts\n * const FormBloc = blac({ isolated: true })(\n *   class extends Cubit<FormState> {}\n * );\n * ```\n */\nexport function blac(options: BlacOptions) {\n  return function <T extends new (...args: any[]) => any>(\n    target: T,\n    _context?: ClassDecoratorContext,\n  ): T {\n    if ('isolated' in options && options.isolated) {\n      (target as any)[BLAC_STATIC_PROPS.ISOLATED] = true;\n    }\n    if ('keepAlive' in options && options.keepAlive) {\n      (target as any)[BLAC_STATIC_PROPS.KEEP_ALIVE] = true;\n    }\n    if ('excludeFromDevTools' in options && options.excludeFromDevTools) {\n      (target as any)[BLAC_STATIC_PROPS.EXCLUDE_FROM_DEVTOOLS] = true;\n    }\n    return target;\n  };\n}\n","import { globalRegistry } from '../core/StateContainerRegistry';\nimport type {\n  StateContainerConstructor,\n  ExtractProps,\n} from '../types/utilities';\n\nexport interface AcquireOptions<T extends StateContainerConstructor> {\n  props?: ExtractProps<T>;\n}\n\nexport function acquire<T extends StateContainerConstructor>(\n  BlocClass: T,\n  instanceKey?: string,\n  options?: AcquireOptions<T>,\n): InstanceType<T> {\n  return globalRegistry.acquire(BlocClass, instanceKey, {\n    canCreate: true,\n    countRef: true,\n    props: options?.props,\n  });\n}\n","import { globalRegistry } from '../core/StateContainerRegistry';\nimport type { StateContainerConstructor } from '../types/utilities';\n\nexport function borrow<T extends StateContainerConstructor>(\n  BlocClass: T,\n  instanceKey?: string,\n): InstanceType<T> {\n  return globalRegistry.borrow(BlocClass, instanceKey);\n}\n\nexport function borrowSafe<T extends StateContainerConstructor>(\n  BlocClass: T,\n  instanceKey?: string,\n):\n  | { error: Error; instance: null }\n  | { error: null; instance: InstanceType<T> } {\n  return globalRegistry.borrowSafe(BlocClass, instanceKey);\n}\n","import { globalRegistry } from '../core/StateContainerRegistry';\nimport type { StateContainerConstructor } from '../types/utilities';\n\nexport function ensure<T extends StateContainerConstructor>(\n  BlocClass: T,\n  instanceKey?: string,\n): InstanceType<T> {\n  return globalRegistry.ensure(BlocClass, instanceKey);\n}\n","import { globalRegistry } from '../core/StateContainerRegistry';\nimport type { StateContainerConstructor } from '../types/utilities';\n\nexport function release<T extends StateContainerConstructor>(\n  BlocClass: T,\n  instanceKey?: string,\n  forceDispose = false,\n): void {\n  globalRegistry.release(BlocClass, instanceKey, forceDispose);\n}\n","import { globalRegistry } from '../core/StateContainerRegistry';\nimport type {\n  StateContainerConstructor,\n  InstanceReadonlyState,\n} from '../types/utilities';\n\nexport function hasInstance<T extends StateContainerConstructor>(\n  BlocClass: T,\n  instanceKey?: string,\n): boolean {\n  return globalRegistry.hasInstance(BlocClass, instanceKey);\n}\n\nexport function getRefCount<T extends StateContainerConstructor>(\n  BlocClass: T,\n  instanceKey?: string,\n): number {\n  return globalRegistry.getRefCount(BlocClass, instanceKey);\n}\n\nexport function getAll<T extends StateContainerConstructor>(\n  BlocClass: T,\n): InstanceReadonlyState<T>[] {\n  return globalRegistry.getAll(BlocClass);\n}\n\nexport function forEach<T extends StateContainerConstructor>(\n  BlocClass: T,\n  callback: (instance: InstanceReadonlyState<T>) => void,\n): void {\n  globalRegistry.forEach(BlocClass, callback);\n}\n","import { globalRegistry } from '../core/StateContainerRegistry';\nimport type { StateContainerConstructor } from '../types/utilities';\n\nexport function clear<T extends StateContainerConstructor>(BlocClass: T): void {\n  globalRegistry.clear(BlocClass);\n}\n\nexport function clearAll(): void {\n  globalRegistry.clearAll();\n}\n\nexport function register<T extends StateContainerConstructor>(\n  BlocClass: T,\n  isolated = false,\n): void {\n  globalRegistry.register(BlocClass, isolated);\n}\n","import {\n  globalRegistry,\n  StateContainerRegistry,\n} from '../core/StateContainerRegistry';\n\nlet _registry = globalRegistry;\n\nexport function getRegistry(): StateContainerRegistry {\n  return _registry;\n}\n\nexport function setRegistry(registry: StateContainerRegistry): void {\n  _registry.clearAll();\n  _registry = registry;\n}\n\nexport function getStats(): {\n  registeredTypes: number;\n  totalInstances: number;\n  typeBreakdown: Record<string, number>;\n} {\n  return _registry.getStats();\n}\n","export class WaitUntilTimeoutError extends Error {\n  constructor(timeout: number) {\n    super(`waitUntil timed out after ${timeout}ms`);\n    this.name = 'WaitUntilTimeoutError';\n  }\n}\n\nexport class WaitUntilAbortedError extends Error {\n  constructor() {\n    super('waitUntil was aborted');\n    this.name = 'WaitUntilAbortedError';\n  }\n}\n\nexport class WaitUntilDisposedError extends Error {\n  constructor(blocName: string) {\n    super(`waitUntil failed: ${blocName} was disposed while waiting`);\n    this.name = 'WaitUntilDisposedError';\n  }\n}\n","import { ensure, getRegistry } from '../registry';\nimport type { StateContainerConstructor } from '../types/utilities';\nimport { BLAC_DEFAULTS } from '../constants';\nimport {\n  WaitUntilTimeoutError,\n  WaitUntilAbortedError,\n  WaitUntilDisposedError,\n} from './errors';\nimport {\n  createState,\n  startTracking,\n  stopTracking,\n  createTrackingProxy,\n  type TrackingProxyState,\n} from '../tracking/tracking-proxy';\nimport { DependencyManager } from '../tracking/dependency-manager';\n\nexport interface WaitUntilOptions {\n  instanceId?: string;\n  timeout?: number;\n  signal?: AbortSignal;\n}\n\n/**\n * Wait until a condition is met on a bloc instance.\n * Returns the bloc instance when the predicate returns true.\n * Automatically tracks dependencies accessed in the predicate.\n *\n * @example\n * ```ts\n * // Wait for bloc state to be ready\n * const userBloc = await waitUntil(UserBloc, (bloc) => bloc.state.isAuthenticated);\n *\n * // Wait using a getter\n * const userBloc = await waitUntil(UserBloc, (bloc) => bloc.isReady);\n * ```\n */\nexport function waitUntil<T extends StateContainerConstructor>(\n  BlocClass: T,\n  predicate: (bloc: InstanceType<T>) => boolean,\n  options?: WaitUntilOptions,\n): Promise<InstanceType<T>>;\n\n/**\n * Wait until a condition is met on a selected value from a bloc.\n * Returns the selected value when the predicate returns true.\n * Automatically tracks dependencies accessed in selector and predicate.\n *\n * @example\n * ```ts\n * // Wait for layout to be set and get it directly\n * const layout = await waitUntil(\n *   LayoutBloc,\n *   (bloc) => bloc.state.currentLayout,\n *   (layout) => layout !== null\n * );\n *\n * // Using a getter as selector\n * const user = await waitUntil(\n *   UserBloc,\n *   (bloc) => bloc.currentUser,\n *   (user) => user !== null\n * );\n * ```\n */\nexport function waitUntil<T extends StateContainerConstructor, TSelected>(\n  BlocClass: T,\n  selector: (bloc: InstanceType<T>) => TSelected,\n  predicate: (selected: TSelected) => boolean,\n  options?: WaitUntilOptions,\n): Promise<TSelected>;\n\nexport function waitUntil<T extends StateContainerConstructor, TSelected>(\n  BlocClass: T,\n  selectorOrPredicate:\n    | ((bloc: InstanceType<T>) => TSelected)\n    | ((bloc: InstanceType<T>) => boolean),\n  predicateOrOptions?: ((selected: TSelected) => boolean) | WaitUntilOptions,\n  maybeOptions?: WaitUntilOptions,\n): Promise<InstanceType<T> | TSelected> {\n  const isSimpleForm = typeof predicateOrOptions !== 'function';\n\n  if (isSimpleForm) {\n    const predicate = selectorOrPredicate as (bloc: InstanceType<T>) => boolean;\n    const options = predicateOrOptions as WaitUntilOptions | undefined;\n    return waitUntilSimple(BlocClass, predicate, options);\n  } else {\n    const selector = selectorOrPredicate as (\n      bloc: InstanceType<T>,\n    ) => TSelected;\n    const predicate = predicateOrOptions as (selected: TSelected) => boolean;\n    const options = maybeOptions;\n    return waitUntilSelector(BlocClass, selector, predicate, options);\n  }\n}\n\nfunction waitUntilSimple<T extends StateContainerConstructor>(\n  BlocClass: T,\n  predicate: (bloc: InstanceType<T>) => boolean,\n  options?: WaitUntilOptions,\n): Promise<InstanceType<T>> {\n  const {\n    instanceId = BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY,\n    timeout,\n    signal,\n  } = options ?? {};\n\n  return new Promise((resolve, reject) => {\n    if (signal?.aborted) {\n      reject(new WaitUntilAbortedError());\n      return;\n    }\n\n    const bloc = ensure(BlocClass, instanceId) as InstanceType<T>;\n\n    if (bloc.isDisposed) {\n      reject(new WaitUntilDisposedError(BlocClass.name));\n      return;\n    }\n\n    const tracker: TrackingProxyState = createState();\n    const proxiedBloc = createTrackingProxy(bloc, tracker);\n    const externalDepsManager = new DependencyManager();\n\n    const runPredicate = (): boolean => {\n      startTracking(tracker);\n      try {\n        return predicate(proxiedBloc);\n      } finally {\n        const deps = stopTracking(tracker, bloc);\n        for (const dep of tracker.getterState.externalDependencies) {\n          deps.add(dep);\n        }\n        deps.delete(bloc);\n        externalDepsManager.sync(deps, checkCondition, bloc);\n      }\n    };\n\n    if (runPredicate()) {\n      resolve(bloc);\n      return;\n    }\n\n    let unsubscribe: (() => void) | null = null;\n    let unsubscribeDispose: (() => void) | null = null;\n    let timeoutId: ReturnType<typeof setTimeout> | null = null;\n    let abortHandler: (() => void) | null = null;\n\n    const cleanup = () => {\n      unsubscribe?.();\n      unsubscribeDispose?.();\n      externalDepsManager.cleanup();\n      if (timeoutId) clearTimeout(timeoutId);\n      if (abortHandler && signal) {\n        signal.removeEventListener('abort', abortHandler);\n      }\n    };\n\n    function checkCondition() {\n      try {\n        if (runPredicate()) {\n          cleanup();\n          resolve(bloc);\n        }\n      } catch (error) {\n        cleanup();\n        reject(error);\n      }\n    }\n\n    unsubscribe = bloc.subscribe(checkCondition);\n\n    unsubscribeDispose = getRegistry().on('disposed', (instance) => {\n      if (instance === bloc) {\n        cleanup();\n        reject(new WaitUntilDisposedError(BlocClass.name));\n      }\n    });\n\n    if (timeout !== undefined) {\n      timeoutId = setTimeout(() => {\n        cleanup();\n        reject(new WaitUntilTimeoutError(timeout));\n      }, timeout);\n    }\n\n    if (signal) {\n      abortHandler = () => {\n        cleanup();\n        reject(new WaitUntilAbortedError());\n      };\n      signal.addEventListener('abort', abortHandler);\n    }\n  });\n}\n\nfunction waitUntilSelector<T extends StateContainerConstructor, TSelected>(\n  BlocClass: T,\n  selector: (bloc: InstanceType<T>) => TSelected,\n  predicate: (selected: TSelected) => boolean,\n  options?: WaitUntilOptions,\n): Promise<TSelected> {\n  const {\n    instanceId = BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY,\n    timeout,\n    signal,\n  } = options ?? {};\n\n  return new Promise((resolve, reject) => {\n    if (signal?.aborted) {\n      reject(new WaitUntilAbortedError());\n      return;\n    }\n\n    const bloc = ensure(BlocClass, instanceId) as InstanceType<T>;\n\n    if (bloc.isDisposed) {\n      reject(new WaitUntilDisposedError(BlocClass.name));\n      return;\n    }\n\n    const tracker: TrackingProxyState = createState();\n    const proxiedBloc = createTrackingProxy(bloc, tracker);\n    const externalDepsManager = new DependencyManager();\n\n    const runSelector = (): { value: TSelected; matches: boolean } => {\n      startTracking(tracker);\n      try {\n        const value = selector(proxiedBloc);\n        const matches = predicate(value);\n        return { value, matches };\n      } finally {\n        const deps = stopTracking(tracker, bloc);\n        for (const dep of tracker.getterState.externalDependencies) {\n          deps.add(dep);\n        }\n        deps.delete(bloc);\n        externalDepsManager.sync(deps, checkCondition, bloc);\n      }\n    };\n\n    const initial = runSelector();\n    if (initial.matches) {\n      resolve(initial.value);\n      return;\n    }\n\n    let unsubscribe: (() => void) | null = null;\n    let unsubscribeDispose: (() => void) | null = null;\n    let timeoutId: ReturnType<typeof setTimeout> | null = null;\n    let abortHandler: (() => void) | null = null;\n\n    const cleanup = () => {\n      unsubscribe?.();\n      unsubscribeDispose?.();\n      externalDepsManager.cleanup();\n      if (timeoutId) clearTimeout(timeoutId);\n      if (abortHandler && signal) {\n        signal.removeEventListener('abort', abortHandler);\n      }\n    };\n\n    function checkCondition() {\n      try {\n        const result = runSelector();\n        if (result.matches) {\n          cleanup();\n          resolve(result.value);\n        }\n      } catch (error) {\n        cleanup();\n        reject(error);\n      }\n    }\n\n    unsubscribe = bloc.subscribe(checkCondition);\n\n    unsubscribeDispose = getRegistry().on('disposed', (instance) => {\n      if (instance === bloc) {\n        cleanup();\n        reject(new WaitUntilDisposedError(BlocClass.name));\n      }\n    });\n\n    if (timeout !== undefined) {\n      timeoutId = setTimeout(() => {\n        cleanup();\n        reject(new WaitUntilTimeoutError(timeout));\n      }, timeout);\n    }\n\n    if (signal) {\n      abortHandler = () => {\n        cleanup();\n        reject(new WaitUntilAbortedError());\n      };\n      signal.addEventListener('abort', abortHandler);\n    }\n  });\n}\n","import { ensure } from '../registry';\nimport type {\n  StateContainerConstructor,\n  StateContainerInstance,\n} from '../types/utilities';\nimport { BLAC_DEFAULTS } from '../constants';\nimport {\n  createState,\n  startTracking,\n  stopTracking,\n  createTrackingProxy,\n  type TrackingProxyState,\n} from '../tracking/tracking-proxy';\nimport { DependencyManager } from '../tracking/dependency-manager';\n\nconst STOP: unique symbol = Symbol('watch.STOP');\n\nconst BLOC_REF_MARKER = Symbol('BlocRef');\n\n/**\n * Reference to a specific bloc instance by class and instance ID.\n */\nexport interface BlocRef<T extends StateContainerConstructor> {\n  [BLOC_REF_MARKER]: true;\n  blocClass: T;\n  instanceId: string;\n}\n\n/**\n * Create a reference to a specific bloc instance.\n *\n * @example\n * ```ts\n * watch(instance(UserBloc, 'user-123'), (userBloc) => {\n *   console.log(userBloc.state.name);\n * });\n * ```\n */\nexport function instance<T extends StateContainerConstructor>(\n  BlocClass: T,\n  instanceId: string,\n): BlocRef<T> {\n  return {\n    [BLOC_REF_MARKER]: true,\n    blocClass: BlocClass,\n    instanceId,\n  };\n}\n\nfunction isBlocRef(\n  input: unknown,\n): input is BlocRef<StateContainerConstructor> {\n  return (\n    typeof input === 'object' && input !== null && BLOC_REF_MARKER in input\n  );\n}\n\ntype BlocInput = StateContainerConstructor | BlocRef<StateContainerConstructor>;\n\ntype ExtractInstance<T> =\n  T extends BlocRef<infer C>\n    ? InstanceType<C>\n    : T extends StateContainerConstructor\n      ? InstanceType<T>\n      : never;\n\ntype ExtractInstances<T extends readonly BlocInput[]> = {\n  [K in keyof T]: ExtractInstance<T[K]>;\n};\n\ntype StopSymbol = typeof STOP;\n\n/**\n * Watch function signature for single bloc.\n */\nexport interface WatchSingleFn {\n  <T extends StateContainerConstructor>(\n    bloc: T | BlocRef<T>,\n    callback: (bloc: InstanceType<T>) => void | StopSymbol,\n  ): () => void;\n\n  STOP: StopSymbol;\n}\n\n/**\n * Watch function signature for multiple blocs.\n */\nexport interface WatchMultipleFn {\n  <T extends readonly BlocInput[]>(\n    blocs: T,\n    callback: (blocs: ExtractInstances<T>) => void | StopSymbol,\n  ): () => void;\n\n  STOP: StopSymbol;\n}\n\n/**\n * Combined watch function type.\n */\nexport interface WatchFn extends WatchSingleFn {\n  <T extends readonly BlocInput[]>(\n    blocs: T,\n    callback: (blocs: ExtractInstances<T>) => void | StopSymbol,\n  ): () => void;\n}\n\nfunction resolveBloc(input: BlocInput): StateContainerInstance {\n  if (isBlocRef(input)) {\n    return ensure(input.blocClass, input.instanceId);\n  }\n  return ensure(input, BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY);\n}\n\nfunction isArray(input: unknown): input is readonly BlocInput[] {\n  return Array.isArray(input);\n}\n\n/**\n * Watch one or more blocs for state changes.\n * Automatically tracks state property and getter accesses.\n *\n * @example Single bloc\n * ```ts\n * const unwatch = watch(UserBloc, (userBloc) => {\n *   console.log(userBloc.state.name);\n *   console.log(userBloc.fullName); // getter also tracked\n * });\n * ```\n *\n * @example Multiple blocs\n * ```ts\n * const unwatch = watch(\n *   [UserBloc, SettingsBloc] as const,\n *   ([userBloc, settingsBloc]) => {\n *     console.log(userBloc.state.name, settingsBloc.state.theme);\n *   }\n * );\n * ```\n *\n * @example With specific instance\n * ```ts\n * const unwatch = watch(\n *   instance(UserBloc, 'user-123'),\n *   (userBloc) => {\n *     console.log(userBloc.state.name);\n *   }\n * );\n * ```\n *\n * @example Stop watching from callback\n * ```ts\n * const unwatch = watch(UserBloc, (userBloc) => {\n *   if (userBloc.state.done) {\n *     return watch.STOP;\n *   }\n * });\n * ```\n */\nfunction watchImpl<T extends StateContainerConstructor>(\n  bloc: T | BlocRef<T>,\n  callback: (bloc: InstanceType<T>) => void | StopSymbol,\n): () => void;\n\nfunction watchImpl<T extends readonly BlocInput[]>(\n  blocs: T,\n  callback: (blocs: ExtractInstances<T>) => void | StopSymbol,\n): () => void;\n\nfunction watchImpl(\n  blocsOrBloc: BlocInput | readonly BlocInput[],\n  callback: (blocsOrBloc: any) => void | StopSymbol,\n): () => void {\n  const isSingle = !isArray(blocsOrBloc);\n  const inputs = isSingle ? [blocsOrBloc] : blocsOrBloc;\n\n  const instances = inputs.map(resolveBloc);\n\n  const tracker: TrackingProxyState = createState();\n  const proxiedInstances = instances.map((inst) =>\n    createTrackingProxy(inst, tracker),\n  );\n\n  const externalDepsManager = new DependencyManager();\n\n  let disposed = false;\n  const primarySubscriptions: (() => void)[] = [];\n\n  const cleanup = () => {\n    if (disposed) return;\n    disposed = true;\n    primarySubscriptions.forEach((unsub) => unsub());\n    externalDepsManager.cleanup();\n  };\n\n  const runCallback = () => {\n    if (disposed) return;\n\n    startTracking(tracker);\n\n    let result: void | StopSymbol;\n    try {\n      const arg = isSingle ? proxiedInstances[0] : proxiedInstances;\n      result = callback(arg);\n    } finally {\n      const externalDeps = new Set<StateContainerInstance>();\n      for (const inst of instances) {\n        const deps = stopTracking(tracker, inst);\n        for (const dep of deps) {\n          externalDeps.add(dep);\n        }\n      }\n\n      for (const dep of tracker.getterState.externalDependencies) {\n        externalDeps.add(dep);\n      }\n\n      for (const inst of instances) {\n        externalDeps.delete(inst);\n      }\n\n      externalDepsManager.sync(externalDeps, runCallback);\n    }\n\n    if (result === STOP) {\n      cleanup();\n    }\n  };\n\n  const onChange = () => {\n    if (disposed) return;\n    runCallback();\n  };\n\n  for (const inst of instances) {\n    primarySubscriptions.push(inst.subscribe(onChange));\n  }\n\n  runCallback();\n\n  return cleanup;\n}\n\nexport const watch: WatchFn = Object.assign(watchImpl, { STOP }) as WatchFn;\n"],"mappings":"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"}
+{"version":3,"file":"index.cjs","names":["globalRegistry","globalRegistry","BLAC_STATIC_PROPS"],"sources":["../src/utils/idGenerator.ts","../src/core/StateContainer.ts","../src/core/Cubit.ts","../src/registry/acquire.ts","../src/registry/borrow.ts","../src/registry/release.ts","../src/decorators/blac.ts"],"sourcesContent":["/**\n * Centralized ID Generation\n *\n * Provides consistent, collision-resistant ID generation for all BlaC subsystems.\n * Uses timestamp + counter + random suffix for uniqueness.\n */\n\n// Global counter map for ID generation\nconst globalCounters = new Map<string, number>();\n\n/**\n * Creates an ID generator with isolated counter state\n *\n * @param prefix - Prefix for generated IDs\n * @returns Object with next(), nextSimple(), and reset() methods\n *\n * @example\n * ```ts\n * const generator = createIdGenerator('sub');\n * const id1 = generator.next(); // \"sub:1698765432100_1_a3k9d7f2q\"\n * const id2 = generator.next(); // \"sub:1698765432101_2_b4n8e9g3r\"\n * ```\n */\nexport function createIdGenerator(prefix: string) {\n  let counter = 0;\n  return {\n    next: () =>\n      `${prefix}:${Date.now()}_${++counter}_${Math.random().toString(36).substring(2, 11)}`,\n    nextSimple: () => `${prefix}:${++counter}`,\n    reset: () => {\n      counter = 0;\n    },\n  };\n}\n\n/**\n * Generate ID with timestamp, counter, and random suffix (tree-shakeable)\n *\n * Format: `${prefix}:${timestamp}_${counter}_${random}`\n *\n * @param prefix - Prefix for the ID (e.g., 'sub', 'consumer', 'stage')\n * @returns Branded ID string\n *\n * @example\n * const id = generateId('sub');\n * // Returns: \"sub:1698765432100_1_a3k9d7f2q\"\n */\nexport function generateId(prefix: string): string {\n  const counter = (globalCounters.get(prefix) ?? 0) + 1;\n  globalCounters.set(prefix, counter);\n  const timestamp = Date.now();\n  const random = Math.random().toString(36).substring(2, 11);\n  return `${prefix}:${timestamp}_${counter}_${random}`;\n}\n\n/**\n * Generate simple ID with timestamp and random (no counter tracking)\n *\n * Format: `${prefix}:${timestamp}_${random}`\n *\n * @param prefix - Prefix for the ID\n * @returns Branded ID string\n *\n * @example\n * ```ts\n * const id = generateSimpleId('CounterBloc');\n * // Returns: \"CounterBloc:1698765432100_a3k9d7f2q\"\n * ```\n */\nexport function generateSimpleId(prefix: string, affix?: string): string {\n  if (affix) {\n    return `${prefix}:${affix}`;\n  }\n  const timestamp = Date.now();\n  const random = Math.random().toString(36).substring(2, 11);\n  return `${prefix}:${timestamp}_${random}`;\n}\n\n/**\n * Reset all counters for testing purposes\n * @internal\n */\nexport function __resetIdCounters(): void {\n  globalCounters.clear();\n}\n\n/**\n * Generate a unique isolated instance key\n * Uses base36 encoding for compact, URL-safe identifiers\n *\n * Format: \"isolated-{9-char-random-string}\"\n * Example: \"isolated-k7x2m9p4q\"\n *\n * @returns A unique isolated instance key\n */\nexport function generateIsolatedKey(): string {\n  const randomPart = Math.random().toString(36).slice(2, 11);\n  return `isolated-${randomPart}`;\n}\n\n/**\n * Check if a key is an isolated instance key\n * @param key - The instance key to check\n * @returns true if the key is an isolated instance key\n */\nexport function isIsolatedKey(key: string): boolean {\n  return key.startsWith('isolated-');\n}\n","import { generateSimpleId } from '../utils/idGenerator';\nimport { globalRegistry } from './StateContainerRegistry';\n\n/**\n * Configuration options for initializing a StateContainer instance\n */\nexport interface StateContainerConfig {\n  /** Display name for the instance (defaults to class name) */\n  name?: string;\n  /** Enable debug logging for this instance */\n  debug?: boolean;\n  /** Custom instance identifier */\n  instanceId?: string;\n}\n\n/**\n * Listener function for state changes\n * @internal\n */\ntype StateListener<S> = (state: S) => void;\n\n/**\n * System events emitted by StateContainer lifecycle\n */\nexport type SystemEvent = 'stateChanged' | 'dispose';\n\n/**\n * Payload types for each system event\n * @template S - State type\n */\nexport interface SystemEventPayloads<S> {\n  /** Emitted when state changes via emit() or update() */\n  stateChanged: { state: S; previousState: S };\n  /** Emitted when the instance is disposed */\n  dispose: void;\n}\n\n/**\n * Handler function for system events\n * @internal\n */\ntype SystemEventHandler<S, E extends SystemEvent> = (\n  payload: SystemEventPayloads<S>[E],\n) => void;\n\n/**\n * Abstract base class for all state containers in BlaC.\n * Provides lifecycle management, subscription handling, ref counting,\n * and integration with the global registry.\n *\n * @template S - State type managed by this container\n *\n * @example\n * ```ts\n * class CounterBloc extends StateContainer<{ count: number }> {\n *   constructor() {\n *     super({ count: 0 });\n *   }\n *   increment() {\n *     this.emit({ count: this.state.count + 1 });\n *   }\n * }\n * ```\n */\nexport abstract class StateContainer<S extends object = any> {\n  static __excludeFromDevTools = false;\n  static enableStackTrace = true;\n\n  private _state: S;\n  private readonly listeners = new Set<StateListener<S>>();\n  private _disposed = false;\n  private config: StateContainerConfig = {};\n  private readonly systemEventHandlers = new Map<\n    SystemEvent,\n    Set<SystemEventHandler<S, any>>\n  >();\n\n  /** Display name for this instance */\n  name: string = this.constructor.name;\n  /** Whether debug logging is enabled */\n  debug: boolean = false;\n  /** Unique identifier for this instance */\n  instanceId: string = generateSimpleId(this.constructor.name, 'main');\n  /** Timestamp when this instance was created */\n  createdAt: number = Date.now();\n\n  constructor(initialState: S) {\n    this._state = initialState;\n  }\n\n  /**\n   * Initialize configuration for this instance.\n   * Called by the registry after construction.\n   * @param config - Configuration options\n   */\n  initConfig(config: StateContainerConfig): void {\n    this.config = { ...config };\n    this.name = this.config.name || this.constructor.name;\n    this.debug = this.config.debug ?? false;\n    this.instanceId = generateSimpleId(\n      this.constructor.name,\n      this.config.instanceId,\n    );\n\n    globalRegistry.emit('created', this);\n  }\n\n  /** Current state value */\n  get state(): Readonly<S> {\n    return this._state;\n  }\n\n  /** Whether this instance has been disposed */\n  get isDisposed(): boolean {\n    return this._disposed;\n  }\n\n  /**\n   * Subscribe to state changes\n   * @param listener - Function called when state changes\n   * @returns Unsubscribe function\n   */\n  subscribe(listener: StateListener<S>): () => void {\n    if (this._disposed) {\n      throw new Error(`Cannot subscribe to disposed container ${this.name}`);\n    }\n\n    this.listeners.add(listener);\n    return () => this.listeners.delete(listener);\n  }\n\n  /**\n   * Dispose this instance and clean up resources.\n   * Clears all listeners and emits the 'dispose' system event.\n   */\n  dispose(): void {\n    if (this._disposed) return;\n\n    if (this.debug) {\n      console.log(`[${this.name}] Disposing...`);\n    }\n\n    this._disposed = true;\n\n    this.emitSystemEvent('dispose', undefined as void);\n\n    this.listeners.clear();\n    this.systemEventHandlers.clear();\n\n    globalRegistry.emit('disposed', this);\n\n    if (this.debug) {\n      console.log(`[${this.name}] Disposed successfully`);\n    }\n  }\n\n  /**\n   * Emit a new state value and notify all listeners.\n   * @param newState - The new state value\n   * @protected\n   */\n  protected emit(newState: S): void {\n    if (this._disposed) {\n      throw new Error(`Cannot emit state from disposed container ${this.name}`);\n    }\n\n    if (this._state === newState) return;\n\n    const previousState = this._state;\n    this._state = newState;\n\n    this.emitSystemEvent('stateChanged', {\n      state: newState,\n      previousState,\n    });\n\n    for (const listener of this.listeners) {\n      try {\n        listener(newState);\n      } catch (error) {\n        console.error(`[${this.name}] Error in listener:`, error);\n      }\n    }\n\n    const stackTrace = this.captureStackTrace();\n\n    globalRegistry.emit(\n      'stateChanged',\n      this,\n      previousState,\n      newState,\n      stackTrace,\n    );\n    this.lastUpdateTimestamp = Date.now();\n  }\n\n  private captureStackTrace(): string {\n    if (\n      !StateContainer.enableStackTrace ||\n      (typeof process !== 'undefined' && process.env?.NODE_ENV === 'production')\n    ) {\n      return '';\n    }\n\n    try {\n      const error = new Error();\n      const stack = error.stack || '';\n      const lines = stack.split('\\n');\n      const relevantLines = lines.slice(1);\n      const formattedLines: string[] = [];\n\n      for (const line of relevantLines) {\n        if (!line.trim()) continue;\n\n        if (\n          line.includes('StateContainer.emit') ||\n          line.includes('StateContainer.update') ||\n          line.includes('StateContainer.captureStackTrace') ||\n          line.includes('Cubit.patch')\n        ) {\n          continue;\n        }\n\n        if (\n          line.includes('node_modules') ||\n          line.includes('react-dom') ||\n          line.includes('react_jsx') ||\n          line.includes('.vite/deps') ||\n          line.includes('executeDispatch') ||\n          line.includes('runWithFiber') ||\n          line.includes('invokeGuarded') ||\n          line.includes('callCallback') ||\n          line.includes('processDispatchQueue') ||\n          line.includes('dispatchEvent') ||\n          line.includes('batchedUpdates')\n        ) {\n          continue;\n        }\n\n        const formatted = this.formatStackLine(line);\n        if (formatted) {\n          formattedLines.push(formatted);\n        }\n      }\n\n      return formattedLines.join('\\n');\n    } catch {\n      return '';\n    }\n  }\n\n  private formatStackLine(line: string): string | null {\n    const match = line.match(/at\\s+(.+?)\\s+\\((.+?):(\\d+):(\\d+)\\)/);\n    if (!match) {\n      const simpleMatch = line.match(/at\\s+(.+?):(\\d+):(\\d+)/);\n      if (simpleMatch) {\n        const [, url, lineNum, col] = simpleMatch;\n        const cleanPath = this.cleanFilePath(url);\n        return `  at ${cleanPath}:${lineNum}:${col}`;\n      }\n      return null;\n    }\n\n    const [, functionName, url, lineNum, col] = match;\n    const cleanPath = this.cleanFilePath(url);\n\n    return `  at ${functionName} (${cleanPath}:${lineNum}:${col})`;\n  }\n\n  private cleanFilePath(url: string): string {\n    let path = url\n      .replace(/http:\\/\\/localhost:\\d+\\/@fs/, '')\n      .replace(/http:\\/\\/localhost:\\d+\\//, '')\n      .replace(/\\?t=\\d+/, '')\n      .replace(/\\?v=[a-f0-9]+/, '');\n\n    const projectMatch = path.match(/\\/Projects\\/blac\\/(.+)/);\n    if (projectMatch) {\n      path = projectMatch[1];\n    }\n\n    const segments = path.split('/');\n    if (segments.length > 3) {\n      path = segments.slice(-3).join('/');\n    }\n\n    return path;\n  }\n\n  /** Timestamp of the last state update */\n  lastUpdateTimestamp: number = Date.now();\n\n  /**\n   * Update state using a transform function.\n   * @param updater - Function that receives current state and returns new state\n   * @protected\n   */\n  protected update(updater: (current: S) => S): void {\n    if (this._disposed) {\n      throw new Error(\n        `Cannot update state from disposed container ${this.name}`,\n      );\n    }\n    this.emit(updater(this._state));\n  }\n\n  /**\n   * Subscribe to system lifecycle events.\n   * @param event - The event type to listen for\n   * @param handler - Handler function called when event occurs\n   * @returns Unsubscribe function\n   * @protected\n   */\n  protected onSystemEvent = <E extends SystemEvent>(\n    event: E,\n    handler: SystemEventHandler<S, E>,\n  ): (() => void) => {\n    let handlers = this.systemEventHandlers.get(event);\n    if (!handlers) {\n      handlers = new Set();\n      this.systemEventHandlers.set(event, handlers);\n    }\n    handlers.add(handler as SystemEventHandler<S, any>);\n\n    return () => {\n      handlers?.delete(handler as SystemEventHandler<S, any>);\n    };\n  };\n\n  private emitSystemEvent<E extends SystemEvent>(\n    event: E,\n    payload: SystemEventPayloads<S>[E],\n  ): void {\n    const handlers = this.systemEventHandlers.get(event);\n    if (!handlers) return;\n\n    for (const handler of handlers) {\n      try {\n        handler(payload);\n      } catch (error) {\n        console.error(`[${this.name}] Error in system event handler:`, error);\n      }\n    }\n  }\n}\n","import { StateContainer } from './StateContainer';\n\n/**\n * Simple state container with direct state emission.\n * Extends StateContainer with public methods for emitting and updating state.\n *\n * @template S - State type\n */\nexport abstract class Cubit<S extends object = any> extends StateContainer<S> {\n  constructor(initialState: S) {\n    super(initialState);\n  }\n\n  /**\n   * Replace state with a new value and notify all listeners\n   * @param newState - The new state value\n   */\n  public emit(newState: S): void {\n    super['emit'](newState);\n  }\n\n  /**\n   * Transform current state using an updater function and emit the new state\n   * @param updater - Function that receives current state and returns new state\n   */\n  public update(updater: (current: S) => S): void {\n    super['update'](updater);\n  }\n\n  /**\n   * Merge partial state changes into current state (only for object states)\n   */\n  public patch = ((partial: S extends object ? Partial<S> : never): void => {\n    if (typeof this.state !== 'object' || this.state === null) {\n      throw new Error('patch() is only available for object state types');\n    }\n    this.update((current) => ({ ...current, ...partial }) as S);\n  }) as S extends object ? (partial: Partial<S>) => void : never;\n}\n","import { globalRegistry } from '../core/StateContainerRegistry';\nimport type { StateContainerConstructor } from '../types/utilities';\n\nexport function acquire<T extends StateContainerConstructor>(\n  BlocClass: T,\n  instanceKey?: string,\n): InstanceType<T> {\n  return globalRegistry.acquire(BlocClass, instanceKey, {\n    canCreate: true,\n    countRef: true,\n  });\n}\n","import { globalRegistry } from '../core/StateContainerRegistry';\nimport type { StateContainerConstructor } from '../types/utilities';\n\nexport function borrow<T extends StateContainerConstructor>(\n  BlocClass: T,\n  instanceKey?: string,\n): InstanceType<T> {\n  return globalRegistry.borrow(BlocClass, instanceKey);\n}\n\nexport function borrowSafe<T extends StateContainerConstructor>(\n  BlocClass: T,\n  instanceKey?: string,\n):\n  | { error: Error; instance: null }\n  | { error: null; instance: InstanceType<T> } {\n  return globalRegistry.borrowSafe(BlocClass, instanceKey);\n}\n","import { globalRegistry } from '../core/StateContainerRegistry';\nimport type { StateContainerConstructor } from '../types/utilities';\n\nexport function release<T extends StateContainerConstructor>(\n  BlocClass: T,\n  instanceKey?: string,\n  forceDispose = false,\n): void {\n  globalRegistry.release(BlocClass, instanceKey, forceDispose);\n}\n","import { BLAC_STATIC_PROPS } from '../constants';\n\n/**\n * Configuration options for the @blac decorator.\n * Only one option can be specified at a time (union type).\n */\nexport type BlacOptions =\n  /** Mark bloc as isolated (each component gets its own instance) */\n  | { isolated: true }\n  /** Mark bloc to never be auto-disposed when ref count reaches 0 */\n  | { keepAlive: true }\n  /** Exclude bloc from DevTools tracking (prevents infinite loops) */\n  | { excludeFromDevTools: true };\n\n/**\n * Decorator to configure StateContainer classes.\n *\n * @example Decorator syntax (requires experimentalDecorators or TC39 decorators)\n * ```ts\n * @blac({ isolated: true })\n * class FormBloc extends Cubit<FormState> {}\n *\n * @blac({ keepAlive: true })\n * class AuthBloc extends Cubit<AuthState> {}\n *\n * @blac({ excludeFromDevTools: true })\n * class InternalBloc extends Cubit<InternalState> {}\n * ```\n *\n * @example Function syntax (no decorator support needed)\n * ```ts\n * const FormBloc = blac({ isolated: true })(\n *   class extends Cubit<FormState> {}\n * );\n * ```\n */\nexport function blac(options: BlacOptions) {\n  return function <T extends new (...args: any[]) => any>(\n    target: T,\n    _context?: ClassDecoratorContext,\n  ): T {\n    if ('isolated' in options && options.isolated) {\n      (target as any)[BLAC_STATIC_PROPS.ISOLATED] = true;\n    }\n    if ('keepAlive' in options && options.keepAlive) {\n      (target as any)[BLAC_STATIC_PROPS.KEEP_ALIVE] = true;\n    }\n    if ('excludeFromDevTools' in options && options.excludeFromDevTools) {\n      (target as any)[BLAC_STATIC_PROPS.EXCLUDE_FROM_DEVTOOLS] = true;\n    }\n    return target;\n  };\n}\n"],"mappings":"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"}