@blac/core 2.0.10 → 2.0.12

package/dist/StateContainerRegistry-BhcnG0DF.js

@@ -0,0 +1,602 @@
+//#region src/constants.ts
+/**
+* Default configuration constants for BlaC
+*
+* Centralized location for all magic numbers and default values.
+*/
+/**
+* Default configuration constants for BlaC
+*/
+const BLAC_DEFAULTS = {
+	DEFAULT_INSTANCE_KEY: "default",
+	MAX_GETTER_DEPTH: 10,
+	CLEANUP_INTERVAL_MS: 3e4,
+	WEAKREF_CLEANUP_INTERVAL_MS: 1e4,
+	MAX_SUBSCRIPTIONS: 1e3,
+	MAX_SUBSCRIPTIONS_HIGH_PERF: 1e4,
+	PIPELINE_TIMEOUT_MS: 5e3,
+	CLEANUP_INTERVAL_HIGH_PERF_MS: 5e3,
+	MAX_PIPELINE_STAGES: 30
+};
+/**
+* Static property names for StateContainer classes
+* Used for feature flags and configuration on bloc classes
+*/
+const BLAC_STATIC_PROPS = {
+	KEEP_ALIVE: "keepAlive",
+	EXCLUDE_FROM_DEVTOOLS: "__excludeFromDevTools"
+};
+/**
+* Standard error message prefix
+*/
+const BLAC_ERROR_PREFIX = "[BlaC]";
+//#endregion
+//#region src/plugin/PluginManager.ts
+/**
+* Manages plugin lifecycle for the BlaC state management system.
+* Plugins receive notifications about state container lifecycle events.
+*
+* @example
+* ```ts
+* const manager = createPluginManager(registry);
+* manager.install(myPlugin, { environment: 'development' });
+* ```
+*/
+var PluginManager = class {
+	/**
+	* Create a new PluginManager
+	* @param registry - The StateContainerRegistry to monitor for lifecycle events
+	*/
+	constructor(registry) {
+		this.plugins = /* @__PURE__ */ new Map();
+		this.registry = registry;
+		this.setupLifecycleHooks();
+	}
+	/**
+	* Install a plugin with optional configuration
+	* @param plugin - The plugin to install
+	* @param config - Optional plugin configuration
+	* @throws Error if plugin is already installed
+	*/
+	install(plugin, config = {}) {
+		const effectiveConfig = {
+			enabled: true,
+			environment: "all",
+			...config
+		};
+		if (!this.shouldEnablePlugin(effectiveConfig)) {
+			console.log(`[BlaC] Plugin "${plugin.name}" skipped (environment mismatch)`);
+			return;
+		}
+		if (this.plugins.has(plugin.name)) throw new Error(`Plugin "${plugin.name}" is already installed`);
+		const context = this.createPluginContext();
+		this.plugins.set(plugin.name, {
+			plugin,
+			config: effectiveConfig,
+			context
+		});
+		if (plugin.onInstall) try {
+			plugin.onInstall(context);
+		} catch (error) {
+			console.error(`[BlaC] Error installing plugin "${plugin.name}":`, error);
+			this.plugins.delete(plugin.name);
+			throw error;
+		}
+		console.log(`[BlaC] Plugin "${plugin.name}" v${plugin.version} installed`);
+	}
+	/**
+	* Uninstall a plugin by name
+	* @param pluginName - The name of the plugin to uninstall
+	* @throws Error if plugin is not installed
+	*/
+	uninstall(pluginName) {
+		const installed = this.plugins.get(pluginName);
+		if (!installed) throw new Error(`Plugin "${pluginName}" is not installed`);
+		if (installed.plugin.onUninstall) try {
+			installed.plugin.onUninstall();
+		} catch (error) {
+			console.error(`[BlaC] Error uninstalling plugin "${pluginName}":`, error);
+		}
+		this.plugins.delete(pluginName);
+		console.log(`[BlaC] Plugin "${pluginName}" uninstalled`);
+	}
+	/**
+	* Get an installed plugin by name
+	* @param pluginName - The name of the plugin to retrieve
+	* @returns The plugin instance or undefined if not found
+	*/
+	getPlugin(pluginName) {
+		return this.plugins.get(pluginName)?.plugin;
+	}
+	/**
+	* Get all installed plugins
+	* @returns Array of all installed plugins
+	*/
+	getAllPlugins() {
+		return Array.from(this.plugins.values()).map((p) => p.plugin);
+	}
+	/**
+	* Check if a plugin is installed
+	* @param pluginName - The name of the plugin to check
+	* @returns true if the plugin is installed
+	*/
+	hasPlugin(pluginName) {
+		return this.plugins.has(pluginName);
+	}
+	/**
+	* Uninstall all plugins
+	*/
+	clear() {
+		for (const name of this.plugins.keys()) this.uninstall(name);
+	}
+	/**
+	* Setup lifecycle hooks to notify plugins
+	*/
+	setupLifecycleHooks() {
+		this.registry.on("created", (instance) => {
+			this.notifyPlugins("onInstanceCreated", instance);
+		});
+		this.registry.on("stateChanged", (instance, previousState, currentState, callstack) => {
+			this.notifyPlugins("onStateChanged", instance, previousState, currentState, callstack);
+		});
+		this.registry.on("disposed", (instance) => {
+			this.notifyPlugins("onInstanceDisposed", instance);
+		});
+	}
+	/**
+	* Notify all plugins of a lifecycle event
+	*/
+	notifyPlugins(hookName, ...args) {
+		for (const { plugin, config, context } of this.plugins.values()) {
+			if (!config.enabled) continue;
+			const hook = plugin[hookName];
+			if (typeof hook === "function") try {
+				hook.apply(plugin, [...args, context]);
+			} catch (error) {
+				console.error(`[BlaC] Error in plugin "${plugin.name}" ${hookName}:`, error);
+			}
+		}
+	}
+	/**
+	* Create plugin context with safe API access
+	*/
+	createPluginContext() {
+		return {
+			getInstanceMetadata: (instance) => {
+				return {
+					id: instance.instanceId,
+					className: instance.constructor.name,
+					isDisposed: instance.isDisposed,
+					name: instance.name,
+					lastStateChangeTimestamp: instance.lastUpdateTimestamp,
+					createdAt: instance.createdAt,
+					state: instance.state,
+					hydrationStatus: instance.hydrationStatus,
+					isHydrated: instance.isHydrated,
+					hydrationError: instance.hydrationError,
+					changedWhileHydrating: instance.changedWhileHydrating,
+					createdFrom: instance.createdFrom || void 0
+				};
+			},
+			getState: (instance) => {
+				return instance.state;
+			},
+			getHydrationStatus: (instance) => {
+				return instance.hydrationStatus;
+			},
+			startHydration: (instance) => {
+				instance.beginHydration();
+			},
+			applyHydratedState: (instance, state) => {
+				return instance.applyHydratedState(state);
+			},
+			finishHydration: (instance) => {
+				instance.finishHydration();
+			},
+			failHydration: (instance, error) => {
+				instance.failHydration(error);
+			},
+			waitForHydration: (instance) => {
+				return instance.waitForHydration();
+			},
+			queryInstances: (typeClass) => {
+				return this.registry.getAll(typeClass);
+			},
+			getAllTypes: () => {
+				return this.registry.getTypes();
+			},
+			getStats: () => {
+				return this.registry.getStats();
+			},
+			getRefIds: (instanceId) => {
+				for (const Type of this.registry.getTypes()) {
+					const map = this.registry.getInstancesMap(Type);
+					for (const [, entry] of map) if (entry.instance.instanceId === instanceId) return Array.from(entry.refs);
+				}
+				return [];
+			}
+		};
+	}
+	/**
+	* Check if plugin should be enabled based on environment
+	*/
+	shouldEnablePlugin(config) {
+		if (!config.enabled) return false;
+		if (config.environment === "all") return true;
+		return this.getCurrentEnvironment() === config.environment;
+	}
+	/**
+	* Get current environment
+	*/
+	getCurrentEnvironment() {
+		if (typeof process !== "undefined") {
+			if (process.env.NODE_ENV === "test") return "test";
+			if (process.env.NODE_ENV === "production") return "production";
+			return "development";
+		}
+		return "development";
+	}
+};
+/**
+* Create a plugin manager instance
+* @param registry - The StateContainerRegistry to monitor for lifecycle events
+* @returns A new PluginManager instance
+*/
+function createPluginManager(registry) {
+	return new PluginManager(registry);
+}
+//#endregion
+//#region src/utils/static-props.ts
+/**
+* Utility functions for accessing static properties on StateContainer classes
+*/
+/**
+* Get a static property from a class constructor
+* Type-safe helper that avoids (Type as any) casts
+*
+* @param Type - The class constructor
+* @param propName - The property name to access
+* @param defaultValue - Optional default value if property is undefined
+* @returns The property value or default
+*/
+function getStaticProp(Type, propName, defaultValue) {
+	return Type[propName] ?? defaultValue;
+}
+/**
+* Check if a class is marked as keepAlive.
+* KeepAlive classes are never auto-disposed when ref count reaches 0.
+* @param Type - The class constructor to check
+* @returns true if the class has `static keepAlive = true`
+*/
+function isKeepAliveClass(Type) {
+	return getStaticProp(Type, BLAC_STATIC_PROPS.KEEP_ALIVE) === true;
+}
+//#endregion
+//#region src/core/StateContainerRegistry.ts
+/**
+* Central registry for managing StateContainer instances.
+* Handles instance lifecycle, named ref tracking, and lifecycle event emission.
+*
+* @example
+* ```ts
+* const registry = new StateContainerRegistry();
+* const instance = registry.acquire(MyBloc);  // ownership, must release
+* const other = registry.ensure(OtherBloc);   // no ownership, bloc-to-bloc
+* registry.on('stateChanged', (container, prev, next) => {
+*   console.log('State changed:', prev, '->', next);
+* });
+* ```
+*/
+var StateContainerRegistry = class {
+	constructor() {
+		this.instancesByConstructor = /* @__PURE__ */ new WeakMap();
+		this.types = /* @__PURE__ */ new Set();
+		this.registeredTypeNames = /* @__PURE__ */ new Set();
+		this.listeners = /* @__PURE__ */ new Map();
+		this._autoRefIdCounter = 0;
+	}
+	/**
+	* Register a type for lifecycle event tracking
+	* @param constructor - The StateContainer class constructor
+	*/
+	registerType(constructor) {
+		this.types.add(constructor);
+	}
+	/**
+	* Register a StateContainer class with configuration
+	* @param constructor - The StateContainer class constructor
+	* @throws Error if type is already registered
+	*/
+	register(constructor) {
+		const className = constructor.name;
+		if (this.registeredTypeNames.has(className)) throw new Error(`${BLAC_ERROR_PREFIX} Type "${className}" is already registered`);
+		this.registeredTypeNames.add(className);
+		this.registerType(constructor);
+	}
+	ensureInstancesMap(Type) {
+		let instances = this.instancesByConstructor.get(Type);
+		if (!instances) {
+			instances = /* @__PURE__ */ new Map();
+			this.instancesByConstructor.set(Type, instances);
+		}
+		return instances;
+	}
+	/**
+	* Get the instances Map for a specific class (public API for stats/debugging)
+	*/
+	getInstancesMap(Type) {
+		return this.instancesByConstructor.get(Type) || /* @__PURE__ */ new Map();
+	}
+	/**
+	* Acquire an instance with ref tracking (ownership semantics).
+	* Creates a new instance if one doesn't exist, or returns existing and adds a ref.
+	* You must call `release()` with the same refId when done.
+	* @param Type - The StateContainer class constructor
+	* @param instanceKey - Instance key (defaults to 'default')
+	* @param options - Acquisition options
+	* @param options.canCreate - Whether to create new instance if not found (default: true)
+	* @param options.countRef - Whether to add a reference (default: true)
+	* @param options.refId - Named reference ID for debugging; auto-generated if omitted
+	* @returns The state container instance
+	*/
+	acquire(Type, instanceKey = BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY, options = {}) {
+		const { canCreate = true, countRef = true } = options;
+		const config = { instanceId: instanceKey };
+		const instances = this.ensureInstancesMap(Type);
+		let entry = instances.get(instanceKey);
+		if (entry?.instance.isDisposed) {
+			instances.delete(instanceKey);
+			entry = void 0;
+		}
+		if (entry && countRef) {
+			const refId = options.refId ?? `_auto_${this._autoRefIdCounter++}`;
+			entry.refs.add(refId);
+		}
+		if (entry) return entry.instance;
+		if (!canCreate) throw new Error(`${BLAC_ERROR_PREFIX} ${Type.name} instance "${instanceKey}" not found and creation is disabled.`);
+		const instance = new Type();
+		instance.initConfig(config);
+		const initialRefs = /* @__PURE__ */ new Set();
+		if (countRef) {
+			const refId = options.refId ?? `_auto_${this._autoRefIdCounter++}`;
+			initialRefs.add(refId);
+		}
+		instances.set(instanceKey, {
+			instance,
+			refs: initialRefs
+		});
+		this.registerType(Type);
+		return instance;
+	}
+	/**
+	* Borrow an existing instance without adding a ref (borrowing semantics).
+	* Tracks cross-bloc dependency for reactive updates.
+	* @param Type - The StateContainer class constructor
+	* @param instanceKey - Instance key (defaults to 'default')
+	* @returns The state container instance
+	* @throws Error if instance doesn't exist
+	*/
+	borrow(Type, instanceKey = BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY) {
+		return this.acquire(Type, instanceKey, {
+			canCreate: false,
+			countRef: false
+		});
+	}
+	/**
+	* Safely borrow an existing instance (borrowing semantics with error handling).
+	* Returns discriminated union for type-safe conditional access.
+	* @param Type - The StateContainer class constructor
+	* @param instanceKey - Instance key (defaults to 'default')
+	* @returns Discriminated union with either the instance or an error
+	*/
+	borrowSafe(Type, instanceKey = BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY) {
+		try {
+			return {
+				error: null,
+				instance: this.borrow(Type, instanceKey)
+			};
+		} catch (error) {
+			return {
+				error,
+				instance: null
+			};
+		}
+	}
+	/**
+	* Ensure an instance exists without taking ownership (for bloc-to-bloc communication).
+	* Gets existing instance OR creates it if it doesn't exist, without adding a ref.
+	* Tracks cross-bloc dependency for reactive updates.
+	*
+	* Use this in bloc-to-bloc communication when you need to ensure an instance exists
+	* but don't want to claim ownership (no ref added).
+	* @param Type - The StateContainer class constructor
+	* @param instanceKey - Instance key (defaults to 'default')
+	* @returns The state container instance
+	*/
+	ensure(Type, instanceKey = BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY) {
+		return this.acquire(Type, instanceKey, {
+			canCreate: true,
+			countRef: false
+		});
+	}
+	/**
+	* Release a reference to an instance.
+	* Removes the ref and disposes when refs is empty (unless keepAlive).
+	* Releasing an already-removed refId is a no-op (idempotent).
+	* @param Type - The StateContainer class constructor
+	* @param instanceKey - Instance key (defaults to 'default')
+	* @param forceDispose - Force immediate disposal regardless of refs
+	* @param refId - The specific ref to remove; removes one arbitrary ref if omitted
+	*/
+	release(Type, instanceKey = BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY, forceDispose = false, refId) {
+		const instances = this.ensureInstancesMap(Type);
+		const entry = instances.get(instanceKey);
+		if (!entry) return;
+		if (forceDispose) {
+			if (!entry.instance.isDisposed) entry.instance.dispose();
+			instances.delete(instanceKey);
+			return;
+		}
+		if (refId !== void 0) entry.refs.delete(refId);
+		else {
+			const first = entry.refs.values().next().value;
+			if (first !== void 0) entry.refs.delete(first);
+		}
+		const keepAlive = isKeepAliveClass(Type);
+		if (entry.refs.size === 0 && !keepAlive) {
+			if (!entry.instance.isDisposed) entry.instance.dispose();
+			instances.delete(instanceKey);
+		}
+	}
+	/**
+	* Get all instances of a specific type.
+	* @param Type - The StateContainer class constructor
+	* @returns Array of all instances
+	*/
+	getAll(Type) {
+		const instances = this.ensureInstancesMap(Type);
+		const result = [];
+		for (const entry of instances.values()) result.push(entry.instance);
+		return result;
+	}
+	/**
+	* Safely iterate over all instances of a type.
+	* Skips disposed instances and catches callback errors.
+	* @param Type - The StateContainer class constructor
+	* @param callback - Function to call for each instance
+	*/
+	forEach(Type, callback) {
+		const instances = this.ensureInstancesMap(Type);
+		for (const entry of instances.values()) {
+			const instance = entry.instance;
+			if (!instance.isDisposed) try {
+				callback(instance);
+			} catch (error) {
+				console.error(`${BLAC_ERROR_PREFIX} forEach callback error for ${Type.name}:`, error);
+			}
+		}
+	}
+	/**
+	* Clear all instances of a specific type (disposes them).
+	* @param Type - The StateContainer class constructor
+	*/
+	clear(Type) {
+		const instances = this.ensureInstancesMap(Type);
+		for (const entry of instances.values()) if (!entry.instance.isDisposed) entry.instance.dispose();
+		instances.clear();
+	}
+	/**
+	* Get reference count for an instance (number of active refs).
+	* @param Type - The StateContainer class constructor
+	* @param instanceKey - Instance key (defaults to 'default')
+	* @returns Current ref count (0 if instance doesn't exist)
+	*/
+	getRefCount(Type, instanceKey = BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY) {
+		return this.ensureInstancesMap(Type).get(instanceKey)?.refs.size ?? 0;
+	}
+	/**
+	* Get all active reference IDs for an instance.
+	* @param Type - The StateContainer class constructor
+	* @param instanceKey - Instance key (defaults to 'default')
+	* @returns Array of ref ID strings (empty if instance doesn't exist)
+	*/
+	getRefIds(Type, instanceKey = BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY) {
+		const instances = this.instancesByConstructor.get(Type);
+		if (!instances) return [];
+		const entry = instances.get(instanceKey);
+		return entry ? Array.from(entry.refs) : [];
+	}
+	/**
+	* Check if an instance exists.
+	* @param Type - The StateContainer class constructor
+	* @param instanceKey - Instance key (defaults to 'default')
+	* @returns true if instance exists
+	*/
+	hasInstance(Type, instanceKey = BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY) {
+		return this.ensureInstancesMap(Type).has(instanceKey);
+	}
+	/**
+	* Clear all instances from all types (for testing)
+	*
+	* Iterates all registered types and clears their instances.
+	* Also clears type tracking to reset the registry state.
+	*/
+	clearAll() {
+		for (const Type of this.types) this.clear(Type);
+		this.types.clear();
+		this.registeredTypeNames.clear();
+	}
+	/**
+	* Get registry statistics for debugging.
+	* @returns Object with registeredTypes, totalInstances, and typeBreakdown
+	*/
+	getStats() {
+		const typeBreakdown = {};
+		let totalInstances = 0;
+		for (const Type of this.types) {
+			const typeName = Type.name;
+			const count = this.getInstancesMap(Type).size;
+			typeBreakdown[typeName] = count;
+			totalInstances += count;
+		}
+		return {
+			registeredTypes: this.types.size,
+			totalInstances,
+			typeBreakdown
+		};
+	}
+	/**
+	* Get all registered types (for plugin system).
+	* @returns Array of all registered StateContainer class constructors
+	*/
+	getTypes() {
+		return Array.from(this.types);
+	}
+	/**
+	* Subscribe to lifecycle events
+	* @param event - The lifecycle event to listen for
+	* @param listener - The listener function to call when the event occurs
+	* @returns Unsubscribe function
+	*/
+	on(event, listener) {
+		if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
+		const instance = this.listeners.get(event);
+		if (!instance) throw new Error(`${BLAC_ERROR_PREFIX} Failed to register listener for event '${event}'`);
+		instance.add(listener);
+		return () => {
+			this.listeners.get(event)?.delete(listener);
+		};
+	}
+	/**
+	* Emit lifecycle event to all listeners
+	* @internal - Called by StateContainer lifecycle methods
+	*/
+	emit(event, ...args) {
+		const listeners = this.listeners.get(event);
+		if (!listeners || listeners.size === 0) return;
+		for (const listener of listeners) try {
+			listener(...args);
+		} catch (error) {
+			console.error(`${BLAC_ERROR_PREFIX} Listener error for '${event}':`, error);
+		}
+	}
+};
+/**
+* Global default registry instance
+*/
+const globalRegistry = new StateContainerRegistry();
+/**
+* Global plugin manager (initialized lazily)
+*/
+let _globalPluginManager = null;
+/**
+* Get the global plugin manager
+*/
+function getPluginManager() {
+	if (!_globalPluginManager) _globalPluginManager = createPluginManager(globalRegistry);
+	return _globalPluginManager;
+}
+//#endregion
+export { BLAC_DEFAULTS as a, PluginManager as i, getPluginManager as n, BLAC_ERROR_PREFIX as o, globalRegistry as r, BLAC_STATIC_PROPS as s, StateContainerRegistry as t };
+
+//# sourceMappingURL=StateContainerRegistry-BhcnG0DF.js.map

