@blac/core 2.0.5 → 2.0.7

package/dist/config-BD9MkJ0k.js

@@ -0,0 +1,42 @@
+import { n as globalRegistry } from "./StateContainerRegistry-DS_wyKck.js";
+//#region src/registry/queries.ts
+function hasInstance(BlocClass, instanceKey) {
+	return globalRegistry.hasInstance(BlocClass, instanceKey);
+}
+function getRefCount(BlocClass, instanceKey) {
+	return globalRegistry.getRefCount(BlocClass, instanceKey);
+}
+function getAll(BlocClass) {
+	return globalRegistry.getAll(BlocClass);
+}
+function forEach(BlocClass, callback) {
+	globalRegistry.forEach(BlocClass, callback);
+}
+//#endregion
+//#region src/registry/management.ts
+function clear(BlocClass) {
+	globalRegistry.clear(BlocClass);
+}
+function clearAll() {
+	globalRegistry.clearAll();
+}
+function register(BlocClass) {
+	globalRegistry.register(BlocClass);
+}
+//#endregion
+//#region src/registry/config.ts
+let _registry = globalRegistry;
+function getRegistry() {
+	return _registry;
+}
+function setRegistry(registry) {
+	_registry.clearAll();
+	_registry = registry;
+}
+function getStats() {
+	return _registry.getStats();
+}
+//#endregion
+export { clearAll as a, getAll as c, clear as i, getRefCount as l, getStats as n, register as o, setRegistry as r, forEach as s, getRegistry as t, hasInstance as u };
+
+//# sourceMappingURL=config-BD9MkJ0k.js.map

package/dist/config-BD9MkJ0k.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-BD9MkJ0k.js","names":[],"sources":["../src/registry/queries.ts","../src/registry/management.ts","../src/registry/config.ts"],"sourcesContent":["import { globalRegistry } from '../core/StateContainerRegistry';\nimport type {\n  StateContainerConstructor,\n  InstanceReadonlyState,\n} from '../types/utilities';\n\nexport function hasInstance<T extends StateContainerConstructor>(\n  BlocClass: T,\n  instanceKey?: string,\n): boolean {\n  return globalRegistry.hasInstance(BlocClass, instanceKey);\n}\n\nexport function getRefCount<T extends StateContainerConstructor>(\n  BlocClass: T,\n  instanceKey?: string,\n): number {\n  return globalRegistry.getRefCount(BlocClass, instanceKey);\n}\n\nexport function getAll<T extends StateContainerConstructor>(\n  BlocClass: T,\n): InstanceReadonlyState<T>[] {\n  return globalRegistry.getAll(BlocClass);\n}\n\nexport function forEach<T extends StateContainerConstructor>(\n  BlocClass: T,\n  callback: (instance: InstanceReadonlyState<T>) => void,\n): void {\n  globalRegistry.forEach(BlocClass, callback);\n}\n","import { globalRegistry } from '../core/StateContainerRegistry';\nimport type { StateContainerConstructor } from '../types/utilities';\n\nexport function clear<T extends StateContainerConstructor>(BlocClass: T): void {\n  globalRegistry.clear(BlocClass);\n}\n\nexport function clearAll(): void {\n  globalRegistry.clearAll();\n}\n\nexport function register<T extends StateContainerConstructor>(\n  BlocClass: T,\n): void {\n  globalRegistry.register(BlocClass);\n}\n","import {\n  globalRegistry,\n  StateContainerRegistry,\n} from '../core/StateContainerRegistry';\n\nlet _registry = globalRegistry;\n\nexport function getRegistry(): StateContainerRegistry {\n  return _registry;\n}\n\nexport function setRegistry(registry: StateContainerRegistry): void {\n  _registry.clearAll();\n  _registry = registry;\n}\n\nexport function getStats(): {\n  registeredTypes: number;\n  totalInstances: number;\n  typeBreakdown: Record<string, number>;\n} {\n  return _registry.getStats();\n}\n"],"mappings":";;AAMA,SAAgB,YACd,WACA,aACS;AACT,QAAO,eAAe,YAAY,WAAW,YAAY;;AAG3D,SAAgB,YACd,WACA,aACQ;AACR,QAAO,eAAe,YAAY,WAAW,YAAY;;AAG3D,SAAgB,OACd,WAC4B;AAC5B,QAAO,eAAe,OAAO,UAAU;;AAGzC,SAAgB,QACd,WACA,UACM;AACN,gBAAe,QAAQ,WAAW,SAAS;;;;AC3B7C,SAAgB,MAA2C,WAAoB;AAC7E,gBAAe,MAAM,UAAU;;AAGjC,SAAgB,WAAiB;AAC/B,gBAAe,UAAU;;AAG3B,SAAgB,SACd,WACM;AACN,gBAAe,SAAS,UAAU;;;;ACTpC,IAAI,YAAY;AAEhB,SAAgB,cAAsC;AACpD,QAAO;;AAGT,SAAgB,YAAY,UAAwC;AAClE,WAAU,UAAU;AACpB,aAAY;;AAGd,SAAgB,WAId;AACA,QAAO,UAAU,UAAU"}

