@blac/core 2.0.1 → 2.0.4

package/dist/index.d.cts

@@ -1,51 +1,4 @@
-/* Excluded from this release type: __resetIdCounters */
-
-export declare function acquire<T extends StateContainerConstructor>(BlocClass: T, instanceKey?: string, options?: AcquireOptions<T>): InstanceType<T>;
-
-export declare interface AcquireOptions<T extends StateContainerConstructor> {
-    props?: ExtractProps<T>;
-}
-
-/**
- * Internal state for framework adapters, holding tracking and caching data.
- * @template TBloc - The state container type
- */
-export declare interface AdapterState<TBloc extends StateContainerConstructor> {
-    /** Dependency tracker for state property access tracking */
-    dependencyState: DependencyState<ExtractState<TBloc>> | null;
-    /** Cached manual dependencies for comparison */
-    manualDepsCache: unknown[] | null;
-    /** Getter state for computed property tracking */
-    getterState: GetterState | null;
-    /** Proxied bloc instance for auto-tracking */
-    proxiedBloc: InstanceState<TBloc> | null;
-}
-
-/**
- * Initialize adapter state for auto-tracking mode.
- * Creates getter tracker and proxied bloc instance.
- * @param instance - The state container instance
- * @returns Initialized adapter state
- */
-export declare function autoTrackInit<TBloc extends StateContainerConstructor>(instance: InstanceState<TBloc>): AdapterState<TBloc>;
-
-/**
- * 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
- */
-export declare function autoTrackSnapshot<TBloc extends StateContainerConstructor>(instance: InstanceReadonlyState<TBloc>, adapterState: AdapterState<TBloc>): SnapshotFunction<ExtractState<TBloc>>;
-
-/**
- * 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
- */
-export declare function autoTrackSubscribe<TBloc extends StateContainerConstructor>(instance: InstanceReadonlyState<TBloc>, adapterState: AdapterState<TBloc>): SubscribeFunction;
+export declare function acquire<T extends StateContainerConstructor>(BlocClass: T, instanceKey?: string): InstanceType<T>;
 
 /**
  * Decorator to configure StateContainer classes.
@@ -71,96 +24,6 @@ export declare function autoTrackSubscribe<TBloc extends StateContainerConstruct
  */
 export declare function blac(options: BlacOptions): <T extends new (...args: any[]) => any>(target: T, _context?: ClassDecoratorContext) => T;
 
-/**
- * Default configuration constants for BlaC
- */
-export declare const BLAC_DEFAULTS: {
-    /**
-     * Default instance key for shared instances
-     */
-    readonly DEFAULT_INSTANCE_KEY: "default";
-    /**
-     * Maximum getter nesting depth (prevents infinite recursion)
-     */
-    readonly MAX_GETTER_DEPTH: 10;
-    /**
-     * Default cleanup interval for subscriptions (30 seconds)
-     */
-    readonly CLEANUP_INTERVAL_MS: 30000;
-    /**
-     * Cleanup interval for weak reference stage (10 seconds)
-     */
-    readonly WEAKREF_CLEANUP_INTERVAL_MS: 10000;
-    /**
-     * Default maximum subscriptions per container
-     */
-    readonly MAX_SUBSCRIPTIONS: 1000;
-    /**
-     * Maximum subscriptions for high-performance mode
-     */
-    readonly MAX_SUBSCRIPTIONS_HIGH_PERF: 10000;
-    /**
-     * Default timeout for pipeline execution (5 seconds)
-     */
-    readonly PIPELINE_TIMEOUT_MS: 5000;
-    /**
-     * Cleanup interval for high-performance mode (5 seconds)
-     */
-    readonly CLEANUP_INTERVAL_HIGH_PERF_MS: 5000;
-    /**
-     * Maximum number of stages in a pipeline
-     */
-    readonly MAX_PIPELINE_STAGES: 30;
-};
-
-/**
- * Standard error message prefix
- */
-export declare const BLAC_ERROR_PREFIX: "[BlaC]";
-
-/**
- * ID generation patterns and constants
- */
-export declare const BLAC_ID_PATTERNS: {
-    /**
-     * Prefix for isolated instance keys
-     */
-    readonly ISOLATED_PREFIX: "isolated-";
-    /**
-     * Length of generated ID portion (9 characters from base36)
-     */
-    readonly ID_LENGTH: 9;
-};
-
-/**
- * Static property names for StateContainer classes
- * Used for feature flags and configuration on bloc classes
- */
-export declare const BLAC_STATIC_PROPS: {
-    /**
-     * Mark a bloc as isolated (each component gets its own instance)
-     */
-    readonly ISOLATED: "isolated";
-    /**
-     * Mark a bloc to never be auto-disposed (kept alive permanently)
-     */
-    readonly KEEP_ALIVE: "keepAlive";
-    /**
-     * Exclude a bloc from DevTools reporting (prevents infinite loops)
-     */
-    readonly EXCLUDE_FROM_DEVTOOLS: "__excludeFromDevTools";
-};
-
-/**
- * Global configuration for @blac/core
- */
-export declare interface BlacConfig {
-    /** Enable development mode (enables additional warnings and checks) */
-    devMode: boolean;
-    /** Logger configuration */
-    logger: Partial<LogConfig>;
-}
-
 /**
  * Configuration options for the @blac decorator.
  * Only one option can be specified at a time (union type).
@@ -203,10 +66,6 @@ export declare interface BlacPlugin {
      * Called when state changes in a container instance
      */
     onStateChanged?<S extends object = any>(instance: StateContainer<S>, previousState: S, currentState: S, callstack: string | undefined, context: PluginContext): void;
-    /**
-     * Called when an event is added to a Vertex instance
-     */
-    onEventAdded?<E extends DiscriminatedEvent>(vertex: Vertex<any, E>, event: EventWithMetadata<E>, context: PluginContext): void;
     /**
      * Called when a state container instance is disposed
      */
