@blac/core 2.0.3 → 2.0.5

package/dist/index.d.ts

@@ -1,794 +1,18 @@
-export declare function acquire<T extends StateContainerConstructor>(BlocClass: T, instanceKey?: string): InstanceType<T>;
-
-/**
- * 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> {}
- * );
- * ```
- */
-export declare function blac(options: BlacOptions): <T extends new (...args: any[]) => any>(target: T, _context?: ClassDecoratorContext) => T;
-
-/**
- * Configuration options for the @blac decorator.
- * Only one option can be specified at a time (union type).
- */
-export declare type BlacOptions = 
-/** Mark bloc as isolated (each component gets its own instance) */
-    {
-    isolated: true;
-}
-/** Mark bloc to never be auto-disposed when ref count reaches 0 */
-| {
-    keepAlive: true;
-}
-/** Exclude bloc from DevTools tracking (prevents infinite loops) */
-| {
-    excludeFromDevTools: true;
-};
-
-/**
- * Interface for plugins that extend BlaC functionality
- */
-export declare interface BlacPlugin {
-    /** Unique plugin identifier */
-    readonly name: string;
-    /** Plugin version identifier */
-    readonly version: string;
-    /**
-     * Called when the plugin is installed (optional)
-     */
-    onInstall?(context: PluginContext): void;
-    /**
-     * Called when the plugin is uninstalled
-     */
-    onUninstall?(): void;
-    /**
-     * Called when a state container instance is created
-     */
-    onInstanceCreated?(instance: StateContainer<any>, context: PluginContext): void;
-    /**
-     * 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 a state container instance is disposed
-     */
-    onInstanceDisposed?(instance: StateContainer<any>, context: PluginContext): void;
-}
-
-/**
- * Plugin interface variant that requires mandatory onInstall hook
- */
-export declare interface BlacPluginWithInit extends BlacPlugin {
-    /**
-     * Required initialization hook called when plugin is installed
-     */
-    onInstall(context: PluginContext): void;
-}
-
-declare const BLOC_REF_MARKER: unique symbol;
-
-/**
- * Constructor type for StateContainer classes with static registry methods.
- * 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> = 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[]): {
-        error: Error;
-        instance: null;
-    } | {
-        error: null;
-        instance: InstanceType<T>;
-    };
-    ensure(instanceKey?: string): InstanceType<T>;
-    release(instanceKey?: string): void;
-    isolated?: boolean;
-    keepAlive?: boolean;
-};
-
-declare type BlocInput = StateContainerConstructor | BlocRef<StateContainerConstructor>;
-
-/**
- * Extract instance type from an abstract class constructor
- * @template T - The abstract class constructor type
- */
-export declare type BlocInstanceType<T extends abstract new (...args: any) => any> = T extends abstract new (...args: any) => infer R ? R : any;
-
-/**
- * Reference to a specific bloc instance by class and instance ID.
- */
-export declare interface BlocRef<T extends StateContainerConstructor> {
-    [BLOC_REF_MARKER]: true;
-    blocClass: T;
-    instanceId: string;
-}
-
-export declare function borrow<T extends StateContainerConstructor>(BlocClass: T, instanceKey?: string): InstanceType<T>;
-
-export declare function borrowSafe<T extends StateContainerConstructor>(BlocClass: T, instanceKey?: string): {
-    error: Error;
-    instance: null;
-} | {
-    error: null;
-    instance: InstanceType<T>;
-};
-
-/* Excluded from this release type: capturePaths */
-
-export declare function clear<T extends StateContainerConstructor>(BlocClass: T): void;
-
-/* Excluded from this release type: clearActiveTracker */
-
-export declare function clearAll(): void;
-
-/* Excluded from this release type: clearExternalDependencies */
-
-/* Excluded from this release type: commitTrackedGetters */
-
-/* Excluded from this release type: createBlocProxy */
-
-/* Excluded from this release type: createDependencyProxy */
-
-/* Excluded from this release type: createDependencyState */
-
-/* Excluded from this release type: createGetterState */
-
-/**
- * Simple state container with direct state emission.
- * Extends StateContainer with public methods for emitting and updating state.
- *
- * @template S - State type
- */
-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
-     * @param newState - The new state value
-     */
-    emit(newState: S): void;
-    /**
-     * 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: (current: S) => S): void;
-    /**
-     * Merge partial state changes into current state (only for object states)
-     */
-    patch: S extends object ? (partial: Partial<S>) => void : never;
-}
-
-/**
- * Manages subscriptions to state container dependencies.
- * Provides efficient sync mechanism to add/remove subscriptions
- * as dependencies change between callback invocations.
- */
-export declare class DependencyManager {
-    private subscriptions;
-    private currentDeps;
-    /**
-     * Sync subscriptions with a new set of dependencies.
-     * Adds subscriptions for new deps, removes subscriptions for stale deps.
-     *
-     * @param newDeps - The new set of dependencies to subscribe to
-     * @param onChange - Callback to invoke when any dependency changes
-     * @param exclude - Optional instance to exclude from subscriptions (e.g., primary bloc)
-     * @returns true if the dependency set changed, false if unchanged
-     */
-    sync(newDeps: Set<StateContainerInstance>, onChange: () => void, exclude?: StateContainerInstance): boolean;
-    /**
-     * Add a single dependency subscription.
-     */
-    add(dep: StateContainerInstance, onChange: () => void): void;
-    /**
-     * Check if a dependency is currently subscribed.
-     */
-    has(dep: StateContainerInstance): boolean;
-    /**
-     * Get the current set of dependencies.
-     */
-    getDependencies(): Set<StateContainerInstance>;
-    /**
-     * Clean up all active subscriptions.
-     */
-    cleanup(): void;
-    private areSetsEqual;
-}
-
-/* Excluded from this release type: DependencyState */
-
-export declare function ensure<T extends StateContainerConstructor>(BlocClass: T, instanceKey?: string): InstanceType<T>;
-
-/**
- * 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[];
-
-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 state type from a StateContainer
- * @template T - The StateContainer type
- */
-export declare type ExtractState<T> = T extends StateContainerConstructor<infer S> ? Readonly<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 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
- */
-export declare function generateIsolatedKey(): string;
-
-export declare function getAll<T extends StateContainerConstructor>(BlocClass: T): InstanceReadonlyState<T>[];
-
-/**
- * Get the global plugin manager
- */
-export declare function getPluginManager(): any;
-
-export declare function getRefCount<T extends StateContainerConstructor>(BlocClass: T, instanceKey?: string): number;
-
-/* Excluded from this release type: GetterState */
-
-/**
- * Global default registry instance
- */
-export declare const globalRegistry: StateContainerRegistry;
-
-/* Excluded from this release type: hasDependencyChanges */
-
-/* Excluded from this release type: hasGetterChanges */
-
-export declare function hasInstance<T extends StateContainerConstructor>(BlocClass: T, instanceKey?: string): boolean;
-
-/* Excluded from this release type: hasTrackedData */
-
-/**
- * Create a reference to a specific bloc instance.
- *
- * @example
- * ```ts
- * watch(instance(UserBloc, 'user-123'), (userBloc) => {
- *   console.log(userBloc.state.name);
- * });
- * ```
- */
-export declare function instance<T extends StateContainerConstructor>(BlocClass: T, instanceId: string): BlocRef<T>;
-
-/**
- * Entry in the instance registry, tracking the instance and its reference count
- * @template T - Instance type
- */
-export declare interface InstanceEntry<T = any> {
-    /** The state container instance */
-    instance: T;
-    /** Number of active references to this instance */
-    refCount: number;
-}
-
-/**
- * Metadata information about a state container instance for debugging and inspection
- */
-export declare interface InstanceMetadata {
-    /** Unique instance identifier */
-    id: string;
-    /** Name of the state container class */
-    className: string;
-    /** Whether the instance has been disposed */
-    isDisposed: boolean;
-    /** Display name for the instance */
-    name: string;
-    /** When state last changed (milliseconds) */
-    lastStateChangeTimestamp: number;
-    /** Current state value */
-    state: any;
-    /** Timestamp when instance was created (milliseconds) */
-    createdAt: number;
-    /** Whether this is an isolated (component-scoped) instance */
-    isIsolated: boolean;
-    /** Stack trace from when instance was created (for debugging) */
-    callstack?: string;
-    /** Previous state value */
-    previousState?: any;
-    /** Current state value */
-    currentState?: any;
-}
-
-export declare type InstanceReadonlyState<T extends StateContainerConstructor = any> = Omit<InstanceType<T>, 'state'> & {
-    state: ExtractState<T>;
-};
-
-export declare type InstanceState<T extends StateContainerConstructor = any> = Omit<InstanceType<T>, 'state'> & {
-    state: ExtractStateMutable<T>;
-};
-
-/* Excluded from this release type: invalidateRenderCache */
-
-/**
- * Check if a class is marked as isolated.
- * Isolated classes create separate instances per component.
- * @param Type - The class constructor to check
- * @returns true if the class has `static isolated = true`
- */
-export declare function isIsolatedClass<T extends StateContainerConstructor>(Type: T): boolean;
-
-/**
- * Lifecycle events emitted by the registry
- */
-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 'disposed' ? (container: StateContainer<any>) => void : never;
-
-/* Excluded from this release type: PathInfo */
-
-/**
- * Configuration options for plugin installation
- */
-export declare interface PluginConfig {
-    /** Enable or disable the plugin */
-    enabled?: boolean;
-    /** Environments where plugin runs */
-    environment?: 'development' | 'production' | 'test' | 'all';
-}
-
-/**
- * Safe context API provided to plugins for accessing registry data
- */
-export declare interface PluginContext {
-    /**
-     * Get metadata for a specific instance
-     */
-    getInstanceMetadata(instance: StateContainer<any>): InstanceMetadata;
-    /**
-     * Get current state from a container
-     */
-    getState<S extends object = any>(instance: StateContainer<S>): S;
-    /**
-     * Get all instances of a specific type
-     */
-    queryInstances<T extends StateContainer<any>>(typeClass: new (...args: any[]) => T): T[];
-    /**
-     * Get all registered state container types
-     */
-    getAllTypes(): Array<new (...args: any[]) => StateContainer<any>>;
-    /**
-     * Get registry statistics
-     */
-    getStats(): {
-        registeredTypes: number;
-        totalInstances: number;
-        typeBreakdown: Record<string, number>;
-    };
-}
-
-/**
- * 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' });
- * ```
- */
-export declare class PluginManager {
-    private plugins;
-    private registry;
-    /**
-     * Create a new PluginManager
-     * @param registry - The StateContainerRegistry to monitor for lifecycle events
-     */
-    constructor(registry: StateContainerRegistry);
-    /**
-     * 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: BlacPlugin, config?: PluginConfig): void;
-    /**
-     * Uninstall a plugin by name
-     * @param pluginName - The name of the plugin to uninstall
-     * @throws Error if plugin is not installed
-     */
-    uninstall(pluginName: string): void;
-    /**
-     * 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: string): BlacPlugin | undefined;
-    /**
-     * Get all installed plugins
-     * @returns Array of all installed plugins
-     */
-    getAllPlugins(): BlacPlugin[];
-    /**
-     * Check if a plugin is installed
-     * @param pluginName - The name of the plugin to check
-     * @returns true if the plugin is installed
-     */
-    hasPlugin(pluginName: string): boolean;
-    /**
-     * Uninstall all plugins
-     */
-    clear(): void;
-    /**
-     * Setup lifecycle hooks to notify plugins
-     */
-    private setupLifecycleHooks;
-    /**
-     * Notify all plugins of a lifecycle event
-     */
-    private notifyPlugins;
-    /**
-     * Create plugin context with safe API access
-     */
-    private createPluginContext;
-    /**
-     * Check if plugin should be enabled based on environment
-     */
-    private shouldEnablePlugin;
-    /**
-     * Get current environment
-     */
-    private getCurrentEnvironment;
-}
-
-/* Excluded from this release type: ProxyState */
-
-export declare function release<T extends StateContainerConstructor>(BlocClass: T, instanceKey?: string, forceDispose?: boolean): void;
-
-/* Excluded from this release type: setActiveTracker */
-
-/* Excluded from this release type: shallowEqual */
-
-/* Excluded from this release type: startDependency */
-
-/**
- * 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
- *
- * @example
- * ```ts
- * class CounterBloc extends StateContainer<{ count: number }> {
- *   constructor() {
- *     super({ count: 0 });
- *   }
- *   increment() {
- *     this.emit({ count: this.state.count + 1 });
- *   }
- * }
- * ```
- */
-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 readonly systemEventHandlers;
-    /** Display name for this instance */
-    name: string;
-    /** Whether debug logging is enabled */
-    debug: boolean;
-    /** Unique identifier for this instance */
-    instanceId: string;
-    /** Timestamp when this instance was created */
-    createdAt: number;
-    constructor(initialState: S);
-    /**
-     * Initialize configuration for this instance.
-     * Called by the registry after construction.
-     * @param config - Configuration options
-     */
-    initConfig(config: StateContainerConfig): void;
-    /** Current state value */
-    get state(): Readonly<S>;
-    /** Whether this instance has been disposed */
-    get isDisposed(): boolean;
-    /**
-     * Subscribe to state changes
-     * @param listener - Function called when state changes
-     * @returns Unsubscribe function
-     */
-    subscribe(listener: StateListener<S>): () => void;
-    /**
-     * Dispose this instance and clean up resources.
-     * Clears all listeners and emits the 'dispose' system event.
-     */
-    dispose(): void;
-    /**
-     * Emit a new state value and notify all listeners.
-     * @param newState - The new state value
-     * @protected
-     */
-    protected emit(newState: S): void;
-    private captureStackTrace;
-    private formatStackLine;
-    private cleanFilePath;
-    /** Timestamp of the last state update */
-    lastUpdateTimestamp: number;
-    /**
-     * Update state using a transform function.
-     * @param updater - Function that receives current state and returns new state
-     * @protected
-     */
-    protected update(updater: (current: S) => S): void;
-    /**
-     * Subscribe to system lifecycle events.
-     * @param event - The event type to listen for
-     * @param handler - Handler function called when event occurs
-     * @returns Unsubscribe function
-     * @protected
-     */
-    protected onSystemEvent: <E extends SystemEvent>(event: E, handler: SystemEventHandler<S, E>) => (() => void);
-    private emitSystemEvent;
-}
-
-/**
- * Configuration options for initializing a StateContainer instance
- */
-export declare interface StateContainerConfig {
-    /** Display name for the instance (defaults to class name) */
-    name?: string;
-    /** Enable debug logging for this instance */
-    debug?: boolean;
-    /** Custom instance identifier */
-    instanceId?: string;
-}
-
-/**
- * Constructor type for StateContainer classes
- * @template S - State type managed by the container
- */
-export declare type StateContainerConstructor<S extends object = any> = new (...args: any[]) => StateContainer<S>;
-
-export declare type StateContainerInstance<S extends object = any> = Omit<StateContainer<S>, 'state'> & {
-    state: Readonly<S>;
-};
-
-/**
- * Central registry for managing StateContainer instances.
- * Handles instance lifecycle, ref counting, and lifecycle event emission.
- *
- * @example
- * ```ts
- * const registry = new StateContainerRegistry();
- * const instance = registry.acquire(MyBloc);  // ownership, must release
- * const other = registry.ensure(OtherBloc);   // no ownership, bloc-to-bloc
- * registry.on('stateChanged', (container, prev, next) => {
- *   console.log('State changed:', prev, '->', next);
- * });
- * ```
- */
-declare class StateContainerRegistry {
-    private readonly instancesByConstructor;
-    private readonly types;
-    private readonly typeConfigs;
-    private readonly listeners;
-    /**
-     * Register a type for lifecycle event tracking
-     * @param constructor - The StateContainer class constructor
-     */
-    registerType<T extends StateContainerConstructor>(constructor: T): void;
-    /**
-     * 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<T extends StateContainerConstructor>(constructor: T, isolated?: boolean): void;
-    private ensureInstancesMap;
-    /**
-     * 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.
-     * You must call `release()` when done to decrement the ref count.
-     * @param Type - The StateContainer class constructor
-     * @param instanceKey - Instance key (defaults to 'default')
-     * @param options - Acquisition options
-     * @param options.canCreate - Whether to create new instance if not found (default: true)
-     * @param options.countRef - Whether to increment ref count (default: true)
-     * @param options.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;
-        trackExecutionContext?: boolean;
-    }): InstanceType<T>;
-    /**
-     * Borrow an existing instance without incrementing ref count (borrowing semantics).
-     * Tracks cross-bloc dependency for reactive updates.
-     * @param Type - The StateContainer class constructor
-     * @param instanceKey - Instance key (defaults to 'default')
-     * @returns The state container instance
-     * @throws Error if instance doesn't exist
-     */
-    borrow<T extends StateContainerConstructor = StateContainerConstructor>(Type: T, instanceKey?: string): InstanceType<T>;
-    /**
-     * Safely borrow an existing instance (borrowing semantics with error handling).
-     * Returns discriminated union for type-safe conditional access.
-     * @param Type - The StateContainer class constructor
-     * @param instanceKey - Instance key (defaults to 'default')
-     * @returns Discriminated union with either the instance or an error
-     */
-    borrowSafe<T extends StateContainerConstructor = StateContainerConstructor>(Type: T, instanceKey?: string): {
-        error: Error;
-        instance: null;
-    } | {
-        error: null;
-        instance: InstanceType<T>;
-    };
-    /**
-     * Ensure an instance exists without taking ownership (for bloc-to-bloc communication).
-     * Gets existing instance OR creates it if it doesn't exist, without incrementing ref count.
-     * Tracks cross-bloc dependency for reactive updates.
-     *
-     * Use this in bloc-to-bloc communication when you need to ensure an instance exists
-     * but don't want to claim ownership (no ref count increment).
-     * @param Type - The StateContainer class constructor
-     * @param instanceKey - Instance key (defaults to 'default')
-     * @returns The state container instance
-     */
-    ensure<T extends StateContainerConstructor = StateContainerConstructor>(Type: T, instanceKey?: string): InstanceType<T>;
-    /**
-     * Release a reference to an instance.
-     * Decrements ref count and disposes when it reaches 0 (unless keepAlive).
-     * @param Type - The StateContainer class constructor
-     * @param instanceKey - Instance key (defaults to 'default')
-     * @param forceDispose - Force immediate disposal regardless of ref count
-     */
-    release<T extends StateContainerConstructor>(Type: T, instanceKey?: string, forceDispose?: boolean): void;
-    /**
-     * Get all instances of a specific type.
-     * @param Type - The StateContainer class constructor
-     * @returns Array of all instances
-     */
-    getAll<T extends StateContainerConstructor>(Type: T): InstanceReadonlyState<T>[];
-    /**
-     * Safely iterate over all instances of a type.
-     * Skips disposed instances and catches callback errors.
-     * @param Type - The StateContainer class constructor
-     * @param callback - Function to call for each instance
-     */
-    forEach<T extends StateContainerConstructor>(Type: T, callback: (instance: InstanceReadonlyState<T>) => void): void;
-    /**
-     * Clear all instances of a specific type (disposes them).
-     * @param Type - The StateContainer class constructor
-     */
-    clear<T extends StateContainerConstructor>(Type: T): void;
-    /**
-     * Get reference count for an instance.
-     * @param Type - The StateContainer class constructor
-     * @param instanceKey - Instance key (defaults to 'default')
-     * @returns Current ref count (0 if instance doesn't exist)
-     */
-    getRefCount<T extends StateContainerConstructor>(Type: T, instanceKey?: string): number;
-    /**
-     * Check if an instance exists.
-     * @param Type - The StateContainer class constructor
-     * @param instanceKey - Instance key (defaults to 'default')
-     * @returns true if instance exists
-     */
-    hasInstance<T extends StateContainerConstructor>(Type: T, instanceKey?: string): boolean;
-    /**
-     * 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(): void;
-    /**
-     * Get registry statistics for debugging.
-     * @returns Object with registeredTypes, totalInstances, and typeBreakdown
-     */
-    getStats(): {
-        registeredTypes: number;
-        totalInstances: number;
-        typeBreakdown: Record<string, number>;
-    };
-    /**
-     * Get all registered types (for plugin system).
-     * @returns Array of all registered StateContainer class constructors
-     */
-    getTypes(): StateContainerConstructor[];
-    /**
-     * 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<E extends LifecycleEvent>(event: E, listener: LifecycleListener<E>): () => void;
-    /* Excluded from this release type: emit */
-}
-
-/* Excluded from this release type: StateListener */
-
-declare const STOP: unique symbol;
-
-declare type StopSymbol = typeof STOP;
-
-/**
- * System events emitted by StateContainer lifecycle
- */
-export declare type SystemEvent = 'stateChanged' | 'dispose';
-
-/* Excluded from this release type: SystemEventHandler */
-
-/**
- * Payload types for each system event
- * @template S - State type
- */
-export declare interface SystemEventPayloads<S> {
-    /** Emitted when state changes via emit() or update() */
-    stateChanged: {
-        state: S;
-        previousState: S;
-    };
-    /** Emitted when the instance is disposed */
-    dispose: void;
-}
-
-export declare const watch: WatchFn;
-
-/**
- * Combined watch function type.
- */
-export declare interface WatchFn extends WatchSingleFn {
-    <T extends readonly BlocInput[]>(blocs: T, callback: (blocs: ExtractInstances<T>) => void | StopSymbol): () => void;
-}
-
-/**
- * Watch function signature for single bloc.
- */
-declare interface WatchSingleFn {
-    <T extends StateContainerConstructor>(bloc: T | BlocRef<T>, callback: (bloc: InstanceType<T>) => void | StopSymbol): () => void;
-    STOP: StopSymbol;
-}
-
-export { }
+export { StateContainer } from './core/StateContainer';
+export type { StateContainerConfig, SystemEvent, SystemEventPayloads, } from './core/StateContainer';
+export { Cubit } from './core/Cubit';
+export { acquire, borrow, borrowSafe, ensure, release, clear, clearAll, register, hasInstance, getRefCount, getAll, forEach, getRegistry, setRegistry, getStats, } from './registry';
+export { globalRegistry } from './core/StateContainerRegistry';
+export type { LifecycleEvent, LifecycleListener, InstanceEntry, } from './core/StateContainerRegistry';
+export { blac, type BlacOptions } from './decorators';
+export { getPluginManager } from './core/StateContainerRegistry';
+export type { BlacPlugin, BlacPluginWithInit, PluginContext, PluginConfig, InstanceMetadata, } from './plugin/BlacPlugin';
+export { PluginManager } from './plugin/PluginManager';
+export { watch, instance, type WatchFn, type BlocRef } from './watch';
+export { tracked, createTrackedContext, TrackedContext, type TrackedResult, type TrackedOptions, } from './tracking/tracked';
+export type { StateContainerConstructor, ExtractState, ExtractStateMutable, ExtractConstructorArgs, BlocInstanceType, BlocConstructor, InstanceReadonlyState, InstanceState, StateContainerInstance, } from './types/utilities';
+export type { Brand, BrandedId, InstanceId } from './types/branded';
+export { instanceId } from './types/branded';
+export * from './tracking';
+export { isIsolatedClass } from './utils/static-props';
+export { generateIsolatedKey } from './utils/idGenerator';