package/dist/config-DTuCbHcJ.cjs

@@ -0,0 +1,101 @@
+const require_StateContainerRegistry = require("./StateContainerRegistry-COxgpYAw.cjs");
+//#region src/registry/queries.ts
+function hasInstance(BlocClass, instanceKey) {
+	return require_StateContainerRegistry.globalRegistry.hasInstance(BlocClass, instanceKey);
+}
+function getRefCount(BlocClass, instanceKey) {
+	return require_StateContainerRegistry.globalRegistry.getRefCount(BlocClass, instanceKey);
+}
+function getAll(BlocClass) {
+	return require_StateContainerRegistry.globalRegistry.getAll(BlocClass);
+}
+function forEach(BlocClass, callback) {
+	require_StateContainerRegistry.globalRegistry.forEach(BlocClass, callback);
+}
+//#endregion
+//#region src/registry/management.ts
+function clear(BlocClass) {
+	require_StateContainerRegistry.globalRegistry.clear(BlocClass);
+}
+function clearAll() {
+	require_StateContainerRegistry.globalRegistry.clearAll();
+}
+function register(BlocClass) {
+	require_StateContainerRegistry.globalRegistry.register(BlocClass);
+}
+//#endregion
+//#region src/registry/config.ts
+let _registry = require_StateContainerRegistry.globalRegistry;
+function getRegistry() {
+	return _registry;
+}
+function setRegistry(registry) {
+	_registry.clearAll();
+	_registry = registry;
+}
+function getStats() {
+	return _registry.getStats();
+}
+//#endregion
+Object.defineProperty(exports, "clear", {
+	enumerable: true,
+	get: function() {
+		return clear;
+	}
+});
+Object.defineProperty(exports, "clearAll", {
+	enumerable: true,
+	get: function() {
+		return clearAll;
+	}
+});
+Object.defineProperty(exports, "forEach", {
+	enumerable: true,
+	get: function() {
+		return forEach;
+	}
+});
+Object.defineProperty(exports, "getAll", {
+	enumerable: true,
+	get: function() {
+		return getAll;
+	}
+});
+Object.defineProperty(exports, "getRefCount", {
+	enumerable: true,
+	get: function() {
+		return getRefCount;
+	}
+});
+Object.defineProperty(exports, "getRegistry", {
+	enumerable: true,
+	get: function() {
+		return getRegistry;
+	}
+});
+Object.defineProperty(exports, "getStats", {
+	enumerable: true,
+	get: function() {
+		return getStats;
+	}
+});
+Object.defineProperty(exports, "hasInstance", {
+	enumerable: true,
+	get: function() {
+		return hasInstance;
+	}
+});
+Object.defineProperty(exports, "register", {
+	enumerable: true,
+	get: function() {
+		return register;
+	}
+});
+Object.defineProperty(exports, "setRegistry", {
+	enumerable: true,
+	get: function() {
+		return setRegistry;
+	}
+});
+
+//# sourceMappingURL=config-DTuCbHcJ.cjs.map

