@blac/core 2.0.13 → 2.0.14

package/dist/config.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Global configuration for @blac/core
+ */
+export type EqualityFn = <S>(prev: S, next: S) => boolean;
+export interface BlacConfig {
+    /**
+     * Equality check used by `StateContainer.applyState` to skip emits when
+     * `prev` and `next` are structurally equal. Default: `shallowEqualState`.
+     *
+     * Return `true` to skip the emit (states considered equal).
+     */
+    equality: EqualityFn;
+    /**
+     * Circuit breaker: maximum number of live instances allowed under a single
+     * bloc constructor before `acquire` throws. Guards against runaway instance
+     * creation — typically an unstable/args-derived key churning out instances
+     * that are never disposed (a memory leak that eventually freezes the app).
+     *
+     * Default: `1000`. Set to `Infinity` (or any non-positive value) to disable.
+     */
+    maxInstancesPerType: number;
+    /**
+     * Circuit breaker: maximum number of distinct live references (consumers)
+     * allowed on a single instance before `acquire` throws. Guards against the
+     * other leak shape — consumer cleanup (e.g. `useBloc` unmount `release`)
+     * never firing, so refs accumulate without bound on one instance.
+     *
+     * Default: `1000`. Set to `Infinity` (or any non-positive value) to disable.
+     */
+    maxRefsPerInstance: number;
+    /**
+     * Dev-only soft circuit breaker: if a single instance emits more than this
+     * many *real* state changes within a rolling one-second window, log a single
+     * `console.warn`. This is the "frozen app" smell — almost always a tight loop
+     * (RAF/animation, or an effect that emits on every commit) pushing
+     * high-frequency data through bloc state, which then saturates subscribers,
+     * plugins (logging/devtools), and the main thread.
+     *
+     * Heuristic by nature — warns, never throws, since high-frequency state can
+     * occasionally be legitimate. No-op in production. Default: `100`. Set to
+     * `Infinity` (or any non-positive value) to disable.
+     */
+    maxEmitsPerSecond: number;
+}
+/**
+ * Default equality: shallow per-key `Object.is` comparison.
+ * Falls through to `false` for primitives/null so reference-only state still
+ * behaves correctly.
+ */
+export declare const shallowEqualState: EqualityFn;
+/**
+ * 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 });
+ * ```
+ */
+export declare function configureBlac(config: Partial<BlacConfig>): void;
+/**
+ * Get the current global configuration.
+ * @internal
+ */
+export declare function getBlacConfig(): BlacConfig;
+/**
+ * Reset configuration to defaults (useful for testing).
+ * @internal
+ */
+export declare function resetBlacConfig(): void;

package/dist/constants.d.cts

@@ -34,6 +34,19 @@ export declare const BLAC_STATIC_PROPS: {
      * The React adapter auto-keys via `useId()` when this is set.
      */
     readonly ISOLATED: "isolated";
+    /**
+     * Per-class equality function used to short-circuit `emit`/`patch` when the
+     * new state is structurally equal to the previous state. Falls back to the
+     * global `configureBlac({ equality })` value when unset.
+     */
+    readonly EQUALITY: "__equality";
+    /**
+     * Per-class key function: `static key = (args) => string`.
+     * When set, the registry calls `Type.key(args)` to derive the instance key
+     * instead of using a structural hash of `args`. Allows blocs to ignore
+     * non-identity fields (e.g., `readonly` flags) while still keying by id.
+     */
+    readonly KEY: "key";
 };
 /**
  * ID generation patterns and constants

package/dist/constants.d.ts

@@ -34,6 +34,19 @@ export declare const BLAC_STATIC_PROPS: {
      * The React adapter auto-keys via `useId()` when this is set.
      */
     readonly ISOLATED: "isolated";
