@blac/core 2.0.0 → 2.0.1

package/dist/index.js

@@ -0,0 +1,2884 @@
+//#region src/utils/idGenerator.ts
+/**
+* Centralized ID Generation
+*
+* Provides consistent, collision-resistant ID generation for all BlaC subsystems.
+* Uses timestamp + counter + random suffix for uniqueness.
+*/
+const globalCounters = /* @__PURE__ */ new Map();
+/**
+* Creates an ID generator with isolated counter state
+*
+* @param prefix - Prefix for generated IDs
+* @returns Object with next(), nextSimple(), and reset() methods
+*
+* @example
+* ```ts
+* const generator = createIdGenerator('sub');
+* const id1 = generator.next(); // "sub:1698765432100_1_a3k9d7f2q"
+* const id2 = generator.next(); // "sub:1698765432101_2_b4n8e9g3r"
+* ```
+*/
+function createIdGenerator(prefix) {
+	let counter = 0;
+	return {
+		next: () => `${prefix}:${Date.now()}_${++counter}_${Math.random().toString(36).substring(2, 11)}`,
+		nextSimple: () => `${prefix}:${++counter}`,
+		reset: () => {
+			counter = 0;
+		}
+	};
+}
+/**
+* Generate ID with timestamp, counter, and random suffix (tree-shakeable)
+*
+* Format: `${prefix}:${timestamp}_${counter}_${random}`
+*
+* @param prefix - Prefix for the ID (e.g., 'sub', 'consumer', 'stage')
+* @returns Branded ID string
+*
+* @example
+* const id = generateId('sub');
+* // Returns: "sub:1698765432100_1_a3k9d7f2q"
+*/
+function generateId(prefix) {
+	const counter = (globalCounters.get(prefix) ?? 0) + 1;
+	globalCounters.set(prefix, counter);
+	return `${prefix}:${Date.now()}_${counter}_${Math.random().toString(36).substring(2, 11)}`;
+}
+/**
+* Generate simple ID with timestamp and random (no counter tracking)
+*
+* Format: `${prefix}:${timestamp}_${random}`
+*
+* @param prefix - Prefix for the ID
+* @returns Branded ID string
+*
+* @example
+* ```ts
+* const id = generateSimpleId('CounterBloc');
+* // Returns: "CounterBloc:1698765432100_a3k9d7f2q"
+* ```
+*/
+function generateSimpleId(prefix, affix) {
+	if (affix) return `${prefix}:${affix}`;
+	return `${prefix}:${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+}
+/**
+* Reset all counters for testing purposes
+* @internal
+*/
+function __resetIdCounters() {
+	globalCounters.clear();
+}
+/**
+* Generate a unique isolated instance key
+* Uses base36 encoding for compact, URL-safe identifiers
+*
+* Format: "isolated-{9-char-random-string}"
+* Example: "isolated-k7x2m9p4q"
+*
+* @returns A unique isolated instance key
+*/
+function generateIsolatedKey() {
+	return `isolated-${Math.random().toString(36).slice(2, 11)}`;
+}
+/**
+* Check if a key is an isolated instance key
+* @param key - The instance key to check
+* @returns true if the key is an isolated instance key
+*/
+function isIsolatedKey(key) {
+	return key.startsWith("isolated-");
+}
+
+//#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$1) {
+			console.error(`[BlaC] Error installing plugin "${plugin.name}":`, error$1);
+			this.plugins.delete(plugin.name);
+			throw error$1;
+		}
+		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$1) {
+			console.error(`[BlaC] Error uninstalling plugin "${pluginName}":`, error$1);
+		}
+		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$1) => {
+			this.notifyPlugins("onInstanceCreated", instance$1);
+		});
+		this.registry.on("stateChanged", (instance$1, previousState, currentState, callstack) => {
+			this.notifyPlugins("onStateChanged", instance$1, previousState, currentState, callstack);
+		});
+		this.registry.on("eventAdded", (vertex, event) => {
+			this.notifyPlugins("onEventAdded", vertex, event);
+		});
+		this.registry.on("disposed", (instance$1) => {
+			this.notifyPlugins("onInstanceDisposed", instance$1);
+		});
+	}
+	/**
+	* 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$1) {
+				console.error(`[BlaC] Error in plugin "${plugin.name}" ${hookName}:`, error$1);
+			}
+		}
+	}
+	/**
+	* Create plugin context with safe API access
+	*/
+	createPluginContext() {
+		return {
+			getInstanceMetadata: (instance$1) => {
+				return {
+					id: instance$1.instanceId,
+					className: instance$1.constructor.name,
+					isDisposed: instance$1.isDisposed,
+					name: instance$1.name,
+					lastStateChangeTimestamp: instance$1.lastUpdateTimestamp,
+					createdAt: instance$1.createdAt,
+					state: instance$1.state,
+					isIsolated: instance$1.instanceId.startsWith("isolated-")
+				};
+			},
+			getState: (instance$1) => {
+				return instance$1.state;
+			},
+			queryInstances: (typeClass) => {
+				return this.registry.getAll(typeClass);
+			},
+			getAllTypes: () => {
+				return this.registry.getTypes();
+			},
+			getStats: () => {
+				return this.registry.getStats();
+			}
+		};
+	}
+	/**
+	* 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/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 = {
+	ISOLATED: "isolated",
+	KEEP_ALIVE: "keepAlive",
+	EXCLUDE_FROM_DEVTOOLS: "__excludeFromDevTools"
+};
+/**
+* ID generation patterns and constants
+*/
+const BLAC_ID_PATTERNS = {
+	ISOLATED_PREFIX: "isolated-",
+	ID_LENGTH: 9
+};
+/**
+* Standard error message prefix
+*/
+const BLAC_ERROR_PREFIX = "[BlaC]";
+
+//#endregion
+//#region src/tracking/getter-tracker.ts
+const descriptorCache = /* @__PURE__ */ new WeakMap();
+const blocProxyCache = /* @__PURE__ */ new WeakMap();
+const activeTrackerMap = /* @__PURE__ */ new WeakMap();
+const getterExecutionContext = {
+	tracker: null,
+	currentBloc: null,
+	depth: 0,
+	visitedBlocs: /* @__PURE__ */ new Set()
+};
+const MAX_GETTER_DEPTH$1 = BLAC_DEFAULTS.MAX_GETTER_DEPTH;
+/**
+* @internal
+*/
+function getGetterExecutionContext() {
+	return getterExecutionContext;
+}
+/**
+* @internal
+*/
+function getDescriptor(obj, prop) {
+	const constructor = obj.constructor;
+	let constructorCache = descriptorCache.get(constructor);
+	if (constructorCache?.has(prop)) return constructorCache.get(prop);
+	let current = obj;
+	let descriptor;
+	while (current && current !== Object.prototype) {
+		descriptor = Object.getOwnPropertyDescriptor(current, prop);
+		if (descriptor) break;
+		current = Object.getPrototypeOf(current);
+	}
+	if (!constructorCache) {
+		constructorCache = /* @__PURE__ */ new Map();
+		descriptorCache.set(constructor, constructorCache);
+	}
+	constructorCache.set(prop, descriptor);
+	return descriptor;
+}
+/**
+* @internal
+*/
+function isGetter(obj, prop) {
+	return getDescriptor(obj, prop)?.get !== void 0;
+}
+/**
+* @internal
+*/
+function createGetterState() {
+	return {
+		trackedValues: /* @__PURE__ */ new Map(),
+		currentlyAccessing: /* @__PURE__ */ new Set(),
+		trackedGetters: /* @__PURE__ */ new Set(),
+		isTracking: false,
+		renderCache: /* @__PURE__ */ new Map(),
+		cacheValid: false,
+		externalDependencies: /* @__PURE__ */ new Set()
+	};
+}
+/**
+* @internal
+*/
+function setActiveTracker(bloc, tracker) {
+	activeTrackerMap.set(bloc, tracker);
+}
+/**
+* @internal
+*/
+function clearActiveTracker(bloc) {
+	activeTrackerMap.delete(bloc);
+}
+/**
+* @internal
+*/
+function getActiveTracker(bloc) {
+	return activeTrackerMap.get(bloc);
+}
+/**
+* @internal
+*/
+function commitTrackedGetters(tracker) {
+	if (tracker.currentlyAccessing.size > 0) tracker.trackedGetters = new Set(tracker.currentlyAccessing);
+	tracker.currentlyAccessing.clear();
+}
+/**
+* @internal
+*/
+function createBlocProxy(bloc) {
+	const cached = blocProxyCache.get(bloc);
+	if (cached) return cached;
+	const proxy = new Proxy(bloc, { get(target, prop, receiver) {
+		const tracker = activeTrackerMap.get(target);
+		if (tracker?.isTracking && isGetter(target, prop)) {
+			tracker.currentlyAccessing.add(prop);
+			if (tracker.cacheValid && tracker.renderCache.has(prop)) {
+				const cachedValue = tracker.renderCache.get(prop);
+				tracker.trackedValues.set(prop, cachedValue);
+				return cachedValue;
+			}
+			if (getterExecutionContext.depth >= MAX_GETTER_DEPTH$1) {
+				console.warn(`${BLAC_ERROR_PREFIX} Maximum getter depth (${MAX_GETTER_DEPTH$1}) exceeded. Possible circular dependency in getter "${String(prop)}" on ${target.constructor.name}. Returning undefined to prevent stack overflow.`);
+				return;
+			}
+			if (getterExecutionContext.visitedBlocs.has(target)) {
+				console.warn(`${BLAC_ERROR_PREFIX} Circular dependency detected: getter "${String(prop)}" on ${target.constructor.name} is calling back into itself. Returning undefined to prevent infinite recursion.`);
+				return;
+			}
+			const prevContext = {
+				tracker: getterExecutionContext.tracker,
+				currentBloc: getterExecutionContext.currentBloc,
+				depth: getterExecutionContext.depth,
+				visitedBlocs: new Set(getterExecutionContext.visitedBlocs)
+			};
+			getterExecutionContext.tracker = tracker;
+			getterExecutionContext.currentBloc = target;
+			getterExecutionContext.depth++;
+			getterExecutionContext.visitedBlocs.add(target);
+			try {
+				const value = getDescriptor(target, prop).get.call(target);
+				tracker.trackedValues.set(prop, value);
+				return value;
+			} catch (error$1) {
+				tracker.currentlyAccessing.delete(prop);
+				throw error$1;
+			} finally {
+				getterExecutionContext.tracker = prevContext.tracker;
+				getterExecutionContext.currentBloc = prevContext.currentBloc;
+				getterExecutionContext.depth = prevContext.depth;
+				getterExecutionContext.visitedBlocs = prevContext.visitedBlocs;
+			}
+		}
+		return Reflect.get(target, prop, receiver);
+	} });
+	blocProxyCache.set(bloc, proxy);
+	return proxy;
+}
+/**
+* @internal
+*/
+function hasGetterChanges(bloc, tracker) {
+	if (!tracker || tracker.trackedGetters.size === 0) return false;
+	tracker.renderCache.clear();
+	let hasAnyChange = false;
+	for (const prop of tracker.trackedGetters) try {
+		const descriptor = getDescriptor(bloc, prop);
+		if (!descriptor?.get) continue;
+		const newValue = descriptor.get.call(bloc);
+		const oldValue = tracker.trackedValues.get(prop);
+		tracker.renderCache.set(prop, newValue);
+		tracker.trackedValues.set(prop, newValue);
+		if (!Object.is(newValue, oldValue)) hasAnyChange = true;
+	} catch (error$1) {
+		console.warn(`${BLAC_ERROR_PREFIX} Getter "${String(prop)}" threw error during change detection. Stopping tracking for this getter.`, error$1);
+		tracker.trackedGetters.delete(prop);
+		tracker.trackedValues.delete(prop);
+		tracker.cacheValid = false;
+		return true;
+	}
+	tracker.cacheValid = true;
+	return hasAnyChange;
+}
+/**
+* @internal
+*/
+function invalidateRenderCache(tracker) {
+	tracker.cacheValid = false;
+}
+/**
+* @internal
+*/
+function clearExternalDependencies(tracker) {
+	tracker.externalDependencies.clear();
+}
+/**
+* @internal
+*/
+function resetGetterState(tracker) {
+	tracker.trackedValues.clear();
+	tracker.currentlyAccessing.clear();
+	tracker.trackedGetters.clear();
+	tracker.renderCache.clear();
+	tracker.cacheValid = false;
+	tracker.isTracking = false;
+	tracker.externalDependencies.clear();
+}
+
+//#endregion
+//#region src/core/markers.ts
+/**
+* Marker symbols for identifying container types.
+* These are in a separate file to avoid circular dependencies.
+* @internal
+*/
+/**
+* Marker symbol to identify stateless containers at the type level.
+* Used by React hooks to prevent `useBloc` from accepting stateless containers.
+*/
+const STATELESS_MARKER = Symbol("STATELESS_CONTAINER");
+
+//#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 isolated.
+* Isolated classes create separate instances per component.
+* @param Type - The class constructor to check
+* @returns true if the class has `static isolated = true`
+*/
+function isIsolatedClass(Type) {
+	return getStaticProp(Type, BLAC_STATIC_PROPS.ISOLATED) === true;
+}
+/**
+* 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;
+}
+/**
+* Check if a class should be excluded from DevTools.
+* Used to prevent infinite loops when DevTools tracks itself.
+* @param Type - The class constructor to check
+* @returns true if the class has `static __excludeFromDevTools = true`
+*/
+function isExcludedFromDevTools(Type) {
+	return getStaticProp(Type, BLAC_STATIC_PROPS.EXCLUDE_FROM_DEVTOOLS) === true;
+}
+/**
+* Check if a class is a stateless container (StatelessCubit or StatelessVertex).
+* Stateless containers don't have state, emit, update, or subscribe methods.
+* @param Type - The class constructor to check
+* @returns true if the class is a stateless container
+*/
+function isStatelessClass(Type) {
+	return Type[STATELESS_MARKER] === true;
+}
+
+//#endregion
+//#region src/core/StateContainerRegistry.ts
+/**
+* Central registry for managing StateContainer instances.
+* Handles instance lifecycle, ref counting, 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.typeConfigs = /* @__PURE__ */ new Map();
+		this.listeners = /* @__PURE__ */ new Map();
+	}
+	/**
+	* 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
+	* @param isolated - Whether instances should be isolated (component-scoped)
+	* @throws Error if type is already registered
+	*/
+	register(constructor, isolated = false) {
+		const className = constructor.name;
+		if (!isolated && isIsolatedClass(constructor)) isolated = true;
+		if (this.typeConfigs.has(className)) throw new Error(`${BLAC_ERROR_PREFIX} Type "${className}" is already registered`);
+		this.typeConfigs.set(className, { isolated });
+		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();
+	}
+	trackExecutionContext(instance$1) {
+		const context = getGetterExecutionContext();
+		if (context.tracker && context.currentBloc && context.currentBloc !== instance$1) context.tracker.externalDependencies.add(instance$1);
+	}
+	/**
+	* Acquire an instance with ref counting (ownership semantics).
+	* Creates a new instance if one doesn't exist, or returns existing and increments ref count.
+	* You must call `release()` when done to decrement the ref count.
+	* @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 increment ref count (default: true)
+	* @param options.props - Props to pass to constructor if creating new instance
+	* @param options.trackExecutionContext - Whether to track cross-bloc dependency (default: false)
+	* @returns The state container instance
+	*/
+	acquire(Type, instanceKey = BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY, options = {}) {
+		const { canCreate = true, countRef = true, props, trackExecutionContext = false } = options;
+		const registryConfig = this.typeConfigs.get(Type.name);
+		const isolated = isIsolatedClass(Type) || registryConfig?.isolated === true;
+		const config = { instanceId: instanceKey };
+		if (isolated && !canCreate) throw new Error(`${BLAC_ERROR_PREFIX} Cannot get isolated instance "${instanceKey}" of ${Type.name} when creation is disabled.`);
+		if (isolated) {
+			const instance$2 = new Type(props);
+			instance$2.initConfig(config);
+			this.registerType(Type);
+			if (trackExecutionContext) this.trackExecutionContext(instance$2);
+			return instance$2;
+		}
+		const instances = this.ensureInstancesMap(Type);
+		const entry = instances.get(instanceKey);
+		if (entry && (countRef || entry.refCount === 0)) entry.refCount++;
+		if (entry) {
+			if (trackExecutionContext) this.trackExecutionContext(entry.instance);
+			return entry.instance;
+		}
+		if (!canCreate) throw new Error(`${BLAC_ERROR_PREFIX} ${Type.name} instance "${instanceKey}" not found and creation is disabled.`);
+		const instance$1 = new Type(props);
+		instance$1.initConfig(config);
+		instances.set(instanceKey, {
+			instance: instance$1,
+			refCount: 1
+		});
+		this.registerType(Type);
+		if (trackExecutionContext) this.trackExecutionContext(instance$1);
+		return instance$1;
+	}
+	/**
+	* Borrow an existing instance without incrementing ref count (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,
+			trackExecutionContext: true
+		});
+	}
+	/**
+	* 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$1) {
+			return {
+				error: error$1,
+				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 incrementing ref count.
+	* 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 count increment).
+	* @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,
+			trackExecutionContext: true
+		});
+	}
+	/**
+	* Release a reference to an instance.
+	* Decrements ref count and disposes when it reaches 0 (unless keepAlive).
+	* @param Type - The StateContainer class constructor
+	* @param instanceKey - Instance key (defaults to 'default')
+	* @param forceDispose - Force immediate disposal regardless of ref count
+	*/
+	release(Type, instanceKey = BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY, forceDispose = false) {
+		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;
+		}
+		entry.refCount--;
+		const keepAlive = isKeepAliveClass(Type);
+		if (entry.refCount <= 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$1 = entry.instance;
+			if (!instance$1.isDisposed) try {
+				callback(instance$1);
+			} catch (error$1) {
+				console.error(`${BLAC_ERROR_PREFIX} forEach callback error for ${Type.name}:`, error$1);
+			}
+		}
+	}
+	/**
+	* 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.
+	* @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)?.refCount ?? 0;
+	}
+	/**
+	* 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.typeConfigs.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$1 = this.listeners.get(event);
+		if (!instance$1) throw new Error(`${BLAC_ERROR_PREFIX} Failed to register listener for event '${event}'`);
+		instance$1.add(listener);
+		return () => {
+			this.listeners.get(event)?.delete(listener);
+		};
+	}
+	/**
+	* Emit lifecycle event to all listeners
+	* @internal - Called by StateContainer/Vertex 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$1) {
+			console.error(`${BLAC_ERROR_PREFIX} Listener error for '${event}':`, error$1);
+		}
+	}
+};
+/**
+* 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
+//#region src/core/StateContainer.ts
+/**
+* Abstract base class for all state containers in BlaC.
+* Provides lifecycle management, subscription handling, ref counting,
+* and integration with the global registry.
+*
+* @template S - State type managed by this container
+* @template P - Props type passed to the container (optional)
+*
+* @example
+* ```ts
+* class CounterBloc extends StateContainer<{ count: number }> {
+*   constructor() {
+*     super({ count: 0 });
+*   }
+*   increment() {
+*     this.emit({ count: this.state.count + 1 });
+*   }
+* }
+* ```
+*/
+var StateContainer = class StateContainer {
+	static {
+		this.__excludeFromDevTools = false;
+	}
+	static {
+		this.enableStackTrace = true;
+	}
+	/** Current props value passed to this container */
+	get props() {
+		return this._props;
+	}
+	constructor(initialState) {
+		this.listeners = /* @__PURE__ */ new Set();
+		this._disposed = false;
+		this.config = {};
+		this._props = void 0;
+		this.systemEventHandlers = /* @__PURE__ */ new Map();
+		this.name = this.constructor.name;
+		this.debug = false;
+		this.instanceId = generateSimpleId(this.constructor.name, "main");
+		this.createdAt = Date.now();
+		this.lastUpdateTimestamp = Date.now();
+		this.onSystemEvent = (event, handler) => {
+			let handlers = this.systemEventHandlers.get(event);
+			if (!handlers) {
+				handlers = /* @__PURE__ */ new Set();
+				this.systemEventHandlers.set(event, handlers);
+			}
+			handlers.add(handler);
+			return () => {
+				handlers?.delete(handler);
+			};
+		};
+		this._state = initialState;
+	}
+	/**
+	* Initialize configuration for this instance.
+	* Called by the registry after construction.
+	* @param config - Configuration options
+	*/
+	initConfig(config) {
+		this.config = { ...config };
+		this.name = this.config.name || this.constructor.name;
+		this.debug = this.config.debug ?? false;
+		this.instanceId = generateSimpleId(this.constructor.name, this.config.instanceId);
+		globalRegistry.emit("created", this);
+	}
+	/** Current state value */
+	get state() {
+		return this._state;
+	}
+	/** Whether this instance has been disposed */
+	get isDisposed() {
+		return this._disposed;
+	}
+	/**
+	* Subscribe to state changes
+	* @param listener - Function called when state changes
+	* @returns Unsubscribe function
+	*/
+	subscribe(listener) {
+		if (this._disposed) throw new Error(`Cannot subscribe to disposed container ${this.name}`);
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	}
+	/**
+	* Dispose this instance and clean up resources.
+	* Clears all listeners and emits the 'dispose' system event.
+	*/
+	dispose() {
+		if (this._disposed) return;
+		if (this.debug) console.log(`[${this.name}] Disposing...`);
+		this._disposed = true;
+		this.emitSystemEvent("dispose", void 0);
+		this.listeners.clear();
+		this.systemEventHandlers.clear();
+		globalRegistry.emit("disposed", this);
+		if (this.debug) console.log(`[${this.name}] Disposed successfully`);
+	}
+	/**
+	* Emit a new state value and notify all listeners.
+	* @param newState - The new state value
+	* @protected
+	*/
+	emit(newState) {
+		if (this._disposed) throw new Error(`Cannot emit state from disposed container ${this.name}`);
+		if (this._state === newState) return;
+		const previousState = this._state;
+		this._state = newState;
+		this.emitSystemEvent("stateChanged", {
+			state: newState,
+			previousState
+		});
+		for (const listener of this.listeners) try {
+			listener(newState);
+		} catch (error$1) {
+			console.error(`[${this.name}] Error in listener:`, error$1);
+		}
+		const stackTrace = this.captureStackTrace();
+		globalRegistry.emit("stateChanged", this, previousState, newState, stackTrace);
+		this.lastUpdateTimestamp = Date.now();
+	}
+	captureStackTrace() {
+		if (!StateContainer.enableStackTrace || typeof process !== "undefined" && process.env?.NODE_ENV === "production") return "";
+		try {
+			const relevantLines = ((/* @__PURE__ */ new Error()).stack || "").split("\n").slice(1);
+			const formattedLines = [];
+			for (const line of relevantLines) {
+				if (!line.trim()) continue;
+				if (line.includes("StateContainer.emit") || line.includes("StateContainer.update") || line.includes("StateContainer.captureStackTrace") || line.includes("Cubit.patch") || line.includes("Vertex.")) continue;
+				if (line.includes("node_modules") || line.includes("react-dom") || line.includes("react_jsx") || line.includes(".vite/deps") || line.includes("executeDispatch") || line.includes("runWithFiber") || line.includes("invokeGuarded") || line.includes("callCallback") || line.includes("processDispatchQueue") || line.includes("dispatchEvent") || line.includes("batchedUpdates")) continue;
+				const formatted = this.formatStackLine(line);
+				if (formatted) formattedLines.push(formatted);
+			}
+			return formattedLines.join("\n");
+		} catch {
+			return "";
+		}
+	}
+	formatStackLine(line) {
+		const match = line.match(/at\s+(.+?)\s+\((.+?):(\d+):(\d+)\)/);
+		if (!match) {
+			const simpleMatch = line.match(/at\s+(.+?):(\d+):(\d+)/);
+			if (simpleMatch) {
+				const [, url$1, lineNum$1, col$1] = simpleMatch;
+				return `  at ${this.cleanFilePath(url$1)}:${lineNum$1}:${col$1}`;
+			}
+			return null;
+		}
+		const [, functionName, url, lineNum, col] = match;
+		return `  at ${functionName} (${this.cleanFilePath(url)}:${lineNum}:${col})`;
+	}
+	cleanFilePath(url) {
+		let path = url.replace(/http:\/\/localhost:\d+\/@fs/, "").replace(/http:\/\/localhost:\d+\//, "").replace(/\?t=\d+/, "").replace(/\?v=[a-f0-9]+/, "");
+		const projectMatch = path.match(/\/Projects\/blac\/(.+)/);
+		if (projectMatch) path = projectMatch[1];
+		const segments = path.split("/");
+		if (segments.length > 3) path = segments.slice(-3).join("/");
+		return path;
+	}
+	/**
+	* Update state using a transform function.
+	* @param updater - Function that receives current state and returns new state
+	* @protected
+	*/
+	update(updater) {
+		if (this._disposed) throw new Error(`Cannot update state from disposed container ${this.name}`);
+		this.emit(updater(this._state));
+	}
+	emitSystemEvent(event, payload) {
+		const handlers = this.systemEventHandlers.get(event);
+		if (!handlers) return;
+		for (const handler of handlers) try {
+			handler(payload);
+		} catch (error$1) {
+			console.error(`[${this.name}] Error in system event handler:`, error$1);
+		}
+	}
+	/**
+	* Update the props for this container.
+	* Emits the 'propsUpdated' system event.
+	* @param newProps - The new props value
+	*/
+	updateProps(newProps) {
+		if (this._disposed) throw new Error(`Cannot update props on disposed container ${this.name}`);
+		const previousProps = this._props;
+		this._props = newProps;
+		this.emitSystemEvent("propsUpdated", {
+			props: newProps,
+			previousProps
+		});
+		if (this.debug) console.log(`[${this.name}] Props updated:`, {
+			newProps,
+			previousProps
+		});
+	}
+};
+
+//#endregion
+//#region src/core/Cubit.ts
+/**
+* Simple state container with direct state emission.
+* Extends StateContainer with public methods for emitting and updating state.
+*
+* @template S - State type
+* @template P - Props type (optional)
+*/
+var Cubit = class extends StateContainer {
+	constructor(initialState) {
+		super(initialState);
+		this.patch = ((partial) => {
+			if (typeof this.state !== "object" || this.state === null) throw new Error("patch() is only available for object state types");
+			this.update((current) => ({
+				...current,
+				...partial
+			}));
+		});
+	}
+	/**
+	* Replace state with a new value and notify all listeners
+	* @param newState - The new state value
+	*/
+	emit(newState) {
+		super["emit"](newState);
+	}
+	/**
+	* Transform current state using an updater function and emit the new state
+	* @param updater - Function that receives current state and returns new state
+	*/
+	update(updater) {
+		super["update"](updater);
+	}
+};
+
+//#endregion
+//#region src/core/Vertex.ts
+/**
+* Event-driven state container using discriminated union events.
+* Extends StateContainer with event-based state transitions and
+* compile-time exhaustive checking for event handlers.
+*
+* @template S - State type (must be an object)
+* @template E - Event union type (discriminated by 'type' property)
+* @template P - Props type (optional)
+*
+* @example
+* ```typescript
+* type CounterEvent =
+*   | { type: 'increment'; amount: number }
+*   | { type: 'decrement' }
+*   | { type: 'reset' };
+*
+* class CounterVertex extends Vertex<{ count: number }, CounterEvent> {
+*   constructor() {
+*     super({ count: 0 });
+*     this.createHandlers({
+*       increment: (event, emit) => {
+*         emit({ count: this.state.count + event.amount });
+*       },
+*       decrement: (_, emit) => {
+*         emit({ count: this.state.count - 1 });
+*       },
+*       reset: (_, emit) => {
+*         emit({ count: 0 });
+*       },
+*     });
+*   }
+*
+*   increment = (amount = 1) => this.add({ type: 'increment', amount });
+* }
+* ```
+*/
+var Vertex = class extends StateContainer {
+	constructor(initialState) {
+		super(initialState);
+		this.handlers = /* @__PURE__ */ new Map();
+		this.isProcessing = false;
+		this.eventQueue = [];
+		this.add = (event) => {
+			const enrichedEvent = this.enrichEvent(event);
+			globalRegistry.emit("eventAdded", this, enrichedEvent);
+			this.processEvent(enrichedEvent);
+		};
+	}
+	/**
+	* Register all event handlers with exhaustive type checking.
+	* TypeScript will error if any event type from the union is missing.
+	*
+	* @param handlers - Map of event type to handler function
+	*/
+	createHandlers(handlers) {
+		for (const [eventType, handler] of Object.entries(handlers)) this.handlers.set(eventType, handler);
+	}
+	/** @internal */
+	enrichEvent(event) {
+		return {
+			...event,
+			timestamp: Date.now()
+		};
+	}
+	/** @internal */
+	processEvent(event) {
+		if (this.isProcessing) {
+			this.eventQueue.push(event);
+			return;
+		}
+		this.isProcessing = true;
+		try {
+			this.handleEvent(event);
+			while (this.eventQueue.length > 0) {
+				const nextEvent = this.eventQueue.shift();
+				this.handleEvent(nextEvent);
+			}
+		} finally {
+			this.isProcessing = false;
+		}
+	}
+	/** @internal */
+	handleEvent(event) {
+		const handler = this.handlers.get(event.type);
+		if (!handler) {
+			if (this.debug) console.warn(`No handler registered for event type: ${event.type}`);
+			return;
+		}
+		const emitFn = (state) => {
+			this.emit(state);
+		};
+		try {
+			handler(event, emitFn);
+		} catch (error$1) {
+			if (this.debug) console.error(`Error handling event ${event.type}:`, error$1);
+			this.onEventError(event, error$1);
+		}
+	}
+	/**
+	* Called when an error occurs during event processing.
+	* Override to implement custom error handling.
+	*
+	* @param _event - The event that caused the error
+	* @param _error - The error that occurred
+	*/
+	onEventError(_event, _error) {}
+};
+
+//#endregion
+//#region src/core/StatelessCubit.ts
+/**
+* A Cubit without state management capabilities.
+* Use this for action-only containers that don't need to manage or emit state.
+*
+* StatelessCubit:
+* - Has no `emit()`, `update()`, or `patch()` methods
+* - Has no accessible `state` property
+* - Cannot be subscribed to (throws error)
+* - Is rejected by `useBloc` hook (use `useBlocActions` instead)
+*
+* @template P - Props type (optional)
+*
+* @example
+* ```typescript
+* class AnalyticsService extends StatelessCubit {
+*   trackPageView(page: string) {
+*     analytics.track('page_view', { page });
+*   }
+*
+*   trackClick(element: string) {
+*     analytics.track('click', { element });
+*   }
+* }
+*
+* // In React component:
+* const analytics = useBlocActions(AnalyticsService);
+* analytics.trackPageView('/home');
+* ```
+*/
+var StatelessCubit = class extends Cubit {
+	static {
+		this[STATELESS_MARKER] = true;
+	}
+	constructor() {
+		super({});
+		this.patch = (_partial) => {
+			throw new Error(`${this.name} is a StatelessCubit and does not support patch(). Use a regular Cubit if you need state management.`);
+		};
+	}
+	/**
+	* State is not available on StatelessCubit.
+	* @throws Always throws an error when accessed.
+	*/
+	get state() {
+		throw new Error(`${this.name} is a StatelessCubit and does not have state. Use a regular Cubit if you need state management.`);
+	}
+	/**
+	* Subscriptions are not available on StatelessCubit.
+	* @throws Always throws an error when called.
+	*/
+	subscribe(_listener) {
+		throw new Error(`${this.name} is a StatelessCubit and does not support subscriptions. Use useBlocActions() instead of useBloc() in React.`);
+	}
+	/**
+	* emit() is not available on StatelessCubit.
+	* TypeScript will show an error if you try to call this method.
+	*/
+	emit(_newState) {
+		throw new Error(`${this.name} is a StatelessCubit and does not support emit(). Use a regular Cubit if you need state management.`);
+	}
+	/**
+	* update() is not available on StatelessCubit.
+	* TypeScript will show an error if you try to call this method.
+	*/
+	update(_updater) {
+		throw new Error(`${this.name} is a StatelessCubit and does not support update(). Use a regular Cubit if you need state management.`);
+	}
+};
+
+//#endregion
+//#region src/core/StatelessVertex.ts
+/**
+* An event-driven container without state management capabilities.
+* Use this for event processing that only produces side effects (logging, analytics, etc).
+*
+* StatelessVertex:
+* - Processes events via `add()` method
+* - Handlers receive only the event (no `emit` function)
+* - Has no accessible `state` property
+* - Cannot be subscribed to (throws error)
+* - Is rejected by `useBloc` hook (use `useBlocActions` instead)
+*
+* @template E - Event union type (discriminated by 'type' property)
+* @template P - Props type (optional)
+*
+* @example
+* ```typescript
+* type LogEvent =
+*   | { type: 'info'; message: string }
+*   | { type: 'error'; message: string; error: Error }
+*   | { type: 'warn'; message: string };
+*
+* class LoggingVertex extends StatelessVertex<LogEvent> {
+*   constructor() {
+*     super();
+*     this.createHandlers({
+*       info: (event) => console.log('[INFO]', event.message),
+*       error: (event) => console.error('[ERROR]', event.message, event.error),
+*       warn: (event) => console.warn('[WARN]', event.message),
+*     });
+*   }
+*
+*   info = (message: string) => this.add({ type: 'info', message });
+*   error = (message: string, error: Error) => this.add({ type: 'error', message, error });
+*   warn = (message: string) => this.add({ type: 'warn', message });
+* }
+*
+* // In React component:
+* const logger = useBlocActions(LoggingVertex);
+* logger.info('Page loaded');
+* ```
+*/
+var StatelessVertex = class extends StateContainer {
+	static {
+		this[STATELESS_MARKER] = true;
+	}
+	constructor() {
+		super({});
+		this.handlers = /* @__PURE__ */ new Map();
+		this.isProcessing = false;
+		this.eventQueue = [];
+		this.add = (event) => {
+			const enrichedEvent = this.enrichEvent(event);
+			globalRegistry.emit("eventAdded", this, enrichedEvent);
+			this.processEvent(enrichedEvent);
+		};
+	}
+	/**
+	* State is not available on StatelessVertex.
+	* @throws Always throws an error when accessed.
+	*/
+	get state() {
+		throw new Error(`${this.name} is a StatelessVertex and does not have state. Use a regular Vertex if you need state management.`);
+	}
+	/**
+	* Subscriptions are not available on StatelessVertex.
+	* @throws Always throws an error when called.
+	*/
+	subscribe(_listener) {
+		throw new Error(`${this.name} is a StatelessVertex and does not support subscriptions. Use useBlocActions() instead of useBloc() in React.`);
+	}
+	/**
+	* Register all event handlers with exhaustive type checking.
+	* TypeScript will error if any event type from the union is missing.
+	*
+	* Unlike regular Vertex, handlers do NOT receive an emit function
+	* since StatelessVertex cannot emit state.
+	*
+	* @param handlers - Map of event type to handler function
+	*/
+	createHandlers(handlers) {
+		for (const [eventType, handler] of Object.entries(handlers)) this.handlers.set(eventType, handler);
+	}
+	/** @internal */
+	enrichEvent(event) {
+		return {
+			...event,
+			timestamp: Date.now()
+		};
+	}
+	/** @internal */
+	processEvent(event) {
+		if (this.isProcessing) {
+			this.eventQueue.push(event);
+			return;
+		}
+		this.isProcessing = true;
+		try {
+			this.handleEvent(event);
+			while (this.eventQueue.length > 0) {
+				const nextEvent = this.eventQueue.shift();
+				this.handleEvent(nextEvent);
+			}
+		} finally {
+			this.isProcessing = false;
+		}
+	}
+	/** @internal */
+	handleEvent(event) {
+		const handler = this.handlers.get(event.type);
+		if (!handler) {
+			if (this.debug) console.warn(`No handler registered for event type: ${event.type}`);
+			return;
+		}
+		try {
+			handler(event);
+		} catch (error$1) {
+			if (this.debug) console.error(`Error handling event ${event.type}:`, error$1);
+			this.onEventError(event, error$1);
+		}
+	}
+	/**
+	* Called when an error occurs during event processing.
+	* Override to implement custom error handling.
+	*
+	* @param _event - The event that caused the error
+	* @param _error - The error that occurred
+	*/
+	onEventError(_event, _error) {}
+	/**
+	* emit() is not available on StatelessVertex.
+	* @internal
+	*/
+	emit(_newState) {
+		throw new Error(`${this.name} is a StatelessVertex and does not support emit(). Use a regular Vertex if you need state management.`);
+	}
+	/**
+	* update() is not available on StatelessVertex.
+	* @internal
+	*/
+	update(_updater) {
+		throw new Error(`${this.name} is a StatelessVertex and does not support update(). Use a regular Vertex if you need state management.`);
+	}
+};
+
+//#endregion
+//#region src/plugin/BlacPlugin.ts
+/**
+* Type guard to check if a plugin has a required onInstall hook
+* @param plugin - The plugin to check
+* @returns true if the plugin implements BlacPluginWithInit
+*/
+function hasInitHook(plugin) {
+	return typeof plugin.onInstall === "function";
+}
+
+//#endregion
+//#region src/tracking/proxy-tracker.ts
+/**
+* Functional proxy tracker for automatic dependency tracking
+*
+* This module provides a functional approach to proxy-based dependency tracking.
+* Unlike the class-based ProxyTracker, this uses a state object pattern that's
+* easier to integrate with functional programming patterns and framework hooks.
+*
+* @internal
+*/
+/**
+* Check if a value can be proxied
+*
+* Returns true for plain objects and arrays only.
+* Excludes built-in objects like Date, Map, Set, etc.
+*
+* @internal
+*/
+function isProxyable(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === Array.prototype;
+}
+/**
+* Create a new proxy tracker state
+*
+* @example
+* const state = createProxyTrackerState<MyState>();
+* startProxyTracking(state);
+* const proxy = createProxyForTarget(state, myObject);
+* // ... use proxy ...
+* const paths = stopProxyTracking(state);
+*
+* @internal
+*/
+function createProxyState() {
+	return {
+		trackedPaths: /* @__PURE__ */ new Set(),
+		isTracking: false,
+		proxyCache: /* @__PURE__ */ new WeakMap(),
+		boundFunctionsCache: null,
+		lastProxiedState: null,
+		lastProxy: null,
+		maxDepth: 10
+	};
+}
+/**
+* Start tracking property accesses
+*
+* Clears previous tracked paths and enables tracking mode.
+*
+* @internal
+*/
+function startProxy(state) {
+	state.isTracking = true;
+	state.trackedPaths.clear();
+}
+/**
+* Stop tracking and return the tracked paths
+*
+* Returns a new Set containing all tracked paths.
+*
+* @internal
+*/
+function stopProxy(state) {
+	state.isTracking = false;
+	return new Set(state.trackedPaths);
+}
+/**
+* Create a proxy for an array with property access tracking
+*
+* Tracks:
+* - Array element access (arr[0])
+* - Length access (arr.length)
+* - Array method calls (arr.map, arr.filter, etc.)
+*
+* @internal
+*/
+function createArrayProxy(state, target, path, depth = 0) {
+	const proxy = new Proxy(target, { get: (arr, prop) => {
+		if (typeof prop === "symbol") return Reflect.get(arr, prop);
+		const value = Reflect.get(arr, prop);
+		if (typeof value === "function") {
+			if (!state.boundFunctionsCache) state.boundFunctionsCache = /* @__PURE__ */ new WeakMap();
+			const cached = state.boundFunctionsCache.get(value);
+			if (cached) return cached;
+			const bound = value.bind(arr);
+			state.boundFunctionsCache.set(value, bound);
+			return bound;
+		}
+		if (prop === "length") {
+			if (state.isTracking) {
+				const fullPath$1 = path ? `${path}.length` : "length";
+				state.trackedPaths.add(fullPath$1);
+			}
+			return value;
+		}
+		let fullPath;
+		if (typeof prop === "string") {
+			const index = Number(prop);
+			if (!isNaN(index) && index >= 0) fullPath = path ? `${path}[${index}]` : `[${index}]`;
+			else fullPath = path ? `${path}.${prop}` : prop;
+		} else return value;
+		if (isProxyable(value)) return createInternal(state, value, fullPath, depth + 1);
+		if (state.isTracking) state.trackedPaths.add(fullPath);
+		return value;
+	} });
+	state.proxyCache.set(target, proxy);
+	return proxy;
+}
+/**
+* Create a proxy for an object with property access tracking
+*
+* This is the core proxy creation function that recursively creates proxies
+* for nested objects and arrays.
+*
+* Tracks:
+* - Property access (obj.prop)
+* - Nested property access (obj.nested.prop)
+* - 'in' operator usage ('prop' in obj)
+* - Object.keys, Object.entries, etc.
+*
+* @internal
+*/
+function createInternal(state, target, path = "", depth = 0) {
+	if (!state.isTracking || !isProxyable(target)) return target;
+	if (depth >= state.maxDepth) return target;
+	if (state.proxyCache.has(target)) return state.proxyCache.get(target);
+	if (Array.isArray(target)) return createArrayProxy(state, target, path, depth);
+	const proxy = new Proxy(target, {
+		get: (obj, prop) => {
+			if (typeof prop === "symbol") return Reflect.get(obj, prop);
+			const value = Reflect.get(obj, prop);
+			if (typeof value === "function") {
+				if (!state.boundFunctionsCache) state.boundFunctionsCache = /* @__PURE__ */ new WeakMap();
+				const cached = state.boundFunctionsCache.get(value);
+				if (cached) return cached;
+				const bound = value.bind(obj);
+				state.boundFunctionsCache.set(value, bound);
+				return bound;
+			}
+			const fullPath = path ? `${path}.${String(prop)}` : String(prop);
+			if (typeof prop === "string" && state.isTracking) {
+				if (!prop.startsWith("_") && !prop.startsWith("$$")) state.trackedPaths.add(fullPath);
+			}
+			if (isProxyable(value)) return createInternal(state, value, fullPath, depth + 1);
+			return value;
+		},
+		has: (obj, prop) => {
+			if (typeof prop === "string" && state.isTracking) {
+				const fullPath = path ? `${path}.${prop}` : prop;
+				state.trackedPaths.add(fullPath);
+			}
+			return Reflect.has(obj, prop);
+		},
+		ownKeys: (obj) => {
+			if (state.isTracking && path) state.trackedPaths.add(path);
+			return Reflect.ownKeys(obj);
+		}
+	});
+	state.proxyCache.set(target, proxy);
+	return proxy;
+}
+/**
+* Create a proxy for a target with caching
+*
+* If the target hasn't changed since the last call, returns the cached proxy.
+* Otherwise, creates a new proxy and caches it.
+*
+* This is the main entry point for creating tracked proxies.
+*
+* @internal
+*/
+function createForTarget(state, target) {
+	if (state.lastProxiedState === target && state.lastProxy) return state.lastProxy;
+	state.proxyCache = /* @__PURE__ */ new WeakMap();
+	state.boundFunctionsCache = null;
+	const proxy = createInternal(state, target, "", 0);
+	state.lastProxiedState = target;
+	state.lastProxy = proxy;
+	return proxy;
+}
+
+//#endregion
+//#region src/tracking/path-utils.ts
+/**
+* Path utilities for dependency tracking
+*
+* Provides utilities for parsing property paths and extracting values
+* from nested objects using path strings.
+*
+* @internal
+*/
+/**
+* Parse a property path string into an array of segments
+*
+* @internal
+*
+* Handles both dot notation (a.b.c) and bracket notation (a[0].b)
+*
+* @example
+* ```ts
+* parsePath('user.name') // ['user', 'name']
+* parsePath('items[0].name') // ['items', '0', 'name']
+* parsePath('data.users[2].address.city') // ['data', 'users', '2', 'address', 'city']
+* ```
+*/
+function parsePath(path) {
+	const segments = [];
+	let current = "";
+	let i = 0;
+	while (i < path.length) {
+		const char = path[i];
+		if (char === ".") {
+			if (current) segments.push(current);
+			current = "";
+		} else if (char === "[") {
+			if (current) segments.push(current);
+			current = "";
+			i++;
+			while (i < path.length && path[i] !== "]") current += path[i++];
+			if (current) segments.push(current);
+			current = "";
+		} else current += char;
+		i++;
+	}
+	if (current) segments.push(current);
+	return segments;
+}
+/**
+* Get a value from an object using a path of segments
+*
+* @example
+* ```ts
+* const obj = { user: { name: 'Alice', age: 30 } }
+* getValueAtPath(obj, ['user', 'name']) // 'Alice'
+* getValueAtPath(obj, ['user', 'age']) // 30
+* getValueAtPath(obj, ['user', 'missing']) // undefined
+* ```
+*
+* @internal
+*/
+function getValueAtPath(obj, segments) {
+	if (obj == null) return void 0;
+	let current = obj;
+	for (let i = 0; i < segments.length; i++) {
+		current = current[segments[i]];
+		if (current == null) return void 0;
+	}
+	return current;
+}
+/**
+* Shallow equality comparison for arrays
+*
+* Compares two arrays element-by-element using Object.is
+*
+* @example
+* ```ts
+* shallowEqual([1, 2, 3], [1, 2, 3]) // true
+* shallowEqual([1, 2, 3], [1, 2, 4]) // false
+* shallowEqual([1, 2], [1, 2, 3]) // false
+* ```
+*
+* @internal
+*/
+function shallowEqual(arr1, arr2) {
+	if (arr1.length !== arr2.length) return false;
+	for (let i = 0; i < arr1.length; i++) if (!Object.is(arr1[i], arr2[i])) return false;
+	return true;
+}
+
+//#endregion
+//#region src/tracking/dependency-tracker.ts
+function isChildPath(child, parent) {
+	if (child === parent) return false;
+	return child.startsWith(parent + ".") || child.startsWith(parent + "[");
+}
+/**
+* Extract the parent array path from an array child path
+* Examples:
+*   'messages.length' -> 'messages'
+*   'messages[0]' -> 'messages'
+*   'messages[0].text' -> 'messages'
+*   'data.items[0]' -> 'data.items'
+*/
+function getArrayParentPath(path) {
+	if (path.endsWith(".length")) return path.slice(0, -7);
+	const arrayIndexMatch = path.match(/^(.+?)\[\d+\]/);
+	if (arrayIndexMatch) return arrayIndexMatch[1];
+	return null;
+}
+/**
+* @internal
+*/
+function optimizeTrackedPaths(paths) {
+	if (paths.size === 0) return /* @__PURE__ */ new Set();
+	if (paths.size === 1) return new Set(paths);
+	const sortedPaths = Array.from(paths).sort((a, b) => b.length - a.length);
+	const optimized = /* @__PURE__ */ new Set();
+	for (const path of sortedPaths) {
+		let hasMoreSpecificChild = false;
+		for (const optimizedPath of optimized) if (isChildPath(optimizedPath, path)) {
+			hasMoreSpecificChild = true;
+			break;
+		}
+		if (!hasMoreSpecificChild) optimized.add(path);
+	}
+	const arrayParents = /* @__PURE__ */ new Set();
+	for (const path of optimized) {
+		const arrayParent = getArrayParentPath(path);
+		if (arrayParent) arrayParents.add(arrayParent);
+	}
+	for (const arrayParent of arrayParents) optimized.add(arrayParent);
+	return optimized;
+}
+/**
+* @internal
+*/
+function createDependencyState() {
+	return {
+		proxyState: createProxyState(),
+		previousRenderPaths: /* @__PURE__ */ new Set(),
+		currentRenderPaths: /* @__PURE__ */ new Set(),
+		pathCache: /* @__PURE__ */ new Map(),
+		lastCheckedState: null,
+		lastCheckedValues: /* @__PURE__ */ new Map()
+	};
+}
+/**
+* @internal
+*/
+function startDependency(tracker) {
+	startProxy(tracker.proxyState);
+}
+/**
+* @internal
+*/
+function createDependencyProxy(tracker, state) {
+	return createForTarget(tracker.proxyState, state);
+}
+/**
+* @internal
+*/
+function capturePaths(tracker, state) {
+	tracker.previousRenderPaths = tracker.currentRenderPaths;
+	tracker.currentRenderPaths = optimizeTrackedPaths(stopProxy(tracker.proxyState));
+	if (tracker.previousRenderPaths.size === 0 && tracker.currentRenderPaths.size === 0) return;
+	const trackedPathsUnion = new Set(tracker.previousRenderPaths);
+	for (const path of tracker.currentRenderPaths) trackedPathsUnion.add(path);
+	const canReuseCache = tracker.lastCheckedState === state;
+	for (const path of trackedPathsUnion) if (!tracker.pathCache.has(path)) {
+		const segments = parsePath(path);
+		const value = canReuseCache && tracker.lastCheckedValues.has(path) ? tracker.lastCheckedValues.get(path) : getValueAtPath(state, segments);
+		tracker.pathCache.set(path, {
+			segments,
+			value
+		});
+	} else {
+		const info$1 = tracker.pathCache.get(path);
+		info$1.value = canReuseCache && tracker.lastCheckedValues.has(path) ? tracker.lastCheckedValues.get(path) : getValueAtPath(state, info$1.segments);
+	}
+	tracker.lastCheckedValues.clear();
+}
+/**
+* @internal
+*/
+function hasDependencyChanges(tracker, state) {
+	if (tracker.pathCache.size === 0) return true;
+	tracker.lastCheckedValues.clear();
+	for (const [path, info$1] of tracker.pathCache.entries()) {
+		const currentValue = getValueAtPath(state, info$1.segments);
+		tracker.lastCheckedValues.set(path, currentValue);
+		if (!Object.is(currentValue, info$1.value)) {
+			tracker.lastCheckedState = state;
+			return true;
+		}
+	}
+	tracker.lastCheckedState = state;
+	return false;
+}
+/**
+* @internal
+*/
+function hasTrackedData(tracker) {
+	return tracker.proxyState.trackedPaths.size > 0 || tracker.pathCache.size > 0 || tracker.previousRenderPaths.size > 0;
+}
+
+//#endregion
+//#region src/tracking/tracking-proxy.ts
+/**
+* Create a new tracking proxy state.
+*/
+function createState() {
+	return {
+		dependencyState: createDependencyState(),
+		getterState: createGetterState(),
+		dependencies: /* @__PURE__ */ new Set(),
+		isTracking: false
+	};
+}
+/**
+* Start tracking on a tracking proxy.
+*/
+function startTracking(tracker) {
+	tracker.isTracking = true;
+	tracker.dependencies.clear();
+	tracker.getterState.isTracking = true;
+	tracker.getterState.externalDependencies.clear();
+	startDependency(tracker.dependencyState);
+}
+/**
+* Stop tracking and collect all dependencies.
+*/
+function stopTracking(tracker, bloc) {
+	tracker.isTracking = false;
+	tracker.getterState.isTracking = false;
+	capturePaths(tracker.dependencyState, bloc.state);
+	commitTrackedGetters(tracker.getterState);
+	const allDeps = new Set(tracker.dependencies);
+	for (const dep of tracker.getterState.externalDependencies) allDeps.add(dep);
+	tracker.getterState.externalDependencies.clear();
+	return allDeps;
+}
+/**
+* Check if tracked state or getters have changed.
+*/
+function hasChanges(tracker, bloc) {
+	invalidateRenderCache(tracker.getterState);
+	const stateChanged = hasDependencyChanges(tracker.dependencyState, bloc.state);
+	const getterChanged = hasGetterChanges(bloc, tracker.getterState);
+	return stateChanged || getterChanged;
+}
+const MAX_GETTER_DEPTH = BLAC_DEFAULTS.MAX_GETTER_DEPTH;
+/**
+* Create a tracking proxy for a bloc instance.
+* Tracks both state property access and getter access.
+*/
+function createTrackingProxy(bloc, tracker) {
+	tracker.dependencies.add(bloc);
+	const stateProxyCache = /* @__PURE__ */ new WeakMap();
+	return new Proxy(bloc, { get(target, prop, receiver) {
+		if (prop === "state") {
+			if (!tracker.isTracking) return target.state;
+			const rawState = target.state;
+			if (rawState === null || typeof rawState !== "object") return rawState;
+			if (stateProxyCache.has(rawState)) return stateProxyCache.get(rawState);
+			const stateProxy = createDependencyProxy(tracker.dependencyState, rawState);
+			stateProxyCache.set(rawState, stateProxy);
+			return stateProxy;
+		}
+		if (typeof prop === "symbol") return Reflect.get(target, prop, receiver);
+		const value = Reflect.get(target, prop, receiver);
+		if (typeof value === "function") return value.bind(target);
+		if (tracker.isTracking && isGetter(target, prop)) {
+			tracker.getterState.currentlyAccessing.add(prop);
+			if (tracker.getterState.cacheValid && tracker.getterState.renderCache.has(prop)) {
+				const cachedValue = tracker.getterState.renderCache.get(prop);
+				tracker.getterState.trackedValues.set(prop, cachedValue);
+				return cachedValue;
+			}
+			const context = getGetterExecutionContext();
+			if (context.depth >= MAX_GETTER_DEPTH) {
+				console.warn(`${BLAC_ERROR_PREFIX} Maximum getter depth (${MAX_GETTER_DEPTH}) exceeded. Possible circular dependency in getter "${String(prop)}" on ${target.constructor.name}.`);
+				return;
+			}
+			if (context.visitedBlocs.has(target)) {
+				console.warn(`${BLAC_ERROR_PREFIX} Circular dependency detected: getter "${String(prop)}" on ${target.constructor.name}.`);
+				return;
+			}
+			const prevContext = {
+				tracker: context.tracker,
+				currentBloc: context.currentBloc,
+				depth: context.depth,
+				visitedBlocs: new Set(context.visitedBlocs)
+			};
+			context.tracker = tracker.getterState;
+			context.currentBloc = target;
+			context.depth++;
+			context.visitedBlocs.add(target);
+			try {
+				const getterValue = getDescriptor(target, prop).get.call(target);
+				tracker.getterState.trackedValues.set(prop, getterValue);
+				return getterValue;
+			} catch (error$1) {
+				tracker.getterState.currentlyAccessing.delete(prop);
+				throw error$1;
+			} finally {
+				context.tracker = prevContext.tracker;
+				context.currentBloc = prevContext.currentBloc;
+				context.depth = prevContext.depth;
+				context.visitedBlocs = prevContext.visitedBlocs;
+			}
+		}
+		return value;
+	} });
+}
+
+//#endregion
+//#region src/tracking/dependency-manager.ts
+/**
+* Manages subscriptions to state container dependencies.
+* Provides efficient sync mechanism to add/remove subscriptions
+* as dependencies change between callback invocations.
+*/
+var DependencyManager = class {
+	constructor() {
+		this.subscriptions = /* @__PURE__ */ new Map();
+		this.currentDeps = /* @__PURE__ */ new Set();
+	}
+	/**
+	* Sync subscriptions with a new set of dependencies.
+	* Adds subscriptions for new deps, removes subscriptions for stale deps.
+	*
+	* @param newDeps - The new set of dependencies to subscribe to
+	* @param onChange - Callback to invoke when any dependency changes
+	* @param exclude - Optional instance to exclude from subscriptions (e.g., primary bloc)
+	* @returns true if the dependency set changed, false if unchanged
+	*/
+	sync(newDeps, onChange, exclude) {
+		const filteredNewDeps = /* @__PURE__ */ new Set();
+		for (const dep of newDeps) if (dep !== exclude && !dep.isDisposed) filteredNewDeps.add(dep);
+		if (this.areSetsEqual(this.currentDeps, filteredNewDeps)) return false;
+		for (const dep of this.currentDeps) if (!filteredNewDeps.has(dep)) {
+			const unsub = this.subscriptions.get(dep);
+			if (unsub) {
+				unsub();
+				this.subscriptions.delete(dep);
+			}
+		}
+		for (const dep of filteredNewDeps) if (!this.currentDeps.has(dep) && !this.subscriptions.has(dep)) {
+			const unsub = dep.subscribe(onChange);
+			this.subscriptions.set(dep, unsub);
+		}
+		this.currentDeps = filteredNewDeps;
+		return true;
+	}
+	/**
+	* Add a single dependency subscription.
+	*/
+	add(dep, onChange) {
+		if (this.subscriptions.has(dep) || dep.isDisposed) return;
+		const unsub = dep.subscribe(onChange);
+		this.subscriptions.set(dep, unsub);
+		this.currentDeps.add(dep);
+	}
+	/**
+	* Check if a dependency is currently subscribed.
+	*/
+	has(dep) {
+		return this.currentDeps.has(dep);
+	}
+	/**
+	* Get the current set of dependencies.
+	*/
+	getDependencies() {
+		return new Set(this.currentDeps);
+	}
+	/**
+	* Clean up all active subscriptions.
+	*/
+	cleanup() {
+		for (const unsub of this.subscriptions.values()) unsub();
+		this.subscriptions.clear();
+		this.currentDeps.clear();
+	}
+	areSetsEqual(a, b) {
+		if (a.size !== b.size) return false;
+		for (const item of a) if (!b.has(item)) return false;
+		return true;
+	}
+};
+
+//#endregion
+//#region src/tracking/tracked.ts
+/**
+* Run a callback while tracking all bloc dependencies accessed.
+* Returns both the result and the set of discovered dependencies.
+*
+* @example
+* ```ts
+* const { result, dependencies } = tracked(() => {
+*   const user = ensure(UserBloc);
+*   return user.fullName; // getter that may access other blocs
+* });
+* // dependencies contains UserBloc + any blocs accessed in fullName getter
+* ```
+*/
+function tracked(callback, options) {
+	const tracker = createState();
+	startTracking(tracker);
+	let result;
+	try {
+		result = callback();
+	} finally {
+		stopTracking(tracker, { state: null });
+	}
+	const dependencies = new Set(tracker.dependencies);
+	for (const dep of tracker.getterState.externalDependencies) dependencies.add(dep);
+	if (options?.exclude) dependencies.delete(options.exclude);
+	return {
+		result,
+		dependencies
+	};
+}
+/**
+* Context for running tracked callbacks with bloc proxies.
+* Provides methods to create proxies and check for changes.
+*/
+var TrackedContext = class {
+	constructor() {
+		this.proxiedBlocs = /* @__PURE__ */ new WeakMap();
+		this.primaryBlocs = /* @__PURE__ */ new Set();
+		this.tracker = createState();
+	}
+	/**
+	* Get a tracking proxy for a bloc instance.
+	* The proxy will track state and getter accesses.
+	*/
+	proxy(bloc) {
+		const cached = this.proxiedBlocs.get(bloc);
+		if (cached) return cached;
+		const proxied = createTrackingProxy(bloc, this.tracker);
+		this.proxiedBlocs.set(bloc, proxied);
+		this.primaryBlocs.add(bloc);
+		return proxied;
+	}
+	/**
+	* Start tracking for a new callback execution.
+	*/
+	start() {
+		startTracking(this.tracker);
+	}
+	/**
+	* Stop tracking and get discovered dependencies.
+	* Excludes primary blocs (those explicitly proxied via proxy()).
+	*/
+	stop() {
+		const allDeps = /* @__PURE__ */ new Set();
+		for (const bloc of this.primaryBlocs) {
+			const deps = stopTracking(this.tracker, bloc);
+			for (const dep of deps) if (!this.primaryBlocs.has(dep)) allDeps.add(dep);
+		}
+		for (const dep of this.tracker.getterState.externalDependencies) if (!this.primaryBlocs.has(dep)) allDeps.add(dep);
+		return allDeps;
+	}
+	/**
+	* Check if any tracked state or getters have changed.
+	*/
+	changed() {
+		for (const bloc of this.primaryBlocs) if (hasChanges(this.tracker, bloc)) return true;
+		return false;
+	}
+	/**
+	* Get all primary blocs (those explicitly proxied).
+	*/
+	getPrimaryBlocs() {
+		return new Set(this.primaryBlocs);
+	}
+	/**
+	* Reset the context for reuse.
+	*/
+	reset() {
+		this.tracker = createState();
+		this.proxiedBlocs = /* @__PURE__ */ new WeakMap();
+		this.primaryBlocs.clear();
+	}
+};
+/**
+* Create a new tracked context for manual control over tracking.
+*/
+function createTrackedContext() {
+	return new TrackedContext();
+}
+
+//#endregion
+//#region src/adapter/framework-adapter.ts
+/**
+* Manages subscriptions to external bloc dependencies for getter tracking.
+* When a getter accesses another bloc's state, this manager ensures
+* re-renders occur when those external dependencies change.
+*
+* @deprecated Use DependencyManager from tracking module instead.
+* This class is kept for backward compatibility.
+*/
+var ExternalDepsManager = class {
+	constructor() {
+		this.manager = new DependencyManager();
+	}
+	/**
+	* Update subscriptions to external bloc dependencies.
+	* Creates subscriptions to blocs accessed via getters.
+	* @param getterTracker - The getter tracker state with external dependencies
+	* @param rawInstance - The primary bloc instance (excluded from subscriptions)
+	* @param onGetterChange - Callback to invoke when external dependency changes
+	* @returns true if subscriptions were updated, false if unchanged
+	*/
+	updateSubscriptions(getterState, rawInstance, onGetterChange) {
+		if (!getterState?.externalDependencies) return false;
+		const currentDeps = getterState.externalDependencies;
+		const onExternalChange = () => {
+			invalidateRenderCache(getterState);
+			if (hasGetterChanges(rawInstance, getterState)) onGetterChange();
+		};
+		const changed = this.manager.sync(currentDeps, onExternalChange, rawInstance);
+		clearExternalDependencies(getterState);
+		return changed;
+	}
+	/**
+	* Clean up all active subscriptions
+	*/
+	cleanup() {
+		this.manager.cleanup();
+	}
+};
+/**
+* Create a subscribe function for auto-tracking mode.
+* Only triggers callback when tracked properties change.
+* @param instance - The state container instance
+* @param adapterState - The adapter state for tracking
+* @returns Subscribe function for use with useSyncExternalStore
+*/
+function autoTrackSubscribe(instance$1, adapterState) {
+	return (callback) => {
+		return instance$1.subscribe(() => {
+			const depState = adapterState.dependencyState || (adapterState.dependencyState = createDependencyState());
+			const hasStateDeps = depState.pathCache && depState.pathCache.size > 0;
+			const hasGetterDeps = adapterState.getterState && adapterState.getterState.trackedGetters.size > 0;
+			const isPrimitiveState = instance$1.state !== null && typeof instance$1.state !== "object" && typeof instance$1.state !== "function";
+			if (!hasStateDeps && !hasGetterDeps && !isPrimitiveState) return;
+			let stateChanged = hasDependencyChanges(depState, instance$1.state);
+			if (!hasStateDeps && hasGetterDeps) stateChanged = false;
+			if (stateChanged) {
+				callback();
+				return;
+			}
+			if (hasGetterChanges(instance$1, adapterState.getterState)) callback();
+		});
+	};
+}
+/**
+* Create a subscribe function for manual dependency tracking mode.
+* Only triggers callback when dependencies array changes.
+* @param instance - The state container instance
+* @param adapterState - The adapter state for caching
+* @param config - Configuration with dependencies function
+* @returns Subscribe function for use with useSyncExternalStore
+*/
+function manualDepsSubscribe(instance$1, adapterState, config) {
+	return (callback) => {
+		return instance$1.subscribe(() => {
+			const newDeps = config.dependencies(instance$1.state, instance$1);
+			if (!adapterState.manualDepsCache || !shallowEqual(adapterState.manualDepsCache, newDeps)) {
+				adapterState.manualDepsCache = newDeps;
+				callback();
+			}
+		});
+	};
+}
+/**
+* Create a subscribe function for no-tracking mode.
+* Triggers callback on every state change.
+* @param instance - The state container instance
+* @returns Subscribe function for use with useSyncExternalStore
+*/
+function noTrackSubscribe(instance$1) {
+	return (callback) => instance$1.subscribe(callback);
+}
+/**
+* Create a snapshot function for auto-tracking mode.
+* Returns a proxied state that tracks property access.
+* @param instance - The state container instance
+* @param adapterState - The adapter state for tracking
+* @returns Snapshot function for use with useSyncExternalStore
+*/
+function autoTrackSnapshot(instance$1, adapterState) {
+	return () => {
+		const depState = adapterState.dependencyState || (adapterState.dependencyState = createDependencyState());
+		if (hasTrackedData(depState)) capturePaths(depState, instance$1.state);
+		if (adapterState.getterState) {
+			invalidateRenderCache(adapterState.getterState);
+			commitTrackedGetters(adapterState.getterState);
+			adapterState.getterState.isTracking = true;
+			setActiveTracker(instance$1, adapterState.getterState);
+		}
+		startDependency(depState);
+		return createDependencyProxy(depState, instance$1.state);
+	};
+}
+/**
+* Create a snapshot function for manual dependency tracking mode.
+* Caches dependencies for comparison on next render.
+* @param instance - The state container instance
+* @param adapterState - The adapter state for caching
+* @param config - Configuration with dependencies function
+* @returns Snapshot function for use with useSyncExternalStore
+*/
+function manualDepsSnapshot(instance$1, adapterState, config) {
+	return () => {
+		adapterState.manualDepsCache = config.dependencies(instance$1.state, instance$1);
+		return instance$1.state;
+	};
+}
+/**
+* Create a snapshot function for no-tracking mode.
+* Returns the raw state directly.
+* @param instance - The state container instance
+* @returns Snapshot function for use with useSyncExternalStore
+*/
+function noTrackSnapshot(instance$1) {
+	return () => instance$1.state;
+}
+/**
+* Initialize adapter state for auto-tracking mode.
+* Creates getter tracker and proxied bloc instance.
+* @param instance - The state container instance
+* @returns Initialized adapter state
+*/
+function autoTrackInit(instance$1) {
+	return {
+		dependencyState: null,
+		manualDepsCache: null,
+		getterState: createGetterState(),
+		proxiedBloc: createBlocProxy(instance$1)
+	};
+}
+/**
+* Initialize adapter state for manual dependency tracking mode.
+* No proxy is created; bloc is used directly.
+* @param instance - The state container instance
+* @returns Initialized adapter state
+*/
+function manualDepsInit(instance$1) {
+	return {
+		dependencyState: null,
+		manualDepsCache: null,
+		getterState: null,
+		proxiedBloc: instance$1
+	};
+}
+/**
+* Initialize adapter state for no-tracking mode.
+* No tracking or proxy is created.
+* @param instance - The state container instance
+* @returns Initialized adapter state
+*/
+function noTrackInit(instance$1) {
+	return {
+		dependencyState: null,
+		manualDepsCache: null,
+		getterState: null,
+		proxiedBloc: instance$1
+	};
+}
+/**
+* Disable getter tracking after render phase completes.
+* Clears the active tracker to prevent tracking outside of render.
+* @param adapterState - The adapter state
+* @param rawInstance - The raw bloc instance
+*/
+function disableGetterTracking(adapterState, rawInstance) {
+	if (adapterState.getterState) {
+		adapterState.getterState.isTracking = false;
+		clearActiveTracker(rawInstance);
+	}
+}
+
+//#endregion
+//#region src/logging/Logger.ts
+/**
+* Log severity levels (lower number = higher severity)
+*/
+let LogLevel = /* @__PURE__ */ function(LogLevel$1) {
+	/** Critical errors that may cause application failure */
+	LogLevel$1[LogLevel$1["ERROR"] = 0] = "ERROR";
+	/** Warning conditions that should be addressed */
+	LogLevel$1[LogLevel$1["WARN"] = 1] = "WARN";
+	/** Informational messages about application state */
+	LogLevel$1[LogLevel$1["INFO"] = 2] = "INFO";
+	/** Detailed debugging information */
+	LogLevel$1[LogLevel$1["DEBUG"] = 3] = "DEBUG";
+	return LogLevel$1;
+}({});
+/**
+* Creates a logger instance with given configuration
+*
+* @param config - Logger configuration
+* @returns Logger instance with debug, info, warn, error, and configure methods
+*
+* @example
+* ```ts
+* const logger = createLogger({
+*   enabled: true,
+*   level: LogLevel.DEBUG,
+*   output: (entry) => console.log(JSON.stringify(entry))
+* });
+* logger.debug('MyComponent', 'Rendering', { props: { foo: 'bar' } });
+* ```
+*/
+function createLogger(config) {
+	const shouldLog = (level) => {
+		return config.enabled && config.level >= level;
+	};
+	const log = (level, context, message, data) => {
+		try {
+			const entry = {
+				level,
+				context,
+				message,
+				timestamp: Date.now(),
+				...data !== void 0 && { data: serialize(data) }
+			};
+			config.output(entry);
+		} catch (e) {
+			console.error("[BlacLogger] Error logging:", e);
+		}
+	};
+	const serialize = (data) => {
+		try {
+			return JSON.parse(JSON.stringify(data));
+		} catch {
+			return String(data);
+		}
+	};
+	return {
+		debug: (context, message, data) => {
+			if (shouldLog(LogLevel.DEBUG)) log("DEBUG", context, message, data);
+		},
+		info: (context, message, data) => {
+			if (shouldLog(LogLevel.INFO)) log("INFO", context, message, data);
+		},
+		warn: (context, message, data) => {
+			if (shouldLog(LogLevel.WARN)) log("WARN", context, message, data);
+		},
+		error: (context, message, data) => {
+			if (shouldLog(LogLevel.ERROR)) log("ERROR", context, message, data);
+		},
+		configure: (opts) => {
+			Object.assign(config, opts);
+		}
+	};
+}
+let currentConfig = {
+	enabled: false,
+	level: LogLevel.INFO,
+	output: (entry) => console.log(JSON.stringify(entry))
+};
+let defaultLogger = createLogger(currentConfig);
+/**
+* Log a debug message (tree-shakeable export)
+* @param context - Context identifier (module or component name)
+* @param message - Log message
+* @param data - Optional structured data
+*/
+const debug = (context, message, data) => defaultLogger.debug(context, message, data);
+/**
+* Log an info message (tree-shakeable export)
+* @param context - Context identifier (module or component name)
+* @param message - Log message
+* @param data - Optional structured data
+*/
+const info = (context, message, data) => defaultLogger.info(context, message, data);
+/**
+* Log a warning message (tree-shakeable export)
+* @param context - Context identifier (module or component name)
+* @param message - Log message
+* @param data - Optional structured data
+*/
+const warn = (context, message, data) => defaultLogger.warn(context, message, data);
+/**
+* Log an error message (tree-shakeable export)
+* @param context - Context identifier (module or component name)
+* @param message - Log message
+* @param data - Optional structured data
+*/
+const error = (context, message, data) => defaultLogger.error(context, message, data);
+/**
+* Configuration function that recreates the default logger
+*
+* @param opts - Partial logger configuration
+*
+* @example
+* ```ts
+* configureLogger({ enabled: true, level: LogLevel.DEBUG });
+* ```
+*/
+function configureLogger(opts) {
+	currentConfig = {
+		...currentConfig,
+		...opts
+	};
+	defaultLogger = createLogger(currentConfig);
+}
+
+//#endregion
+//#region src/config.ts
+const defaultConfig = {
+	devMode: process.env.NODE_ENV !== "production",
+	logger: {
+		enabled: false,
+		level: LogLevel.INFO
+	}
+};
+let globalConfig = { ...defaultConfig };
+/**
+* Configure global defaults for @blac/core.
+*
+* @example
+* ```ts
+* import { configureBlac, LogLevel } from '@blac/core';
+*
+* configureBlac({
+*   devMode: true,
+*   logger: {
+*     enabled: true,
+*     level: LogLevel.DEBUG
+*   }
+* });
+* ```
+*
+* @param config - Partial configuration to merge with defaults
+*/
+function configureBlac(config) {
+	globalConfig = {
+		...globalConfig,
+		...config,
+		logger: {
+			...globalConfig.logger,
+			...config.logger
+		}
+	};
+	if (config.logger) configureLogger(config.logger);
+}
+/**
+* Get the current global configuration.
+* @internal
+*/
+function getBlacConfig() {
+	return globalConfig;
+}
+/**
+* Check if development mode is enabled.
+*/
+function isDevMode() {
+	return globalConfig.devMode;
+}
+/**
+* Reset configuration to defaults (useful for testing).
+* @internal
+*/
+function resetBlacConfig() {
+	globalConfig = { ...defaultConfig };
+	configureLogger(defaultConfig.logger);
+}
+
+//#endregion
+//#region src/decorators/blac.ts
+/**
+* Decorator to configure StateContainer classes.
+*
+* @example Decorator syntax (requires experimentalDecorators or TC39 decorators)
+* ```ts
+* @blac({ isolated: true })
+* class FormBloc extends Cubit<FormState> {}
+*
+* @blac({ keepAlive: true })
+* class AuthBloc extends Cubit<AuthState> {}
+*
+* @blac({ excludeFromDevTools: true })
+* class InternalBloc extends Cubit<InternalState> {}
+* ```
+*
+* @example Function syntax (no decorator support needed)
+* ```ts
+* const FormBloc = blac({ isolated: true })(
+*   class extends Cubit<FormState> {}
+* );
+* ```
+*/
+function blac(options) {
+	return function(target, _context) {
+		if ("isolated" in options && options.isolated) target[BLAC_STATIC_PROPS.ISOLATED] = true;
+		if ("keepAlive" in options && options.keepAlive) target[BLAC_STATIC_PROPS.KEEP_ALIVE] = true;
+		if ("excludeFromDevTools" in options && options.excludeFromDevTools) target[BLAC_STATIC_PROPS.EXCLUDE_FROM_DEVTOOLS] = true;
+		return target;
+	};
+}
+
+//#endregion
+//#region src/registry/acquire.ts
+function acquire(BlocClass, instanceKey, options) {
+	return globalRegistry.acquire(BlocClass, instanceKey, {
+		canCreate: true,
+		countRef: true,
+		props: options?.props
+	});
+}
+
+//#endregion
+//#region src/registry/borrow.ts
+function borrow(BlocClass, instanceKey) {
+	return globalRegistry.borrow(BlocClass, instanceKey);
+}
+function borrowSafe(BlocClass, instanceKey) {
+	return globalRegistry.borrowSafe(BlocClass, instanceKey);
+}
+
+//#endregion
+//#region src/registry/ensure.ts
+function ensure(BlocClass, instanceKey) {
+	return globalRegistry.ensure(BlocClass, instanceKey);
+}
+
+//#endregion
+//#region src/registry/release.ts
+function release(BlocClass, instanceKey, forceDispose = false) {
+	globalRegistry.release(BlocClass, instanceKey, forceDispose);
+}
+
+//#endregion
+//#region src/registry/queries.ts
+function hasInstance(BlocClass, instanceKey) {
+	return globalRegistry.hasInstance(BlocClass, instanceKey);
+}
+function getRefCount(BlocClass, instanceKey) {
+	return globalRegistry.getRefCount(BlocClass, instanceKey);
+}
+function getAll(BlocClass) {
+	return globalRegistry.getAll(BlocClass);
+}
+function forEach(BlocClass, callback) {
+	globalRegistry.forEach(BlocClass, callback);
+}
+
+//#endregion
+//#region src/registry/management.ts
+function clear(BlocClass) {
+	globalRegistry.clear(BlocClass);
+}
+function clearAll() {
+	globalRegistry.clearAll();
+}
+function register(BlocClass, isolated = false) {
+	globalRegistry.register(BlocClass, isolated);
+}
+
+//#endregion
+//#region src/registry/config.ts
+let _registry = globalRegistry;
+function getRegistry() {
+	return _registry;
+}
+function setRegistry(registry) {
+	_registry.clearAll();
+	_registry = registry;
+}
+function getStats() {
+	return _registry.getStats();
+}
+
+//#endregion
+//#region src/waitUntil/errors.ts
+var WaitUntilTimeoutError = class extends Error {
+	constructor(timeout) {
+		super(`waitUntil timed out after ${timeout}ms`);
+		this.name = "WaitUntilTimeoutError";
+	}
+};
+var WaitUntilAbortedError = class extends Error {
+	constructor() {
+		super("waitUntil was aborted");
+		this.name = "WaitUntilAbortedError";
+	}
+};
+var WaitUntilDisposedError = class extends Error {
+	constructor(blocName) {
+		super(`waitUntil failed: ${blocName} was disposed while waiting`);
+		this.name = "WaitUntilDisposedError";
+	}
+};
+
+//#endregion
+//#region src/waitUntil/waitUntil.ts
+function waitUntil(BlocClass, selectorOrPredicate, predicateOrOptions, maybeOptions) {
+	if (typeof predicateOrOptions !== "function") return waitUntilSimple(BlocClass, selectorOrPredicate, predicateOrOptions);
+	else return waitUntilSelector(BlocClass, selectorOrPredicate, predicateOrOptions, maybeOptions);
+}
+function waitUntilSimple(BlocClass, predicate, options) {
+	const { instanceId = BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY, timeout, signal } = options ?? {};
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(new WaitUntilAbortedError());
+			return;
+		}
+		const bloc = ensure(BlocClass, instanceId);
+		if (bloc.isDisposed) {
+			reject(new WaitUntilDisposedError(BlocClass.name));
+			return;
+		}
+		const tracker = createState();
+		const proxiedBloc = createTrackingProxy(bloc, tracker);
+		const externalDepsManager = new DependencyManager();
+		const runPredicate = () => {
+			startTracking(tracker);
+			try {
+				return predicate(proxiedBloc);
+			} finally {
+				const deps = stopTracking(tracker, bloc);
+				for (const dep of tracker.getterState.externalDependencies) deps.add(dep);
+				deps.delete(bloc);
+				externalDepsManager.sync(deps, checkCondition, bloc);
+			}
+		};
+		if (runPredicate()) {
+			resolve(bloc);
+			return;
+		}
+		let unsubscribe = null;
+		let unsubscribeDispose = null;
+		let timeoutId = null;
+		let abortHandler = null;
+		const cleanup = () => {
+			unsubscribe?.();
+			unsubscribeDispose?.();
+			externalDepsManager.cleanup();
+			if (timeoutId) clearTimeout(timeoutId);
+			if (abortHandler && signal) signal.removeEventListener("abort", abortHandler);
+		};
+		function checkCondition() {
+			try {
+				if (runPredicate()) {
+					cleanup();
+					resolve(bloc);
+				}
+			} catch (error$1) {
+				cleanup();
+				reject(error$1);
+			}
+		}
+		unsubscribe = bloc.subscribe(checkCondition);
+		unsubscribeDispose = getRegistry().on("disposed", (instance$1) => {
+			if (instance$1 === bloc) {
+				cleanup();
+				reject(new WaitUntilDisposedError(BlocClass.name));
+			}
+		});
+		if (timeout !== void 0) timeoutId = setTimeout(() => {
+			cleanup();
+			reject(new WaitUntilTimeoutError(timeout));
+		}, timeout);
+		if (signal) {
+			abortHandler = () => {
+				cleanup();
+				reject(new WaitUntilAbortedError());
+			};
+			signal.addEventListener("abort", abortHandler);
+		}
+	});
+}
+function waitUntilSelector(BlocClass, selector, predicate, options) {
+	const { instanceId = BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY, timeout, signal } = options ?? {};
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(new WaitUntilAbortedError());
+			return;
+		}
+		const bloc = ensure(BlocClass, instanceId);
+		if (bloc.isDisposed) {
+			reject(new WaitUntilDisposedError(BlocClass.name));
+			return;
+		}
+		const tracker = createState();
+		const proxiedBloc = createTrackingProxy(bloc, tracker);
+		const externalDepsManager = new DependencyManager();
+		const runSelector = () => {
+			startTracking(tracker);
+			try {
+				const value = selector(proxiedBloc);
+				return {
+					value,
+					matches: predicate(value)
+				};
+			} finally {
+				const deps = stopTracking(tracker, bloc);
+				for (const dep of tracker.getterState.externalDependencies) deps.add(dep);
+				deps.delete(bloc);
+				externalDepsManager.sync(deps, checkCondition, bloc);
+			}
+		};
+		const initial = runSelector();
+		if (initial.matches) {
+			resolve(initial.value);
+			return;
+		}
+		let unsubscribe = null;
+		let unsubscribeDispose = null;
+		let timeoutId = null;
+		let abortHandler = null;
+		const cleanup = () => {
+			unsubscribe?.();
+			unsubscribeDispose?.();
+			externalDepsManager.cleanup();
+			if (timeoutId) clearTimeout(timeoutId);
+			if (abortHandler && signal) signal.removeEventListener("abort", abortHandler);
+		};
+		function checkCondition() {
+			try {
+				const result = runSelector();
+				if (result.matches) {
+					cleanup();
+					resolve(result.value);
+				}
+			} catch (error$1) {
+				cleanup();
+				reject(error$1);
+			}
+		}
+		unsubscribe = bloc.subscribe(checkCondition);
+		unsubscribeDispose = getRegistry().on("disposed", (instance$1) => {
+			if (instance$1 === bloc) {
+				cleanup();
+				reject(new WaitUntilDisposedError(BlocClass.name));
+			}
+		});
+		if (timeout !== void 0) timeoutId = setTimeout(() => {
+			cleanup();
+			reject(new WaitUntilTimeoutError(timeout));
+		}, timeout);
+		if (signal) {
+			abortHandler = () => {
+				cleanup();
+				reject(new WaitUntilAbortedError());
+			};
+			signal.addEventListener("abort", abortHandler);
+		}
+	});
+}
+
+//#endregion
+//#region src/watch/watch.ts
+const STOP = Symbol("watch.STOP");
+const BLOC_REF_MARKER = Symbol("BlocRef");
+/**
+* Create a reference to a specific bloc instance.
+*
+* @example
+* ```ts
+* watch(instance(UserBloc, 'user-123'), (userBloc) => {
+*   console.log(userBloc.state.name);
+* });
+* ```
+*/
+function instance(BlocClass, instanceId) {
+	return {
+		[BLOC_REF_MARKER]: true,
+		blocClass: BlocClass,
+		instanceId
+	};
+}
+function isBlocRef(input) {
+	return typeof input === "object" && input !== null && BLOC_REF_MARKER in input;
+}
+function resolveBloc(input) {
+	if (isBlocRef(input)) return ensure(input.blocClass, input.instanceId);
+	return ensure(input, BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY);
+}
+function isArray(input) {
+	return Array.isArray(input);
+}
+function watchImpl(blocsOrBloc, callback) {
+	const isSingle = !isArray(blocsOrBloc);
+	const instances = (isSingle ? [blocsOrBloc] : blocsOrBloc).map(resolveBloc);
+	const tracker = createState();
+	const proxiedInstances = instances.map((inst) => createTrackingProxy(inst, tracker));
+	const externalDepsManager = new DependencyManager();
+	let disposed = false;
+	const primarySubscriptions = [];
+	const cleanup = () => {
+		if (disposed) return;
+		disposed = true;
+		primarySubscriptions.forEach((unsub) => unsub());
+		externalDepsManager.cleanup();
+	};
+	const runCallback = () => {
+		if (disposed) return;
+		startTracking(tracker);
+		let result;
+		try {
+			result = callback(isSingle ? proxiedInstances[0] : proxiedInstances);
+		} finally {
+			const externalDeps = /* @__PURE__ */ new Set();
+			for (const inst of instances) {
+				const deps = stopTracking(tracker, inst);
+				for (const dep of deps) externalDeps.add(dep);
+			}
+			for (const dep of tracker.getterState.externalDependencies) externalDeps.add(dep);
+			for (const inst of instances) externalDeps.delete(inst);
+			externalDepsManager.sync(externalDeps, runCallback);
+		}
+		if (result === STOP) cleanup();
+	};
+	const onChange = () => {
+		if (disposed) return;
+		runCallback();
+	};
+	for (const inst of instances) primarySubscriptions.push(inst.subscribe(onChange));
+	runCallback();
+	return cleanup;
+}
+const watch = Object.assign(watchImpl, { STOP });
+
+//#endregion
+export { BLAC_DEFAULTS, BLAC_ERROR_PREFIX, BLAC_ID_PATTERNS, BLAC_STATIC_PROPS, Cubit, DependencyManager, ExternalDepsManager, LogLevel, PluginManager, STATELESS_MARKER, StateContainer, StateContainerRegistry, StatelessCubit, StatelessVertex, TrackedContext, Vertex, WaitUntilAbortedError, WaitUntilDisposedError, WaitUntilTimeoutError, __resetIdCounters, acquire, autoTrackInit, autoTrackSnapshot, autoTrackSubscribe, blac, borrow, borrowSafe, capturePaths, clear, clearActiveTracker, clearAll, clearExternalDependencies, commitTrackedGetters, configureBlac, configureLogger, createArrayProxy, createBlocProxy, createDependencyProxy, createDependencyState, createForTarget, createGetterState, createIdGenerator, createInternal, createLogger, createPluginManager, createProxyState, createTrackedContext, createTrackingProxy, createState as createTrackingProxyState, debug, disableGetterTracking, ensure, error, forEach, generateId, generateIsolatedKey, generateSimpleId, getActiveTracker, getAll, getBlacConfig, getDescriptor, getGetterExecutionContext, getPluginManager, getRefCount, getRegistry, getStaticProp, getStats, getValueAtPath, globalRegistry, hasDependencyChanges, hasGetterChanges, hasInitHook, hasInstance, hasTrackedData, hasChanges as hasTrackingProxyChanges, info, instance, invalidateRenderCache, isDevMode, isExcludedFromDevTools, isGetter, isIsolatedClass, isIsolatedKey, isKeepAliveClass, isProxyable, isStatelessClass, manualDepsInit, manualDepsSnapshot, manualDepsSubscribe, noTrackInit, noTrackSnapshot, noTrackSubscribe, parsePath, register, release, resetBlacConfig, resetGetterState, setActiveTracker, setRegistry, shallowEqual, startDependency, startProxy, startTracking as startTrackingProxy, stopProxy, stopTracking as stopTrackingProxy, tracked, waitUntil, warn, watch };
+//# sourceMappingURL=index.js.map