package/dist/config-DTuCbHcJ.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-DTuCbHcJ.cjs","names":["globalRegistry","globalRegistry"],"sources":["../src/registry/queries.ts","../src/registry/management.ts","../src/registry/config.ts"],"sourcesContent":["import { globalRegistry } from '../core/StateContainerRegistry';\nimport type {\n  StateContainerConstructor,\n  InstanceReadonlyState,\n} from '../types/utilities';\n\nexport function hasInstance<T extends StateContainerConstructor>(\n  BlocClass: T,\n  instanceKey?: string,\n): boolean {\n  return globalRegistry.hasInstance(BlocClass, instanceKey);\n}\n\nexport function getRefCount<T extends StateContainerConstructor>(\n  BlocClass: T,\n  instanceKey?: string,\n): number {\n  return globalRegistry.getRefCount(BlocClass, instanceKey);\n}\n\nexport function getAll<T extends StateContainerConstructor>(\n  BlocClass: T,\n): InstanceReadonlyState<T>[] {\n  return globalRegistry.getAll(BlocClass);\n}\n\nexport function forEach<T extends StateContainerConstructor>(\n  BlocClass: T,\n  callback: (instance: InstanceReadonlyState<T>) => void,\n): void {\n  globalRegistry.forEach(BlocClass, callback);\n}\n","import { globalRegistry } from '../core/StateContainerRegistry';\nimport type { StateContainerConstructor } from '../types/utilities';\n\nexport function clear<T extends StateContainerConstructor>(BlocClass: T): void {\n  globalRegistry.clear(BlocClass);\n}\n\nexport function clearAll(): void {\n  globalRegistry.clearAll();\n}\n\nexport function register<T extends StateContainerConstructor>(\n  BlocClass: T,\n): void {\n  globalRegistry.register(BlocClass);\n}\n","import {\n  globalRegistry,\n  StateContainerRegistry,\n} from '../core/StateContainerRegistry';\n\nlet _registry = globalRegistry;\n\nexport function getRegistry(): StateContainerRegistry {\n  return _registry;\n}\n\nexport function setRegistry(registry: StateContainerRegistry): void {\n  _registry.clearAll();\n  _registry = registry;\n}\n\nexport function getStats(): {\n  registeredTypes: number;\n  totalInstances: number;\n  typeBreakdown: Record<string, number>;\n} {\n  return _registry.getStats();\n}\n"],"mappings":";;AAMA,SAAgB,YACd,WACA,aACS;AACT,QAAOA,+BAAAA,eAAe,YAAY,WAAW,YAAY;;AAG3D,SAAgB,YACd,WACA,aACQ;AACR,QAAOA,+BAAAA,eAAe,YAAY,WAAW,YAAY;;AAG3D,SAAgB,OACd,WAC4B;AAC5B,QAAOA,+BAAAA,eAAe,OAAO,UAAU;;AAGzC,SAAgB,QACd,WACA,UACM;AACN,gCAAA,eAAe,QAAQ,WAAW,SAAS;;;;AC3B7C,SAAgB,MAA2C,WAAoB;AAC7E,gCAAA,eAAe,MAAM,UAAU;;AAGjC,SAAgB,WAAiB;AAC/B,gCAAA,eAAe,UAAU;;AAG3B,SAAgB,SACd,WACM;AACN,gCAAA,eAAe,SAAS,UAAU;;;;ACTpC,IAAI,YAAYC,+BAAAA;AAEhB,SAAgB,cAAsC;AACpD,QAAO;;AAGT,SAAgB,YAAY,UAAwC;AAClE,WAAU,UAAU;AACpB,aAAY;;AAGd,SAAgB,WAId;AACA,QAAO,UAAU,UAAU"}

package/dist/constants.d.cts