+    /**
+     * Per-class equality function used to short-circuit `emit`/`patch` when the
+     * new state is structurally equal to the previous state. Falls back to the
+     * global `configureBlac({ equality })` value when unset.
+     */
+    readonly EQUALITY: "__equality";
+    /**
+     * Per-class key function: `static key = (args) => string`.
+     * When set, the registry calls `Type.key(args)` to derive the instance key
+     * instead of using a structural hash of `args`. Allows blocs to ignore
+     * non-identity fields (e.g., `readonly` flags) while still keying by id.
+     */
+    readonly KEY: "key";
 };
 /**
  * ID generation patterns and constants

package/dist/core/Cubit.d.ts

@@ -1,6 +1,16 @@
 import { StateContainer } from './StateContainer';
-export declare abstract class Cubit<S extends object = any> extends StateContainer<S> {
-    constructor(initialState: S);
-    emit(newState: S): void;
-    patch: S extends object ? (partial: Partial<S>) => void : never;
+/**
+ * `Cubit<S>` is a `StateContainer<S>` with `emit` / `patch` exposed as
+ * public mutation surface. Today it adds nothing structurally beyond
+ * `StateContainer` — both are inherited from the underlying
+ * `StructuralContainer<S>`. Kept as a real class (not a type alias) because
+ * downstream code does `instance instanceof Cubit` checks (see A2 audit).
+ *
+ * The class body is intentionally empty: a no-op `emit` override would
+ * still go through `applyState`, and `patch` is inherited from
+ * `StructuralContainer` (path-diffed, microtask-flushed). If a caller
+ * needs the old "skip if no real change" patch semantics, they can wrap
+ * `patch` themselves or call `emit` after a manual equality check.
+ */
+export declare abstract class Cubit<S extends object = any, Args = void, Deps extends object = Record<string, never>> extends StateContainer<S, Args, Deps> {
 }

package/dist/core/StateContainer.d.ts

@@ -1,9 +1,12 @@
+import { StructuralContainer, type DeepPartial, type StructuralContainerOptions } from '@dirtytalk/structural';
 import type { StateContainerConstructor } from '../types/utilities';
-import { EMIT } from './symbols';
+import { APPLY_DEPS, EMIT, REMOVE_DEPS_OWNER } from './symbols';
 export interface StateContainerConfig {
     name?: string;
     debug?: boolean;
     instanceId?: string;
+    /** Args passed at acquire time; forwarded to init(). */
+    args?: unknown;
 }
 export type HydrationStatus = 'idle' | 'hydrating' | 'hydrated' | 'error';
 type StateListener<S> = (state: S) => void;
@@ -22,10 +25,55 @@ export interface SystemEventPayloads<S> {
     };
 }
 type SystemEventHandler<S, E extends SystemEvent> = (payload: SystemEventPayloads<S>[E]) => void;