package/dist/StateContainerRegistry-BhcnG0DF.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StateContainerRegistry-BhcnG0DF.js","names":[],"sources":["../src/constants.ts","../src/plugin/PluginManager.ts","../src/utils/static-props.ts","../src/core/StateContainerRegistry.ts"],"sourcesContent":["/**\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 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   * 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 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    // 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        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          hydrationStatus: instance.hydrationStatus,\n          isHydrated: instance.isHydrated,\n          hydrationError: instance.hydrationError,\n          changedWhileHydrating: instance.changedWhileHydrating,\n          createdFrom: instance.createdFrom || undefined,\n        };\n      },\n\n      getState: <S extends object = any>(instance: StateContainer<S>): S => {\n        return instance.state;\n      },\n\n      getHydrationStatus: (instance: StateContainer<any>) => {\n        return instance.hydrationStatus;\n      },\n\n      startHydration: (instance: StateContainer<any>) => {\n        instance.beginHydration();\n      },\n\n      applyHydratedState: <S extends object = any>(\n        instance: StateContainer<S>,\n        state: S,\n      ): boolean => {\n        return instance.applyHydratedState(state);\n      },\n\n      finishHydration: (instance: StateContainer<any>) => {\n        instance.finishHydration();\n      },\n\n      failHydration: (instance: StateContainer<any>, error: Error) => {\n        instance.failHydration(error);\n      },\n\n      waitForHydration: (instance: StateContainer<any>) => {\n        return instance.waitForHydration();\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      getRefIds: (instanceId: string): string[] => {\n        for (const Type of this.registry.getTypes()) {\n          const map = this.registry.getInstancesMap(Type);\n          for (const [, entry] of map) {\n            if ((entry.instance as any).instanceId === instanceId) {\n              return Array.from(entry.refs);\n            }\n          }\n        }\n        return [];\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 * Utility functions for accessing static properties on StateContainer classes\n */\n\nimport { BLAC_STATIC_PROPS } from '../constants';\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 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","import type { StateContainer, StateContainerConfig } from './StateContainer';\nimport { createPluginManager } from '../plugin/PluginManager';\nimport { BLAC_DEFAULTS, BLAC_ERROR_PREFIX } from '../constants';\nimport { isKeepAliveClass } from '../utils/static-props';\nimport {\n  InstanceReadonlyState,\n  StateContainerConstructor,\n} from '../types/utilities';\n\n/**\n * Entry in the instance registry, tracking the instance and its named references\n * @template T - Instance type\n */\nexport interface InstanceEntry<T = any> {\n  /** The state container instance */\n  instance: T;\n  /** Set of active reference IDs holding this instance */\n  refs: Set<string>;\n}\n\n/**\n * Lifecycle events emitted by the registry\n */\nexport type LifecycleEvent = 'created' | 'stateChanged' | '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 'disposed'\n      ? (container: StateContainer<any>) => void\n      : never;\n\n/**\n * Central registry for managing StateContainer instances.\n * Handles instance lifecycle, named ref tracking, 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 registeredTypeNames = new Set<string>();\n\n  private readonly listeners = new Map<\n    LifecycleEvent,\n    Set<(...args: any[]) => void>\n  >();\n\n  private _autoRefIdCounter = 0;\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   * @throws Error if type is already registered\n   */\n  register<T extends StateContainerConstructor>(constructor: T): void {\n    const className = constructor.name;\n\n    if (this.registeredTypeNames.has(className)) {\n      throw new Error(\n        `${BLAC_ERROR_PREFIX} Type \"${className}\" is already registered`,\n      );\n    }\n\n    this.registeredTypeNames.add(className);\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  /**\n   * Acquire an instance with ref tracking (ownership semantics).\n   * Creates a new instance if one doesn't exist, or returns existing and adds a ref.\n   * You must call `release()` with the same refId when done.\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 add a reference (default: true)\n   * @param options.refId - Named reference ID for debugging; auto-generated if omitted\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      refId?: string;\n    } = {},\n  ): InstanceType<T> {\n    const { canCreate = true, countRef = true } = options;\n\n    const config: StateContainerConfig = {\n      instanceId: instanceKey,\n    };\n\n    const instances = this.ensureInstancesMap(Type);\n    let entry = instances.get(instanceKey);\n\n    // Detect stale disposed entries (disposed directly, not through release)\n    if (entry?.instance.isDisposed) {\n      instances.delete(instanceKey);\n      entry = undefined;\n    }\n\n    if (entry && countRef) {\n      const refId = options.refId ?? `_auto_${this._autoRefIdCounter++}`;\n      entry.refs.add(refId);\n    }\n\n    if (entry) {\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() as InstanceType<T>;\n    instance.initConfig(config);\n    const initialRefs = new Set<string>();\n    if (countRef) {\n      const refId = options.refId ?? `_auto_${this._autoRefIdCounter++}`;\n      initialRefs.add(refId);\n    }\n    instances.set(instanceKey, { instance, refs: initialRefs });\n\n    // Register type for lifecycle coordination\n    this.registerType(Type);\n\n    return instance;\n  }\n\n  /**\n   * Borrow an existing instance without adding a ref (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      countRef: false,\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 adding a ref.\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 added).\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    });\n  }\n\n  /**\n   * Release a reference to an instance.\n   * Removes the ref and disposes when refs is empty (unless keepAlive).\n   * Releasing an already-removed refId is a no-op (idempotent).\n   * @param Type - The StateContainer class constructor\n   * @param instanceKey - Instance key (defaults to 'default')\n   * @param forceDispose - Force immediate disposal regardless of refs\n   * @param refId - The specific ref to remove; removes one arbitrary ref if omitted\n   */\n  release<T extends StateContainerConstructor>(\n    Type: T,\n    instanceKey: string = BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY,\n    forceDispose = false,\n    refId?: string,\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    // Remove the specific ref, or one arbitrary ref for backward compat\n    if (refId !== undefined) {\n      entry.refs.delete(refId);\n    } else {\n      const first = entry.refs.values().next().value;\n      if (first !== undefined) {\n        entry.refs.delete(first);\n      }\n    }\n\n    // Check static keepAlive property\n    const keepAlive = isKeepAliveClass(Type);\n\n    // Auto-dispose when refs are empty (unless keepAlive)\n    if (entry.refs.size === 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 (number of active refs).\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?.refs.size ?? 0;\n  }\n\n  /**\n   * Get all active reference IDs for an instance.\n   * @param Type - The StateContainer class constructor\n   * @param instanceKey - Instance key (defaults to 'default')\n   * @returns Array of ref ID strings (empty if instance doesn't exist)\n   */\n  getRefIds<T extends StateContainerConstructor>(\n    Type: T,\n    instanceKey: string = BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY,\n  ): string[] {\n    const instances = this.instancesByConstructor.get(Type);\n    if (!instances) return [];\n    const entry = instances.get(instanceKey);\n    return entry ? Array.from(entry.refs) : [];\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.registeredTypeNames.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 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"],"mappings":";;;;;;;;;AASA,MAAa,gBAAgB;CAI3B,sBAAsB;CAKtB,kBAAkB;CAKlB,qBAAqB;CAKrB,6BAA6B;CAK7B,mBAAmB;CAKnB,6BAA6B;CAK7B,qBAAqB;CAKrB,+BAA+B;CAK/B,qBAAqB;CACtB;;;;;AAMD,MAAa,oBAAoB;CAI/B,YAAY;CAKZ,uBAAuB;CACxB;;;;AAeD,MAAa,oBAAoB;;;;;;;;;;;;;ACxDjC,IAAa,gBAAb,MAA2B;;;;;CAQzB,YAAY,UAAkC;iCAP5B,IAAI,KAA8B;AAQlD,OAAK,WAAW;AAChB,OAAK,qBAAqB;;;;;;;;CAS5B,QAAQ,QAAoB,SAAuB,EAAE,EAAQ;EAC3D,MAAM,kBAAgC;GACpC,SAAS;GACT,aAAa;GACb,GAAG;GACJ;AAED,MAAI,CAAC,KAAK,mBAAmB,gBAAgB,EAAE;AAC7C,WAAQ,IACN,kBAAkB,OAAO,KAAK,kCAC/B;AACD;;AAGF,MAAI,KAAK,QAAQ,IAAI,OAAO,KAAK,CAC/B,OAAM,IAAI,MAAM,WAAW,OAAO,KAAK,wBAAwB;EAGjE,MAAM,UAAU,KAAK,qBAAqB;AAE1C,OAAK,QAAQ,IAAI,OAAO,MAAM;GAC5B;GACA,QAAQ;GACR;GACD,CAAC;AAEF,MAAI,OAAO,UACT,KAAI;AACF,UAAO,UAAU,QAAQ;WAClB,OAAO;AACd,WAAQ,MACN,mCAAmC,OAAO,KAAK,KAC/C,MACD;AACD,QAAK,QAAQ,OAAO,OAAO,KAAK;AAChC,SAAM;;AAIV,UAAQ,IAAI,kBAAkB,OAAO,KAAK,KAAK,OAAO,QAAQ,YAAY;;;;;;;CAQ5E,UAAU,YAA0B;EAClC,MAAM,YAAY,KAAK,QAAQ,IAAI,WAAW;AAC9C,MAAI,CAAC,UACH,OAAM,IAAI,MAAM,WAAW,WAAW,oBAAoB;AAG5D,MAAI,UAAU,OAAO,YACnB,KAAI;AACF,aAAU,OAAO,aAAa;WACvB,OAAO;AACd,WAAQ,MACN,qCAAqC,WAAW,KAChD,MACD;;AAIL,OAAK,QAAQ,OAAO,WAAW;AAC/B,UAAQ,IAAI,kBAAkB,WAAW,eAAe;;;;;;;CAQ1D,UAAU,YAA4C;AACpD,SAAO,KAAK,QAAQ,IAAI,WAAW,EAAE;;;;;;CAOvC,gBAA8B;AAC5B,SAAO,MAAM,KAAK,KAAK,QAAQ,QAAQ,CAAC,CAAC,KAAK,MAAM,EAAE,OAAO;;;;;;;CAQ/D,UAAU,YAA6B;AACrC,SAAO,KAAK,QAAQ,IAAI,WAAW;;;;;CAMrC,QAAc;AACZ,OAAK,MAAM,QAAQ,KAAK,QAAQ,MAAM,CACpC,MAAK,UAAU,KAAK;;;;;CAOxB,sBAAoC;AAElC,OAAK,SAAS,GAAG,YAAY,aAAa;AACxC,QAAK,cAAc,qBAAqB,SAAS;IACjD;AAGF,OAAK,SAAS,GACZ,iBACC,UAAU,eAAe,cAAc,cAAc;AACpD,QAAK,cACH,kBACA,UACA,eACA,cACA,UACD;IAEJ;AAGD,OAAK,SAAS,GAAG,aAAa,aAAa;AACzC,QAAK,cAAc,sBAAsB,SAAS;IAClD;;;;;CAMJ,cAAsB,UAA4B,GAAG,MAAmB;AACtE,OAAK,MAAM,EAAE,QAAQ,QAAQ,aAAa,KAAK,QAAQ,QAAQ,EAAE;AAC/D,OAAI,CAAC,OAAO,QAAS;GAErB,MAAM,OAAO,OAAO;AACpB,OAAI,OAAO,SAAS,WAClB,KAAI;AACD,SAAa,MAAM,QAAQ,CAAC,GAAG,MAAM,QAAQ,CAAC;YACxC,OAAO;AACd,YAAQ,MACN,2BAA2B,OAAO,KAAK,IAAI,SAAS,IACpD,MACD;;;;;;;CAST,sBAA6C;AAC3C,SAAO;GACL,sBACE,aACqB;AACrB,WAAO;KACL,IAAI,SAAS;KACb,WAAW,SAAS,YAAY;KAChC,YAAY,SAAS;KACrB,MAAM,SAAS;KACf,0BAA0B,SAAS;KACnC,WAAW,SAAS;KACpB,OAAO,SAAS;KAChB,iBAAiB,SAAS;KAC1B,YAAY,SAAS;KACrB,gBAAgB,SAAS;KACzB,uBAAuB,SAAS;KAChC,aAAa,SAAS,eAAe,KAAA;KACtC;;GAGH,WAAmC,aAAmC;AACpE,WAAO,SAAS;;GAGlB,qBAAqB,aAAkC;AACrD,WAAO,SAAS;;GAGlB,iBAAiB,aAAkC;AACjD,aAAS,gBAAgB;;GAG3B,qBACE,UACA,UACY;AACZ,WAAO,SAAS,mBAAmB,MAAM;;GAG3C,kBAAkB,aAAkC;AAClD,aAAS,iBAAiB;;GAG5B,gBAAgB,UAA+B,UAAiB;AAC9D,aAAS,cAAc,MAAM;;GAG/B,mBAAmB,aAAkC;AACnD,WAAO,SAAS,kBAAkB;;GAGpC,iBACE,cACQ;AACR,WAAO,KAAK,SAAS,OAAO,UAAiB;;GAG/C,mBAAmB;AACjB,WAAO,KAAK,SAAS,UAAU;;GAGjC,gBAAgB;AACd,WAAO,KAAK,SAAS,UAAU;;GAGjC,YAAY,eAAiC;AAC3C,SAAK,MAAM,QAAQ,KAAK,SAAS,UAAU,EAAE;KAC3C,MAAM,MAAM,KAAK,SAAS,gBAAgB,KAAK;AAC/C,UAAK,MAAM,GAAG,UAAU,IACtB,KAAK,MAAM,SAAiB,eAAe,WACzC,QAAO,MAAM,KAAK,MAAM,KAAK;;AAInC,WAAO,EAAE;;GAEZ;;;;;CAMH,mBAA2B,QAA+B;AACxD,MAAI,CAAC,OAAO,QAAS,QAAO;AAC5B,MAAI,OAAO,gBAAgB,MAAO,QAAO;AAGzC,SADmB,KAAK,uBAAuB,KACzB,OAAO;;;;;CAM/B,wBAAuE;AACrE,MAAI,OAAO,YAAY,aAAa;AAClC,OAAI,QAAQ,IAAI,aAAa,OAAQ,QAAO;AAC5C,OAAI,QAAQ,IAAI,aAAa,aAAc,QAAO;AAClD,UAAO;;AAET,SAAO;;;;;;;;AASX,SAAgB,oBACd,UACe;AACf,QAAO,IAAI,cAAc,SAAS;;;;;;;;;;;;;;;;AC5SpC,SAAgB,cAGd,MAAS,UAAkB,cAAiC;AAC5D,QAAQ,KAAa,aAAa;;;;;;;;AASpC,SAAgB,iBACd,MACS;AACT,QAAO,cAAuB,MAAM,kBAAkB,WAAW,KAAK;;;;;;;;;;;;;;;;;;ACwBxE,IAAa,yBAAb,MAAoC;;gDACQ,IAAI,SAG3C;+BAEsB,IAAI,KAAgC;6CAEtB,IAAI,KAAa;mCAE3B,IAAI,KAG9B;2BAEyB;;;;;;CAM5B,aAAkD,aAAsB;AACtE,OAAK,MAAM,IAAI,YAAY;;;;;;;CAQ7B,SAA8C,aAAsB;EAClE,MAAM,YAAY,YAAY;AAE9B,MAAI,KAAK,oBAAoB,IAAI,UAAU,CACzC,OAAM,IAAI,MACR,GAAG,kBAAkB,SAAS,UAAU,yBACzC;AAGH,OAAK,oBAAoB,IAAI,UAAU;AACvC,OAAK,aAAa,YAAY;;CAGhC,mBACE,MAC4B;EAC5B,IAAI,YAAY,KAAK,uBAAuB,IAAI,KAAK;AACrD,MAAI,CAAC,WAAW;AACd,+BAAY,IAAI,KAA4B;AAC5C,QAAK,uBAAuB,IAAI,MAAM,UAAU;;AAElD,SAAO;;;;;CAMT,gBACE,MAC4B;AAC5B,SAAO,KAAK,uBAAuB,IAAI,KAAK,oBAAI,IAAI,KAAK;;;;;;;;;;;;;;CAe3D,QACE,MACA,cAAsB,cAAc,sBACpC,UAII,EAAE,EACW;EACjB,MAAM,EAAE,YAAY,MAAM,WAAW,SAAS;EAE9C,MAAM,SAA+B,EACnC,YAAY,aACb;EAED,MAAM,YAAY,KAAK,mBAAmB,KAAK;EAC/C,IAAI,QAAQ,UAAU,IAAI,YAAY;AAGtC,MAAI,OAAO,SAAS,YAAY;AAC9B,aAAU,OAAO,YAAY;AAC7B,WAAQ,KAAA;;AAGV,MAAI,SAAS,UAAU;GACrB,MAAM,QAAQ,QAAQ,SAAS,SAAS,KAAK;AAC7C,SAAM,KAAK,IAAI,MAAM;;AAGvB,MAAI,MACF,QAAO,MAAM;AAGf,MAAI,CAAC,UACH,OAAM,IAAI,MACR,GAAG,kBAAkB,GAAG,KAAK,KAAK,aAAa,YAAY,uCAC5D;EAIH,MAAM,WAAW,IAAI,MAAM;AAC3B,WAAS,WAAW,OAAO;EAC3B,MAAM,8BAAc,IAAI,KAAa;AACrC,MAAI,UAAU;GACZ,MAAM,QAAQ,QAAQ,SAAS,SAAS,KAAK;AAC7C,eAAY,IAAI,MAAM;;AAExB,YAAU,IAAI,aAAa;GAAE;GAAU,MAAM;GAAa,CAAC;AAG3D,OAAK,aAAa,KAAK;AAEvB,SAAO;;;;;;;;;;CAWT,OACE,MACA,cAAsB,cAAc,sBACnB;AACjB,SAAO,KAAK,QAAQ,MAAM,aAAa;GACrC,WAAW;GACX,UAAU;GACX,CAAC;;;;;;;;;CAUJ,WACE,MACA,cAAsB,cAAc,sBAGS;AAC7C,MAAI;AAEF,UAAO;IAAE,OAAO;IAAM,UADL,KAAK,OAAO,MAAM,YAAY;IACf;WACzB,OAAY;AACnB,UAAO;IAAE;IAAO,UAAU;IAAM;;;;;;;;;;;;;;CAepC,OACE,MACA,cAAsB,cAAc,sBACnB;AACjB,SAAO,KAAK,QAAQ,MAAM,aAAa;GACrC,WAAW;GACX,UAAU;GACX,CAAC;;;;;;;;;;;CAYJ,QACE,MACA,cAAsB,cAAc,sBACpC,eAAe,OACf,OACM;EACN,MAAM,YAAY,KAAK,mBAAmB,KAAK;EAC/C,MAAM,QAAQ,UAAU,IAAI,YAAY;AAExC,MAAI,CAAC,MAAO;AAGZ,MAAI,cAAc;AAChB,OAAI,CAAC,MAAM,SAAS,WAClB,OAAM,SAAS,SAAS;AAE1B,aAAU,OAAO,YAAY;AAC7B;;AAIF,MAAI,UAAU,KAAA,EACZ,OAAM,KAAK,OAAO,MAAM;OACnB;GACL,MAAM,QAAQ,MAAM,KAAK,QAAQ,CAAC,MAAM,CAAC;AACzC,OAAI,UAAU,KAAA,EACZ,OAAM,KAAK,OAAO,MAAM;;EAK5B,MAAM,YAAY,iBAAiB,KAAK;AAGxC,MAAI,MAAM,KAAK,SAAS,KAAK,CAAC,WAAW;AACvC,OAAI,CAAC,MAAM,SAAS,WAClB,OAAM,SAAS,SAAS;AAE1B,aAAU,OAAO,YAAY;;;;;;;;CASjC,OACE,MAC4B;EAC5B,MAAM,YAAY,KAAK,mBAAmB,KAAK;EAC/C,MAAM,SAAqC,EAAE;AAC7C,OAAK,MAAM,SAAS,UAAU,QAAQ,CACpC,QAAO,KAAK,MAAM,SAAS;AAE7B,SAAO;;;;;;;;CAST,QACE,MACA,UACM;EACN,MAAM,YAAY,KAAK,mBAAmB,KAAK;AAC/C,OAAK,MAAM,SAAS,UAAU,QAAQ,EAAE;GACtC,MAAM,WAAW,MAAM;AACvB,OAAI,CAAC,SAAS,WACZ,KAAI;AACF,aAAS,SAAS;YACX,OAAO;AACd,YAAQ,MACN,GAAG,kBAAkB,8BAA8B,KAAK,KAAK,IAC7D,MACD;;;;;;;;CAUT,MAA2C,MAAe;EACxD,MAAM,YAAY,KAAK,mBAAmB,KAAK;AAE/C,OAAK,MAAM,SAAS,UAAU,QAAQ,CACpC,KAAI,CAAC,MAAM,SAAS,WAClB,OAAM,SAAS,SAAS;AAI5B,YAAU,OAAO;;;;;;;;CASnB,YACE,MACA,cAAsB,cAAc,sBAC5B;AAGR,SAFkB,KAAK,mBAAmB,KAAK,CACvB,IAAI,YAAY,EAC1B,KAAK,QAAQ;;;;;;;;CAS7B,UACE,MACA,cAAsB,cAAc,sBAC1B;EACV,MAAM,YAAY,KAAK,uBAAuB,IAAI,KAAK;AACvD,MAAI,CAAC,UAAW,QAAO,EAAE;EACzB,MAAM,QAAQ,UAAU,IAAI,YAAY;AACxC,SAAO,QAAQ,MAAM,KAAK,MAAM,KAAK,GAAG,EAAE;;;;;;;;CAS5C,YACE,MACA,cAAsB,cAAc,sBAC3B;AAET,SADkB,KAAK,mBAAmB,KAAK,CAC9B,IAAI,YAAY;;;;;;;;CASnC,WAAiB;AAEf,OAAK,MAAM,QAAQ,KAAK,MACtB,MAAK,MAAM,KAAK;AAGlB,OAAK,MAAM,OAAO;AAClB,OAAK,oBAAoB,OAAO;;;;;;CAOlC,WAIE;EACA,MAAM,gBAAwC,EAAE;EAChD,IAAI,iBAAiB;AAGrB,OAAK,MAAM,QAAQ,KAAK,OAAO;GAC7B,MAAM,WAAW,KAAK;GAEtB,MAAM,QADY,KAAK,gBAAgB,KAAK,CACpB;AAExB,iBAAc,YAAY;AAC1B,qBAAkB;;AAGpB,SAAO;GACL,iBAAiB,KAAK,MAAM;GAC5B;GACA;GACD;;;;;;CAOH,WAAwC;AACtC,SAAO,MAAM,KAAK,KAAK,MAAM;;;;;;;;CAS/B,GACE,OACA,UACY;AACZ,MAAI,CAAC,KAAK,UAAU,IAAI,MAAM,CAC5B,MAAK,UAAU,IAAI,uBAAO,IAAI,KAAK,CAAC;EAEtC,MAAM,WAAW,KAAK,UAAU,IAAI,MAAM;AAC1C,MAAI,CAAC,SACH,OAAM,IAAI,MACR,GAAG,kBAAkB,0CAA0C,MAAM,GACtE;AAGH,WAAS,IAAI,SAAqC;AAGlD,eAAa;AACX,QAAK,UAAU,IAAI,MAAM,EAAE,OAAO,SAAqC;;;;;;;CAQ3E,KAAK,OAAuB,GAAG,MAAmB;EAChD,MAAM,YAAY,KAAK,UAAU,IAAI,MAAM;AAC3C,MAAI,CAAC,aAAa,UAAU,SAAS,EAAG;AAExC,OAAK,MAAM,YAAY,UACrB,KAAI;AACF,YAAS,GAAG,KAAK;WACV,OAAO;AACd,WAAQ,MACN,GAAG,kBAAkB,uBAAuB,MAAM,KAClD,MACD;;;;;;;AAST,MAAa,iBAAiB,IAAI,wBAAwB;;;;AAK1D,IAAI,uBAA4B;;;;AAKhC,SAAgB,mBAAwB;AACtC,KAAI,CAAC,qBACH,wBAAuB,oBAAoB,eAAe;AAE5D,QAAO"}