@@ -0,0 +1,73 @@
+/**
+ * Default configuration constants for BlaC
+ *
+ * Centralized location for all magic numbers and default values.
+ */
+/**
+ * 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;
+};
+/**
+ * Static property names for StateContainer classes
+ * Used for feature flags and configuration on bloc classes
+ */
+export declare const BLAC_STATIC_PROPS: {
+    /**
+     * 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";
+};
+/**
+ * ID generation patterns and constants
+ */
+export declare const BLAC_ID_PATTERNS: {
+    /**
+     * Length of generated ID portion (9 characters from base36)
+     */
+    readonly ID_LENGTH: 9;
+};
+/**
+ * Standard error message prefix
+ */
+export declare const BLAC_ERROR_PREFIX: "[BlaC]";

package/dist/constants.d.ts

@@ -49,10 +49,6 @@ export declare const BLAC_DEFAULTS: {
  * 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)
      */
@@ -66,10 +62,6 @@ export declare const BLAC_STATIC_PROPS: {
  * 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)
      */

package/dist/core/Cubit.d.ts

@@ -1,24 +1,7 @@
 import { StateContainer } from './StateContainer';
-/**
- * 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;
 }

package/dist/core/StateContainer.d.ts

@@ -1,126 +1,75 @@
 import type { StateContainerConstructor } from '../types/utilities';
-/**
- * Configuration options for initializing a StateContainer instance
- */
+import { EMIT, UPDATE } from './symbols';
 export 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;
 }
-/**
- * Listener function for state changes
- * @internal
- */
+export type HydrationStatus = 'idle' | 'hydrating' | 'hydrated' | 'error';
 type StateListener<S> = (state: S) => void;
-/**
- * System events emitted by StateContainer lifecycle
- */
-export type SystemEvent = 'stateChanged' | 'dispose';
-/**
- * Payload types for each system event
- * @template S - State type
- */
+export type SystemEvent = 'stateChanged' | 'dispose' | 'hydrationChanged';
 export interface SystemEventPayloads<S> {
-    /** Emitted when state changes via emit() or update() */
     stateChanged: {
         state: S;
         previousState: S;
     };
-    /** Emitted when the instance is disposed */
     dispose: void;
+    hydrationChanged: {
+        status: HydrationStatus;
+        previousStatus: HydrationStatus;
+        error?: Error;
+        changedWhileHydrating: boolean;
+    };
 }
-/**
- * Handler function for system events
- * @internal
- */
 type SystemEventHandler<S, E extends SystemEvent> = (payload: SystemEventPayloads<S>[E]) => 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
- *
- * @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 readonly _listeners;
     private _disposed;
-    private config;
-    private readonly systemEventHandlers;
-    /** Display name for this instance */
+    private _hydrationStatus;
+    private _hydrationError?;
+    private _changedWhileHydrating;
+    private _hydrationPromise;
+    private _resolveHydrationPromise?;
+    private _rejectHydrationPromise?;
+    private _hydrationPromiseSettled;
+    private _config;
+    private readonly _systemEventHandlers;
+    private _dependencies;
     name: string;
-    /** Whether debug logging is enabled */
     debug: boolean;
-    /** Unique identifier for this instance */
     instanceId: string;
-    /** Timestamp when this instance was created */
     createdAt: number;
-    private _dependencies;
+    lastUpdateTimestamp: number;
     get dependencies(): ReadonlyMap<StateContainerConstructor, string>;
     protected depend<T extends StateContainerConstructor>(Type: T, instanceKey?: string): () => InstanceType<T>;
     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
-     */
+    get hydrationStatus(): HydrationStatus;
+    get hydrationError(): Error | undefined;
+    get isHydrated(): boolean;
+    get changedWhileHydrating(): boolean;
     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;
+    protected [EMIT](newState: S): void;
+    protected [UPDATE](updater: (current: S) => S): void;
+    beginHydration(): void;
+    applyHydratedState(newState: S): boolean;
+    finishHydration(): void;
+    failHydration(error: Error): void;
+    waitForHydration(): Promise<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
-     */
+    private applyState;
+    private setHydrationStatus;
+    private ensureHydrationPromise;
+    private resolveHydration;
+    private rejectHydration;
     protected onSystemEvent: <E extends SystemEvent>(event: E, handler: SystemEventHandler<S, E>) => (() => void);
     private emitSystemEvent;
 }