-export declare abstract class StateContainer<S extends object = any> {
+/**
+ * BlaC's lifecycle/identity/dependency layer on top of `StructuralContainer`.
+ *
+ * StructuralContainer provides:
+ *   - `state` getter
+ *   - `emit` / `patch` / `update` (path-tracked, microtask-flushed)
+ *   - `channel` (the underlying `DirtyChannel`)
+ *   - `registerConsumerPaths` / `unregisterConsumer` (for fine-grained consumers)
+ *   - per-class `PathInterner`
+ *
+ * StateContainer layers on:
+ *   - identity (`name`, `instanceId`, `createdAt`, `debug`)
+ *   - lifecycle (`dispose`, `isDisposed`, `onSystemEvent`)
+ *   - hydration (`beginHydration` / `applyHydratedState` / `finishHydration` / `failHydration` / `waitForHydration`)
+ *   - cross-bloc deps (`depend()`, `dependencies` getter)
+ *   - per-consumer deps slices (`APPLY_DEPS` / `REMOVE_DEPS_OWNER` / `onDepsChanged`)
+ *   - registry integration (config-driven equality, emit-rate circuit breaker)
+ *
+ * Subscribers can attach via:
+ *   - `subscribe(listener)` — legacy state listener (back-compat); fires on
+ *     every flush with the latest state.
+ *   - `onSystemEvent('stateChanged' | 'dispose' | 'hydrationChanged', cb)` —
+ *     coarse lifecycle events.
+ *   - `this.channel.subscribe(interest, cb)` — path-scoped (new code).
+ */
+export declare abstract class StateContainer<S extends object = any, Args = void, Deps extends object = Record<string, never>> extends StructuralContainer<S> {
     static __excludeFromDevTools: boolean;
-    private _state;
-    private readonly _listeners;
+    /** @internal phantom — the args type this bloc is constructed with (see init()) */
+    readonly __args: Args;
+    /** @internal phantom — the injected deps type */
+    readonly __deps: Deps;
+    private _depsByOwner;
+    private _deps;
+    get deps(): Readonly<Deps>;
+    /**
+     * @internal Apply one owner's (consumer's) deps slice. Shallow-merges the
+     * slice, reconciles keys the owner dropped since its last apply (other
+     * owners' keys untouched), dev-warns on cross-owner key collisions, then
+     * recomputes the merged view and fires onDepsChanged if it changed.
+     *
+     * Idempotent: re-applying an identical slice for the same owner is a no-op.
+     */
+    [APPLY_DEPS](ownerId: string, slice: Partial<Deps>): void;
+    /**
+     * @internal Withdraw an owner's entire deps slice (consumer unmounted).
+     */
+    [REMOVE_DEPS_OWNER](ownerId: string): void;
+    private reconcileDeps;
+    protected onDepsChanged(_next: Readonly<Deps>, _prev: Readonly<Deps>): void;
     private _disposed;
     private _hydrationStatus;
     private _hydrationError?;
@@ -35,19 +83,43 @@ export declare abstract class StateContainer<S extends object = any> {
     private _rejectHydrationPromise?;
     private _hydrationPromiseSettled;
     private _config;
+    private _initCalled;
+    private _emitWindowStart;
+    private _emitCount;
+    private _emitRateWarned;
+    private readonly _listeners;
     private readonly _systemEventHandlers;
     private _dependencies;
-    private _hasStateChangeHandlers;
+    private _pendingChange;
+    private _bridgeUnsub;
     private _registry;
+    private _equalityFn;
     name: string;
     debug: boolean;
     instanceId: string;
     createdAt: number;
     get dependencies(): ReadonlyMap<StateContainerConstructor, string>;
+    get args(): Args | undefined;
+    /**
+     * Declare a cross-bloc dependency. Returns a getter so callers write
+     * `this.user()` lazily — the dep is resolved against the registry on each
+     * call, which keeps the surface immune to dep-instance churn.
+     *
+     * Note: this does NOT auto-resubscribe to the dep's channel. Consumers that
+     * need reactive updates from a dep should subscribe explicitly (typically
+     * via the framework adapter / `useBloc`'s tracker). A naive auto-bridge
+     * here would cycle on mutual deps; the channel's same-tick coalescing
+     * limits the blast radius but a true mutual cycle is still a user bug.
+     */
     protected depend<T extends StateContainerConstructor>(Type: T, instanceKey?: string): () => InstanceType<T>;
-    constructor(initialState: S);
+    constructor(initialState: S, options?: StructuralContainerOptions);
+    /**
+     * Called once after construction with the args passed at acquire time, before the first
+     * state snapshot is read by any consumer. Override to seed args-derived state (via
+     * this.emit(...)) or kick off loads.
+     */
+    protected init(_args: Args): void;
     initConfig(config: StateContainerConfig): void;
-    get state(): Readonly<S>;
     get isDisposed(): boolean;
     get hydrationStatus(): HydrationStatus;
     get hydrationError(): Error | undefined;
@@ -55,19 +127,47 @@ export declare abstract class StateContainer<S extends object = any> {
     get changedWhileHydrating(): boolean;
     subscribe(listener: StateListener<S>): () => void;
     dispose(): void;
-    protected [EMIT](newState: S): void;
-    protected emit(newState: S): void;
+    emit(next: S): void;
+    /**
+     * Override of `StructuralContainer.patch` that routes through the
+     * StateContainer concerns: disposed guard, dev-only emit-rate check,
+     * `_changedWhileHydrating` flag, pending-change capture (so legacy
+     * listeners and `stateChanged` system events see the merged prev/next),
+     * and the registry-level `stateChanged` notification. We still call
+     * `super.patch` so path-marking semantics (the whole point of patch) are
+     * preserved.
+     */
+    patch(partial: DeepPartial<S>): void;
+    /**
+     * @internal @deprecated Symbol-keyed alias for `emit`. Kept only so legacy
+     * in-package tests that index with `[EMIT]` typecheck/run unchanged. C5
+     * removes this along with the `EMIT` symbol.
+     */
+    protected [EMIT](next: S): void;
+    private applyState;
+    /**
+     * Called by the channel-bridge subscriber on each flush. Drains the
+     * pending change (if any) into legacy listeners and the 'stateChanged'
+     * system event. No pending change == flush from a no-op patch == skip.
+     */
+    private _drainPending;
     beginHydration(): void;
-    applyHydratedState(newState: S): boolean;
+    applyHydratedState(next: S): boolean;
     finishHydration(): void;
     failHydration(error: Error): void;
     waitForHydration(): Promise<void>;
-    private applyState;
     private setHydrationStatus;
     private ensureHydrationPromise;
     private resolveHydration;
     private rejectHydration;
     protected onSystemEvent: <E extends SystemEvent>(event: E, handler: SystemEventHandler<S, E>) => (() => void);
     private emitSystemEvent;
+    /**
+     * Dev-only soft circuit breaker. Counts real state changes in a rolling 1s
+     * window and warns once if the rate exceeds `maxEmitsPerSecond` — the
+     * signature of a runaway loop (RAF/animation or emit-on-every-commit) pushing
+     * high-frequency data through state, which freezes subscribers/plugins.
+     */
+    private _checkEmitRate;
 }
 export {};

package/dist/core/StateContainerRegistry.d.ts

@@ -10,16 +10,18 @@ export interface InstanceEntry<T = any> {
     instance: T;
     /** Map of active reference IDs to their acquire count (supports paired acquire/release) */
     refs: Map<string, number>;
+    /** The args used when this entry was first created; used for dev-warn on arg mismatch. */
+    args?: unknown;
 }
 /**
  * Lifecycle events emitted by the registry
  */
-export type LifecycleEvent = 'created' | 'stateChanged' | 'disposed' | 'refAcquired' | 'refReleased';
+export type LifecycleEvent = 'created' | 'stateChanged' | 'disposed' | 'refAcquired' | 'refReleased' | 'depsChanged';
 /**
  * Listener function type for each lifecycle event
  * @template E - The lifecycle event type
  */
-export type LifecycleListener<E extends LifecycleEvent> = E extends 'created' ? (container: StateContainer<any>) => void : E extends 'stateChanged' ? (container: StateContainer<any>, previousState: any, currentState: any) => void : E extends 'disposed' ? (container: StateContainer<any>) => void : E extends 'refAcquired' ? (container: StateContainer<any>, refId: string) => void : E extends 'refReleased' ? (container: StateContainer<any>, refId: string) => void : never;
+export type LifecycleListener<E extends LifecycleEvent> = E extends 'created' ? (container: StateContainer<any, any, any>) => void : E extends 'stateChanged' ? (container: StateContainer<any, any, any>, previousState: any, currentState: any) => void : E extends 'disposed' ? (container: StateContainer<any, any, any>) => void : E extends 'refAcquired' ? (container: StateContainer<any, any, any>, refId: string) => void : E extends 'refReleased' ? (container: StateContainer<any, any, any>, refId: string) => void : E extends 'depsChanged' ? (container: StateContainer<any, any, any>, previousDeps: Readonly<Record<string, unknown>>, currentDeps: Readonly<Record<string, unknown>>) => void : never;
 /**
  * Central registry for managing StateContainer instances.
  * Handles instance lifecycle, named ref tracking, and lifecycle event emission.
@@ -59,6 +61,44 @@ export declare class StateContainerRegistry {
      * Get the instances Map for a specific class (public API for stats/debugging)
      */
     getInstancesMap<T extends StateContainerConstructor>(Type: T): Map<string, InstanceEntry>;
+    /**
+     * 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<T extends StateContainerConstructor>(Type: T, instanceKey: string, instance: InstanceType<T>, refs?: Map<string, number>): void;
+    /**
+     * 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<T extends StateContainerConstructor = StateContainerConstructor>(Type: T, instanceKey: string | undefined, args: unknown): string;
+    /**
+     * 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.
+     */
+    private assertInstanceLimit;
+    /**
+     * 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.
+     */
+    private assertRefLimit;
     /**
      * Acquire an instance with ref tracking (ownership semantics).
      * Creates a new instance if one doesn't exist, or returns existing and adds a ref.
@@ -71,10 +111,11 @@ export declare class StateContainerRegistry {
      * @param options.refId - Named reference ID for debugging; auto-generated if omitted
      * @returns The state container instance
      */
-    acquire<T extends StateContainerConstructor = StateContainerConstructor>(Type: T, instanceKey?: string, options?: {
+    acquire<T extends StateContainerConstructor = StateContainerConstructor>(Type: T, instanceKey?: string | undefined, options?: {
         canCreate?: boolean;
         countRef?: boolean;
         refId?: string;
+        args?: unknown;
     }): InstanceType<T>;
     /**
      * Borrow an existing instance without adding a ref (borrowing semantics).
@@ -107,10 +148,12 @@ export declare class StateContainerRegistry {
      * 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 - Instance key (defaults to 'default')
+     * @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<T extends StateContainerConstructor = StateContainerConstructor>(Type: T, instanceKey?: string): InstanceType<T>;
+    ensure<T extends StateContainerConstructor = StateContainerConstructor>(Type: T, instanceKey?: string | undefined, args?: unknown): InstanceType<T>;
     /**
      * Release a reference to an instance.
      * Removes the ref and disposes when refs is empty (unless keepAlive).
@@ -192,17 +235,18 @@ export declare class StateContainerRegistry {
      * Emit lifecycle event to all listeners
      * @internal - Called by StateContainer lifecycle methods
      */
-    emit(event: 'created', container: StateContainer<any>): void;
-    emit(event: 'disposed', container: StateContainer<any>): void;
-    emit(event: 'stateChanged', container: StateContainer<any>, previousState: any, currentState: any): void;
-    emit(event: 'refAcquired', container: StateContainer<any>, refId: string): void;
-    emit(event: 'refReleased', container: StateContainer<any>, refId: string): void;
+    emit(event: 'created', container: StateContainer<any, any, any>): void;
+    emit(event: 'disposed', container: StateContainer<any, any, any>): void;
+    emit(event: 'stateChanged', container: StateContainer<any, any, any>, previousState: any, currentState: any): void;
+    emit(event: 'refAcquired', container: StateContainer<any, any, any>, refId: string): void;
+    emit(event: 'refReleased', container: StateContainer<any, any, any>, refId: string): void;
+    emit(event: 'depsChanged', container: StateContainer<any, any, any>, previousDeps: Readonly<Record<string, unknown>>, currentDeps: Readonly<Record<string, unknown>>): void;
     /**
      * Schedule a deferred stateChanged notification via microtask.
      * Skips entirely when no stateChanged listeners are registered.
      * @internal - Called by StateContainer.applyState
      */
-    notifyStateChanged(container: StateContainer<any>, previousState: any, newState: any): void;
+    notifyStateChanged(container: StateContainer<any, any, any>, previousState: any, newState: any): void;
     private flushStateChanged;
 }
 /**

package/dist/core/symbols.d.ts

@@ -1 +1,27 @@
+/**
+ * @internal @deprecated Symbol-keyed mutation entry point on `StateContainer`.
+ *
+ * Per A2 audit (`plans/blac-core-migration/_audit.md`), this symbol has zero
+ * external consumers — only in-package tests still reference it. C0 keeps it
+ * as a thin alias for `emit()` so the existing test files typecheck and run
+ * unchanged; C5 will port those tests to use `emit()` directly and delete
+ * this symbol along with its `[EMIT]` method on `StateContainer`.
+ *
+ * Do not add new uses of this symbol.
+ */
 export declare const EMIT: unique symbol;
+/**
+ * @internal Apply one owner's (consumer's) deps slice to an instance.
+ * Called by framework adapters (e.g. @blac/react useBloc) — not public API.
+ *
+ * Kept until D0 ports `useBloc` off the legacy adapter surface. See A2 audit
+ * (`plans/blac-core-migration/_audit.md`) for the consumer list.
+ */
+export declare const APPLY_DEPS: unique symbol;
+/**
+ * @internal Withdraw one owner's entire deps slice (consumer unmounted).
+ * Called by framework adapters — not public API.
+ *
+ * Kept until D0 ports `useBloc`. See A2 audit for the consumer list.
+ */
+export declare const REMOVE_DEPS_OWNER: unique symbol;

package/dist/debug.cjs

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_StateContainerRegistry = require("./StateContainerRegistry-CX2CBOmv.cjs");
-const require_config = require("./config-H6FAqbW4.cjs");
-const require_management = require("./management-DMZ8qpwr.cjs");
+const require_StateContainerRegistry = require("./StateContainerRegistry-B4yVMYbx.cjs");
+const require_config = require("./config-B_4xXpvK.cjs");
+const require_management = require("./management-DTzcC6aD.cjs");
 exports.forEach = require_management.forEach;
 exports.getAll = require_management.getAll;
 exports.getRefCount = require_management.getRefCount;

package/dist/debug.js

@@ -1,4 +1,4 @@
-import { r as globalRegistry } from "./StateContainerRegistry-BK57H92E.js";
-import { n as getStats, r as setRegistry, t as getRegistry } from "./config-ispAzOZV.js";
-import { a as getAll, c as hasInstance, i as forEach, o as getRefCount, r as register, s as getRefIds } from "./management-CK-GL3wY.js";
+import { r as globalRegistry } from "./StateContainerRegistry-DmmzYa7S.js";
+import { n as getStats, r as setRegistry, t as getRegistry } from "./config-DoHx0Xsl.js";
+import { a as getAll, c as hasInstance, i as forEach, o as getRefCount, r as register, s as getRefIds } from "./management-H4m3ciJO.js";
 export { forEach, getAll, getRefCount, getRefIds, getRegistry, getStats, globalRegistry, hasInstance, register, setRegistry };

package/dist/decorators/blac.d.ts

@@ -1,3 +1,4 @@
+import type { EqualityFn } from '../config';
 /**
  * Configuration options for the @blac decorator.
  * Only one option can be specified at a time (union type).
@@ -10,6 +11,22 @@ export type BlacOptions =
 /** Exclude bloc from DevTools tracking (prevents infinite loops) */
  | {
     excludeFromDevTools: true;
+}
+/**
+ * Override the global equality check for this bloc.
+ * Return `true` to skip the emit (states considered equal).
+ */
+ | {
+    equality: EqualityFn;
+}
+/**
+ * Override the default structural-hash identity key.
+ * The function receives `args` and returns the instance key string.
+ * Distinct return values → distinct instances; identical values → shared instance.
+ * Non-identity fields can be excluded so they don't fork new instances.
+ */
+ | {
+    key: (args: any) => string;
 };
 /**
  * Decorator to configure StateContainer classes.

package/dist/ensure-9VEq5H0L.js

@@ -1,9 +1,9 @@
-import { t as getRegistry } from "./config-CR_Bz7RD.js";
+import { t as getRegistry } from './config-CR_Bz7RD.js';
 //#region src/registry/ensure.ts
 function ensure(BlocClass, instanceKey) {
-	return getRegistry().ensure(BlocClass, instanceKey);
+  return getRegistry().ensure(BlocClass, instanceKey);
 }
 //#endregion
 export { ensure as t };
 
-//# sourceMappingURL=ensure-9VEq5H0L.js.map
+//# sourceMappingURL=ensure-9VEq5H0L.js.map

package/dist/ensure-BB6xHQAF.cjs

@@ -0,0 +1,14 @@
+const require_config = require("./config-B_4xXpvK.cjs");
+//#region src/registry/ensure.ts
+function ensure(BlocClass, instanceKey, args) {
+	return require_config.getRegistry().ensure(BlocClass, instanceKey, args);
+}
+//#endregion
+Object.defineProperty(exports, "ensure", {
+	enumerable: true,
+	get: function() {
+		return ensure;
+	}
+});
+
+//# sourceMappingURL=ensure-BB6xHQAF.cjs.map

package/dist/ensure-BB6xHQAF.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensure-BB6xHQAF.cjs","names":["getRegistry"],"sources":["../src/registry/ensure.ts"],"sourcesContent":["import { getRegistry } from './config';\nimport type {\n  ExtractArgs,\n  StateContainerConstructor,\n} from '../types/utilities';\n\nexport function ensure<T extends StateContainerConstructor>(\n  BlocClass: T,\n  instanceKey?: string,\n  args?: ExtractArgs<T>,\n): InstanceType<T> {\n  return getRegistry().ensure(BlocClass, instanceKey, args);\n}\n"],"mappings":";;AAMA,SAAgB,OACd,WACA,aACA,MACiB;CACjB,OAAOA,eAAAA,aAAa,CAAC,OAAO,WAAW,aAAa,KAAK"}

package/dist/ensure-BNDfTzqg.cjs

@@ -1,14 +1,14 @@
-const require_config = require("./config-CTOa-yPN.cjs");
+const require_config = require('./config-CTOa-yPN.cjs');
 //#region src/registry/ensure.ts
 function ensure(BlocClass, instanceKey) {
-	return require_config.getRegistry().ensure(BlocClass, instanceKey);
+  return require_config.getRegistry().ensure(BlocClass, instanceKey);
 }
 //#endregion
-Object.defineProperty(exports, "ensure", {
-	enumerable: true,
-	get: function() {
-		return ensure;
-	}
+Object.defineProperty(exports, 'ensure', {
+  enumerable: true,
+  get: function () {
+    return ensure;
+  },
 });
 
-//# sourceMappingURL=ensure-BNDfTzqg.cjs.map
+//# sourceMappingURL=ensure-BNDfTzqg.cjs.map