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

package/dist/index.js

@@ -1,38 +1,2029 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./Blac"), exports);
-__exportStar(require("./Bloc"), exports);
-__exportStar(require("./BlocBase"), exports);
-__exportStar(require("./Cubit"), exports);
-__exportStar(require("./types"), exports);
-__exportStar(require("./events"), exports);
-__exportStar(require("./subscription"), exports);
-__exportStar(require("./lifecycle"), exports);
-// Utilities
-__exportStar(require("./utils/uuid"), exports);
-__exportStar(require("./utils/shallowEqual"), exports);
-__exportStar(require("./utils/generateInstanceId"), exports);
-__exportStar(require("./utils/RerenderLogger"), exports);
-// Test utilities
-__exportStar(require("./testing"), exports);
-// Adapter
-__exportStar(require("./adapter"), exports);
-// Plugins
-__exportStar(require("./plugins"), exports);
-// Error handling
-__exportStar(require("./errors"), exports);
+//#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) => {
+			this.notifyPlugins("onInstanceCreated", instance);
+		});
+		this.registry.on("stateChanged", (instance, previousState, currentState, callstack) => {
+			this.notifyPlugins("onStateChanged", instance, previousState, currentState, callstack);
+		});
+		this.registry.on("eventAdded", (vertex, event) => {
+			this.notifyPlugins("onEventAdded", vertex, event);
+		});
+		this.registry.on("disposed", (instance) => {
+			this.notifyPlugins("onInstanceDisposed", instance);
+		});
+	}
+	/**
+	* Notify all plugins of a lifecycle event
+	*/
+	notifyPlugins(hookName, ...args) {
+		for (const { plugin, config, context } of this.plugins.values()) {
+			if (!config.enabled) continue;
+			const hook = plugin[hookName];
+			if (typeof hook === "function") try {
+				hook.apply(plugin, [...args, context]);
+			} catch (error$1) {
+				console.error(`[BlaC] Error in plugin "${plugin.name}" ${hookName}:`, error$1);
+			}
+		}
+	}
+	/**
+	* Create plugin context with safe API access
+	*/
+	createPluginContext() {
+		return {
+			getInstanceMetadata: (instance) => {
+				return {
+					id: instance.instanceId,
+					className: instance.constructor.name,
+					isDisposed: instance.isDisposed,
+					name: instance.name,
+					lastStateChangeTimestamp: instance.lastUpdateTimestamp,
+					createdAt: instance.createdAt,
+					state: instance.state,
+					isIsolated: instance.instanceId.startsWith("isolated-")
+				};
+			},
+			getState: (instance) => {
+				return instance.state;
+			},
+			queryInstances: (typeClass) => {
+				return typeClass.getAll();
+			},
+			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
+*/
+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 = 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 createGetterTracker() {
+	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) {
+				console.warn(`${BLAC_ERROR_PREFIX} Maximum getter depth (${MAX_GETTER_DEPTH}) 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 resetGetterTracker(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/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
+*/
+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
+*/
+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
+*/
+function isExcludedFromDevTools(Type) {
+	return getStaticProp(Type, BLAC_STATIC_PROPS.EXCLUDE_FROM_DEVTOOLS) === 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.resolve(MyBloc);
+* 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();
+	}
+	/**
+	* Resolve an instance with ref counting (ownership semantics)
+	*/
+	resolve(Type, instanceKey = BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY, constructorArgs) {
+		const registryConfig = this.typeConfigs.get(Type.name);
+		const isolated = isIsolatedClass(Type) || registryConfig?.isolated === true;
+		const config = { instanceId: instanceKey };
+		if (isolated) {
+			const instance$1 = new Type(constructorArgs);
+			instance$1.initConfig(config);
+			this.registerType(Type);
+			return instance$1;
+		}
+		const instances = this.ensureInstancesMap(Type);
+		const entry = instances.get(instanceKey);
+		if (entry) {
+			entry.refCount++;
+			return entry.instance;
+		}
+		const instance = new Type(constructorArgs);
+		instance.initConfig(config);
+		instances.set(instanceKey, {
+			instance,
+			refCount: 1
+		});
+		this.registerType(Type);
+		return instance;
+	}
+	/**
+	* Get an existing instance without ref counting (borrowing semantics)
+	* @throws Error if instance doesn't exist
+	*/
+	get(Type, instanceKey = BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY) {
+		const entry = this.ensureInstancesMap(Type).get(instanceKey);
+		if (!entry) throw new Error(`${BLAC_ERROR_PREFIX} ${Type.name} instance "${instanceKey}" not found.\nUse .resolve() to create and claim ownership, or .getSafe() for conditional access.`);
+		const context = getGetterExecutionContext();
+		if (context.tracker && context.currentBloc && context.currentBloc !== entry.instance) context.tracker.externalDependencies.add(entry.instance);
+		return entry.instance;
+	}
+	/**
+	* Safely get an existing instance (borrowing semantics with error handling)
+	* Returns discriminated union for type-safe conditional access
+	*/
+	getSafe(Type, instanceKey = BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY) {
+		const entry = this.ensureInstancesMap(Type).get(instanceKey);
+		if (!entry) return {
+			error: /* @__PURE__ */ new Error(`${BLAC_ERROR_PREFIX} ${Type.name} instance "${instanceKey}" not found`),
+			instance: null
+		};
+		const context = getGetterExecutionContext();
+		if (context.tracker && context.currentBloc && context.currentBloc !== entry.instance) context.tracker.externalDependencies.add(entry.instance);
+		return {
+			error: null,
+			instance: entry.instance
+		};
+	}
+	/**
+	* Connect to an instance with borrowing semantics (for B2B 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 bloc class constructor
+	* @param instanceKey - Optional instance key (defaults to 'default')
+	* @param constructorArgs - Constructor arguments (only used if creating new instance)
+	* @returns The bloc instance
+	*/
+	connect(Type, instanceKey = BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY, constructorArgs) {
+		const registryConfig = this.typeConfigs.get(Type.name);
+		if (isIsolatedClass(Type) || registryConfig?.isolated === true) throw new Error(`${BLAC_ERROR_PREFIX} Cannot use .connect() with isolated bloc "${Type.name}".\nIsolated blocs are component-scoped. Use .resolve() in components instead.`);
+		const instances = this.ensureInstancesMap(Type);
+		let entry = instances.get(instanceKey);
+		if (!entry) {
+			const instance = new Type(constructorArgs);
+			const config = { instanceId: instanceKey };
+			instance.initConfig(config);
+			entry = {
+				instance,
+				refCount: 1
+			};
+			instances.set(instanceKey, entry);
+			this.registerType(Type);
+		}
+		const context = getGetterExecutionContext();
+		if (context.tracker && context.currentBloc && context.currentBloc !== entry.instance) context.tracker.externalDependencies.add(entry.instance);
+		return entry.instance;
+	}
+	/**
+	* Release a reference to an instance
+	*/
+	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
+	*/
+	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
+	*/
+	forEach(Type, callback) {
+		const instances = this.ensureInstancesMap(Type);
+		for (const entry of instances.values()) {
+			const instance = entry.instance;
+			if (!instance.isDisposed) try {
+				callback(instance);
+			} catch (error$1) {
+				console.error(`${BLAC_ERROR_PREFIX} forEach callback error for ${Type.name}:`, error$1);
+			}
+		}
+	}
+	/**
+	* Clear all instances of a specific type
+	*/
+	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
+	*/
+	getRefCount(Type, instanceKey = BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY) {
+		return this.ensureInstancesMap(Type).get(instanceKey)?.refCount ?? 0;
+	}
+	/**
+	* Check if an 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)
+	*/
+	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)
+	*/
+	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());
+		this.listeners.get(event).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<number> {
+*   constructor() {
+*     super(0);
+*   }
+*   increment() {
+*     this.emit(this.state + 1);
+*   }
+* }
+* ```
+*/
+var StateContainer = class StateContainer {
+	static {
+		this.__excludeFromDevTools = false;
+	}
+	static {
+		this._registry = globalRegistry;
+	}
+	/**
+	* Get the global StateContainerRegistry
+	* @returns The registry managing all state container instances
+	*/
+	static getRegistry() {
+		return StateContainer._registry;
+	}
+	/**
+	* Replace the global registry (clears existing instances)
+	* @param registry - The new registry to use
+	*/
+	static setRegistry(registry) {
+		StateContainer._registry.clearAll();
+		StateContainer._registry = registry;
+	}
+	/**
+	* Register this class with the global registry
+	* @param isolated - Whether instances should be isolated (component-scoped)
+	*/
+	static register(isolated = false) {
+		StateContainer._registry.register(this, isolated);
+	}
+	/**
+	* Resolve an instance with ref counting (ownership semantics).
+	* Creates a new instance if one doesn't exist, or returns existing and increments ref count.
+	* @param instanceKey - Optional instance key (defaults to 'default')
+	* @param constructorArgs - Arguments to pass to constructor if creating new instance
+	* @returns The state container instance
+	*/
+	static resolve(instanceKey, constructorArgs) {
+		return StateContainer._registry.resolve(this, instanceKey, constructorArgs);
+	}
+	/**
+	* Get an existing instance without incrementing ref count (borrowing semantics).
+	* @param instanceKey - Optional instance key (defaults to 'default')
+	* @returns The state container instance
+	* @throws Error if instance doesn't exist
+	*/
+	static get(instanceKey) {
+		return StateContainer._registry.get(this, instanceKey);
+	}
+	/**
+	* Safely get an existing instance with error handling.
+	* @param instanceKey - Optional instance key (defaults to 'default')
+	* @returns Discriminated union with either the instance or an error
+	*/
+	static getSafe(instanceKey) {
+		return StateContainer._registry.getSafe(this, instanceKey);
+	}
+	/**
+	* Connect to an instance for bloc-to-bloc communication (borrowing semantics).
+	* Gets or creates instance without incrementing ref count.
+	* @param instanceKey - Optional instance key (defaults to 'default')
+	* @param constructorArgs - Arguments to pass to constructor if creating new instance
+	* @returns The state container instance
+	*/
+	static connect(instanceKey, constructorArgs) {
+		return StateContainer._registry.connect(this, instanceKey, constructorArgs);
+	}
+	/**
+	* Release a reference to an instance.
+	* Decrements ref count and disposes when it reaches 0 (unless keepAlive).
+	* @param instanceKey - Optional instance key (defaults to 'default')
+	* @param forceDispose - Force immediate disposal regardless of ref count
+	*/
+	static release(instanceKey, forceDispose = false) {
+		StateContainer._registry.release(this, instanceKey, forceDispose);
+	}
+	/**
+	* Get all instances of this class
+	* @returns Array of all instances
+	*/
+	static getAll() {
+		return StateContainer._registry.getAll(this);
+	}
+	/**
+	* Iterate over all instances of this class
+	* @param callback - Function to call for each instance
+	*/
+	static forEach(callback) {
+		StateContainer._registry.forEach(this, callback);
+	}
+	/**
+	* Clear all instances of this class (disposes them)
+	*/
+	static clear() {
+		StateContainer._registry.clear(this);
+	}
+	/**
+	* Clear all instances from all registered types
+	*/
+	static clearAllInstances() {
+		StateContainer._registry.clearAll();
+	}
+	/**
+	* Get registry statistics for debugging
+	* @returns Object with registeredTypes, totalInstances, and typeBreakdown
+	*/
+	static getStats() {
+		return StateContainer._registry.getStats();
+	}
+	/**
+	* Get reference count for an instance
+	* @param instanceKey - Optional instance key (defaults to 'default')
+	* @returns Current ref count (0 if instance doesn't exist)
+	*/
+	static getRefCount(instanceKey) {
+		return StateContainer._registry.getRefCount(this, instanceKey);
+	}
+	/**
+	* Check if an instance exists
+	* @param instanceKey - Optional instance key (defaults to 'default')
+	* @returns true if instance exists
+	*/
+	static hasInstance(instanceKey) {
+		return StateContainer._registry.hasInstance(this, instanceKey);
+	}
+	/** 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);
+		StateContainer._registry.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();
+		StateContainer._registry.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();
+		StateContainer._registry.emit("stateChanged", this, previousState, newState, stackTrace);
+		this.lastUpdateTimestamp = Date.now();
+	}
+	static {
+		this.enableStackTrace = true;
+	}
+	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 that processes events to update state.
+* Use with event handlers registered via the on() method.
+*
+* @template S - State type
+* @template E - Event type (extends BaseEvent)
+* @template P - Props type (optional)
+*/
+var Vertex = class extends StateContainer {
+	constructor(initialState) {
+		super(initialState);
+		this.eventHandlers = /* @__PURE__ */ new Map();
+		this.isProcessing = false;
+		this.eventQueue = [];
+		this.on = (EventClass, handler) => {
+			const className = EventClass.name;
+			const registrations = this.eventHandlers.get(className) || [];
+			registrations.push({
+				eventClass: EventClass,
+				handler
+			});
+			this.eventHandlers.set(className, registrations);
+		};
+		this.add = (event) => {
+			StateContainer._registry.emit("eventAdded", this, event);
+			this.processEvent(event);
+		};
+	}
+	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;
+		}
+	}
+	handleEvent(event) {
+		const className = event.constructor.name;
+		const registrations = this.eventHandlers.get(className);
+		if (!registrations || registrations.length === 0) {
+			if (this.debug) console.warn(`No handler registered for event: ${className}`);
+			return;
+		}
+		const emitFn = (state) => {
+			this.emit(state);
+		};
+		for (const registration of registrations) try {
+			registration.handler(event, emitFn);
+		} catch (error$1) {
+			if (this.debug) console.error(`Error handling event ${className}:`, error$1);
+			this.onEventError(event, error$1);
+		}
+	}
+	/**
+	* Handle errors that occur during event processing.
+	* Override this method 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/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 createProxyTrackerState() {
+	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 startProxyTracking(state) {
+	state.isTracking = true;
+	state.trackedPaths.clear();
+}
+/**
+* Stop tracking and return the tracked paths
+*
+* Returns a new Set containing all tracked paths.
+*
+* @internal
+*/
+function stopProxyTracking(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 createProxyInternal(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 createProxyInternal(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 createProxyInternal(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 createProxyForTarget(state, target) {
+	if (state.lastProxiedState === target && state.lastProxy) return state.lastProxy;
+	state.proxyCache = /* @__PURE__ */ new WeakMap();
+	state.boundFunctionsCache = null;
+	const proxy = createProxyInternal(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 createTrackerState() {
+	return {
+		proxyTrackerState: createProxyTrackerState(),
+		previousRenderPaths: /* @__PURE__ */ new Set(),
+		currentRenderPaths: /* @__PURE__ */ new Set(),
+		pathCache: /* @__PURE__ */ new Map(),
+		lastCheckedState: null,
+		lastCheckedValues: /* @__PURE__ */ new Map()
+	};
+}
+/**
+* @internal
+*/
+function startTracking(tracker) {
+	startProxyTracking(tracker.proxyTrackerState);
+}
+/**
+* @internal
+*/
+function createProxy(tracker, state) {
+	return createProxyForTarget(tracker.proxyTrackerState, state);
+}
+/**
+* @internal
+*/
+function captureTrackedPaths(tracker, state) {
+	tracker.previousRenderPaths = tracker.currentRenderPaths;
+	tracker.currentRenderPaths = optimizeTrackedPaths(stopProxyTracking(tracker.proxyTrackerState));
+	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 hasChanges(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.proxyTrackerState.trackedPaths.size > 0 || tracker.pathCache.size > 0 || tracker.previousRenderPaths.size > 0;
+}
+
+//#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.
+*/
+var ExternalDependencyManager = class {
+	constructor() {
+		this.subscriptions = [];
+		this.previousDeps = /* @__PURE__ */ new Set();
+	}
+	areDependenciesEqual(oldDeps, newDeps) {
+		if (oldDeps.size !== newDeps.size) return false;
+		for (const dep of newDeps) if (!oldDeps.has(dep)) return false;
+		return true;
+	}
+	/**
+	* 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(getterTracker, rawInstance, onGetterChange) {
+		if (!getterTracker?.externalDependencies) return false;
+		const currentDeps = getterTracker.externalDependencies;
+		if (this.areDependenciesEqual(this.previousDeps, currentDeps)) {
+			clearExternalDependencies(getterTracker);
+			return false;
+		}
+		this.cleanup();
+		for (const externalBloc of currentDeps) {
+			if (externalBloc === rawInstance) continue;
+			const unsub = externalBloc.subscribe(() => {
+				invalidateRenderCache(getterTracker);
+				if (hasGetterChanges(rawInstance, getterTracker)) onGetterChange();
+			});
+			this.subscriptions.push(unsub);
+		}
+		this.previousDeps = new Set(currentDeps);
+		clearExternalDependencies(getterTracker);
+		return true;
+	}
+	/**
+	* Clean up all active subscriptions
+	*/
+	cleanup() {
+		this.subscriptions.forEach((unsub) => unsub());
+		this.subscriptions = [];
+	}
+};
+/**
+* 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 createAutoTrackSubscribe(instance, adapterState) {
+	return (callback) => {
+		return instance.subscribe(() => {
+			const tracker = adapterState.tracker || (adapterState.tracker = createTrackerState());
+			const hasStateDeps = tracker.pathCache && tracker.pathCache.size > 0;
+			const hasGetterDeps = adapterState.getterTracker && adapterState.getterTracker.trackedGetters.size > 0;
+			const isPrimitiveState = instance.state !== null && typeof instance.state !== "object" && typeof instance.state !== "function";
+			if (!hasStateDeps && !hasGetterDeps && !isPrimitiveState) return;
+			let stateChanged = hasChanges(tracker, instance.state);
+			if (!hasStateDeps && hasGetterDeps) stateChanged = false;
+			if (stateChanged) {
+				callback();
+				return;
+			}
+			if (hasGetterChanges(instance, adapterState.getterTracker)) 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 createManualDepsSubscribe(instance, adapterState, config) {
+	return (callback) => {
+		return instance.subscribe(() => {
+			const newDeps = config.dependencies(instance.state, instance);
+			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 createNoTrackSubscribe(instance) {
+	return (callback) => instance.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 createAutoTrackSnapshot(instance, adapterState) {
+	return () => {
+		const tracker = adapterState.tracker || (adapterState.tracker = createTrackerState());
+		if (hasTrackedData(tracker)) captureTrackedPaths(tracker, instance.state);
+		if (adapterState.getterTracker) {
+			invalidateRenderCache(adapterState.getterTracker);
+			commitTrackedGetters(adapterState.getterTracker);
+			adapterState.getterTracker.isTracking = true;
+			setActiveTracker(instance, adapterState.getterTracker);
+		}
+		startTracking(tracker);
+		return createProxy(tracker, instance.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 createManualDepsSnapshot(instance, adapterState, config) {
+	return () => {
+		adapterState.manualDepsCache = config.dependencies(instance.state, instance);
+		return instance.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 createNoTrackSnapshot(instance) {
+	return () => instance.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 initAutoTrackState(instance) {
+	return {
+		tracker: null,
+		manualDepsCache: null,
+		getterTracker: createGetterTracker(),
+		proxiedBloc: createBlocProxy(instance)
+	};
+}
+/**
+* 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 initManualDepsState(instance) {
+	return {
+		tracker: null,
+		manualDepsCache: null,
+		getterTracker: null,
+		proxiedBloc: instance
+	};
+}
+/**
+* Initialize adapter state for no-tracking mode.
+* No tracking or proxy is created.
+* @param instance - The state container instance
+* @returns Initialized adapter state
+*/
+function initNoTrackState(instance) {
+	return {
+		tracker: null,
+		manualDepsCache: null,
+		getterTracker: null,
+		proxiedBloc: instance
+	};
+}
+/**
+* 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.getterTracker) {
+		adapterState.getterTracker.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/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
+export { BLAC_DEFAULTS, BLAC_ERROR_PREFIX, BLAC_ID_PATTERNS, BLAC_STATIC_PROPS, Cubit, ExternalDependencyManager, LogLevel, PluginManager, StateContainer, StateContainerRegistry, Vertex, __resetIdCounters, blac, captureTrackedPaths, clearActiveTracker, clearExternalDependencies, commitTrackedGetters, configureLogger, createArrayProxy, createAutoTrackSnapshot, createAutoTrackSubscribe, createBlocProxy, createGetterTracker, createIdGenerator, createLogger, createManualDepsSnapshot, createManualDepsSubscribe, createNoTrackSnapshot, createNoTrackSubscribe, createPluginManager, createProxy, createProxyForTarget, createProxyInternal, createProxyTrackerState, createTrackerState, debug, disableGetterTracking, error, generateId, generateIsolatedKey, generateSimpleId, getActiveTracker, getDescriptor, getGetterExecutionContext, getPluginManager, getStaticProp, getValueAtPath, globalRegistry, hasChanges, hasGetterChanges, hasInitHook, hasTrackedData, info, initAutoTrackState, initManualDepsState, initNoTrackState, invalidateRenderCache, isExcludedFromDevTools, isGetter, isIsolatedClass, isIsolatedKey, isKeepAliveClass, isProxyable, parsePath, resetGetterTracker, setActiveTracker, shallowEqual, startProxyTracking, startTracking, stopProxyTracking, warn };
 //# sourceMappingURL=index.js.map