@blac/core 2.0.15 → 2.0.16

package/dist/StateContainerRegistry-BqS-wpb_.js

@@ -1,957 +0,0 @@
-//#region src/config.ts
-/**
- * Default equality: shallow per-key `Object.is` comparison.
- * Falls through to `false` for primitives/null so reference-only state still
- * behaves correctly.
- */
-const shallowEqualState = (prev, next) => {
-  if (Object.is(prev, next)) return true;
-  if (typeof prev !== 'object' || prev === null) return false;
-  if (typeof next !== 'object' || next === null) return false;
-  const prevKeys = Object.keys(prev);
-  if (prevKeys.length !== Object.keys(next).length) return false;
-  for (let i = 0; i < prevKeys.length; i++) {
-    const key = prevKeys[i];
-    if (!Object.is(prev[key], next[key])) return false;
-  }
-  return true;
-};
-const defaultConfig = {
-  equality: shallowEqualState,
-  maxInstancesPerType: 1e3,
-  maxRefsPerInstance: 1e3,
-  maxEmitsPerSecond: 100,
-};
-let globalConfig = { ...defaultConfig };
-/**
- * Configure global defaults for @blac/core.
- *
- * @example
- * ```ts
- * import { configureBlac, shallowEqualState } from '@blac/core';
- *
- * // Swap in a deep-equality check for all blocs
- * configureBlac({ equality: myDeepEqual });
- * ```
- */
-function configureBlac(config) {
-  globalConfig = {
-    ...globalConfig,
-    ...config,
-  };
-}
-/**
- * Get the current global configuration.
- * @internal
- */
-function getBlacConfig() {
-  return globalConfig;
-}
-/**
- * Reset configuration to defaults (useful for testing).
- * @internal
- */
-function resetBlacConfig() {
-  globalConfig = { ...defaultConfig };
-}
-//#endregion
-//#region src/constants.ts
-/**
- * Default configuration constants for BlaC
- *
- * Centralized location for all magic numbers and default values.
- */
-/**
- * Default configuration constants for BlaC
- */
-const BLAC_DEFAULTS = {
-  DEFAULT_INSTANCE_KEY: 'default',
-  MAX_GETTER_DEPTH: 10,
-};
-/**
- * Static property names for StateContainer classes
- * Used for feature flags and configuration on bloc classes
- */
-const BLAC_STATIC_PROPS = {
-  KEEP_ALIVE: 'keepAlive',
-  EXCLUDE_FROM_DEVTOOLS: '__excludeFromDevTools',
-  ISOLATED: 'isolated',
-  EQUALITY: '__equality',
-  KEY: 'key',
-};
-/**
- * Standard error message prefix
- */
-const BLAC_ERROR_PREFIX = '[BlaC]';
-//#endregion
-//#region src/plugin/PluginManager.ts
-/**
- * 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' });
- * ```
- */
-var PluginManager = class {
-  /**
-   * Create a new PluginManager
-   * @param registry - The StateContainerRegistry to monitor for lifecycle events
-   */
-  constructor(registry) {
-    this.plugins = /* @__PURE__ */ new Map();
-    this.lifecycleUnsubscribers = [];
-    this.registry = registry;
-    this.setupLifecycleHooks();
-  }
-  /**
-   * 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, config = {}) {
-    const effectiveConfig = {
-      enabled: true,
-      environment: 'all',
-      ...config,
-    };
-    if (!this.shouldEnablePlugin(effectiveConfig)) {
-      console.log(
-        `[BlaC] Plugin "${plugin.name}" skipped (environment mismatch)`,
-      );
-      return;
-    }
-    if (this.plugins.has(plugin.name))
-      throw new Error(`Plugin "${plugin.name}" is already installed`);
-    const context = this.createPluginContext();
-    this.plugins.set(plugin.name, {
-      plugin,
-      config: effectiveConfig,
-      context,
-    });
-    if (plugin.onInstall)
-      try {
-        plugin.onInstall(context);
-      } catch (error) {
-        console.error(
-          `[BlaC] Error installing plugin "${plugin.name}":`,
-          error,
-        );
-        this.plugins.delete(plugin.name);
-        throw error;
-      }
-    console.log(`[BlaC] Plugin "${plugin.name}" v${plugin.version} installed`);
-  }
-  /**
-   * Uninstall a plugin by name
-   * @param pluginName - The name of the plugin to uninstall
-   * @throws Error if plugin is not installed
-   */
-  uninstall(pluginName) {
-    const installed = this.plugins.get(pluginName);
-    if (!installed) throw new Error(`Plugin "${pluginName}" is not installed`);
-    if (installed.plugin.onUninstall)
-      try {
-        installed.plugin.onUninstall();
-      } catch (error) {
-        console.error(
-          `[BlaC] Error uninstalling plugin "${pluginName}":`,
-          error,
-        );
-      }
-    this.plugins.delete(pluginName);
-    console.log(`[BlaC] Plugin "${pluginName}" uninstalled`);
-  }
-  /**
-   * 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) {
-    return this.plugins.get(pluginName)?.plugin;
-  }
-  /**
-   * Get all installed plugins
-   * @returns Array of all installed plugins
-   */
-  getAllPlugins() {
-    return Array.from(this.plugins.values()).map((p) => p.plugin);
-  }
-  /**
-   * Check if a plugin is installed
-   * @param pluginName - The name of the plugin to check
-   * @returns true if the plugin is installed
-   */
-  hasPlugin(pluginName) {
-    return this.plugins.has(pluginName);
-  }
-  /**
-   * Uninstall all plugins
-   */
-  clear() {
-    for (const name of this.plugins.keys()) this.uninstall(name);
-  }
-  destroy() {
-    this.clear();
-    for (const unsub of this.lifecycleUnsubscribers) unsub();
-    this.lifecycleUnsubscribers = [];
-  }
-  /**
-   * Setup lifecycle hooks to notify plugins
-   */
-  setupLifecycleHooks() {
-    this.lifecycleUnsubscribers = [
-      this.registry.on('created', (instance) => {
-        this.notifyPlugins('onInstanceCreated', instance);
-      }),
-      this.registry.on(
-        'stateChanged',
-        (instance, previousState, currentState) => {
-          this.notifyPlugins(
-            'onStateChanged',
-            instance,
-            previousState,
-            currentState,
-          );
-        },
-      ),
-      this.registry.on('disposed', (instance) => {
-        this.notifyPlugins('onInstanceDisposed', instance);
-      }),
-      this.registry.on('refAcquired', (instance, refId) => {
-        this.notifyPlugins('onRefAcquired', instance, refId);
-      }),
-      this.registry.on('refReleased', (instance, refId) => {
-        this.notifyPlugins('onRefReleased', instance, refId);
-      }),
-    ];
-  }
-  /**
-   * Notify all plugins of a lifecycle event
-   */
-  notifyPlugins(hookName, ...args) {
-    for (const { plugin, config, context } of this.plugins.values()) {
-      if (!config.enabled) continue;
-      const hook = plugin[hookName];
-      if (typeof hook === 'function')
-        try {
-          hook.apply(plugin, [...args, context]);
-        } catch (error) {
-          console.error(
-            `[BlaC] Error in plugin "${plugin.name}" ${hookName}:`,
-            error,
-          );
-        }
-    }
-  }
-  /**
-   * Create plugin context with safe API access
-   */
-  createPluginContext() {
-    return {
-      getInstanceMetadata: (instance) => {
-        return {
-          id: instance.instanceId,
-          className: instance.constructor.name,
-          isDisposed: instance.isDisposed,
-          name: instance.name,
-          createdAt: instance.createdAt,
-          state: instance.state,
-          hydrationStatus: instance.hydrationStatus,
-          isHydrated: instance.isHydrated,
-          hydrationError: instance.hydrationError,
-          changedWhileHydrating: instance.changedWhileHydrating,
-        };
-      },
-      getState: (instance) => {
-        return instance.state;
-      },
-      getHydrationStatus: (instance) => {
-        return instance.hydrationStatus;
-      },
-      startHydration: (instance) => {
-        instance.beginHydration();
-      },
-      applyHydratedState: (instance, state) => {
-        return instance.applyHydratedState(state);
-      },
-      finishHydration: (instance) => {
-        instance.finishHydration();
-      },
-      failHydration: (instance, error) => {
-        instance.failHydration(error);
-      },
-      waitForHydration: (instance) => {
-        return instance.waitForHydration();
-      },
-      queryInstances: (typeClass) => {
-        return this.registry.getAll(typeClass);
-      },
-      getAllTypes: () => {
-        return this.registry.getTypes();
-      },
-      getStats: () => {
-        return this.registry.getStats();
-      },
-      getRefIds: (instanceId) => {
-        for (const Type of this.registry.getTypes()) {
-          const map = this.registry.getInstancesMap(Type);
-          for (const [, entry] of map)
-            if (entry.instance.instanceId === instanceId)
-              return Array.from(entry.refs.keys());
-        }
-        return [];
-      },
-    };
-  }
-  /**
-   * Check if plugin should be enabled based on environment
-   */
-  shouldEnablePlugin(config) {
-    if (!config.enabled) return false;
-    if (config.environment === 'all') return true;
-    return this.getCurrentEnvironment() === config.environment;
-  }
-  /**
-   * Get current environment
-   */
-  getCurrentEnvironment() {
-    if (typeof process !== 'undefined') {
-      if (process.env.NODE_ENV === 'test') return 'test';
-      if (process.env.NODE_ENV === 'production') return 'production';
-      return 'development';
-    }
-    return 'development';
-  }
-};
-/**
- * Create a plugin manager instance
- * @param registry - The StateContainerRegistry to monitor for lifecycle events
- * @returns A new PluginManager instance
- */
-function createPluginManager(registry) {
-  return new PluginManager(registry);
-}
-//#endregion
-//#region src/utils/static-props.ts
-/**
- * Utility functions for accessing static properties on StateContainer classes
- */
-/**
- * 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
- */
-function getStaticProp(Type, propName, defaultValue) {
-  return Type[propName] ?? defaultValue;
-}
-/**
- * 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`
- */
-function isKeepAliveClass(Type) {
-  return getStaticProp(Type, BLAC_STATIC_PROPS.KEEP_ALIVE) === true;
-}
-/**
- * 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`
- */
-function isExcludedFromDevTools(Type) {
-  return getStaticProp(Type, BLAC_STATIC_PROPS.EXCLUDE_FROM_DEVTOOLS) === true;
-}
-/**
- * Check if a class is marked as isolated.
- * Isolated classes get a fresh, per-mount instance from `useBloc`
- * (auto-keyed via React's `useId()`), instead of sharing the default
- * instance with sibling call sites.
- * @param Type - The class constructor to check
- * @returns true if the class has `static isolated = true`
- */
-function isIsolatedClass(Type) {
-  return getStaticProp(Type, BLAC_STATIC_PROPS.ISOLATED) === true;
-}
-/**
- * Get the per-class equality function set via `@blac({ equality })`, if any.
- * @param Type - The class constructor to check
- * @returns the equality function or `undefined`
- */
-function getClassEquality(Type) {
-  const fn = getStaticProp(Type, BLAC_STATIC_PROPS.EQUALITY);
-  return typeof fn === 'function' ? fn : void 0;
-}
-/**
- * Get the per-class key function set via `@blac({ key })` or `static key = …`, if any.
- * Used by the registry to derive a stable instance key from `args`.
- * @param Type - The class constructor to check
- * @returns the key function or `undefined`
- */
-function getClassKey(Type) {
-  const fn = getStaticProp(Type, BLAC_STATIC_PROPS.KEY, void 0);
-  return typeof fn === 'function' ? fn : void 0;
-}
-//#endregion
-//#region src/utils/structural-key.ts
-/**
- * Deterministic, order-independent hash of serializable args.
- * Sorts object keys so {a,b} === {b,a}.
- * Throws (dev) if it encounters a function or non-plain object — those belong in `deps`.
- */
-const DEFAULT_STRUCTURAL_KEY = 'default';
-/**
- * Produce a stable string key for serializable args.
- * - `undefined` / `void` args → `'default'` sentinel (no-args blocs stay on the default key).
- * - Object keys are sorted for order-independence.
- * - Arrays keep their insertion order.
- * - Functions throw — they must be passed via `deps`, not `args`.
- */
-function structuralKey(args) {
-  if (args === void 0 || args === null) return DEFAULT_STRUCTURAL_KEY;
-  return JSON.stringify(args, function (_k, v) {
-    if (typeof v === 'function')
-      throw new Error(
-        '[blac] args must be serializable; put refs/callbacks in `deps`',
-      );
-    if (v && typeof v === 'object' && !Array.isArray(v))
-      return Object.keys(v)
-        .sort()
-        .reduce((o, k) => {
-          o[k] = v[k];
-          return o;
-        }, {});
-    return v;
-  });
-}
-//#endregion
-//#region src/core/StateContainerRegistry.ts
-/**
- * Central registry for managing StateContainer instances.
- * Handles instance lifecycle, named ref tracking, 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);
- * });
- * ```
- */
-var StateContainerRegistry = class {
-  constructor() {
-    this.instancesByConstructor = /* @__PURE__ */ new WeakMap();
-    this.types = /* @__PURE__ */ new Set();
-    this.registeredTypeNames = /* @__PURE__ */ new Set();
-    this.listeners = /* @__PURE__ */ new Map();
-    this._stateChangedListenerCount = 0;
-    this._pendingStateChanges = null;
-    this._autoRefIdCounter = 0;
-  }
-  get hasStateChangedListeners() {
-    return this._stateChangedListenerCount > 0;
-  }
-  /**
-   * Register a type for lifecycle event tracking
-   * @param constructor - The StateContainer class constructor
-   */
-  registerType(constructor) {
-    this.types.add(constructor);
-  }
-  /**
-   * Register a StateContainer class with configuration
-   * @param constructor - The StateContainer class constructor
-   * @throws Error if type is already registered
-   */
-  register(constructor) {
-    const className = constructor.name;
-    if (this.registeredTypeNames.has(className))
-      throw new Error(
-        `${BLAC_ERROR_PREFIX} Type "${className}" is already registered`,
-      );
-    this.registeredTypeNames.add(className);
-    this.registerType(constructor);
-  }
-  ensureInstancesMap(Type) {
-    let instances = this.instancesByConstructor.get(Type);
-    if (!instances) {
-      instances = /* @__PURE__ */ new Map();
-      this.instancesByConstructor.set(Type, instances);
-    }
-    return instances;
-  }
-  /**
-   * Get the instances Map for a specific class (public API for stats/debugging)
-   */
-  getInstancesMap(Type) {
-    return this.instancesByConstructor.get(Type) || /* @__PURE__ */ new Map();
-  }
-  /**
-   * Directly insert an instance entry into the registry without going through
-   * acquire/release. Creates the internal WeakMap bucket for the constructor if
-   * it does not exist yet. Replaces any existing entry for the same key.
-   *
-   * The provided instance is NOT configured or disposed here — callers are
-   * responsible for any initConfig / dispose calls. Intended for testing
-   * helpers that create stubs outside the normal acquisition path.
-   *
-   * @internal Used by testing helpers only.
-   */
-  insertInstance(
-    Type,
-    instanceKey,
-    instance,
-    refs = /* @__PURE__ */ new Map(),
-  ) {
-    const instances = this.ensureInstancesMap(Type);
-    const existingEntry = instances.get(instanceKey);
-    if (
-      existingEntry &&
-      existingEntry.instance !== instance &&
-      !existingEntry.instance.isDisposed
-    )
-      existingEntry.instance.dispose();
-    instances.set(instanceKey, {
-      instance,
-      refs,
-    });
-  }
-  /**
-   * Resolve the storage key for an instance. This is the single source of truth
-   * for keying — `acquire` and `release` MUST agree, otherwise a ref taken under
-   * an args-derived key is never dropped (instance leaks).
-   *
-   * Resolution order (explicit beats derived):
-   * explicit key > `static key(args)` > structural hash of args > default sentinel.
-   *
-   * @param Type - The StateContainer class constructor
-   * @param instanceKey - Explicit key, or undefined to derive from args
-   * @param args - Construction args used for structural/`static key` derivation
-   */
-  resolveKey(Type, instanceKey, args) {
-    if (instanceKey !== void 0) return instanceKey;
-    const keyFn = getClassKey(Type);
-    if (keyFn) return keyFn(args);
-    if (args !== void 0) return structuralKey(args);
-    return DEFAULT_STRUCTURAL_KEY;
-  }
-  /**
-   * Circuit breaker for runaway instance creation. Throws when a single
-   * constructor would exceed `maxInstancesPerType` live instances — almost
-   * always an unstable instance key (e.g. a new object/array passed as `args`
-   * every render, or a missing `static key`) leaking an instance per render.
-   */
-  assertInstanceLimit(Type, currentCount) {
-    const limit = getBlacConfig().maxInstancesPerType;
-    if (limit > 0 && currentCount >= limit)
-      throw new Error(
-        `${BLAC_ERROR_PREFIX} ${Type.name} exceeded the maximum of ${limit} live instances. This usually means the instance key is unstable — e.g. \`args\` that change identity every render, or a missing \`static key\` — so a new instance is created and never disposed (memory leak). Stabilize the key, add a \`static key(args)\`, or raise \`configureBlac({ maxInstancesPerType })\`.`,
-      );
-  }
-  /**
-   * Circuit breaker for runaway reference growth. Throws when one instance
-   * accumulates more than `maxRefsPerInstance` distinct live refs — almost
-   * always consumer cleanup (e.g. `useBloc`'s unmount `release`) never firing.
-   */
-  assertRefLimit(Type, resolvedKey, refCount) {
-    const limit = getBlacConfig().maxRefsPerInstance;
-    if (limit > 0 && refCount > limit)
-      throw new Error(
-        `${BLAC_ERROR_PREFIX} ${Type.name} instance "${resolvedKey}" exceeded the maximum of ${limit} live references. This usually means references are acquired without a matching release (e.g. a consumer that never unmounts/cleans up), leaking refs that keep the instance alive forever. Ensure every acquire is paired with a release, or raise \`configureBlac({ maxRefsPerInstance })\`.`,
-      );
-  }
-  /**
-   * Acquire an instance with ref tracking (ownership semantics).
-   * Creates a new instance if one doesn't exist, or returns existing and adds a ref.
-   * You must call `release()` with the same refId when done.
-   * @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 add a reference (default: true)
-   * @param options.refId - Named reference ID for debugging; auto-generated if omitted
-   * @returns The state container instance
-   */
-  acquire(Type, instanceKey = void 0, options = {}) {
-    const { canCreate = true, countRef = true } = options;
-    const args = options.args;
-    const resolvedKey = this.resolveKey(Type, instanceKey, args);
-    const config = {
-      instanceId: resolvedKey,
-      args,
-    };
-    const instances = this.ensureInstancesMap(Type);
-    let entry = instances.get(resolvedKey);
-    if (entry?.instance.isDisposed) {
-      instances.delete(resolvedKey);
-      entry = void 0;
-    }
-    if (entry) {
-      if (
-        process.env.NODE_ENV !== 'production' &&
-        args !== void 0 &&
-        entry.args !== void 0
-      ) {
-        const incomingKey = structuralKey(args);
-        const storedKey = structuralKey(entry.args);
-        if (incomingKey !== storedKey)
-          console.warn(
-            `${BLAC_ERROR_PREFIX} ${Type.name} instance key "${resolvedKey}" was acquired with different args. Existing args: ${storedKey}, new args: ${incomingKey}. The existing instance will be reused. If distinct args should produce distinct instances, either remove the explicit instanceKey or provide a \`static key\` function that reflects the difference.`,
-          );
-      }
-      if (countRef) {
-        const refId = options.refId ?? `_auto_${this._autoRefIdCounter++}`;
-        entry.refs.set(refId, (entry.refs.get(refId) ?? 0) + 1);
-        this.assertRefLimit(Type, resolvedKey, entry.refs.size);
-        this.emit('refAcquired', entry.instance, refId);
-      }
-      return entry.instance;
-    }
-    if (!canCreate)
-      throw new Error(
-        `${BLAC_ERROR_PREFIX} ${Type.name} instance "${resolvedKey}" not found and creation is disabled.`,
-      );
-    this.assertInstanceLimit(Type, instances.size);
-    const instance = new Type();
-    instance.initConfig(config);
-    const initialRefs = /* @__PURE__ */ new Map();
-    let initialRefId;
-    if (countRef) {
-      initialRefId = options.refId ?? `_auto_${this._autoRefIdCounter++}`;
-      initialRefs.set(initialRefId, 1);
-    }
-    instances.set(resolvedKey, {
-      instance,
-      refs: initialRefs,
-      args,
-    });
-    this.registerType(Type);
-    if (initialRefId) this.emit('refAcquired', instance, initialRefId);
-    return instance;
-  }
-  /**
-   * Borrow an existing instance without adding a ref (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(Type, instanceKey = BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY) {
-    return this.acquire(Type, instanceKey, {
-      canCreate: false,
-      countRef: false,
-    });
-  }
-  /**
-   * 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(Type, instanceKey = BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY) {
-    try {
-      return {
-        error: null,
-        instance: this.borrow(Type, instanceKey),
-      };
-    } catch (error) {
-      return {
-        error,
-        instance: null,
-      };
-    }
-  }
-  /**
-   * Ensure an instance exists without taking ownership (for bloc-to-bloc communication).
-   * Gets existing instance OR creates it if it doesn't exist, without adding a ref.
-   * 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 added).
-   * @param Type - The StateContainer class constructor
-   * @param instanceKey - Explicit instance key, or undefined to derive from `args`
-   *   (`static key(args)` / structural hash), matching `acquire`.
-   * @param args - Construction args; used for keying when no explicit key is given
-   * @returns The state container instance
-   */
-  ensure(Type, instanceKey = void 0, args) {
-    return this.acquire(Type, instanceKey, {
-      canCreate: true,
-      countRef: false,
-      args,
-    });
-  }
-  /**
-   * Release a reference to an instance.
-   * Removes the ref and disposes when refs is empty (unless keepAlive).
-   * Releasing an already-removed refId is a no-op (idempotent).
-   * @param Type - The StateContainer class constructor
-   * @param instanceKey - Instance key (defaults to 'default')
-   * @param forceDispose - Force immediate disposal regardless of refs
-   * @param refId - The specific ref to remove; removes one arbitrary ref if omitted
-   */
-  release(
-    Type,
-    instanceKey = BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY,
-    forceDispose = false,
-    refId,
-  ) {
-    const instances = this.ensureInstancesMap(Type);
-    const entry = instances.get(instanceKey);
-    if (!entry) return;
-    if (forceDispose) {
-      if (!entry.instance.isDisposed) entry.instance.dispose();
-      instances.delete(instanceKey);
-      return;
-    }
-    let releasedRefId;
-    if (refId !== void 0) {
-      const count = entry.refs.get(refId) ?? 0;
-      if (count <= 1) entry.refs.delete(refId);
-      else entry.refs.set(refId, count - 1);
-      releasedRefId = refId;
-    } else {
-      const firstKey = entry.refs.keys().next().value;
-      if (firstKey !== void 0) {
-        const count = entry.refs.get(firstKey) ?? 0;
-        if (count <= 1) entry.refs.delete(firstKey);
-        else entry.refs.set(firstKey, count - 1);
-        releasedRefId = firstKey;
-      }
-    }
-    if (releasedRefId) this.emit('refReleased', entry.instance, releasedRefId);
-    const keepAlive = isKeepAliveClass(Type);
-    if (entry.refs.size === 0 && !keepAlive) {
-      const deps = entry.instance.dependencies;
-      if (!entry.instance.isDisposed) entry.instance.dispose();
-      instances.delete(instanceKey);
-      for (const [DepType, depKey] of deps) {
-        const depInstances = this.ensureInstancesMap(DepType);
-        const depEntry = depInstances.get(depKey);
-        if (
-          depEntry &&
-          depEntry.refs.size === 0 &&
-          !isKeepAliveClass(DepType) &&
-          !depEntry.instance.isDisposed
-        ) {
-          depEntry.instance.dispose();
-          depInstances.delete(depKey);
-        }
-      }
-    }
-  }
-  /**
-   * Get all instances of a specific type.
-   * @param Type - The StateContainer class constructor
-   * @returns Array of all instances
-   */
-  getAll(Type) {
-    const instances = this.ensureInstancesMap(Type);
-    const result = [];
-    for (const entry of instances.values()) result.push(entry.instance);
-    return result;
-  }
-  /**
-   * 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(Type, callback) {
-    const instances = this.ensureInstancesMap(Type);
-    for (const entry of instances.values()) {
-      const instance = entry.instance;
-      if (!instance.isDisposed)
-        try {
-          callback(instance);
-        } catch (error) {
-          console.error(
-            `${BLAC_ERROR_PREFIX} forEach callback error for ${Type.name}:`,
-            error,
-          );
-        }
-    }
-  }
-  /**
-   * Clear all instances of a specific type (disposes them).
-   * @param Type - The StateContainer class constructor
-   */
-  clear(Type) {
-    const instances = this.ensureInstancesMap(Type);
-    for (const entry of instances.values())
-      if (!entry.instance.isDisposed) entry.instance.dispose();
-    instances.clear();
-  }
-  /**
-   * Get reference count for an instance (number of active refs).
-   * @param Type - The StateContainer class constructor
-   * @param instanceKey - Instance key (defaults to 'default')
-   * @returns Current ref count (0 if instance doesn't exist)
-   */
-  getRefCount(Type, instanceKey = BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY) {
-    return this.ensureInstancesMap(Type).get(instanceKey)?.refs.size ?? 0;
-  }
-  /**
-   * Get all active reference IDs for an instance.
-   * @param Type - The StateContainer class constructor
-   * @param instanceKey - Instance key (defaults to 'default')
-   * @returns Array of ref ID strings (empty if instance doesn't exist)
-   */
-  getRefIds(Type, instanceKey = BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY) {
-    const instances = this.instancesByConstructor.get(Type);
-    if (!instances) return [];
-    const entry = instances.get(instanceKey);
-    return entry ? Array.from(entry.refs.keys()) : [];
-  }
-  /**
-   * Check if an instance exists.
-   * @param Type - The StateContainer class constructor
-   * @param instanceKey - Instance key (defaults to 'default')
-   * @returns true if instance exists
-   */
-  hasInstance(Type, instanceKey = BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY) {
-    return this.ensureInstancesMap(Type).has(instanceKey);
-  }
-  /**
-   * 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() {
-    for (const Type of this.types) this.clear(Type);
-    this.types.clear();
-    this.registeredTypeNames.clear();
-  }
-  /**
-   * Get registry statistics for debugging.
-   * @returns Object with registeredTypes, totalInstances, and typeBreakdown
-   */
-  getStats() {
-    const typeBreakdown = {};
-    let totalInstances = 0;
-    for (const Type of this.types) {
-      const typeName = Type.name;
-      const count = this.getInstancesMap(Type).size;
-      typeBreakdown[typeName] = count;
-      totalInstances += count;
-    }
-    return {
-      registeredTypes: this.types.size,
-      totalInstances,
-      typeBreakdown,
-    };
-  }
-  /**
-   * Get all registered types (for plugin system).
-   * @returns Array of all registered StateContainer class constructors
-   */
-  getTypes() {
-    return Array.from(this.types);
-  }
-  /**
-   * 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(event, listener) {
-    if (!this.listeners.has(event))
-      this.listeners.set(event, /* @__PURE__ */ new Set());
-    const instance = this.listeners.get(event);
-    if (!instance)
-      throw new Error(
-        `${BLAC_ERROR_PREFIX} Failed to register listener for event '${event}'`,
-      );
-    instance.add(listener);
-    if (event === 'stateChanged') this._stateChangedListenerCount++;
-    return () => {
-      if (
-        this.listeners.get(event)?.delete(listener) &&
-        event === 'stateChanged'
-      )
-        this._stateChangedListenerCount--;
-    };
-  }
-  emit(event, ...args) {
-    const listeners = this.listeners.get(event);
-    if (!listeners || listeners.size === 0) return;
-    for (const listener of listeners)
-      try {
-        listener(...args);
-      } catch (error) {
-        console.error(
-          `${BLAC_ERROR_PREFIX} Listener error for '${event}':`,
-          error,
-        );
-      }
-  }
-  /**
-   * Schedule a deferred stateChanged notification via microtask.
-   * Skips entirely when no stateChanged listeners are registered.
-   * @internal - Called by StateContainer.applyState
-   */
-  notifyStateChanged(container, previousState, newState) {
-    if (this._stateChangedListenerCount === 0) return;
-    if (!this._pendingStateChanges) {
-      this._pendingStateChanges = [];
-      queueMicrotask(() => this.flushStateChanged());
-    }
-    this._pendingStateChanges.push([container, previousState, newState]);
-  }
-  flushStateChanged() {
-    const pending = this._pendingStateChanges;
-    this._pendingStateChanges = null;
-    if (!pending) return;
-    for (const [container, prev, next] of pending)
-      this.emit('stateChanged', container, prev, next);
-  }
-};
-/**
- * Global default registry instance
- */
-const globalRegistry = new StateContainerRegistry();
-/**
- * Global plugin manager (initialized lazily)
- */
-let _globalPluginManager = null;
-/**
- * Get the global plugin manager
- */
-function getPluginManager() {
-  if (!_globalPluginManager)
-    _globalPluginManager = createPluginManager(globalRegistry);
-  return _globalPluginManager;
-}
-//#endregion
-export {
-  isExcludedFromDevTools as a,
-  PluginManager as c,
-  BLAC_STATIC_PROPS as d,
-  configureBlac as f,
-  shallowEqualState as h,
-  getClassEquality as i,
-  BLAC_DEFAULTS as l,
-  resetBlacConfig as m,
-  getPluginManager as n,
-  isIsolatedClass as o,
-  getBlacConfig as p,
-  globalRegistry as r,
-  isKeepAliveClass as s,
-  StateContainerRegistry as t,
-  BLAC_ERROR_PREFIX as u,
-};
-
-//# sourceMappingURL=StateContainerRegistry-BqS-wpb_.js.map