@@ -230,7 +89,7 @@ declare const BLOC_REF_MARKER: unique symbol;
  * Used for type-safe hook parameters.
  * @template TBloc - The StateContainer instance type
  */
-export declare type BlocConstructor<S extends object = any, T extends new (...args: any[]) => StateContainer<S, any> = new (...args: any[]) => StateContainer<S, any>> = (new (...args: any[]) => InstanceType<T>) & {
+export declare type BlocConstructor<S extends object = any, T extends new (...args: any[]) => StateContainer<S> = new (...args: any[]) => StateContainer<S>> = (new (...args: any[]) => InstanceType<T>) & {
     acquire(instanceKey?: string, ...args: any[]): InstanceType<T>;
     borrow(instanceKey?: string, ...args: any[]): InstanceType<T> | null;
     borrowSafe(instanceKey?: string, ...args: any[]): {
@@ -273,24 +132,6 @@ export declare function borrowSafe<T extends StateContainerConstructor>(BlocClas
     instance: InstanceType<T>;
 };
 
-/**
- * Utility type for creating branded/nominal types.
- * Prevents accidental type confusion between similar primitive types.
- * @template T - The base type
- * @template B - The brand identifier
- */
-export declare type Brand<T, B> = T & {
-    [brand]: B;
-};
-
-declare const brand: unique symbol;
-
-/**
- * Branded string type for type-safe IDs.
- * @template B - The brand identifier
- */
-export declare type BrandedId<B> = Brand<string, B>;
-
 /* Excluded from this release type: capturePaths */
 
 export declare function clear<T extends StateContainerConstructor>(BlocClass: T): void;
@@ -299,138 +140,23 @@ export declare function clear<T extends StateContainerConstructor>(BlocClass: T)
 
 export declare function clearAll(): void;
 
-/* Excluded from this release type: clearExternalDependencies */
-
 /* Excluded from this release type: commitTrackedGetters */
 
-/**
- * Configure global defaults for @blac/core.
- *
- * @example
- * ```ts
- * import { configureBlac, LogLevel } from '@blac/core';
- *
- * configureBlac({
- *   devMode: true,
- *   logger: {
- *     enabled: true,
- *     level: LogLevel.DEBUG
- *   }
- * });
- * ```
- *
- * @param config - Partial configuration to merge with defaults
- */
-export declare function configureBlac(config: Partial<BlacConfig>): void;
-
-/**
- * Configuration function that recreates the default logger
- *
- * @param opts - Partial logger configuration
- *
- * @example
- * ```ts
- * configureLogger({ enabled: true, level: LogLevel.DEBUG });
- * ```
- */
-export declare function configureLogger(opts: Partial<LogConfig>): void;
-
-/* Excluded from this release type: createArrayProxy */
-
 /* Excluded from this release type: createBlocProxy */
 
 /* Excluded from this release type: createDependencyProxy */
 
 /* Excluded from this release type: createDependencyState */
 
-/* Excluded from this release type: createForTarget */
-
 /* Excluded from this release type: createGetterState */
 
-/**
- * Centralized ID Generation
- *
- * Provides consistent, collision-resistant ID generation for all BlaC subsystems.
- * Uses timestamp + counter + random suffix for uniqueness.
- */
-/**
- * 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"
- * ```
- */
-export declare function createIdGenerator(prefix: string): {
-    next: () => string;
-    nextSimple: () => string;
-    reset: () => void;
-};
-
-/* Excluded from this release type: createInternal */
-
-/**
- * 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' } });
- * ```
- */
-export declare function createLogger(config: LogConfig): {
-    debug: (context: string, message: string, data?: any) => void;
-    info: (context: string, message: string, data?: any) => void;
-    warn: (context: string, message: string, data?: any) => void;
-    error: (context: string, message: string, data?: any) => void;
-    configure: (opts: Partial<LogConfig>) => void;
-};
-
-/**
- * Create a plugin manager instance
- * @param registry - The StateContainerRegistry to monitor for lifecycle events
- * @returns A new PluginManager instance
- */
-export declare function createPluginManager(registry: StateContainerRegistry): PluginManager;
-
-/* Excluded from this release type: createProxyState */
-
-/**
- * Create a new tracked context for manual control over tracking.
- */
-export declare function createTrackedContext(): TrackedContext;
-
-/**
- * Create a tracking proxy for a bloc instance.
- * Tracks both state property access and getter access.
- */
-export declare function createTrackingProxy<T extends StateContainerInstance>(bloc: T, tracker: TrackingProxyState): T;
-
-/**
- * Create a new tracking proxy state.
- */
-export declare function createTrackingProxyState(): TrackingProxyState;
-
 /**
  * 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)
  */
-export declare abstract class Cubit<S extends object = any, P = undefined> extends StateContainer<S, P> {
+export declare abstract class Cubit<S extends object = any> extends StateContainer<S> {
     constructor(initialState: S);
     /**
      * Replace state with a new value and notify all listeners
@@ -448,14 +174,6 @@ export declare abstract class Cubit<S extends object = any, P = undefined> exten
     patch: S extends object ? (partial: Partial<S>) => void : never;
 }
 
-/**
- * Log a debug message (tree-shakeable export)
- * @param context - Context identifier (module or component name)
- * @param message - Log message
- * @param data - Optional structured data
- */
-export declare const debug: (context: string, message: string, data?: any) => void;
-
 /**
  * Manages subscriptions to state container dependencies.
  * Provides efficient sync mechanism to add/remove subscriptions
@@ -495,173 +213,30 @@ export declare class DependencyManager {
 
 /* Excluded from this release type: DependencyState */
 
-/**
- * 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
- */
-export declare function disableGetterTracking<TBloc extends StateContainerConstructor>(adapterState: AdapterState<TBloc>, rawInstance: InstanceState<TBloc>): void;
-
-/**
- * Base type for discriminated union events.
- * All events must have a `type` property as the discriminator.
- *
- * @example
- * ```typescript
- * type MyEvent =
- *   | { type: 'increment'; amount: number }
- *   | { type: 'decrement' };
- * ```
- */
-export declare interface DiscriminatedEvent {
-    readonly type: string;
-}
-
-/* Excluded from this release type: EmptyState */
-
-/* Excluded from this release type: EmptyState_2 */
-
 export declare function ensure<T extends StateContainerConstructor>(BlocClass: T, instanceKey?: string): InstanceType<T>;
 
-/**
- * Log an error message (tree-shakeable export)
- * @param context - Context identifier (module or component name)
- * @param message - Log message
- * @param data - Optional structured data
- */
-export declare const error: (context: string, message: string, data?: any) => void;
-
-/**
- * Map of event handlers requiring exhaustive coverage.
- * TypeScript enforces that every event type in the union has a handler.
- *
- * @template E - The discriminated event union type
- * @template S - The state type
- *
- * @example
- * ```typescript
- * type CounterEvent =
- *   | { type: 'increment'; amount: number }
- *   | { type: 'reset' };
- *
- * // All event types must be handled:
- * const handlers: EventHandlerMap<CounterEvent, { count: number }> = {
- *   increment: (event, emit) => emit({ count: event.amount }),
- *   reset: (_, emit) => emit({ count: 0 }),
- * };
- * ```
- */
-export declare type EventHandlerMap<E extends DiscriminatedEvent, S extends object> = {
-    [K in EventType<E>]: VertexEventHandler<ExtractEvent<E, K>, S>;
-};
-
-/* Excluded from this release type: EventMetadata */
-
-/**
- * Extract the `type` literal union from a discriminated event union.
- *
- * @template E - The discriminated event union type
- *
- * @example
- * ```typescript
- * type MyEvent = { type: 'a' } | { type: 'b' };
- * type Types = EventType<MyEvent>; // 'a' | 'b'
- * ```
- */
-export declare type EventType<E extends DiscriminatedEvent> = E['type'];
-
-/* Excluded from this release type: EventWithMetadata */
-
-/**
- * Manages subscriptions to external bloc dependencies for getter tracking.
- * When a getter accesses another bloc's state, this manager ensures
- * re-renders occur when those external dependencies change.
- *
- * @deprecated Use DependencyManager from tracking module instead.
- * This class is kept for backward compatibility.
- */
-export declare class ExternalDepsManager {
-    private manager;
-    /**
-     * Update subscriptions to external bloc dependencies.
-     * Creates subscriptions to blocs accessed via getters.
-     * @param getterTracker - The getter tracker state with external dependencies
-     * @param rawInstance - The primary bloc instance (excluded from subscriptions)
-     * @param onGetterChange - Callback to invoke when external dependency changes
-     * @returns true if subscriptions were updated, false if unchanged
-     */
-    updateSubscriptions(getterState: GetterState | null, rawInstance: StateContainerInstance, onGetterChange: () => void): boolean;
-    /**
-     * Clean up all active subscriptions
-     */
-    cleanup(): void;
-}
-
 /**
  * Extract constructor argument types from a class
  * @template T - The class type
  */
 export declare type ExtractConstructorArgs<T> = T extends new (...args: infer P) => any ? P : never[];
 
-/**
- * Extract a specific event variant from a union by its type.
- *
- * @template E - The discriminated event union type
- * @template T - The type literal to extract
- *
- * @example
- * ```typescript
- * type MyEvent = { type: 'a'; value: number } | { type: 'b' };
- * type EventA = ExtractEvent<MyEvent, 'a'>; // { type: 'a'; value: number }
- * ```
- */
-export declare type ExtractEvent<E extends DiscriminatedEvent, T extends EventType<E>> = Extract<E, {
-    type: T;
-}>;
-
 declare type ExtractInstance<T> = T extends BlocRef<infer C> ? InstanceType<C> : T extends StateContainerConstructor ? InstanceType<T> : never;
 
 declare type ExtractInstances<T extends readonly BlocInput[]> = {
     [K in keyof T]: ExtractInstance<T[K]>;
 };
 
-/**
- * Extract the props type from a StateContainer
- * @template T - The StateContainer type
- */
-export declare type ExtractProps<T> = T extends StateContainerConstructor<any, infer P> ? P : undefined;
-
 /**
  * Extract the state type from a StateContainer
  * @template T - The StateContainer type
  */
-export declare type ExtractState<T> = T extends StateContainerConstructor<infer S, any> ? Readonly<S> : never;
+export declare type ExtractState<T> = T extends StateContainerConstructor<infer S> ? Readonly<S> : never;
 
-/**
- * Constrain a type to extract state only from stateful containers.
- * Returns `never` for stateless containers.
- */
-export declare type ExtractStatefulState<T extends StateContainerConstructor> = IsStatelessContainer<T> extends true ? never : ExtractState<T>;
-
-export declare type ExtractStateMutable<T> = T extends StateContainerConstructor<infer S, any> ? S : never;
+export declare type ExtractStateMutable<T> = T extends StateContainerConstructor<infer S> ? S : never;
 
 export declare function forEach<T extends StateContainerConstructor>(BlocClass: T, callback: (instance: InstanceReadonlyState<T>) => void): void;
 
-/**
- * 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"
- */
-export declare function generateId(prefix: string): string;
-
 /**
  * Generate a unique isolated instance key
  * Uses base36 encoding for compact, URL-safe identifiers
@@ -673,32 +248,8 @@ export declare function generateId(prefix: string): string;
  */
 export declare function generateIsolatedKey(): string;
 
-/**
- * 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"
- * ```
- */
-export declare function generateSimpleId(prefix: string, affix?: string): string;
-
-/* Excluded from this release type: getActiveTracker */
-
 export declare function getAll<T extends StateContainerConstructor>(BlocClass: T): InstanceReadonlyState<T>[];
 
-/* Excluded from this release type: getBlacConfig */
-
-/* Excluded from this release type: getDescriptor */
-
-/* Excluded from this release type: getGetterExecutionContext */
-
 /**
  * Get the global plugin manager
  */
@@ -706,36 +257,8 @@ export declare function getPluginManager(): any;
 
 export declare function getRefCount<T extends StateContainerConstructor>(BlocClass: T, instanceKey?: string): number;
 
-export declare function getRegistry(): StateContainerRegistry;
-
-/**
- * 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
- */
-export declare function getStaticProp<V, T extends StateContainerConstructor = StateContainerConstructor>(Type: T, propName: string, defaultValue?: V): V | undefined;
-
-export declare function getStats(): {
-    registeredTypes: number;
-    totalInstances: number;
-    typeBreakdown: Record<string, number>;
-};
-
-declare interface GetterExecutionContext {
-    tracker: GetterState | null;
-    currentBloc: StateContainerInstance | null;
-    depth: number;
-    visitedBlocs: Set<StateContainerInstance>;
-}
-
 /* Excluded from this release type: GetterState */
 
-/* Excluded from this release type: getValueAtPath */
-
 /**
  * Global default registry instance
  */
@@ -745,30 +268,10 @@ export declare const globalRegistry: StateContainerRegistry;
 
 /* Excluded from this release type: hasGetterChanges */
 
-/**
- * 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
- */
-export declare function hasInitHook(plugin: BlacPlugin): plugin is BlacPluginWithInit;
-
 export declare function hasInstance<T extends StateContainerConstructor>(BlocClass: T, instanceKey?: string): boolean;
 
 /* Excluded from this release type: hasTrackedData */
 
-/**
- * Check if tracked state or getters have changed.
- */
-export declare function hasTrackingProxyChanges(tracker: TrackingProxyState, bloc: StateContainerInstance): boolean;
-
-/**
- * Log an info message (tree-shakeable export)
- * @param context - Context identifier (module or component name)
- * @param message - Log message
- * @param data - Optional structured data
- */
-export declare const info: (context: string, message: string, data?: any) => void;
-
 /**
  * Create a reference to a specific bloc instance.
  *
@@ -792,11 +295,6 @@ export declare interface InstanceEntry<T = any> {
     refCount: number;
 }
 
-/**
- * Branded string type for state container instance IDs
- */
-export declare type InstanceId = Brand<string, 'InstanceId'>;
-
 /**
  * Metadata information about a state container instance for debugging and inspection
  */
@@ -835,21 +333,6 @@ export declare type InstanceState<T extends StateContainerConstructor = any> = O
 
 /* Excluded from this release type: invalidateRenderCache */
 
-/**
- * Check if development mode is enabled.
- */
-export declare function isDevMode(): boolean;
-
-/**
- * Check if a class should be excluded from DevTools.
- * Used to prevent infinite loops when DevTools tracks itself.
- * @param Type - The class constructor to check
- * @returns true if the class has `static __excludeFromDevTools = true`
- */
-export declare function isExcludedFromDevTools<T extends StateContainerConstructor>(Type: T): boolean;
-
-/* Excluded from this release type: isGetter */
-
 /**
  * Check if a class is marked as isolated.
  * Isolated classes create separate instances per component.
@@ -858,154 +341,16 @@ export declare function isExcludedFromDevTools<T extends StateContainerConstruct
  */
 export declare function isIsolatedClass<T extends StateContainerConstructor>(Type: T): boolean;
 
-/**
- * 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
- */
-export declare function isIsolatedKey(key: string): boolean;
-
-/**
- * Check if a class is marked as keepAlive.
- * KeepAlive classes are never auto-disposed when ref count reaches 0.
- * @param Type - The class constructor to check
- * @returns true if the class has `static keepAlive = true`
- */
-export declare function isKeepAliveClass<T extends StateContainerConstructor>(Type: T): boolean;
-
-/* Excluded from this release type: isProxyable */
-
-/**
- * Check if a class is a stateless container (StatelessCubit or StatelessVertex).
- * Stateless containers don't have state, emit, update, or subscribe methods.
- * @param Type - The class constructor to check
- * @returns true if the class is a stateless container
- */
-export declare function isStatelessClass<T extends StateContainerConstructor>(Type: T): boolean;
-
-/**
- * Check if a StateContainer constructor is a stateless container.
- * Returns true for StatelessCubit and StatelessVertex classes.
- */
-export declare type IsStatelessContainer<T> = T extends {
-    readonly [STATELESS_MARKER]: true;
-} ? true : false;
-
 /**
  * Lifecycle events emitted by the registry
  */
-export declare type LifecycleEvent = 'created' | 'stateChanged' | 'eventAdded' | 'disposed';
+export declare type LifecycleEvent = 'created' | 'stateChanged' | 'disposed';
 
 /**
  * Listener function type for each lifecycle event
  * @template E - The lifecycle event type
  */
-export declare type LifecycleListener<E extends LifecycleEvent> = E extends 'created' ? (container: StateContainer<any>) => void : E extends 'stateChanged' ? (container: StateContainer<any>, previousState: any, currentState: any, callstack?: string) => void : E extends 'eventAdded' ? (container: Vertex<any, any>, event: any) => void : E extends 'disposed' ? (container: StateContainer<any>) => void : never;
-
-/**
- * Configuration for the logger
- */
-export declare interface LogConfig {
-    /** Whether logging is enabled */
-    enabled: boolean;
-    /** Minimum log level to output */
-    level: LogLevel;
-    /** Function called to output log entries */
-    output: (entry: LogEntry) => void;
-}
-
-/**
- * Structure of a log entry passed to output handlers
- */
-export declare interface LogEntry {
-    /** Log level as string (DEBUG, INFO, WARN, ERROR) */
-    level: string;
-    /** Context identifier (typically component or module name) */
-    context: string;
-    /** Log message */
-    message: string;
-    /** Optional structured data */
-    data?: any;
-    /** Unix timestamp in milliseconds */
-    timestamp: number;
-}
-
-/**
- * Log severity levels (lower number = higher severity)
- */
-export declare enum LogLevel {
-    /** Critical errors that may cause application failure */
-    ERROR = 0,
-    /** Warning conditions that should be addressed */
-    WARN = 1,
-    /** Informational messages about application state */
-    INFO = 2,
-    /** Detailed debugging information */
-    DEBUG = 3
-}
-
-/**
- * Configuration for manual dependency tracking mode
- * @template TBloc - The state container type
- */
-export declare interface ManualDepsConfig<TBloc extends StateContainerConstructor> {
-    /** Function that returns dependency array from state and bloc */
-    dependencies: (state: ExtractState<TBloc>, bloc: InstanceState<TBloc>) => any[];
-}
-
-/**
- * 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
- */
-export declare function manualDepsInit<TBloc extends StateContainerConstructor>(instance: InstanceState<TBloc>): AdapterState<TBloc>;
-
-/**
- * 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
- */
-export declare function manualDepsSnapshot<TBloc extends StateContainerConstructor>(instance: InstanceState<TBloc>, adapterState: AdapterState<TBloc>, config: ManualDepsConfig<TBloc>): SnapshotFunction<ExtractState<TBloc>>;
-
-/**
- * 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
- */
-export declare function manualDepsSubscribe<TBloc extends StateContainerConstructor>(instance: InstanceState<TBloc>, adapterState: AdapterState<TBloc>, config: ManualDepsConfig<TBloc>): SubscribeFunction;
-
-/**
- * Initialize adapter state for no-tracking mode.
- * No tracking or proxy is created.
- * @param instance - The state container instance
- * @returns Initialized adapter state
- */
-export declare function noTrackInit<TBloc extends StateContainerConstructor>(instance: InstanceState<TBloc>): AdapterState<TBloc>;
-
-/**
- * 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
- */
-export declare function noTrackSnapshot<TBloc extends StateContainerConstructor>(instance: InstanceReadonlyState<TBloc>): SnapshotFunction<ExtractState<TBloc>>;
-
-/**
- * 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
- */
-export declare function noTrackSubscribe<TBloc extends StateContainerInstance>(instance: TBloc): SubscribeFunction;
-
-/* Excluded from this release type: parsePath */
+export declare type LifecycleListener<E extends LifecycleEvent> = E extends 'created' ? (container: StateContainer<any>) => void : E extends 'stateChanged' ? (container: StateContainer<any>, previousState: any, currentState: any, callstack?: string) => void : E extends 'disposed' ? (container: StateContainer<any>) => void : never;
 
 /* Excluded from this release type: PathInfo */
 
@@ -1125,42 +470,22 @@ export declare class PluginManager {
 
 /* Excluded from this release type: ProxyState */
 
-export declare function register<T extends StateContainerConstructor>(BlocClass: T, isolated?: boolean): void;
-
 export declare function release<T extends StateContainerConstructor>(BlocClass: T, instanceKey?: string, forceDispose?: boolean): void;
 
-/* Excluded from this release type: resetBlacConfig */
-
-/* Excluded from this release type: resetGetterState */
+/* Excluded from this release type: resolveDependencies */
 
 /* Excluded from this release type: setActiveTracker */
 
-export declare function setRegistry(registry: StateContainerRegistry): void;
-
 /* Excluded from this release type: shallowEqual */
 
-/**
- * Function that returns a snapshot of the current state
- * @template TState - The state type
- */
-export declare type SnapshotFunction<TState> = () => TState;
-
 /* Excluded from this release type: startDependency */
 
-/* Excluded from this release type: startProxy */
-
-/**
- * Start tracking on a tracking proxy.
- */
-export declare function startTrackingProxy(tracker: TrackingProxyState): void;
-
 /**
  * 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
@@ -1174,14 +499,13 @@ export declare function startTrackingProxy(tracker: TrackingProxyState): void;
  * }
  * ```
  */
-export declare abstract class StateContainer<S extends object = any, P = any> {
+export declare abstract class StateContainer<S extends object = any> {
     static __excludeFromDevTools: boolean;
     static enableStackTrace: boolean;
     private _state;
     private readonly listeners;
     private _disposed;
     private config;
-    private _props;
     private readonly systemEventHandlers;
     /** Display name for this instance */
     name: string;
@@ -1191,8 +515,9 @@ export declare abstract class StateContainer<S extends object = any, P = any> {
     instanceId: string;
     /** Timestamp when this instance was created */
     createdAt: number;
-    /** Current props value passed to this container */
-    get props(): P | undefined;
+    private _dependencies;
+    get dependencies(): ReadonlyMap<StateContainerConstructor, string>;
+    protected depend<T extends StateContainerConstructor>(Type: T, instanceKey?: string): () => InstanceType<T>;
     constructor(initialState: S);
     /**
      * Initialize configuration for this instance.
@@ -1239,14 +564,8 @@ export declare abstract class StateContainer<S extends object = any, P = any> {
      * @returns Unsubscribe function
      * @protected
      */
-    protected onSystemEvent: <E extends SystemEvent>(event: E, handler: SystemEventHandler<S, P, E>) => (() => void);
+    protected onSystemEvent: <E extends SystemEvent>(event: E, handler: SystemEventHandler<S, E>) => (() => void);
     private emitSystemEvent;
-    /**
-     * Update the props for this container.
-     * Emits the 'propsUpdated' system event.
-     * @param newProps - The new props value
-     */
-    updateProps(newProps: P): void;
 }
 
 /**
@@ -1264,11 +583,10 @@ export declare interface StateContainerConfig {
 /**
  * Constructor type for StateContainer classes
  * @template S - State type managed by the container
- * @template P - Props type passed to the container
  */
-export declare type StateContainerConstructor<S extends object = any, P = any> = new (...args: any[]) => StateContainer<S, P>;
+export declare type StateContainerConstructor<S extends object = any> = new (...args: any[]) => StateContainer<S>;
 
-export declare type StateContainerInstance<S extends object = any, P = any> = Omit<StateContainer<S, P>, 'state'> & {
+export declare type StateContainerInstance<S extends object = any> = Omit<StateContainer<S>, 'state'> & {
     state: Readonly<S>;
 };
 
@@ -1286,7 +604,7 @@ export declare type StateContainerInstance<S extends object = any, P = any> = Om
  * });
  * ```
  */
-export declare class StateContainerRegistry {
+declare class StateContainerRegistry {
     private readonly instancesByConstructor;
     private readonly types;
     private readonly typeConfigs;
@@ -1308,7 +626,6 @@ export declare class StateContainerRegistry {
      * Get the instances Map for a specific class (public API for stats/debugging)
      */
     getInstancesMap<T extends StateContainerConstructor>(Type: T): Map<string, InstanceEntry>;
-    private trackExecutionContext;
     /**
      * Acquire an instance with ref counting (ownership semantics).
      * Creates a new instance if one doesn't exist, or returns existing and increments ref count.
@@ -1318,15 +635,11 @@ export declare class StateContainerRegistry {
      * @param options - Acquisition options
      * @param options.canCreate - Whether to create new instance if not found (default: true)
      * @param options.countRef - Whether to increment ref count (default: true)
-     * @param options.props - Props to pass to constructor if creating new instance
-     * @param options.trackExecutionContext - Whether to track cross-bloc dependency (default: false)
      * @returns The state container instance
      */
     acquire<T extends StateContainerConstructor = StateContainerConstructor>(Type: T, instanceKey?: string, options?: {
         canCreate?: boolean;
         countRef?: boolean;
-        props?: ExtractProps<T>;
-        trackExecutionContext?: boolean;
     }): InstanceType<T>;
     /**
      * Borrow an existing instance without incrementing ref count (borrowing semantics).
@@ -1434,224 +747,24 @@ export declare class StateContainerRegistry {
     /* Excluded from this release type: emit */
 }
 
-/**
- * Constrain a type to only accept stateful containers (not StatelessCubit/StatelessVertex).
- * Use this to reject stateless containers at the type level.
- */
-export declare type StatefulContainerOnly<T extends StateContainerConstructor> = IsStatelessContainer<T> extends true ? never : T;
-
-/**
- * Marker symbol to identify stateless containers at the type level.
- * Used by React hooks to prevent `useBloc` from accepting stateless containers.
- */
-export declare const STATELESS_MARKER: unique symbol;
-
-/**
- * A Cubit without state management capabilities.
- * Use this for action-only containers that don't need to manage or emit state.
- *
- * StatelessCubit:
- * - Has no `emit()`, `update()`, or `patch()` methods
- * - Has no accessible `state` property
- * - Cannot be subscribed to (throws error)
- * - Is rejected by `useBloc` hook (use `useBlocActions` instead)
- *
- * @template P - Props type (optional)
- *
- * @example
- * ```typescript
- * class AnalyticsService extends StatelessCubit {
- *   trackPageView(page: string) {
- *     analytics.track('page_view', { page });
- *   }
- *
- *   trackClick(element: string) {
- *     analytics.track('click', { element });
- *   }
- * }
- *
- * // In React component:
- * const analytics = useBlocActions(AnalyticsService);
- * analytics.trackPageView('/home');
- * ```
- */
-export declare abstract class StatelessCubit<P = undefined> extends Cubit<EmptyState, P> {
-    /* Excluded from this release type: [STATELESS_MARKER] */
-    constructor();
-    /**
-     * State is not available on StatelessCubit.
-     * @throws Always throws an error when accessed.
-     */
-    get state(): never;
-    /**
-     * Subscriptions are not available on StatelessCubit.
-     * @throws Always throws an error when called.
-     */
-    subscribe(_listener: (state: EmptyState) => void): never;
-    /**
-     * emit() is not available on StatelessCubit.
-     * TypeScript will show an error if you try to call this method.
-     */
-    emit(_newState: never): never;
-    /**
-     * update() is not available on StatelessCubit.
-     * TypeScript will show an error if you try to call this method.
-     */
-    update(_updater: never): never;
-    /**
-     * patch() is not available on StatelessCubit.
-     * @throws Error always - StatelessCubit does not support state changes
-     */
-    patch: (_partial: Partial<EmptyState>) => void;
-}
-
-/**
- * Event handler for StatelessVertex that receives only the event (no emit function).
- * Use for side-effect-only event processing.
- */
-export declare type StatelessEventHandler<E extends DiscriminatedEvent> = (event: EventWithMetadata<E>) => void;
-
-/**
- * Map of event types to their handlers for StatelessVertex.
- * Enforces exhaustive handling of all event types in the union.
- */
-export declare type StatelessEventHandlerMap<E extends DiscriminatedEvent> = {
-    [K in E['type']]: StatelessEventHandler<Extract<E, {
-        type: K;
-    }>>;
-};
-
-/**
- * An event-driven container without state management capabilities.
- * Use this for event processing that only produces side effects (logging, analytics, etc).
- *
- * StatelessVertex:
- * - Processes events via `add()` method
- * - Handlers receive only the event (no `emit` function)
- * - Has no accessible `state` property
- * - Cannot be subscribed to (throws error)
- * - Is rejected by `useBloc` hook (use `useBlocActions` instead)
- *
- * @template E - Event union type (discriminated by 'type' property)
- * @template P - Props type (optional)
- *
- * @example
- * ```typescript
- * type LogEvent =
- *   | { type: 'info'; message: string }
- *   | { type: 'error'; message: string; error: Error }
- *   | { type: 'warn'; message: string };
- *
- * class LoggingVertex extends StatelessVertex<LogEvent> {
- *   constructor() {
- *     super();
- *     this.createHandlers({
- *       info: (event) => console.log('[INFO]', event.message),
- *       error: (event) => console.error('[ERROR]', event.message, event.error),
- *       warn: (event) => console.warn('[WARN]', event.message),
- *     });
- *   }
- *
- *   info = (message: string) => this.add({ type: 'info', message });
- *   error = (message: string, error: Error) => this.add({ type: 'error', message, error });
- *   warn = (message: string) => this.add({ type: 'warn', message });
- * }
- *
- * // In React component:
- * const logger = useBlocActions(LoggingVertex);
- * logger.info('Page loaded');
- * ```
- */
-export declare abstract class StatelessVertex<E extends DiscriminatedEvent = DiscriminatedEvent, P = undefined> extends StateContainer<EmptyState_2, P> {
-    /* Excluded from this release type: [STATELESS_MARKER] */
-    /* Excluded from this release type: handlers */
-    /* Excluded from this release type: isProcessing */
-    /* Excluded from this release type: eventQueue */
-    constructor();
-    /**
-     * State is not available on StatelessVertex.
-     * @throws Always throws an error when accessed.
-     */
-    get state(): never;
-    /**
-     * Subscriptions are not available on StatelessVertex.
-     * @throws Always throws an error when called.
-     */
-    subscribe(_listener: (state: EmptyState_2) => void): never;
-    /**
-     * Register all event handlers with exhaustive type checking.
-     * TypeScript will error if any event type from the union is missing.
-     *
-     * Unlike regular Vertex, handlers do NOT receive an emit function
-     * since StatelessVertex cannot emit state.
-     *
-     * @param handlers - Map of event type to handler function
-     */
-    protected createHandlers(handlers: StatelessEventHandlerMap<E>): void;
-    /**
-     * Dispatch an event for processing.
-     * Events are processed synchronously; if called during processing,
-     * the event is queued and processed after the current event completes.
-     *
-     * @param event - The event to process (must match the event union type)
-     */
-    add: (event: E) => void;
-    /* Excluded from this release type: enrichEvent */
-    /* Excluded from this release type: processEvent */
-    /* Excluded from this release type: handleEvent */
-    /**
-     * Called when an error occurs during event processing.
-     * Override to implement custom error handling.
-     *
-     * @param _event - The event that caused the error
-     * @param _error - The error that occurred
-     */
-    protected onEventError(_event: EventWithMetadata<E>, _error: Error): void;
-    /* Excluded from this release type: emit */
-    /* Excluded from this release type: update */
-}
-
 /* Excluded from this release type: StateListener */
 
 declare const STOP: unique symbol;
 
-/* Excluded from this release type: stopProxy */
-
 declare type StopSymbol = typeof STOP;
 
-/**
- * Stop tracking and collect all dependencies.
- */
-export declare function stopTrackingProxy(tracker: TrackingProxyState, bloc: StateContainerInstance): Set<StateContainerInstance>;
-
-/**
- * Function that subscribes to state changes and returns an unsubscribe function
- */
-export declare type SubscribeFunction = (callback: SubscriptionCallback) => () => void;
-
-/**
- * Callback function invoked when subscribed state changes
- */
-export declare type SubscriptionCallback = () => void;
-
 /**
  * System events emitted by StateContainer lifecycle
  */
-export declare type SystemEvent = 'propsUpdated' | 'stateChanged' | 'dispose';
+export declare type SystemEvent = 'stateChanged' | 'dispose';
 
 /* Excluded from this release type: SystemEventHandler */
 
 /**
  * Payload types for each system event
  * @template S - State type
- * @template P - Props type
  */
-export declare interface SystemEventPayloads<S, P> {
-    /** Emitted when props are updated via updateProps() */
-    propsUpdated: {
-        props: P;
-        previousProps: P | undefined;
-    };
+export declare interface SystemEventPayloads<S> {
     /** Emitted when state changes via emit() or update() */
     stateChanged: {
         state: S;
@@ -1661,220 +774,6 @@ export declare interface SystemEventPayloads<S, P> {
     dispose: void;
 }
 
-/**
- * Run a callback while tracking all bloc dependencies accessed.
- * Returns both the result and the set of discovered dependencies.
- *
- * @example
- * ```ts
- * const { result, dependencies } = tracked(() => {
- *   const user = ensure(UserBloc);
- *   return user.fullName; // getter that may access other blocs
- * });
- * // dependencies contains UserBloc + any blocs accessed in fullName getter
- * ```
- */
-export declare function tracked<T>(callback: () => T, options?: TrackedOptions): TrackedResult<T>;
-
-/**
- * Context for running tracked callbacks with bloc proxies.
- * Provides methods to create proxies and check for changes.
- */
-export declare class TrackedContext {
-    private tracker;
-    private proxiedBlocs;
-    private primaryBlocs;
-    constructor();
-    /**
-     * Get a tracking proxy for a bloc instance.
-     * The proxy will track state and getter accesses.
-     */
-    proxy<T extends StateContainerInstance>(bloc: T): T;
-    /**
-     * Start tracking for a new callback execution.
-     */
-    start(): void;
-    /**
-     * Stop tracking and get discovered dependencies.
-     * Excludes primary blocs (those explicitly proxied via proxy()).
-     */
-    stop(): Set<StateContainerInstance>;
-    /**
-     * Check if any tracked state or getters have changed.
-     */
-    changed(): boolean;
-    /**
-     * Get all primary blocs (those explicitly proxied).
-     */
-    getPrimaryBlocs(): Set<StateContainerInstance>;
-    /**
-     * Reset the context for reuse.
-     */
-    reset(): void;
-}
-
-/**
- * Options for the tracked() function.
- */
-export declare interface TrackedOptions {
-    exclude?: StateContainerInstance;
-}
-
-/**
- * Result of running a tracked callback.
- */
-export declare interface TrackedResult<T> {
-    result: T;
-    dependencies: Set<StateContainerInstance>;
-}
-
-/**
- * State for tracking both state property access and getter access.
- */
-export declare interface TrackingProxyState {
-    dependencyState: DependencyState<any>;
-    getterState: GetterState;
-    dependencies: Set<StateContainerInstance>;
-    isTracking: boolean;
-}
-
-/**
- * Event-driven state container using discriminated union events.
- * Extends StateContainer with event-based state transitions and
- * compile-time exhaustive checking for event handlers.
- *
- * @template S - State type (must be an object)
- * @template E - Event union type (discriminated by 'type' property)
- * @template P - Props type (optional)
- *
- * @example
- * ```typescript
- * type CounterEvent =
- *   | { type: 'increment'; amount: number }
- *   | { type: 'decrement' }
- *   | { type: 'reset' };
- *
- * class CounterVertex extends Vertex<{ count: number }, CounterEvent> {
- *   constructor() {
- *     super({ count: 0 });
- *     this.createHandlers({
- *       increment: (event, emit) => {
- *         emit({ count: this.state.count + event.amount });
- *       },
- *       decrement: (_, emit) => {
- *         emit({ count: this.state.count - 1 });
- *       },
- *       reset: (_, emit) => {
- *         emit({ count: 0 });
- *       },
- *     });
- *   }
- *
- *   increment = (amount = 1) => this.add({ type: 'increment', amount });
- * }
- * ```
- */
-export declare abstract class Vertex<S extends object = object, E extends DiscriminatedEvent = DiscriminatedEvent, P = undefined> extends StateContainer<S, P> {
-    /* Excluded from this release type: handlers */
-    /* Excluded from this release type: isProcessing */
-    /* Excluded from this release type: eventQueue */
-    constructor(initialState: S);
-    /**
-     * Register all event handlers with exhaustive type checking.
-     * TypeScript will error if any event type from the union is missing.
-     *
-     * @param handlers - Map of event type to handler function
-     */
-    protected createHandlers(handlers: EventHandlerMap<E, S>): void;
-    /**
-     * Dispatch an event for processing.
-     * Events are processed synchronously; if called during processing,
-     * the event is queued and processed after the current event completes.
-     *
-     * @param event - The event to process (must match the event union type)
-     */
-    add: (event: E) => void;
-    /* Excluded from this release type: enrichEvent */
-    /* Excluded from this release type: processEvent */
-    /* Excluded from this release type: handleEvent */
-    /**
-     * Called when an error occurs during event processing.
-     * Override to implement custom error handling.
-     *
-     * @param _event - The event that caused the error
-     * @param _error - The error that occurred
-     */
-    protected onEventError(_event: EventWithMetadata<E>, _error: Error): void;
-}
-
-/* Excluded from this release type: VertexEventHandler */
-
-/**
- * Wait until a condition is met on a bloc instance.
- * Returns the bloc instance when the predicate returns true.
- * Automatically tracks dependencies accessed in the predicate.
- *
- * @example
- * ```ts
- * // Wait for bloc state to be ready
- * const userBloc = await waitUntil(UserBloc, (bloc) => bloc.state.isAuthenticated);
- *
- * // Wait using a getter
- * const userBloc = await waitUntil(UserBloc, (bloc) => bloc.isReady);
- * ```
- */
-export declare function waitUntil<T extends StateContainerConstructor>(BlocClass: T, predicate: (bloc: InstanceType<T>) => boolean, options?: WaitUntilOptions): Promise<InstanceType<T>>;
-
-/**
- * Wait until a condition is met on a selected value from a bloc.
- * Returns the selected value when the predicate returns true.
- * Automatically tracks dependencies accessed in selector and predicate.
- *
- * @example
- * ```ts
- * // Wait for layout to be set and get it directly
- * const layout = await waitUntil(
- *   LayoutBloc,
- *   (bloc) => bloc.state.currentLayout,
- *   (layout) => layout !== null
- * );
- *
- * // Using a getter as selector
- * const user = await waitUntil(
- *   UserBloc,
- *   (bloc) => bloc.currentUser,
- *   (user) => user !== null
- * );
- * ```
- */
-export declare function waitUntil<T extends StateContainerConstructor, TSelected>(BlocClass: T, selector: (bloc: InstanceType<T>) => TSelected, predicate: (selected: TSelected) => boolean, options?: WaitUntilOptions): Promise<TSelected>;
-
-export declare class WaitUntilAbortedError extends Error {
-    constructor();
-}
-
-export declare class WaitUntilDisposedError extends Error {
-    constructor(blocName: string);
-}
-
-export declare interface WaitUntilOptions {
-    instanceId?: string;
-    timeout?: number;
-    signal?: AbortSignal;
-}
-
-export declare class WaitUntilTimeoutError extends Error {
-    constructor(timeout: number);
-}
-
-/**
- * Log a warning message (tree-shakeable export)
- * @param context - Context identifier (module or component name)
- * @param message - Log message
- * @param data - Optional structured data
- */
-export declare const warn: (context: string, message: string, data?: any) => void;
-
 export declare const watch: WatchFn;
 
 /**