package/dist/core/StateContainerRegistry.d.ts

@@ -36,7 +36,7 @@ export type LifecycleListener<E extends LifecycleEvent> = E extends 'created' ?
 export declare class StateContainerRegistry {
     private readonly instancesByConstructor;
     private readonly types;
-    private readonly typeConfigs;
+    private readonly registeredTypeNames;
     private readonly listeners;
     /**
      * Register a type for lifecycle event tracking
@@ -46,10 +46,9 @@ export declare class StateContainerRegistry {
     /**
      * 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;
+    register<T extends StateContainerConstructor>(constructor: T): void;
     private ensureInstancesMap;
     /**
      * Get the instances Map for a specific class (public API for stats/debugging)

package/dist/core/symbols.d.ts

@@ -0,0 +1,2 @@
+export declare const EMIT: unique symbol;
+export declare const UPDATE: unique symbol;

package/dist/debug.cjs

@@ -0,0 +1,12 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_StateContainerRegistry = require("./StateContainerRegistry-COxgpYAw.cjs");
+const require_config = require("./config-DTuCbHcJ.cjs");
+exports.forEach = require_config.forEach;
+exports.getAll = require_config.getAll;
+exports.getRefCount = require_config.getRefCount;
+exports.getRegistry = require_config.getRegistry;
+exports.getStats = require_config.getStats;
+exports.globalRegistry = require_StateContainerRegistry.globalRegistry;
+exports.hasInstance = require_config.hasInstance;
+exports.register = require_config.register;
+exports.setRegistry = require_config.setRegistry;

package/dist/debug.d.cts

@@ -0,0 +1,35 @@
+/**
+ * Debug/Advanced Subpath Export
+ *
+ * Advanced registry introspection and debugging utilities.
+ * Import from '@blac/core/debug'
+ *
+ * These utilities are intended for debugging, testing, and advanced use cases.
+ * Most applications don't need these - use the main '@blac/core' exports instead.
+ *
+ * @example
+ * ```typescript
+ * import { getStats, globalRegistry, hasInstance } from '@blac/core/debug';
+ *
+ * // Get registry statistics
+ * const stats = getStats();
+ * console.log(`Total instances: ${stats.totalInstances}`);
+ *
+ * // Check if an instance exists
+ * if (hasInstance(UserBloc)) {
+ *   console.log('UserBloc is registered');
+ * }
+ *
+ * // Iterate over all instances of a type
+ * forEach(UserBloc, (instance) => {
+ *   console.log(instance.state);
+ * });
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { hasInstance, getRefCount, getAll, forEach } from './registry/queries';
+export { register } from './registry/management';
+export { getRegistry, setRegistry, getStats } from './registry/config';
+export { globalRegistry } from './core/StateContainerRegistry';
+export type { LifecycleEvent, LifecycleListener, InstanceEntry, } from './core/StateContainerRegistry';

package/dist/debug.js

@@ -0,0 +1,3 @@
+import { n as globalRegistry } from "./StateContainerRegistry-DS_wyKck.js";
+import { c as getAll, l as getRefCount, n as getStats, o as register, r as setRegistry, s as forEach, t as getRegistry, u as hasInstance } from "./config-BD9MkJ0k.js";
+export { forEach, getAll, getRefCount, getRegistry, getStats, globalRegistry, hasInstance, register, setRegistry };

package/dist/decorators/blac.d.ts

@@ -3,12 +3,8 @@
  * Only one option can be specified at a time (union type).
  */
 export 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) */
@@ -20,9 +16,6 @@ export type BlacOptions =
  *
  * @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> {}
  *
@@ -32,8 +25,8 @@ export type BlacOptions =
  *
  * @example Function syntax (no decorator support needed)
  * ```ts
- * const FormBloc = blac({ isolated: true })(
- *   class extends Cubit<FormState> {}
+ * const AuthBloc = blac({ keepAlive: true })(
+ *   class extends Cubit<AuthState> {}
  * );
  * ```
  */