@blac/core 2.0.6 → 2.0.8

package/dist/core/StateContainer.d.ts

@@ -1,38 +1,19 @@
 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;
 }
 export type HydrationStatus = 'idle' | 'hydrating' | 'hydrated' | 'error';
-/**
- * Listener function for state changes
- * @internal
- */
 type StateListener<S> = (state: S) => void;
-/**
- * System events emitted by StateContainer lifecycle
- */
 export type SystemEvent = 'stateChanged' | 'dispose' | 'hydrationChanged';
-/**
- * Payload types for each system event
- * @template S - State type
- */
 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;
-    /** Emitted when hydration status changes */
     hydrationChanged: {
         status: HydrationStatus;
         previousStatus: HydrationStatus;
@@ -40,137 +21,55 @@ export interface SystemEventPayloads<S> {
         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 _hydrationStatus;
     private _hydrationError?;
     private _changedWhileHydrating;
-    private hydrationPromise;
-    private resolveHydrationPromise?;
-    private rejectHydrationPromise?;
-    private hydrationPromiseSettled;
-    private config;
-    private readonly systemEventHandlers;
-    /** Display name for this instance */
+    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;
-    /** Current hydration status for this instance */
     get hydrationStatus(): HydrationStatus;
-    /** Error from the latest failed hydration, if any */
     get hydrationError(): Error | undefined;
-    /** Whether this instance has completed hydration successfully */
     get isHydrated(): boolean;
-    /** Whether user state changes happened while hydration was pending */
     get changedWhileHydrating(): 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;
-    /**
-     * Mark this instance as hydrating. Plugins should call this before starting
-     * asynchronous rehydration work.
-     */
+    protected [EMIT](newState: S): void;
+    protected [UPDATE](updater: (current: S) => S): void;
     beginHydration(): void;
-    /**
-     * Apply hydrated state if no user writes happened since hydration started.
-     * Returns false when hydration should be skipped.
-     */
     applyHydratedState(newState: S): boolean;
-    /**
-     * Mark hydration as completed.
-     */
     finishHydration(): void;
-    /**
-     * Mark hydration as failed.
-     */
     failHydration(error: Error): void;
-    /**
-     * Wait until the current hydration cycle finishes.
-     */
     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;
     private applyState;
     private setHydrationStatus;
     private ensureHydrationPromise;
     private resolveHydration;
     private rejectHydration;
-    /**
-     * 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;
 }

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

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_StateContainerRegistry = require("./StateContainerRegistry-CVPTMaHn.cjs");
-const require_config = require("./config-BInS_9WT.cjs");
+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;

package/dist/debug.js

@@ -1,3 +1,3 @@
-import { n as globalRegistry } from "./StateContainerRegistry-Brmferpf.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-BmFnPVM0.js";
+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> {}
  * );
  * ```
  */

package/dist/index.cjs

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_StateContainerRegistry = require("./StateContainerRegistry-CVPTMaHn.cjs");
-const require_tracked = require("./tracked-B_MUXIpe.cjs");
-const require_config = require("./config-BInS_9WT.cjs");
+const require_StateContainerRegistry = require("./StateContainerRegistry-COxgpYAw.cjs");
+const require_tracked = require("./tracked-DLnq137F.cjs");
+const require_config = require("./config-DTuCbHcJ.cjs");
 const require_branded = require("./branded-DndTHjv2.cjs");
 //#region src/utils/idGenerator.ts
 /**
@@ -22,40 +22,13 @@ function generateSimpleId(prefix, affix) {
 	if (affix) return `${prefix}:${affix}`;
 	return `${prefix}:${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
 }
-/**
-* Generate a unique isolated instance key
-* Uses base36 encoding for compact, URL-safe identifiers
-*
-* Format: "isolated-{9-char-random-string}"
-* Example: "isolated-k7x2m9p4q"
-*
-* @returns A unique isolated instance key
-*/
-function generateIsolatedKey() {
-	return `isolated-${Math.random().toString(36).slice(2, 11)}`;
-}
+//#endregion
+//#region src/core/symbols.ts
+const EMIT = Symbol("blac.emit");
+const UPDATE = Symbol("blac.update");
 //#endregion
 //#region src/core/StateContainer.ts
 const EMPTY_DEPS = /* @__PURE__ */ new Map();
-/**
-* 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 });
-*   }
-* }
-* ```
-*/
 var StateContainer = class StateContainer {
 	static {
 		this.__excludeFromDevTools = false;
@@ -72,25 +45,25 @@ var StateContainer = class StateContainer {
 		return () => require_StateContainerRegistry.globalRegistry.ensure(Type, instanceKey);
 	}
 	constructor(initialState) {
-		this.listeners = /* @__PURE__ */ new Set();
+		this._listeners = /* @__PURE__ */ new Set();
 		this._disposed = false;
 		this._hydrationStatus = "idle";
 		this._changedWhileHydrating = false;
-		this.hydrationPromise = null;
-		this.hydrationPromiseSettled = false;
-		this.config = {};
-		this.systemEventHandlers = /* @__PURE__ */ new Map();
+		this._hydrationPromise = null;
+		this._hydrationPromiseSettled = false;
+		this._config = {};
+		this._systemEventHandlers = /* @__PURE__ */ new Map();
+		this._dependencies = null;
 		this.name = this.constructor.name;
 		this.debug = false;
 		this.instanceId = generateSimpleId(this.constructor.name, "main");
 		this.createdAt = Date.now();
-		this._dependencies = null;
 		this.lastUpdateTimestamp = Date.now();
 		this.onSystemEvent = (event, handler) => {
-			let handlers = this.systemEventHandlers.get(event);
+			let handlers = this._systemEventHandlers.get(event);
 			if (!handlers) {
 				handlers = /* @__PURE__ */ new Set();
-				this.systemEventHandlers.set(event, handlers);
+				this._systemEventHandlers.set(event, handlers);
 			}
 			handlers.add(handler);
 			return () => {
@@ -99,103 +72,71 @@ var StateContainer = class StateContainer {
 		};
 		this._state = initialState;
 	}
-	/**
-	* Initialize configuration for this instance.
-	* Called by the registry after construction.
-	* @param config - Configuration options
-	*/
 	initConfig(config) {
-		this.config = { ...config };
-		this.name = this.config.name || this.constructor.name;
-		this.debug = this.config.debug ?? false;
-		this.instanceId = generateSimpleId(this.constructor.name, this.config.instanceId);
+		this._config = { ...config };
+		this.name = this._config.name || this.constructor.name;
+		this.debug = this._config.debug ?? false;
+		this.instanceId = generateSimpleId(this.constructor.name, this._config.instanceId);
 		require_StateContainerRegistry.globalRegistry.emit("created", this);
 	}
-	/** Current state value */
 	get state() {
 		return this._state;
 	}
-	/** Whether this instance has been disposed */
 	get isDisposed() {
 		return this._disposed;
 	}
-	/** Current hydration status for this instance */
 	get hydrationStatus() {
 		return this._hydrationStatus;
 	}
-	/** Error from the latest failed hydration, if any */
 	get hydrationError() {
 		return this._hydrationError;
 	}
-	/** Whether this instance has completed hydration successfully */
 	get isHydrated() {
 		return this._hydrationStatus === "hydrated";
 	}
-	/** Whether user state changes happened while hydration was pending */
 	get changedWhileHydrating() {
 		return this._changedWhileHydrating;
 	}
-	/**
-	* Subscribe to state changes
-	* @param listener - Function called when state changes
-	* @returns Unsubscribe function
-	*/
 	subscribe(listener) {
 		if (this._disposed) throw new Error(`Cannot subscribe to disposed container ${this.name}`);
-		this.listeners.add(listener);
-		return () => this.listeners.delete(listener);
+		this._listeners.add(listener);
+		return () => this._listeners.delete(listener);
 	}
-	/**
-	* Dispose this instance and clean up resources.
-	* Clears all listeners and emits the 'dispose' system event.
-	*/
 	dispose() {
 		if (this._disposed) return;
 		if (this.debug) console.log(`[${this.name}] Disposing...`);
 		this._disposed = true;
 		if (this._hydrationStatus === "hydrating") this.failHydration(/* @__PURE__ */ new Error(`Hydration cancelled because ${this.name} was disposed`));
 		this.emitSystemEvent("dispose", void 0);
-		this.listeners.clear();
-		this.systemEventHandlers.clear();
+		this._listeners.clear();
+		this._systemEventHandlers.clear();
 		require_StateContainerRegistry.globalRegistry.emit("disposed", this);
 		if (this.debug) console.log(`[${this.name}] Disposed successfully`);
 	}
-	/**
-	* Emit a new state value and notify all listeners.
-	* @param newState - The new state value
-	* @protected
-	*/
-	emit(newState) {
+	[EMIT](newState) {
 		this.applyState(newState, "default");
 	}
-	/**
-	* Mark this instance as hydrating. Plugins should call this before starting
-	* asynchronous rehydration work.
-	*/
+	[UPDATE](updater) {
+		if (this._disposed) throw new Error(`Cannot update state from disposed container ${this.name}`);
+		this[EMIT](updater(this._state));
+	}
 	beginHydration() {
 		if (this._disposed) throw new Error(`Cannot begin hydration for disposed container ${this.name}`);
 		this._changedWhileHydrating = false;
 		this._hydrationError = void 0;
-		this.hydrationPromise = null;
-		this.resolveHydrationPromise = void 0;
-		this.rejectHydrationPromise = void 0;
-		this.hydrationPromiseSettled = false;
+		this._hydrationPromise = null;
+		this._resolveHydrationPromise = void 0;
+		this._rejectHydrationPromise = void 0;
+		this._hydrationPromiseSettled = false;
 		this.ensureHydrationPromise();
 		this.setHydrationStatus("hydrating");
 	}
-	/**
-	* Apply hydrated state if no user writes happened since hydration started.
-	* Returns false when hydration should be skipped.
-	*/
 	applyHydratedState(newState) {
 		if (this._disposed) return false;
 		if (this._hydrationStatus !== "hydrating" || this._changedWhileHydrating) return false;
 		this.applyState(newState, "hydration");
 		return true;
 	}
-	/**
-	* Mark hydration as completed.
-	*/
 	finishHydration() {
 		if (this._hydrationStatus !== "hydrating") {
 			if (this._hydrationStatus === "hydrated") return;
@@ -204,18 +145,12 @@ var StateContainer = class StateContainer {
 		this.setHydrationStatus("hydrated");
 		this.resolveHydration();
 	}
-	/**
-	* Mark hydration as failed.
-	*/
 	failHydration(error) {
 		const err = error instanceof Error ? error : /* @__PURE__ */ new Error(`Hydration failed: ${error}`);
 		this._hydrationError = err;
 		this.setHydrationStatus("error", err);
 		this.rejectHydration(err);
 	}
-	/**
-	* Wait until the current hydration cycle finishes.
-	*/
 	waitForHydration() {
 		if (this._hydrationStatus === "idle" || this._hydrationStatus === "hydrated") return Promise.resolve();
 		if (this._hydrationStatus === "error") return Promise.reject(this._hydrationError ?? /* @__PURE__ */ new Error(`Hydration failed for container ${this.name}`));
@@ -228,7 +163,7 @@ var StateContainer = class StateContainer {
 			const formattedLines = [];
 			for (const line of relevantLines) {
 				if (!line.trim()) continue;
-				if (line.includes("StateContainer.emit") || line.includes("StateContainer.update") || line.includes("StateContainer.captureStackTrace") || line.includes("Cubit.patch")) continue;
+				if (line.includes("StateContainer.emit") || line.includes("StateContainer.update") || line.includes("StateContainer.captureStackTrace") || line.includes("[blac.emit]") || line.includes("[blac.update]") || line.includes("Cubit.patch") || line.includes("/blac-core/dist/") || line.includes("@blac/core/")) continue;
 				if (line.includes("node_modules") || line.includes("react-dom") || line.includes("react_jsx") || line.includes(".vite/deps") || line.includes("executeDispatch") || line.includes("runWithFiber") || line.includes("invokeGuarded") || line.includes("callCallback") || line.includes("processDispatchQueue") || line.includes("dispatchEvent") || line.includes("batchedUpdates")) continue;
 				const formatted = this.formatStackLine(line);
 				if (formatted) formattedLines.push(formatted);
@@ -259,15 +194,6 @@ var StateContainer = class StateContainer {
 		if (segments.length > 3) path = segments.slice(-3).join("/");
 		return path;
 	}
-	/**
-	* Update state using a transform function.
-	* @param updater - Function that receives current state and returns new state
-	* @protected
-	*/
-	update(updater) {
-		if (this._disposed) throw new Error(`Cannot update state from disposed container ${this.name}`);
-		this.emit(updater(this._state));
-	}
 	applyState(newState, source) {
 		if (this._disposed) throw new Error(`Cannot emit state from disposed container ${this.name}`);
 		if (this._state === newState) return;
@@ -278,7 +204,7 @@ var StateContainer = class StateContainer {
 			state: newState,
 			previousState
 		});
-		const listeners = Array.from(this.listeners);
+		const listeners = Array.from(this._listeners);
 		for (const listener of listeners) try {
 			listener(newState);
 		} catch (error) {
@@ -300,33 +226,33 @@ var StateContainer = class StateContainer {
 		});
 	}
 	ensureHydrationPromise() {
-		if (!this.hydrationPromise || this.hydrationPromiseSettled) {
-			this.hydrationPromiseSettled = false;
-			this.hydrationPromise = new Promise((resolve, reject) => {
-				this.resolveHydrationPromise = () => {
-					if (this.hydrationPromiseSettled) return;
-					this.hydrationPromiseSettled = true;
+		if (!this._hydrationPromise || this._hydrationPromiseSettled) {
+			this._hydrationPromiseSettled = false;
+			this._hydrationPromise = new Promise((resolve, reject) => {
+				this._resolveHydrationPromise = () => {
+					if (this._hydrationPromiseSettled) return;
+					this._hydrationPromiseSettled = true;
 					resolve();
 				};
-				this.rejectHydrationPromise = (error) => {
-					if (this.hydrationPromiseSettled) return;
-					this.hydrationPromiseSettled = true;
+				this._rejectHydrationPromise = (error) => {
+					if (this._hydrationPromiseSettled) return;
+					this._hydrationPromiseSettled = true;
 					reject(error);
 				};
 			});
-			this.hydrationPromise.catch(() => {});
+			this._hydrationPromise.catch(() => {});
 		}
-		return this.hydrationPromise;
+		return this._hydrationPromise;
 	}
 	resolveHydration() {
-		this.resolveHydrationPromise?.();
+		this._resolveHydrationPromise?.();
 	}
 	rejectHydration(error) {
 		this.ensureHydrationPromise();
-		this.rejectHydrationPromise?.(error);
+		this._rejectHydrationPromise?.(error);
 	}
 	emitSystemEvent(event, payload) {
-		const handlers = this.systemEventHandlers.get(event);
+		const handlers = this._systemEventHandlers.get(event);
 		if (!handlers) return;
 		for (const handler of handlers) try {
 			handler(payload);
@@ -337,12 +263,6 @@ var StateContainer = class StateContainer {
 };
 //#endregion
 //#region src/core/Cubit.ts
-/**
-* Simple state container with direct state emission.
-* Extends StateContainer with public methods for emitting and updating state.
-*
-* @template S - State type
-*/
 var Cubit = class extends StateContainer {
 	constructor(initialState) {
 		super(initialState);
@@ -360,19 +280,11 @@ var Cubit = class extends StateContainer {
 			}));
 		});
 	}
-	/**
-	* Replace state with a new value and notify all listeners
-	* @param newState - The new state value
-	*/
 	emit(newState) {
-		super["emit"](newState);
+		this[EMIT](newState);
 	}
-	/**
-	* Transform current state using an updater function and emit the new state
-	* @param updater - Function that receives current state and returns new state
-	*/
 	update(updater) {
-		super["update"](updater);
+		this[UPDATE](updater);
 	}
 };
 //#endregion
@@ -403,9 +315,6 @@ function release(BlocClass, instanceKey, forceDispose = false) {
 *
 * @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> {}
 *
@@ -415,14 +324,13 @@ function release(BlocClass, instanceKey, forceDispose = false) {
 *
 * @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> {}
 * );
 * ```
 */
 function blac(options) {
 	return function(target, _context) {
-		if ("isolated" in options && options.isolated) target[require_StateContainerRegistry.BLAC_STATIC_PROPS.ISOLATED] = true;
 		if ("keepAlive" in options && options.keepAlive) target[require_StateContainerRegistry.BLAC_STATIC_PROPS.KEEP_ALIVE] = true;
 		if ("excludeFromDevTools" in options && options.excludeFromDevTools) target[require_StateContainerRegistry.BLAC_STATIC_PROPS.EXCLUDE_FROM_DEVTOOLS] = true;
 		return target;
@@ -430,9 +338,11 @@ function blac(options) {
 }
 //#endregion
 exports.Cubit = Cubit;
+exports.EMIT = EMIT;
 exports.PluginManager = require_StateContainerRegistry.PluginManager;
 exports.StateContainer = StateContainer;
 exports.TrackedContext = require_tracked.TrackedContext;
+exports.UPDATE = UPDATE;
 exports.acquire = acquire;
 exports.blac = blac;
 exports.borrow = borrow;
@@ -442,7 +352,6 @@ exports.clearAll = require_config.clearAll;
 exports.createTrackedContext = require_tracked.createTrackedContext;
 exports.ensure = require_tracked.ensure;
 exports.forEach = require_config.forEach;
-exports.generateIsolatedKey = generateIsolatedKey;
 exports.getAll = require_config.getAll;
 exports.getPluginManager = require_StateContainerRegistry.getPluginManager;
 exports.getRefCount = require_config.getRefCount;
@@ -452,7 +361,6 @@ exports.globalRegistry = require_StateContainerRegistry.globalRegistry;
 exports.hasInstance = require_config.hasInstance;
 exports.instance = require_tracked.instance;
 exports.instanceId = require_branded.instanceId;
-exports.isIsolatedClass = require_StateContainerRegistry.isIsolatedClass;
 exports.register = require_config.register;
 exports.release = release;
 exports.setRegistry = require_config.setRegistry;