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

package/dist/index.js

@@ -1,38 +1,1316 @@
-"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
+* ```ts
+* 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) {
+	return `${prefix}_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+}
+/**
+* Reset all counters for testing purposes
+* @internal
+*/
+function __resetIdCounters() {
+	globalCounters.clear();
+}
+
+//#endregion
+//#region src/core/StateContainerRegistry.ts
+/**
+* Registry for managing StateContainer instances
+*/
+var StateContainerRegistry = class {
+	instances = /* @__PURE__ */ new Map();
+	types = /* @__PURE__ */ new Map();
+	/**
+	* Register a type with isolation mode
+	*/
+	register(constructor, isolated = false) {
+		const className = constructor.name;
+		if (!isolated && constructor.isolated === true) isolated = true;
+		if (this.types.has(className)) throw new Error(`Type "${className}" is already registered`);
+		this.types.set(className, { isolated });
+	}
+	/**
+	* Get or create a StateContainer instance
+	* For isolated: always creates new
+	* For shared: singleton per key
+	*/
+	getOrCreate(constructor, key, ...args) {
+		const className = constructor.name;
+		let config = this.types.get(className);
+		if (!config) {
+			const isolated = constructor.isolated === true;
+			this.types.set(className, { isolated });
+			config = this.types.get(className);
+		}
+		if (config.isolated) return new constructor(...args);
+		const instanceKey = `${className}:${key || "default"}`;
+		const existing = this.instances.get(instanceKey);
+		if (existing) {
+			existing.refCount++;
+			return existing.instance;
+		}
+		const instance = new constructor(...args);
+		this.instances.set(instanceKey, {
+			instance,
+			refCount: 1
+		});
+		return instance;
+	}
+	/**
+	* Release a reference to an instance
+	* Disposes when ref count reaches zero (unless keepAlive)
+	*/
+	release(constructor, key, forceDispose = false) {
+		const instanceKey = `${constructor.name}:${key || "default"}`;
+		const entry = this.instances.get(instanceKey);
+		if (!entry) return;
+		if (forceDispose) {
+			entry.instance.dispose();
+			this.instances.delete(instanceKey);
+			return;
+		}
+		entry.refCount--;
+		if (entry.refCount <= 0 && !entry.instance.keepAlive) {
+			entry.instance.dispose();
+			this.instances.delete(instanceKey);
+		}
+	}
+	/**
+	* Get all instances of a type (shared only, isolated aren't tracked)
+	*/
+	getAll(constructor) {
+		const prefix = `${constructor.name}:`;
+		const results = [];
+		for (const [key, entry] of this.instances) if (key.startsWith(prefix)) results.push(entry.instance);
+		return results;
+	}
+	/**
+	* Clear all instances of a type
+	*/
+	clear(constructor) {
+		const prefix = `${constructor.name}:`;
+		const toDelete = [];
+		for (const [key, entry] of this.instances) if (key.startsWith(prefix)) {
+			if (!entry.instance.isDisposed) entry.instance.dispose();
+			toDelete.push(key);
+		}
+		for (const key of toDelete) this.instances.delete(key);
+	}
+	/**
+	* Clear all instances from all types (for testing)
+	*/
+	clearAll() {
+		for (const entry of this.instances.values()) if (!entry.instance.isDisposed) entry.instance.dispose();
+		this.instances.clear();
+		this.types.clear();
+	}
+	/**
+	* Get registry statistics (for debugging)
+	*/
+	getStats() {
+		const typeBreakdown = {};
+		for (const key of this.instances.keys()) {
+			const typeName = key.split(":")[0];
+			typeBreakdown[typeName] = (typeBreakdown[typeName] || 0) + 1;
+		}
+		return {
+			registeredTypes: this.types.size,
+			totalInstances: this.instances.size,
+			typeBreakdown
+		};
+	}
+	/**
+	* Get reference count for an instance
+	*/
+	getRefCount(constructor, key) {
+		const instanceKey = `${constructor.name}:${key || "default"}`;
+		return this.instances.get(instanceKey)?.refCount ?? 0;
+	}
+	/**
+	* Check if an instance exists
+	*/
+	hasInstance(constructor, key) {
+		const instanceKey = `${constructor.name}:${key || "default"}`;
+		return this.instances.has(instanceKey);
+	}
+};
+/**
+* Global default registry instance
+*/
+const globalRegistry = new StateContainerRegistry();
+
+//#endregion
+//#region src/core/StateContainer.ts
+/**
+* Base abstract class for all state containers
+*/
+var StateContainer = class StateContainer {
+	static _registry = globalRegistry;
+	/**
+	* Set a custom registry (mainly for testing)
+	*/
+	static setRegistry(registry) {
+		StateContainer._registry = registry;
+	}
+	/**
+	* Register a type as isolated or shared
+	*/
+	static register(isolated = false) {
+		StateContainer._registry.register(this, isolated);
+	}
+	/**
+	* Get or create an instance
+	* @param key - Optional instance key for shared instances
+	* @param args - Constructor arguments
+	*/
+	static getOrCreate(key, ...args) {
+		return StateContainer._registry.getOrCreate(this, key, ...args);
+	}
+	/**
+	* Release a reference to an instance
+	* @param key - Optional instance key
+	* @param forceDispose - Force dispose regardless of ref count or keepAlive
+	*/
+	static release(key, forceDispose = false) {
+		StateContainer._registry.release(this, key, forceDispose);
+	}
+	/**
+	* Get all instances of this type
+	*/
+	static getAll() {
+		return StateContainer._registry.getAll(this);
+	}
+	/**
+	* Clear all instances of this type
+	*/
+	static clear() {
+		StateContainer._registry.clear(this);
+	}
+	/**
+	* Clear all instances from all types (for testing)
+	*/
+	static clearAllInstances() {
+		StateContainer._registry.clearAll();
+	}
+	/**
+	* Get registry statistics (for debugging)
+	*/
+	static getStats() {
+		return StateContainer._registry.getStats();
+	}
+	/**
+	* Get reference count for an instance
+	* @param key - Optional instance key
+	*/
+	static getRefCount(key) {
+		return StateContainer._registry.getRefCount(this, key);
+	}
+	/**
+	* Check if an instance exists
+	* @param key - Optional instance key
+	*/
+	static hasInstance(key) {
+		return StateContainer._registry.hasInstance(this, key);
+	}
+	_state;
+	listeners = /* @__PURE__ */ new Set();
+	_disposed = false;
+	config;
+	name;
+	keepAlive;
+	debug;
+	instanceId;
+	/**
+	* Create a new StateContainer
+	*/
+	constructor(initialState, config = {}) {
+		this._state = initialState;
+		this.config = config;
+		this.name = config.name || this.constructor.name;
+		this.keepAlive = config.keepAlive ?? false;
+		this.debug = config.debug ?? false;
+		this.instanceId = config.instanceId || generateSimpleId(this.constructor.name);
+	}
+	/**
+	* Get the current state
+	*/
+	get state() {
+		return this._state;
+	}
+	/**
+	* Check if disposed
+	*/
+	get isDisposed() {
+		return this._disposed;
+	}
+	/**
+	* Subscribe to 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 the container
+	*/
+	dispose() {
+		if (this._disposed) return;
+		if (this.debug) console.log(`[${this.name}] Disposing...`);
+		this._disposed = true;
+		this.onDispose?.();
+		this.listeners.clear();
+		if (this.debug) console.log(`[${this.name}] Disposed successfully`);
+	}
+	/**
+	* Emit a new state (with change detection)
+	*/
+	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.onStateChange?.(newState, previousState);
+		for (const listener of this.listeners) try {
+			listener(newState);
+		} catch (error$1) {
+			console.error(`[${this.name}] Error in listener:`, error$1);
+		}
+	}
+	/**
+	* Update state using a function
+	*/
+	update(updater) {
+		if (this._disposed) throw new Error(`Cannot update state from disposed container ${this.name}`);
+		this.emit(updater(this._state));
+	}
+};
+
+//#endregion
+//#region src/core/Cubit.ts
+/**
+* Cubit is a simple state container that allows direct state emission
+*
+* Unlike StateContainer (where emit is protected), Cubit exposes emit and update
+* as public methods to allow direct state management.
+*/
+var Cubit = class extends StateContainer {
+	/**
+	* Create a new Cubit
+	* @param initialState Initial state value
+	* @param config Configuration options
+	*/
+	constructor(initialState, config) {
+		super(initialState, config);
+	}
+	/**
+	* Emit a new state (public override of protected parent method)
+	*/
+	emit(newState) {
+		super["emit"](newState);
+	}
+	/**
+	* Update state using a function (public override of protected parent method)
+	*/
+	update(updater) {
+		super["update"](updater);
+	}
+	/**
+	* Patch state with partial updates (shallow merge)
+	* Only available when state is an object type
+	* Arrow function to maintain correct 'this' binding in React
+	*
+	* @example
+	* ```typescript
+	* // Update single field
+	* this.patch({ count: 5 });
+	*
+	* // Update multiple fields
+	* this.patch({ count: 5, name: 'Updated' });
+	* ```
+	*/
+	patch = ((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
+		}));
+	});
+};
+/**
+* Example: Counter Cubit
+*/
+var CounterCubit = class extends Cubit {
+	constructor() {
+		super(0, { name: "CounterCubit" });
+	}
+	increment = () => {
+		this.emit(this.state + 1);
+	};
+	decrement = () => {
+		this.emit(this.state - 1);
+	};
+	reset = () => {
+		this.emit(0);
+	};
+	addAmount = (amount) => {
+		this.emit(this.state + amount);
+	};
+};
+var TodoCubit = class extends Cubit {
+	nextId = 0;
+	constructor() {
+		super({
+			todos: [],
+			filter: "all",
+			isLoading: false
+		}, {
+			name: "TodoCubit",
+			keepAlive: true
+		});
+	}
+	addTodo = (text) => {
+		this.update((state) => ({
+			...state,
+			todos: [...state.todos, {
+				id: `todo-${Date.now()}-${this.nextId++}`,
+				text,
+				done: false
+			}]
+		}));
+	};
+	toggleTodo = (id) => {
+		this.update((state) => ({
+			...state,
+			todos: state.todos.map((todo) => todo.id === id ? {
+				...todo,
+				done: !todo.done
+			} : todo)
+		}));
+	};
+	removeTodo = (id) => {
+		this.update((state) => ({
+			...state,
+			todos: state.todos.filter((todo) => todo.id !== id)
+		}));
+	};
+	setFilter = (filter) => {
+		this.patch({ filter });
+	};
+	setLoading = (isLoading) => {
+		this.patch({ isLoading });
+	};
+	get visibleTodos() {
+		const todos = this.state.todos;
+		switch (this.state.filter) {
+			case "active": return todos.filter((t) => !t.done);
+			case "completed": return todos.filter((t) => t.done);
+			case "all":
+			default: return todos;
+		}
+	}
+	get activeTodoCount() {
+		return this.state.todos.filter((t) => !t.done).length;
+	}
+};
+
+//#endregion
+//#region src/core/Vertex.ts
+/**
+* Vertex is an event-driven state container (Bloc pattern)
+*
+* Includes its own simple event system since events are only needed
+* for the Vertex pattern, not for the base StateContainer.
+*/
+var Vertex = class extends StateContainer {
+	eventHandlers = /* @__PURE__ */ new Map();
+	isProcessing = false;
+	eventQueue = [];
+	/**
+	* Create a new Vertex
+	* @param initialState Initial state value
+	* @param config Configuration options
+	*/
+	constructor(initialState, config) {
+		super(initialState, config);
+	}
+	/**
+	* Register an event handler
+	* Arrow function to maintain correct 'this' binding
+	*/
+	on = (EventClass, handler) => {
+		const className = EventClass.name;
+		const registrations = this.eventHandlers.get(className) || [];
+		registrations.push({
+			eventClass: EventClass,
+			handler
+		});
+		this.eventHandlers.set(className, registrations);
+	};
+	/**
+	* Add an event to be processed
+	* Arrow function to maintain correct 'this' binding in React
+	*/
+	add = (event) => {
+		this.processEvent(event);
+	};
+	/**
+	* Process an event (synchronously)
+	*/
+	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;
+		}
+	}
+	/**
+	* Handle a single event (synchronously)
+	*/
+	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);
+		}
+	}
+	/**
+	* Hook for handling event processing errors
+	*/
+	onEventError(event, error$1) {}
+};
+/**
+* Example: Counter Events
+*/
+var IncrementEvent = class {
+	type = "increment";
+	timestamp = Date.now();
+	constructor(amount = 1) {
+		this.amount = amount;
+	}
+};
+var DecrementEvent = class {
+	type = "decrement";
+	timestamp = Date.now();
+	constructor(amount = 1) {
+		this.amount = amount;
+	}
+};
+var ResetEvent = class {
+	type = "reset";
+	timestamp = Date.now();
+};
+/**
+* Example: Counter Vertex
+* Demonstrates proper typing and event handling
+*/
+var CounterVertex = class extends Vertex {
+	constructor() {
+		super(0);
+		this.on(IncrementEvent, (event, emit) => {
+			emit(this.state + event.amount);
+		});
+		this.on(DecrementEvent, (event, emit) => {
+			emit(this.state - event.amount);
+		});
+		this.on(ResetEvent, (_, emit) => {
+			emit(0);
+		});
+	}
+	increment = (amount = 1) => {
+		this.add(new IncrementEvent(amount));
+	};
+	decrement = (amount = 1) => {
+		this.add(new DecrementEvent(amount));
+	};
+	reset = () => {
+		this.add(new ResetEvent());
+	};
+};
+var LoginEvent = class {
+	type = "login";
+	timestamp = Date.now();
+	constructor(email, password) {
+		this.email = email;
+		this.password = password;
+	}
+};
+var LogoutEvent = class {
+	type = "logout";
+	timestamp = Date.now();
+};
+var AuthVertex = class extends Vertex {
+	constructor() {
+		super({
+			isAuthenticated: false,
+			isLoading: false,
+			user: null,
+			error: null
+		});
+		this.on(LoginEvent, (event, emit) => {
+			emit({
+				...this.state,
+				isLoading: true,
+				error: null
+			});
+			if (event.email === "user@example.com" && event.password === "password") emit({
+				isAuthenticated: true,
+				isLoading: false,
+				user: {
+					id: "123",
+					name: "Test User",
+					email: "user@example.com"
+				},
+				error: null
+			});
+			else emit({
+				isAuthenticated: false,
+				isLoading: false,
+				user: null,
+				error: "Invalid credentials"
+			});
+		});
+		this.on(LogoutEvent, (_, emit) => {
+			emit({
+				isAuthenticated: false,
+				isLoading: false,
+				user: null,
+				error: null
+			});
+		});
+	}
+	login = (email, password) => {
+		this.add(new LoginEvent(email, password));
+	};
+	logout = () => {
+		this.add(new LogoutEvent());
+	};
+};
+
+//#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.
+*/
+/**
+* Array methods that should trigger tracking of the entire array
+*/
+const ARRAY_METHODS = new Set([
+	"map",
+	"filter",
+	"forEach",
+	"find",
+	"some",
+	"every",
+	"reduce"
+]);
+/**
+* Check if a value can be proxied
+*
+* Returns true for plain objects and arrays only.
+* Excludes built-in objects like Date, Map, Set, etc.
+*/
+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);
+*/
+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.
+*/
+function startProxyTracking(state) {
+	state.isTracking = true;
+	state.trackedPaths.clear();
+}
+/**
+* Stop tracking and return the tracked paths
+*
+* Returns a new Set containing all tracked paths.
+*/
+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.)
+*/
+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 (ARRAY_METHODS.has(prop)) {
+				if (state.isTracking && path) state.trackedPaths.add(path);
+			}
+			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;
+		}
+		let fullPath;
+		if (prop === "length") fullPath = path ? `${path}.length` : "length";
+		else 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.
+*/
+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 (isProxyable(value)) return createProxyInternal(state, value, fullPath, depth + 1);
+			if (typeof prop === "string" && state.isTracking) {
+				if (!prop.startsWith("_") && !prop.startsWith("$$")) state.trackedPaths.add(fullPath);
+			}
+			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.
+*/
+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.
+*/
+/**
+* Parse a property path string into an array of segments
+*
+* Handles both dot notation (a.b.c) and bracket notation (a[0].b)
+*
+* @example
+* parsePath('user.name') // ['user', 'name']
+* parsePath('items[0].name') // ['items', '0', 'name']
+* parsePath('data.users[2].address.city') // ['data', 'users', '2', 'address', 'city']
+*/
+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
+* const obj = { user: { name: 'Alice', age: 30 } }
+* getValueAtPath(obj, ['user', 'name']) // 'Alice'
+* getValueAtPath(obj, ['user', 'age']) // 30
+* getValueAtPath(obj, ['user', 'missing']) // undefined
+*/
+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
+* shallowEqual([1, 2, 3], [1, 2, 3]) // true
+* shallowEqual([1, 2, 3], [1, 2, 4]) // false
+* shallowEqual([1, 2], [1, 2, 3]) // false
+*/
+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
+/**
+* How often to clean up unused paths from the cache
+*/
+const CLEANUP_INTERVAL = 10;
+/**
+* Create a new tracker state
+*/
+function createTrackerState() {
+	return {
+		proxyTrackerState: createProxyTrackerState(),
+		previousRenderPaths: /* @__PURE__ */ new Set(),
+		currentRenderPaths: /* @__PURE__ */ new Set(),
+		pathCache: /* @__PURE__ */ new Map(),
+		lastCheckedState: null,
+		lastCheckedValues: /* @__PURE__ */ new Map(),
+		cleanupCounter: 0
+	};
+}
+/**
+* Start tracking property accesses
+*/
+function startTracking(tracker) {
+	startProxyTracking(tracker.proxyTrackerState);
+}
+/**
+* Create a proxy for the given state
+*/
+function createProxy(tracker, state) {
+	return createProxyForTarget(tracker.proxyTrackerState, state);
+}
+/**
+* Capture the paths that were tracked during a render
+*
+* This should be called after each render to record which paths were accessed.
+* It also performs periodic cleanup of unused paths to prevent memory leaks.
+*/
+function captureTrackedPaths(tracker, state) {
+	tracker.previousRenderPaths = tracker.currentRenderPaths;
+	tracker.currentRenderPaths = 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.cleanupCounter++;
+	if (tracker.cleanupCounter >= CLEANUP_INTERVAL) {
+		tracker.cleanupCounter = 0;
+		for (const path of tracker.pathCache.keys()) if (!trackedPathsUnion.has(path)) tracker.pathCache.delete(path);
+	}
+	tracker.lastCheckedValues.clear();
+}
+/**
+* Check if any tracked paths have changed
+*
+* This is called when state changes to determine if a re-render is needed.
+* Returns true if any tracked path has a different value than before.
+*/
+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;
+}
+/**
+* Check if tracker has any tracked data
+*
+* Returns true if there are any tracked paths or cached paths.
+*/
+function hasTrackedData(tracker) {
+	return tracker.proxyTrackerState.trackedPaths.size > 0 || tracker.pathCache.size > 0 || tracker.previousRenderPaths.size > 0;
+}
+
+//#endregion
+//#region src/logging/Logger.ts
+let LogLevel = /* @__PURE__ */ function(LogLevel$1) {
+	LogLevel$1[LogLevel$1["ERROR"] = 0] = "ERROR";
+	LogLevel$1[LogLevel$1["WARN"] = 1] = "WARN";
+	LogLevel$1[LogLevel$1["INFO"] = 2] = "INFO";
+	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);
+const debug = (context, message, data) => defaultLogger.debug(context, message, data);
+const info = (context, message, data) => defaultLogger.info(context, message, data);
+const warn = (context, message, data) => defaultLogger.warn(context, message, 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/proxy/ProxyTracker.ts
+/**
+* Check if a value is an object that can be proxied
+*/
+function isProxyable$1(value) {
+	return value !== null && typeof value === "object" && !(value instanceof Date) && !(value instanceof RegExp) && !(value instanceof Map) && !(value instanceof Set) && !(value instanceof WeakMap) && !(value instanceof WeakSet) && !(value instanceof Promise);
+}
+/**
+* Tracks property access on state objects
+*/
+var ProxyTracker = class {
+	trackedPaths = /* @__PURE__ */ new Set();
+	isTracking = false;
+	proxyCache = /* @__PURE__ */ new WeakMap();
+	maxDepth = 10;
+	/**
+	* Create a proxy that tracks property access
+	*/
+	createProxy(target, path = "", depth = 0) {
+		if (!this.isTracking || !isProxyable$1(target)) return target;
+		if (depth >= this.maxDepth) return target;
+		if (this.proxyCache.has(target)) return this.proxyCache.get(target);
+		if (Array.isArray(target)) return this.createArrayProxy(target, path, depth);
+		const proxy = new Proxy(target, {
+			get: (obj, prop) => {
+				const value = Reflect.get(obj, prop);
+				if (typeof value === "function") return value.bind(obj);
+				const fullPath = path ? `${path}.${String(prop)}` : String(prop);
+				if (isProxyable$1(value)) return this.createProxy(value, fullPath, depth + 1);
+				if (typeof prop === "string" && this.isTracking) {
+					if (!prop.startsWith("_") && !prop.startsWith("$$")) {
+						this.trackedPaths.add(fullPath);
+						debug("ProxyTracker", "Tracked property access", {
+							path: fullPath,
+							valueType: typeof value
+						});
+					}
+				}
+				return value;
+			},
+			has: (obj, prop) => {
+				if (typeof prop === "string" && this.isTracking) {
+					const fullPath = path ? `${path}.${prop}` : prop;
+					this.trackedPaths.add(fullPath);
+					debug("ProxyTracker", "Tracked \"in\" operator access", { path: fullPath });
+				}
+				return Reflect.has(obj, prop);
+			},
+			ownKeys: (obj) => {
+				if (this.isTracking && path) {
+					this.trackedPaths.add(path);
+					debug("ProxyTracker", "Tracked object keys iteration", { path });
+				}
+				return Reflect.ownKeys(obj);
+			}
+		});
+		this.proxyCache.set(target, proxy);
+		return proxy;
+	}
+	/**
+	* Create a proxy for arrays with special handling
+	*/
+	createArrayProxy(target, path, depth = 0) {
+		const proxy = new Proxy(target, { get: (arr, prop) => {
+			const value = Reflect.get(arr, prop);
+			if (typeof value === "function") {
+				if ([
+					"map",
+					"filter",
+					"forEach",
+					"find",
+					"some",
+					"every",
+					"reduce"
+				].includes(String(prop))) {
+					if (this.isTracking && path) {
+						this.trackedPaths.add(path);
+						debug("ProxyTracker", "Tracked array method access", {
+							path,
+							method: String(prop)
+						});
+					}
+				}
+				return value.bind(arr);
+			}
+			let fullPath;
+			if (prop === "length") fullPath = path ? `${path}.length` : "length";
+			else 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$1(value)) return this.createProxy(value, fullPath, depth + 1);
+			if (this.isTracking) {
+				this.trackedPaths.add(fullPath);
+				debug("ProxyTracker", "Tracked array property access", {
+					path: fullPath,
+					valueType: typeof value
+				});
+			}
+			return value;
+		} });
+		this.proxyCache.set(target, proxy);
+		return proxy;
+	}
+	/**
+	* Start tracking property access
+	*/
+	startTracking() {
+		this.isTracking = true;
+		this.trackedPaths.clear();
+		debug("ProxyTracker", "Started tracking");
+	}
+	/**
+	* Stop tracking and return tracked paths
+	*/
+	stopTracking() {
+		this.isTracking = false;
+		debug("ProxyTracker", "Stopped tracking", {
+			pathCount: this.trackedPaths.size,
+			paths: Array.from(this.trackedPaths)
+		});
+		return new Set(this.trackedPaths);
+	}
+	/**
+	* Get currently tracked paths
+	*/
+	getTrackedPaths() {
+		return new Set(this.trackedPaths);
+	}
+	/**
+	* Check if currently tracking
+	*/
+	isCurrentlyTracking() {
+		return this.isTracking;
+	}
+	/**
+	* Clear proxy cache (useful for memory management)
+	*/
+	clearCache() {
+		this.proxyCache = /* @__PURE__ */ new WeakMap();
+	}
+	/**
+	* Set maximum tracking depth
+	*/
+	setMaxDepth(depth) {
+		this.maxDepth = Math.max(1, depth);
+	}
+	/**
+	* Add a path manually (useful for forcing dependencies)
+	*/
+	addPath(path) {
+		this.trackedPaths.add(path);
+	}
+	/**
+	* Remove a path manually
+	*/
+	removePath(path) {
+		this.trackedPaths.delete(path);
+	}
+	/**
+	* Clear all tracked paths
+	*/
+	clearPaths() {
+		this.trackedPaths.clear();
+	}
+};
+/**
+* Global proxy tracker instance for convenience
+*/
+const globalProxyTracker = new ProxyTracker();
+/**
+* Utility function to track property access in a callback
+*/
+function trackAccess(state, callback) {
+	const tracker = new ProxyTracker();
+	tracker.startTracking();
+	return {
+		result: callback(tracker.createProxy(state)),
+		trackedPaths: tracker.stopTracking()
+	};
+}
+
+//#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 = {
+	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
+};
+
+//#endregion
+export { AuthVertex, BLAC_DEFAULTS, CounterCubit, CounterVertex, Cubit, DecrementEvent, IncrementEvent, LogLevel, LoginEvent, LogoutEvent, ProxyTracker, ResetEvent, StateContainer, StateContainerRegistry, TodoCubit, Vertex, __resetIdCounters, captureTrackedPaths, configureLogger, createArrayProxy, createIdGenerator, createLogger, createProxy, createProxyForTarget, createProxyInternal, createProxyTrackerState, createTrackerState, debug, error, generateId, generateSimpleId, getValueAtPath, globalProxyTracker, globalRegistry, hasChanges, hasTrackedData, info, isProxyable, parsePath, shallowEqual, startProxyTracking, startTracking, stopProxyTracking, trackAccess, warn };
 //# sourceMappingURL=index.js.map