@blac/core 2.0.14 → 2.0.16

package/dist/plugins.cjs

@@ -1,4 +1,4 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_StateContainerRegistry = require("./StateContainerRegistry-B4yVMYbx.cjs");
+const require_StateContainerRegistry = require("./StateContainerRegistry-FWKzPfS-.cjs");
 exports.PluginManager = require_StateContainerRegistry.PluginManager;
 exports.getPluginManager = require_StateContainerRegistry.getPluginManager;

package/dist/plugins.js

@@ -1,2 +1,2 @@
-import { c as PluginManager, n as getPluginManager } from "./StateContainerRegistry-DmmzYa7S.js";
+import { c as PluginManager, n as getPluginManager } from "./StateContainerRegistry-B_ViBLvJ.js";
 export { PluginManager, getPluginManager };

package/dist/registry/acquire.d.ts

@@ -1,9 +1,22 @@
 import type { ExtractArgs, StateContainerConstructor } from '../types/utilities';
-export declare function acquire<T extends StateContainerConstructor>(BlocClass: T, instanceKey?: string, refId?: string, args?: ExtractArgs<T>): InstanceType<T>;
 /**
- * Resolve the storage key an instance would be acquired under, given an
- * (optional) explicit key and construction args. Callers that both acquire and
- * release (e.g. `@blac/react` `useBloc`) must use this once and pass the same
- * resolved key to both, so the ref is dropped under the key it was taken.
+ * Acquire an instance with ref tracking (ownership semantics). Instance
+ * identity is derived purely from `args` (via the class's `static key(args)`,
+ * a structural hash of `args`, or the default sentinel when there are none).
+ *
+ * @param BlocClass - The StateContainer class constructor
+ * @param opts.args - Construction/identity args; derives the instance key
+ * @param opts.refId - Named reference ID for debugging; auto-generated if omitted
  */
-export declare function resolveInstanceKey<T extends StateContainerConstructor>(BlocClass: T, instanceKey: string | undefined, args?: ExtractArgs<T>): string;
+export declare function acquire<T extends StateContainerConstructor>(BlocClass: T, opts?: {
+    args?: ExtractArgs<T>;
+    refId?: string;
+}): InstanceType<T>;
+/**
+ * Resolve the storage key an instance would be acquired under, given its
+ * construction `args`. This is the canonical key-computation path. Callers that
+ * both acquire and release against the `@internal` registry tier (e.g.
+ * `@blac/react` `useBloc`) must use this once and pass the same resolved key to
+ * both, so the ref is dropped under the key it was taken.
+ */
+export declare function resolveInstanceKey<T extends StateContainerConstructor>(BlocClass: T, args?: ExtractArgs<T>): string;

package/dist/registry/borrow.d.ts

@@ -1,6 +1,17 @@
-import type { StateContainerConstructor } from '../types/utilities';
-export declare function borrow<T extends StateContainerConstructor>(BlocClass: T, instanceKey?: string): InstanceType<T>;
-export declare function borrowSafe<T extends StateContainerConstructor>(BlocClass: T, instanceKey?: string): {
+import type { ExtractArgs, StateContainerConstructor } from '../types/utilities';
+/**
+ * How to identify the instance to borrow: the same `args` shape `useBloc`
+ * accepts, resolved through the class's `static key(args)` so call sites use
+ * the *same* shape they pass to `useBloc` instead of hand-deriving the key.
+ *
+ * `borrowSafe(ChannelBloc, { args: { channelId } })` and
+ * `useBloc(ChannelBloc, { args: { channelId } })` therefore always agree.
+ */
+export type BorrowTarget<T extends StateContainerConstructor> = {
+    args?: ExtractArgs<T>;
+};
+export declare function borrow<T extends StateContainerConstructor>(BlocClass: T, target?: BorrowTarget<T>): InstanceType<T>;
+export declare function borrowSafe<T extends StateContainerConstructor>(BlocClass: T, target?: BorrowTarget<T>): {
     error: Error;
     instance: null;
 } | {

package/dist/registry/ensure.d.ts

@@ -1,2 +1,8 @@
 import type { ExtractArgs, StateContainerConstructor } from '../types/utilities';
-export declare function ensure<T extends StateContainerConstructor>(BlocClass: T, instanceKey?: string, args?: ExtractArgs<T>): InstanceType<T>;
+/**
+ * Ensure an instance exists without taking ownership (no ref added). Instance
+ * identity is derived purely from `args`, matching `acquire`.
+ */
+export declare function ensure<T extends StateContainerConstructor>(BlocClass: T, opts?: {
+    args?: ExtractArgs<T>;
+}): InstanceType<T>;

package/dist/registry/index.d.ts

@@ -1,5 +1,6 @@
 export { acquire, resolveInstanceKey } from './acquire';
 export { borrow, borrowSafe } from './borrow';
+export type { BorrowTarget } from './borrow';
 export { ensure } from './ensure';
 export { release } from './release';
 export { hasInstance, getRefCount, getRefIds, getAll, forEach, } from './queries';

package/dist/registry/queries.d.ts

@@ -1,6 +1,12 @@
-import type { StateContainerConstructor, InstanceReadonlyState } from '../types/utilities';
-export declare function hasInstance<T extends StateContainerConstructor>(BlocClass: T, instanceKey?: string): boolean;
-export declare function getRefCount<T extends StateContainerConstructor>(BlocClass: T, instanceKey?: string): number;
-export declare function getRefIds<T extends StateContainerConstructor>(BlocClass: T, instanceKey?: string): string[];
+import type { ExtractArgs, StateContainerConstructor, InstanceReadonlyState } from '../types/utilities';
+export declare function hasInstance<T extends StateContainerConstructor>(BlocClass: T, opts?: {
+    args?: ExtractArgs<T>;
+}): boolean;
+export declare function getRefCount<T extends StateContainerConstructor>(BlocClass: T, opts?: {
+    args?: ExtractArgs<T>;
+}): number;
+export declare function getRefIds<T extends StateContainerConstructor>(BlocClass: T, opts?: {
+    args?: ExtractArgs<T>;
+}): string[];
 export declare function getAll<T extends StateContainerConstructor>(BlocClass: T): InstanceReadonlyState<T>[];
 export declare function forEach<T extends StateContainerConstructor>(BlocClass: T, callback: (instance: InstanceReadonlyState<T>) => void): void;

package/dist/registry/release.d.ts

@@ -1,2 +1,14 @@
-import type { StateContainerConstructor } from '../types/utilities';
-export declare function release<T extends StateContainerConstructor>(BlocClass: T, instanceKey?: string, forceDispose?: boolean, refId?: string): void;
+import type { ExtractArgs, StateContainerConstructor } from '../types/utilities';
+/**
+ * Release a reference to an instance. Instance identity is derived purely from
+ * `args` (must match the `args` it was acquired with).
+ *
+ * @param opts.args - Construction/identity args; derives the instance key
+ * @param opts.refId - The specific ref to drop; drops one arbitrary ref if omitted
+ * @param opts.forceDispose - Force immediate disposal regardless of refs
+ */
+export declare function release<T extends StateContainerConstructor>(BlocClass: T, opts?: {
+    args?: ExtractArgs<T>;
+    refId?: string;
+    forceDispose?: boolean;
+}): void;

package/dist/testing.cjs

@@ -1,8 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_StateContainerRegistry = require("./StateContainerRegistry-B4yVMYbx.cjs");
-const require_Cubit = require("./Cubit-CWP8Ddzx.cjs");
-const require_config = require("./config-B_4xXpvK.cjs");
-const require_ensure = require("./ensure-BB6xHQAF.cjs");
+const require_StateContainerRegistry = require("./StateContainerRegistry-FWKzPfS-.cjs");
+const require_ensure = require("./ensure-CLQEx0Nn.cjs");
+const require_config = require("./config-DVMnlHLv.cjs");
+const require_acquire = require("./acquire-DHEOEVcj.cjs");
 //#region src/testing.ts
 /** Synthetic owner id used by test helpers for pre-wired deps. */
 const TESTING_DEPS_OWNER = "testing-deps";
@@ -39,14 +39,14 @@ function blacTestSetup() {
 		require_config.setRegistry(savedRegistry);
 	});
 }
-const DEFAULT_KEY = "default";
-function registerOverride(BlocClass, instance, instanceKey) {
-	const key = instanceKey ?? DEFAULT_KEY;
-	require_config.getRegistry().insertInstance(BlocClass, key, instance, new Map([["testing-override", 1]]));
+function registerOverride(BlocClass, instance, args) {
+	const registry = require_config.getRegistry();
+	const key = require_acquire.resolveInstanceKey(BlocClass, args);
+	registry.insertInstance(BlocClass, key, instance, new Map([["testing-override", 1]]));
 }
-function overrideEnsure(BlocClass, instance, fn, instanceKey = DEFAULT_KEY) {
+function overrideEnsure(BlocClass, instance, fn, args) {
 	return withTestRegistry(() => {
-		registerOverride(BlocClass, instance, instanceKey);
+		registerOverride(BlocClass, instance, args);
 		return fn();
 	});
 }
@@ -54,7 +54,7 @@ function createCubitStub(BlocClass, options) {
 	const instance = new BlocClass();
 	if (options?.args != null) instance.initConfig({ args: options.args });
 	if (options?.state != null) {
-		if (instance instanceof require_Cubit.Cubit) {
+		if (instance instanceof require_ensure.Cubit) {
 			const currentState = instance.state;
 			if (typeof currentState === "object" && currentState !== null && typeof options.state === "object" && options.state !== null) instance.patch(options.state);
 			else instance.emit(options.state);
@@ -63,20 +63,20 @@ function createCubitStub(BlocClass, options) {
 	if (options?.methods) {
 		for (const [key, impl] of Object.entries(options.methods)) if (typeof impl === "function") instance[key] = impl;
 	}
-	if (options?.deps != null) instance[require_Cubit.APPLY_DEPS](TESTING_DEPS_OWNER, options.deps);
+	if (options?.deps != null) instance[require_ensure.APPLY_DEPS](TESTING_DEPS_OWNER, options.deps);
 	return instance;
 }
-function withBlocState(BlocClass, state, instanceKey) {
-	const instance = require_ensure.ensure(BlocClass, instanceKey);
-	if (instance instanceof require_Cubit.Cubit) {
+function withBlocState(BlocClass, state, args) {
+	const instance = require_ensure.ensure(BlocClass, { args });
+	if (instance instanceof require_ensure.Cubit) {
 		const currentState = instance.state;
 		if (typeof currentState === "object" && currentState !== null && typeof state === "object" && state !== null) instance.patch(state);
 		else instance.emit(state);
 	}
 	return instance;
 }
-function withBlocMethod(BlocClass, methodName, impl, instanceKey) {
-	const instance = require_ensure.ensure(BlocClass, instanceKey);
+function withBlocMethod(BlocClass, methodName, impl, args) {
+	const instance = require_ensure.ensure(BlocClass, { args });
 	instance[methodName] = impl;
 	return instance;
 }

package/dist/testing.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"testing.cjs","names":["StateContainerRegistry","getRegistry","Cubit","APPLY_DEPS","ensure"],"sources":["../src/testing.ts"],"sourcesContent":["import { Cubit } from './core/Cubit';\nimport { StateContainerRegistry } from './core/StateContainerRegistry';\nimport { APPLY_DEPS } from './core/symbols';\nimport { ensure, getRegistry, setRegistry } from './registry';\nimport type {\n  ExtractArgs,\n  ExtractDeps,\n  ExtractState,\n  StateContainerConstructor,\n} from './types/utilities';\n\n/** Synthetic owner id used by test helpers for pre-wired deps. */\nconst TESTING_DEPS_OWNER = 'testing-deps';\n\ndeclare const beforeEach: (fn: () => void) => void;\ndeclare const afterEach: (fn: () => void) => void;\n\n// --- createTestRegistry + withTestRegistry ---\n\nexport function createTestRegistry(): StateContainerRegistry {\n  return new StateContainerRegistry();\n}\n\nexport function withTestRegistry<T>(\n  fn: (registry: StateContainerRegistry) => T,\n): T {\n  const previous = getRegistry();\n  const testRegistry = createTestRegistry();\n  setRegistry(testRegistry);\n  try {\n    const result = fn(testRegistry);\n    if (result instanceof Promise) {\n      return result.then(\n        (value) => {\n          setRegistry(previous);\n          return value;\n        },\n        (error) => {\n          setRegistry(previous);\n          throw error;\n        },\n      ) as T;\n    }\n    setRegistry(previous);\n    return result;\n  } catch (error) {\n    setRegistry(previous);\n    throw error;\n  }\n}\n\n// --- blacTestSetup ---\n\nexport function blacTestSetup(): void {\n  let savedRegistry: StateContainerRegistry;\n  beforeEach(() => {\n    savedRegistry = getRegistry();\n    setRegistry(new StateContainerRegistry());\n  });\n  afterEach(() => {\n    setRegistry(savedRegistry);\n  });\n}\n\n// --- registerOverride + overrideEnsure ---\n\nconst DEFAULT_KEY = 'default';\n\nexport function registerOverride<T extends StateContainerConstructor>(\n  BlocClass: T,\n  instance: InstanceType<T>,\n  instanceKey?: string,\n): void {\n  const key = instanceKey ?? DEFAULT_KEY;\n  const registry = getRegistry();\n  registry.insertInstance(\n    BlocClass,\n    key,\n    instance,\n    new Map([['testing-override', 1]]),\n  );\n}\n\nexport function overrideEnsure<T extends StateContainerConstructor, R>(\n  BlocClass: T,\n  instance: InstanceType<T>,\n  fn: () => R,\n  instanceKey: string = DEFAULT_KEY,\n): R {\n  return withTestRegistry(() => {\n    registerOverride(BlocClass, instance, instanceKey);\n    return fn();\n  });\n}\n\n// --- createCubitStub ---\n\ntype MethodKeys<T> = {\n  [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;\n}[keyof T];\n\nexport interface CubitStubOptions<T extends StateContainerConstructor> {\n  state?: ExtractState<T> extends Record<string, any>\n    ? Partial<ExtractState<T>>\n    : ExtractState<T>;\n  methods?: Partial<\n    Record<MethodKeys<InstanceType<T>>, (...args: any[]) => any>\n  >;\n  /**\n   * Args to pass to init(). If the bloc's Args type is not void, supplying\n   * args here causes initConfig({ args }) to be called so init() runs.\n   */\n  args?: ExtractArgs<T> extends void ? never : ExtractArgs<T>;\n  /**\n   * Deps slice to pre-wire via the core [APPLY_DEPS] path (synthetic owner\n   * \"testing-deps\"), so onDepsChanged fires during tests.\n   */\n  deps?: Partial<ExtractDeps<T>>;\n}\n\nexport function createCubitStub<T extends StateContainerConstructor>(\n  BlocClass: T,\n  options?: CubitStubOptions<T>,\n): InstanceType<T> {\n  const instance = new BlocClass() as InstanceType<T>;\n\n  // Run init() if args are supplied — goes through the same initConfig path\n  // that the registry uses, so lifecycle hooks fire correctly.\n  if (options?.args != null) {\n    instance.initConfig({ args: options.args });\n  }\n\n  if (options?.state != null) {\n    if (instance instanceof Cubit) {\n      const currentState = instance.state;\n      if (\n        typeof currentState === 'object' &&\n        currentState !== null &&\n        typeof options.state === 'object' &&\n        options.state !== null\n      ) {\n        instance.patch(options.state as any);\n      } else {\n        instance.emit(options.state as any);\n      }\n    }\n  }\n  if (options?.methods) {\n    for (const [key, impl] of Object.entries(options.methods)) {\n      if (typeof impl === 'function') {\n        (instance as any)[key] = impl;\n      }\n    }\n  }\n\n  // Pre-wire deps via the core merge path so onDepsChanged fires in tests.\n  if (options?.deps != null) {\n    (instance as any)[APPLY_DEPS](TESTING_DEPS_OWNER, options.deps);\n  }\n\n  return instance;\n}\n\n// --- withBlocState ---\n\nexport function withBlocState<T extends StateContainerConstructor>(\n  BlocClass: T,\n  state: ExtractState<T> extends Record<string, any>\n    ? Partial<ExtractState<T>>\n    : ExtractState<T>,\n  instanceKey?: string,\n): InstanceType<T> {\n  const instance = ensure(BlocClass, instanceKey);\n  if (instance instanceof Cubit) {\n    const currentState = instance.state;\n    if (\n      typeof currentState === 'object' &&\n      currentState !== null &&\n      typeof state === 'object' &&\n      state !== null\n    ) {\n      instance.patch(state as any);\n    } else {\n      instance.emit(state as any);\n    }\n  }\n  return instance;\n}\n\n// --- withBlocMethod ---\n\nexport function withBlocMethod<T extends StateContainerConstructor>(\n  BlocClass: T,\n  methodName: keyof InstanceType<T>,\n  impl: (...args: any[]) => any,\n  instanceKey?: string,\n): InstanceType<T> {\n  const instance = ensure(BlocClass, instanceKey);\n  (instance as any)[methodName] = impl;\n  return instance;\n}\n\n// --- flushBlocUpdates ---\n\n/**\n * Drain pending microtasks so any channel-flushed effects (subscribe()\n * listeners, `onSystemEvent('stateChanged')` handlers, plugin hooks) run\n * before the next assertion.\n *\n * The default `MicrotaskScheduler` coalesces emits within a tick; tests\n * that emit and then assert on listener side-effects need `await flush()`\n * (or its alias `flushBlocUpdates()`) between the two.\n */\nexport async function flush(): Promise<void> {\n  // queueMicrotask wins the race against the channel's own queued flush —\n  // we resolve after the channel has drained its current pending flush.\n  await Promise.resolve();\n  await Promise.resolve();\n}\n\n/** @deprecated Alias for `flush()`. */\nexport async function flushBlocUpdates(): Promise<void> {\n  await flush();\n}\n"],"mappings":";;;;;;;AAYA,MAAM,qBAAqB;AAO3B,SAAgB,qBAA6C;CAC3D,OAAO,IAAIA,+BAAAA,wBAAwB;;AAGrC,SAAgB,iBACd,IACG;CACH,MAAM,WAAWC,eAAAA,aAAa;CAC9B,MAAM,eAAe,oBAAoB;CACzC,eAAA,YAAY,aAAa;CACzB,IAAI;EACF,MAAM,SAAS,GAAG,aAAa;EAC/B,IAAI,kBAAkB,SACpB,OAAO,OAAO,MACX,UAAU;GACT,eAAA,YAAY,SAAS;GACrB,OAAO;MAER,UAAU;GACT,eAAA,YAAY,SAAS;GACrB,MAAM;IAET;EAEH,eAAA,YAAY,SAAS;EACrB,OAAO;UACA,OAAO;EACd,eAAA,YAAY,SAAS;EACrB,MAAM;;;AAMV,SAAgB,gBAAsB;CACpC,IAAI;CACJ,iBAAiB;EACf,gBAAgBA,eAAAA,aAAa;EAC7B,eAAA,YAAY,IAAID,+BAAAA,wBAAwB,CAAC;GACzC;CACF,gBAAgB;EACd,eAAA,YAAY,cAAc;GAC1B;;AAKJ,MAAM,cAAc;AAEpB,SAAgB,iBACd,WACA,UACA,aACM;CACN,MAAM,MAAM,eAAe;CAE3B,eADiBC,aACT,CAAC,eACP,WACA,KACA,UACA,IAAI,IAAI,CAAC,CAAC,oBAAoB,EAAE,CAAC,CAAC,CACnC;;AAGH,SAAgB,eACd,WACA,UACA,IACA,cAAsB,aACnB;CACH,OAAO,uBAAuB;EAC5B,iBAAiB,WAAW,UAAU,YAAY;EAClD,OAAO,IAAI;GACX;;AA4BJ,SAAgB,gBACd,WACA,SACiB;CACjB,MAAM,WAAW,IAAI,WAAW;CAIhC,IAAI,SAAS,QAAQ,MACnB,SAAS,WAAW,EAAE,MAAM,QAAQ,MAAM,CAAC;CAG7C,IAAI,SAAS,SAAS;MAChB,oBAAoBC,cAAAA,OAAO;GAC7B,MAAM,eAAe,SAAS;GAC9B,IACE,OAAO,iBAAiB,YACxB,iBAAiB,QACjB,OAAO,QAAQ,UAAU,YACzB,QAAQ,UAAU,MAElB,SAAS,MAAM,QAAQ,MAAa;QAEpC,SAAS,KAAK,QAAQ,MAAa;;;CAIzC,IAAI,SAAS;OACN,MAAM,CAAC,KAAK,SAAS,OAAO,QAAQ,QAAQ,QAAQ,EACvD,IAAI,OAAO,SAAS,YAClB,SAAkB,OAAO;;CAM/B,IAAI,SAAS,QAAQ,MACnB,SAAkBC,cAAAA,YAAY,oBAAoB,QAAQ,KAAK;CAGjE,OAAO;;AAKT,SAAgB,cACd,WACA,OAGA,aACiB;CACjB,MAAM,WAAWC,eAAAA,OAAO,WAAW,YAAY;CAC/C,IAAI,oBAAoBF,cAAAA,OAAO;EAC7B,MAAM,eAAe,SAAS;EAC9B,IACE,OAAO,iBAAiB,YACxB,iBAAiB,QACjB,OAAO,UAAU,YACjB,UAAU,MAEV,SAAS,MAAM,MAAa;OAE5B,SAAS,KAAK,MAAa;;CAG/B,OAAO;;AAKT,SAAgB,eACd,WACA,YACA,MACA,aACiB;CACjB,MAAM,WAAWE,eAAAA,OAAO,WAAW,YAAY;CAC/C,SAAkB,cAAc;CAChC,OAAO;;;;;;;;;;;AAcT,eAAsB,QAAuB;CAG3C,MAAM,QAAQ,SAAS;CACvB,MAAM,QAAQ,SAAS;;;AAIzB,eAAsB,mBAAkC;CACtD,MAAM,OAAO"}
+{"version":3,"file":"testing.cjs","names":["StateContainerRegistry","getRegistry","resolveInstanceKey","Cubit","APPLY_DEPS","ensure"],"sources":["../src/testing.ts"],"sourcesContent":["import { Cubit } from './core/Cubit';\nimport { StateContainerRegistry } from './core/StateContainerRegistry';\nimport { APPLY_DEPS } from './core/symbols';\nimport { ensure, getRegistry, setRegistry } from './registry';\nimport { resolveInstanceKey } from './registry/acquire';\nimport type {\n  ExtractArgs,\n  ExtractDeps,\n  ExtractState,\n  StateContainerConstructor,\n} from './types/utilities';\n\n/** Synthetic owner id used by test helpers for pre-wired deps. */\nconst TESTING_DEPS_OWNER = 'testing-deps';\n\ndeclare const beforeEach: (fn: () => void) => void;\ndeclare const afterEach: (fn: () => void) => void;\n\n// --- createTestRegistry + withTestRegistry ---\n\nexport function createTestRegistry(): StateContainerRegistry {\n  return new StateContainerRegistry();\n}\n\nexport function withTestRegistry<T>(\n  fn: (registry: StateContainerRegistry) => T,\n): T {\n  const previous = getRegistry();\n  const testRegistry = createTestRegistry();\n  setRegistry(testRegistry);\n  try {\n    const result = fn(testRegistry);\n    if (result instanceof Promise) {\n      return result.then(\n        (value) => {\n          setRegistry(previous);\n          return value;\n        },\n        (error) => {\n          setRegistry(previous);\n          throw error;\n        },\n      ) as T;\n    }\n    setRegistry(previous);\n    return result;\n  } catch (error) {\n    setRegistry(previous);\n    throw error;\n  }\n}\n\n// --- blacTestSetup ---\n\nexport function blacTestSetup(): void {\n  let savedRegistry: StateContainerRegistry;\n  beforeEach(() => {\n    savedRegistry = getRegistry();\n    setRegistry(new StateContainerRegistry());\n  });\n  afterEach(() => {\n    setRegistry(savedRegistry);\n  });\n}\n\n// --- registerOverride + overrideEnsure ---\n\nexport function registerOverride<T extends StateContainerConstructor>(\n  BlocClass: T,\n  instance: InstanceType<T>,\n  args?: ExtractArgs<T>,\n): void {\n  const registry = getRegistry();\n  const key = resolveInstanceKey(BlocClass, args);\n  registry.insertInstance(\n    BlocClass,\n    key,\n    instance,\n    new Map([['testing-override', 1]]),\n  );\n}\n\nexport function overrideEnsure<T extends StateContainerConstructor, R>(\n  BlocClass: T,\n  instance: InstanceType<T>,\n  fn: () => R,\n  args?: ExtractArgs<T>,\n): R {\n  return withTestRegistry(() => {\n    registerOverride(BlocClass, instance, args);\n    return fn();\n  });\n}\n\n// --- createCubitStub ---\n\ntype MethodKeys<T> = {\n  [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;\n}[keyof T];\n\nexport interface CubitStubOptions<T extends StateContainerConstructor> {\n  state?: ExtractState<T> extends Record<string, any>\n    ? Partial<ExtractState<T>>\n    : ExtractState<T>;\n  methods?: Partial<\n    Record<MethodKeys<InstanceType<T>>, (...args: any[]) => any>\n  >;\n  /**\n   * Args to pass to init(). If the bloc's Args type is not void, supplying\n   * args here causes initConfig({ args }) to be called so init() runs.\n   */\n  args?: ExtractArgs<T> extends void ? never : ExtractArgs<T>;\n  /**\n   * Deps slice to pre-wire via the core [APPLY_DEPS] path (synthetic owner\n   * \"testing-deps\"), so onDepsChanged fires during tests.\n   */\n  deps?: Partial<ExtractDeps<T>>;\n}\n\nexport function createCubitStub<T extends StateContainerConstructor>(\n  BlocClass: T,\n  options?: CubitStubOptions<T>,\n): InstanceType<T> {\n  const instance = new BlocClass() as InstanceType<T>;\n\n  // Run init() if args are supplied — goes through the same initConfig path\n  // that the registry uses, so lifecycle hooks fire correctly.\n  if (options?.args != null) {\n    instance.initConfig({ args: options.args });\n  }\n\n  if (options?.state != null) {\n    if (instance instanceof Cubit) {\n      const currentState = instance.state;\n      if (\n        typeof currentState === 'object' &&\n        currentState !== null &&\n        typeof options.state === 'object' &&\n        options.state !== null\n      ) {\n        instance.patch(options.state as any);\n      } else {\n        instance.emit(options.state as any);\n      }\n    }\n  }\n  if (options?.methods) {\n    for (const [key, impl] of Object.entries(options.methods)) {\n      if (typeof impl === 'function') {\n        (instance as any)[key] = impl;\n      }\n    }\n  }\n\n  // Pre-wire deps via the core merge path so onDepsChanged fires in tests.\n  if (options?.deps != null) {\n    (instance as any)[APPLY_DEPS](TESTING_DEPS_OWNER, options.deps);\n  }\n\n  return instance;\n}\n\n// --- withBlocState ---\n\nexport function withBlocState<T extends StateContainerConstructor>(\n  BlocClass: T,\n  state: ExtractState<T> extends Record<string, any>\n    ? Partial<ExtractState<T>>\n    : ExtractState<T>,\n  args?: ExtractArgs<T>,\n): InstanceType<T> {\n  const instance = ensure(BlocClass, { args });\n  if (instance instanceof Cubit) {\n    const currentState = instance.state;\n    if (\n      typeof currentState === 'object' &&\n      currentState !== null &&\n      typeof state === 'object' &&\n      state !== null\n    ) {\n      instance.patch(state as any);\n    } else {\n      instance.emit(state as any);\n    }\n  }\n  return instance;\n}\n\n// --- withBlocMethod ---\n\nexport function withBlocMethod<T extends StateContainerConstructor>(\n  BlocClass: T,\n  methodName: keyof InstanceType<T>,\n  impl: (...args: any[]) => any,\n  args?: ExtractArgs<T>,\n): InstanceType<T> {\n  const instance = ensure(BlocClass, { args });\n  (instance as any)[methodName] = impl;\n  return instance;\n}\n\n// --- flushBlocUpdates ---\n\n/**\n * Drain pending microtasks so any channel-flushed effects (subscribe()\n * listeners, `onSystemEvent('stateChanged')` handlers, plugin hooks) run\n * before the next assertion.\n *\n * The default `MicrotaskScheduler` coalesces emits within a tick; tests\n * that emit and then assert on listener side-effects need `await flush()`\n * (or its alias `flushBlocUpdates()`) between the two.\n */\nexport async function flush(): Promise<void> {\n  // queueMicrotask wins the race against the channel's own queued flush —\n  // we resolve after the channel has drained its current pending flush.\n  await Promise.resolve();\n  await Promise.resolve();\n}\n\n/** @deprecated Alias for `flush()`. */\nexport async function flushBlocUpdates(): Promise<void> {\n  await flush();\n}\n"],"mappings":";;;;;;;AAaA,MAAM,qBAAqB;AAO3B,SAAgB,qBAA6C;CAC3D,OAAO,IAAIA,+BAAAA,uBAAuB;AACpC;AAEA,SAAgB,iBACd,IACG;CACH,MAAM,WAAWC,eAAAA,YAAY;CAC7B,MAAM,eAAe,mBAAmB;CACxC,eAAA,YAAY,YAAY;CACxB,IAAI;EACF,MAAM,SAAS,GAAG,YAAY;EAC9B,IAAI,kBAAkB,SACpB,OAAO,OAAO,MACX,UAAU;GACT,eAAA,YAAY,QAAQ;GACpB,OAAO;EACT,IACC,UAAU;GACT,eAAA,YAAY,QAAQ;GACpB,MAAM;EACR,CACF;EAEF,eAAA,YAAY,QAAQ;EACpB,OAAO;CACT,SAAS,OAAO;EACd,eAAA,YAAY,QAAQ;EACpB,MAAM;CACR;AACF;AAIA,SAAgB,gBAAsB;CACpC,IAAI;CACJ,iBAAiB;EACf,gBAAgBA,eAAAA,YAAY;EAC5B,eAAA,YAAY,IAAID,+BAAAA,uBAAuB,CAAC;CAC1C,CAAC;CACD,gBAAgB;EACd,eAAA,YAAY,aAAa;CAC3B,CAAC;AACH;AAIA,SAAgB,iBACd,WACA,UACA,MACM;CACN,MAAM,WAAWC,eAAAA,YAAY;CAC7B,MAAM,MAAMC,gBAAAA,mBAAmB,WAAW,IAAI;CAC9C,SAAS,eACP,WACA,KACA,UACA,IAAI,IAAI,CAAC,CAAC,oBAAoB,CAAC,CAAC,CAAC,CACnC;AACF;AAEA,SAAgB,eACd,WACA,UACA,IACA,MACG;CACH,OAAO,uBAAuB;EAC5B,iBAAiB,WAAW,UAAU,IAAI;EAC1C,OAAO,GAAG;CACZ,CAAC;AACH;AA2BA,SAAgB,gBACd,WACA,SACiB;CACjB,MAAM,WAAW,IAAI,UAAU;CAI/B,IAAI,SAAS,QAAQ,MACnB,SAAS,WAAW,EAAE,MAAM,QAAQ,KAAK,CAAC;CAG5C,IAAI,SAAS,SAAS;MAChB,oBAAoBC,eAAAA,OAAO;GAC7B,MAAM,eAAe,SAAS;GAC9B,IACE,OAAO,iBAAiB,YACxB,iBAAiB,QACjB,OAAO,QAAQ,UAAU,YACzB,QAAQ,UAAU,MAElB,SAAS,MAAM,QAAQ,KAAY;QAEnC,SAAS,KAAK,QAAQ,KAAY;EAEtC;;CAEF,IAAI,SAAS;OACN,MAAM,CAAC,KAAK,SAAS,OAAO,QAAQ,QAAQ,OAAO,GACtD,IAAI,OAAO,SAAS,YAClB,SAAkB,OAAO;CAAA;CAM/B,IAAI,SAAS,QAAQ,MACnB,SAAkBC,eAAAA,YAAY,oBAAoB,QAAQ,IAAI;CAGhE,OAAO;AACT;AAIA,SAAgB,cACd,WACA,OAGA,MACiB;CACjB,MAAM,WAAWC,eAAAA,OAAO,WAAW,EAAE,KAAK,CAAC;CAC3C,IAAI,oBAAoBF,eAAAA,OAAO;EAC7B,MAAM,eAAe,SAAS;EAC9B,IACE,OAAO,iBAAiB,YACxB,iBAAiB,QACjB,OAAO,UAAU,YACjB,UAAU,MAEV,SAAS,MAAM,KAAY;OAE3B,SAAS,KAAK,KAAY;CAE9B;CACA,OAAO;AACT;AAIA,SAAgB,eACd,WACA,YACA,MACA,MACiB;CACjB,MAAM,WAAWE,eAAAA,OAAO,WAAW,EAAE,KAAK,CAAC;CAC3C,SAAkB,cAAc;CAChC,OAAO;AACT;;;;;;;;;;AAaA,eAAsB,QAAuB;CAG3C,MAAM,QAAQ,QAAQ;CACtB,MAAM,QAAQ,QAAQ;AACxB;;AAGA,eAAsB,mBAAkC;CACtD,MAAM,MAAM;AACd"}

package/dist/testing.d.cts

@@ -3,8 +3,8 @@ import type { ExtractArgs, ExtractDeps, ExtractState, StateContainerConstructor
 export declare function createTestRegistry(): StateContainerRegistry;
 export declare function withTestRegistry<T>(fn: (registry: StateContainerRegistry) => T): T;
 export declare function blacTestSetup(): void;
-export declare function registerOverride<T extends StateContainerConstructor>(BlocClass: T, instance: InstanceType<T>, instanceKey?: string): void;
-export declare function overrideEnsure<T extends StateContainerConstructor, R>(BlocClass: T, instance: InstanceType<T>, fn: () => R, instanceKey?: string): R;
+export declare function registerOverride<T extends StateContainerConstructor>(BlocClass: T, instance: InstanceType<T>, args?: ExtractArgs<T>): void;
+export declare function overrideEnsure<T extends StateContainerConstructor, R>(BlocClass: T, instance: InstanceType<T>, fn: () => R, args?: ExtractArgs<T>): R;
 type MethodKeys<T> = {
     [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
 }[keyof T];
@@ -23,8 +23,8 @@ export interface CubitStubOptions<T extends StateContainerConstructor> {
     deps?: Partial<ExtractDeps<T>>;
 }
 export declare function createCubitStub<T extends StateContainerConstructor>(BlocClass: T, options?: CubitStubOptions<T>): InstanceType<T>;
-export declare function withBlocState<T extends StateContainerConstructor>(BlocClass: T, state: ExtractState<T> extends Record<string, any> ? Partial<ExtractState<T>> : ExtractState<T>, instanceKey?: string): InstanceType<T>;
-export declare function withBlocMethod<T extends StateContainerConstructor>(BlocClass: T, methodName: keyof InstanceType<T>, impl: (...args: any[]) => any, instanceKey?: string): InstanceType<T>;
+export declare function withBlocState<T extends StateContainerConstructor>(BlocClass: T, state: ExtractState<T> extends Record<string, any> ? Partial<ExtractState<T>> : ExtractState<T>, args?: ExtractArgs<T>): InstanceType<T>;
+export declare function withBlocMethod<T extends StateContainerConstructor>(BlocClass: T, methodName: keyof InstanceType<T>, impl: (...args: any[]) => any, args?: ExtractArgs<T>): InstanceType<T>;
 /**
  * Drain pending microtasks so any channel-flushed effects (subscribe()
  * listeners, `onSystemEvent('stateChanged')` handlers, plugin hooks) run

package/dist/testing.d.ts

@@ -3,8 +3,8 @@ import type { ExtractArgs, ExtractDeps, ExtractState, StateContainerConstructor
 export declare function createTestRegistry(): StateContainerRegistry;
 export declare function withTestRegistry<T>(fn: (registry: StateContainerRegistry) => T): T;
 export declare function blacTestSetup(): void;
-export declare function registerOverride<T extends StateContainerConstructor>(BlocClass: T, instance: InstanceType<T>, instanceKey?: string): void;
-export declare function overrideEnsure<T extends StateContainerConstructor, R>(BlocClass: T, instance: InstanceType<T>, fn: () => R, instanceKey?: string): R;
+export declare function registerOverride<T extends StateContainerConstructor>(BlocClass: T, instance: InstanceType<T>, args?: ExtractArgs<T>): void;
+export declare function overrideEnsure<T extends StateContainerConstructor, R>(BlocClass: T, instance: InstanceType<T>, fn: () => R, args?: ExtractArgs<T>): R;
 type MethodKeys<T> = {
     [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
 }[keyof T];
@@ -23,8 +23,8 @@ export interface CubitStubOptions<T extends StateContainerConstructor> {
     deps?: Partial<ExtractDeps<T>>;
 }
 export declare function createCubitStub<T extends StateContainerConstructor>(BlocClass: T, options?: CubitStubOptions<T>): InstanceType<T>;
-export declare function withBlocState<T extends StateContainerConstructor>(BlocClass: T, state: ExtractState<T> extends Record<string, any> ? Partial<ExtractState<T>> : ExtractState<T>, instanceKey?: string): InstanceType<T>;
-export declare function withBlocMethod<T extends StateContainerConstructor>(BlocClass: T, methodName: keyof InstanceType<T>, impl: (...args: any[]) => any, instanceKey?: string): InstanceType<T>;
+export declare function withBlocState<T extends StateContainerConstructor>(BlocClass: T, state: ExtractState<T> extends Record<string, any> ? Partial<ExtractState<T>> : ExtractState<T>, args?: ExtractArgs<T>): InstanceType<T>;
+export declare function withBlocMethod<T extends StateContainerConstructor>(BlocClass: T, methodName: keyof InstanceType<T>, impl: (...args: any[]) => any, args?: ExtractArgs<T>): InstanceType<T>;
 /**
  * Drain pending microtasks so any channel-flushed effects (subscribe()
  * listeners, `onSystemEvent('stateChanged')` handlers, plugin hooks) run

package/dist/testing.js

@@ -1,7 +1,7 @@
-import { t as StateContainerRegistry } from "./StateContainerRegistry-DmmzYa7S.js";
-import { r as APPLY_DEPS, t as Cubit } from "./Cubit-VJuu2tt9.js";
-import { r as setRegistry, t as getRegistry } from "./config-DoHx0Xsl.js";
-import { t as ensure } from "./ensure-mkL-3qh8.js";
+import { t as StateContainerRegistry } from "./StateContainerRegistry-B_ViBLvJ.js";
+import { i as APPLY_DEPS, n as Cubit, t as ensure } from "./ensure-CPMiGvov.js";
+import { r as setRegistry, t as getRegistry } from "./config-8pyOC5gv.js";
+import { n as resolveInstanceKey } from "./acquire-Don7499S.js";
 //#region src/testing.ts
 /** Synthetic owner id used by test helpers for pre-wired deps. */
 const TESTING_DEPS_OWNER = "testing-deps";
@@ -38,14 +38,14 @@ function blacTestSetup() {
 		setRegistry(savedRegistry);
 	});
 }
-const DEFAULT_KEY = "default";
-function registerOverride(BlocClass, instance, instanceKey) {
-	const key = instanceKey ?? DEFAULT_KEY;
-	getRegistry().insertInstance(BlocClass, key, instance, new Map([["testing-override", 1]]));
+function registerOverride(BlocClass, instance, args) {
+	const registry = getRegistry();
+	const key = resolveInstanceKey(BlocClass, args);
+	registry.insertInstance(BlocClass, key, instance, new Map([["testing-override", 1]]));
 }
-function overrideEnsure(BlocClass, instance, fn, instanceKey = DEFAULT_KEY) {
+function overrideEnsure(BlocClass, instance, fn, args) {
 	return withTestRegistry(() => {
-		registerOverride(BlocClass, instance, instanceKey);
+		registerOverride(BlocClass, instance, args);
 		return fn();
 	});
 }
@@ -65,8 +65,8 @@ function createCubitStub(BlocClass, options) {
 	if (options?.deps != null) instance[APPLY_DEPS](TESTING_DEPS_OWNER, options.deps);
 	return instance;
 }
-function withBlocState(BlocClass, state, instanceKey) {
-	const instance = ensure(BlocClass, instanceKey);
+function withBlocState(BlocClass, state, args) {
+	const instance = ensure(BlocClass, { args });
 	if (instance instanceof Cubit) {
 		const currentState = instance.state;
 		if (typeof currentState === "object" && currentState !== null && typeof state === "object" && state !== null) instance.patch(state);
@@ -74,8 +74,8 @@ function withBlocState(BlocClass, state, instanceKey) {
 	}
 	return instance;
 }
-function withBlocMethod(BlocClass, methodName, impl, instanceKey) {
-	const instance = ensure(BlocClass, instanceKey);
+function withBlocMethod(BlocClass, methodName, impl, args) {
+	const instance = ensure(BlocClass, { args });
 	instance[methodName] = impl;
 	return instance;
 }

package/dist/testing.js.map

@@ -1 +1 @@
-{"version":3,"file":"testing.js","names":[],"sources":["../src/testing.ts"],"sourcesContent":["import { Cubit } from './core/Cubit';\nimport { StateContainerRegistry } from './core/StateContainerRegistry';\nimport { APPLY_DEPS } from './core/symbols';\nimport { ensure, getRegistry, setRegistry } from './registry';\nimport type {\n  ExtractArgs,\n  ExtractDeps,\n  ExtractState,\n  StateContainerConstructor,\n} from './types/utilities';\n\n/** Synthetic owner id used by test helpers for pre-wired deps. */\nconst TESTING_DEPS_OWNER = 'testing-deps';\n\ndeclare const beforeEach: (fn: () => void) => void;\ndeclare const afterEach: (fn: () => void) => void;\n\n// --- createTestRegistry + withTestRegistry ---\n\nexport function createTestRegistry(): StateContainerRegistry {\n  return new StateContainerRegistry();\n}\n\nexport function withTestRegistry<T>(\n  fn: (registry: StateContainerRegistry) => T,\n): T {\n  const previous = getRegistry();\n  const testRegistry = createTestRegistry();\n  setRegistry(testRegistry);\n  try {\n    const result = fn(testRegistry);\n    if (result instanceof Promise) {\n      return result.then(\n        (value) => {\n          setRegistry(previous);\n          return value;\n        },\n        (error) => {\n          setRegistry(previous);\n          throw error;\n        },\n      ) as T;\n    }\n    setRegistry(previous);\n    return result;\n  } catch (error) {\n    setRegistry(previous);\n    throw error;\n  }\n}\n\n// --- blacTestSetup ---\n\nexport function blacTestSetup(): void {\n  let savedRegistry: StateContainerRegistry;\n  beforeEach(() => {\n    savedRegistry = getRegistry();\n    setRegistry(new StateContainerRegistry());\n  });\n  afterEach(() => {\n    setRegistry(savedRegistry);\n  });\n}\n\n// --- registerOverride + overrideEnsure ---\n\nconst DEFAULT_KEY = 'default';\n\nexport function registerOverride<T extends StateContainerConstructor>(\n  BlocClass: T,\n  instance: InstanceType<T>,\n  instanceKey?: string,\n): void {\n  const key = instanceKey ?? DEFAULT_KEY;\n  const registry = getRegistry();\n  registry.insertInstance(\n    BlocClass,\n    key,\n    instance,\n    new Map([['testing-override', 1]]),\n  );\n}\n\nexport function overrideEnsure<T extends StateContainerConstructor, R>(\n  BlocClass: T,\n  instance: InstanceType<T>,\n  fn: () => R,\n  instanceKey: string = DEFAULT_KEY,\n): R {\n  return withTestRegistry(() => {\n    registerOverride(BlocClass, instance, instanceKey);\n    return fn();\n  });\n}\n\n// --- createCubitStub ---\n\ntype MethodKeys<T> = {\n  [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;\n}[keyof T];\n\nexport interface CubitStubOptions<T extends StateContainerConstructor> {\n  state?: ExtractState<T> extends Record<string, any>\n    ? Partial<ExtractState<T>>\n    : ExtractState<T>;\n  methods?: Partial<\n    Record<MethodKeys<InstanceType<T>>, (...args: any[]) => any>\n  >;\n  /**\n   * Args to pass to init(). If the bloc's Args type is not void, supplying\n   * args here causes initConfig({ args }) to be called so init() runs.\n   */\n  args?: ExtractArgs<T> extends void ? never : ExtractArgs<T>;\n  /**\n   * Deps slice to pre-wire via the core [APPLY_DEPS] path (synthetic owner\n   * \"testing-deps\"), so onDepsChanged fires during tests.\n   */\n  deps?: Partial<ExtractDeps<T>>;\n}\n\nexport function createCubitStub<T extends StateContainerConstructor>(\n  BlocClass: T,\n  options?: CubitStubOptions<T>,\n): InstanceType<T> {\n  const instance = new BlocClass() as InstanceType<T>;\n\n  // Run init() if args are supplied — goes through the same initConfig path\n  // that the registry uses, so lifecycle hooks fire correctly.\n  if (options?.args != null) {\n    instance.initConfig({ args: options.args });\n  }\n\n  if (options?.state != null) {\n    if (instance instanceof Cubit) {\n      const currentState = instance.state;\n      if (\n        typeof currentState === 'object' &&\n        currentState !== null &&\n        typeof options.state === 'object' &&\n        options.state !== null\n      ) {\n        instance.patch(options.state as any);\n      } else {\n        instance.emit(options.state as any);\n      }\n    }\n  }\n  if (options?.methods) {\n    for (const [key, impl] of Object.entries(options.methods)) {\n      if (typeof impl === 'function') {\n        (instance as any)[key] = impl;\n      }\n    }\n  }\n\n  // Pre-wire deps via the core merge path so onDepsChanged fires in tests.\n  if (options?.deps != null) {\n    (instance as any)[APPLY_DEPS](TESTING_DEPS_OWNER, options.deps);\n  }\n\n  return instance;\n}\n\n// --- withBlocState ---\n\nexport function withBlocState<T extends StateContainerConstructor>(\n  BlocClass: T,\n  state: ExtractState<T> extends Record<string, any>\n    ? Partial<ExtractState<T>>\n    : ExtractState<T>,\n  instanceKey?: string,\n): InstanceType<T> {\n  const instance = ensure(BlocClass, instanceKey);\n  if (instance instanceof Cubit) {\n    const currentState = instance.state;\n    if (\n      typeof currentState === 'object' &&\n      currentState !== null &&\n      typeof state === 'object' &&\n      state !== null\n    ) {\n      instance.patch(state as any);\n    } else {\n      instance.emit(state as any);\n    }\n  }\n  return instance;\n}\n\n// --- withBlocMethod ---\n\nexport function withBlocMethod<T extends StateContainerConstructor>(\n  BlocClass: T,\n  methodName: keyof InstanceType<T>,\n  impl: (...args: any[]) => any,\n  instanceKey?: string,\n): InstanceType<T> {\n  const instance = ensure(BlocClass, instanceKey);\n  (instance as any)[methodName] = impl;\n  return instance;\n}\n\n// --- flushBlocUpdates ---\n\n/**\n * Drain pending microtasks so any channel-flushed effects (subscribe()\n * listeners, `onSystemEvent('stateChanged')` handlers, plugin hooks) run\n * before the next assertion.\n *\n * The default `MicrotaskScheduler` coalesces emits within a tick; tests\n * that emit and then assert on listener side-effects need `await flush()`\n * (or its alias `flushBlocUpdates()`) between the two.\n */\nexport async function flush(): Promise<void> {\n  // queueMicrotask wins the race against the channel's own queued flush —\n  // we resolve after the channel has drained its current pending flush.\n  await Promise.resolve();\n  await Promise.resolve();\n}\n\n/** @deprecated Alias for `flush()`. */\nexport async function flushBlocUpdates(): Promise<void> {\n  await flush();\n}\n"],"mappings":";;;;;;AAYA,MAAM,qBAAqB;AAO3B,SAAgB,qBAA6C;CAC3D,OAAO,IAAI,wBAAwB;;AAGrC,SAAgB,iBACd,IACG;CACH,MAAM,WAAW,aAAa;CAC9B,MAAM,eAAe,oBAAoB;CACzC,YAAY,aAAa;CACzB,IAAI;EACF,MAAM,SAAS,GAAG,aAAa;EAC/B,IAAI,kBAAkB,SACpB,OAAO,OAAO,MACX,UAAU;GACT,YAAY,SAAS;GACrB,OAAO;MAER,UAAU;GACT,YAAY,SAAS;GACrB,MAAM;IAET;EAEH,YAAY,SAAS;EACrB,OAAO;UACA,OAAO;EACd,YAAY,SAAS;EACrB,MAAM;;;AAMV,SAAgB,gBAAsB;CACpC,IAAI;CACJ,iBAAiB;EACf,gBAAgB,aAAa;EAC7B,YAAY,IAAI,wBAAwB,CAAC;GACzC;CACF,gBAAgB;EACd,YAAY,cAAc;GAC1B;;AAKJ,MAAM,cAAc;AAEpB,SAAgB,iBACd,WACA,UACA,aACM;CACN,MAAM,MAAM,eAAe;CAE3B,aAAQ,CAAC,eACP,WACA,KACA,UACA,IAAI,IAAI,CAAC,CAAC,oBAAoB,EAAE,CAAC,CAAC,CACnC;;AAGH,SAAgB,eACd,WACA,UACA,IACA,cAAsB,aACnB;CACH,OAAO,uBAAuB;EAC5B,iBAAiB,WAAW,UAAU,YAAY;EAClD,OAAO,IAAI;GACX;;AA4BJ,SAAgB,gBACd,WACA,SACiB;CACjB,MAAM,WAAW,IAAI,WAAW;CAIhC,IAAI,SAAS,QAAQ,MACnB,SAAS,WAAW,EAAE,MAAM,QAAQ,MAAM,CAAC;CAG7C,IAAI,SAAS,SAAS;MAChB,oBAAoB,OAAO;GAC7B,MAAM,eAAe,SAAS;GAC9B,IACE,OAAO,iBAAiB,YACxB,iBAAiB,QACjB,OAAO,QAAQ,UAAU,YACzB,QAAQ,UAAU,MAElB,SAAS,MAAM,QAAQ,MAAa;QAEpC,SAAS,KAAK,QAAQ,MAAa;;;CAIzC,IAAI,SAAS;OACN,MAAM,CAAC,KAAK,SAAS,OAAO,QAAQ,QAAQ,QAAQ,EACvD,IAAI,OAAO,SAAS,YAClB,SAAkB,OAAO;;CAM/B,IAAI,SAAS,QAAQ,MACnB,SAAkB,YAAY,oBAAoB,QAAQ,KAAK;CAGjE,OAAO;;AAKT,SAAgB,cACd,WACA,OAGA,aACiB;CACjB,MAAM,WAAW,OAAO,WAAW,YAAY;CAC/C,IAAI,oBAAoB,OAAO;EAC7B,MAAM,eAAe,SAAS;EAC9B,IACE,OAAO,iBAAiB,YACxB,iBAAiB,QACjB,OAAO,UAAU,YACjB,UAAU,MAEV,SAAS,MAAM,MAAa;OAE5B,SAAS,KAAK,MAAa;;CAG/B,OAAO;;AAKT,SAAgB,eACd,WACA,YACA,MACA,aACiB;CACjB,MAAM,WAAW,OAAO,WAAW,YAAY;CAC/C,SAAkB,cAAc;CAChC,OAAO;;;;;;;;;;;AAcT,eAAsB,QAAuB;CAG3C,MAAM,QAAQ,SAAS;CACvB,MAAM,QAAQ,SAAS;;;AAIzB,eAAsB,mBAAkC;CACtD,MAAM,OAAO"}
+{"version":3,"file":"testing.js","names":[],"sources":["../src/testing.ts"],"sourcesContent":["import { Cubit } from './core/Cubit';\nimport { StateContainerRegistry } from './core/StateContainerRegistry';\nimport { APPLY_DEPS } from './core/symbols';\nimport { ensure, getRegistry, setRegistry } from './registry';\nimport { resolveInstanceKey } from './registry/acquire';\nimport type {\n  ExtractArgs,\n  ExtractDeps,\n  ExtractState,\n  StateContainerConstructor,\n} from './types/utilities';\n\n/** Synthetic owner id used by test helpers for pre-wired deps. */\nconst TESTING_DEPS_OWNER = 'testing-deps';\n\ndeclare const beforeEach: (fn: () => void) => void;\ndeclare const afterEach: (fn: () => void) => void;\n\n// --- createTestRegistry + withTestRegistry ---\n\nexport function createTestRegistry(): StateContainerRegistry {\n  return new StateContainerRegistry();\n}\n\nexport function withTestRegistry<T>(\n  fn: (registry: StateContainerRegistry) => T,\n): T {\n  const previous = getRegistry();\n  const testRegistry = createTestRegistry();\n  setRegistry(testRegistry);\n  try {\n    const result = fn(testRegistry);\n    if (result instanceof Promise) {\n      return result.then(\n        (value) => {\n          setRegistry(previous);\n          return value;\n        },\n        (error) => {\n          setRegistry(previous);\n          throw error;\n        },\n      ) as T;\n    }\n    setRegistry(previous);\n    return result;\n  } catch (error) {\n    setRegistry(previous);\n    throw error;\n  }\n}\n\n// --- blacTestSetup ---\n\nexport function blacTestSetup(): void {\n  let savedRegistry: StateContainerRegistry;\n  beforeEach(() => {\n    savedRegistry = getRegistry();\n    setRegistry(new StateContainerRegistry());\n  });\n  afterEach(() => {\n    setRegistry(savedRegistry);\n  });\n}\n\n// --- registerOverride + overrideEnsure ---\n\nexport function registerOverride<T extends StateContainerConstructor>(\n  BlocClass: T,\n  instance: InstanceType<T>,\n  args?: ExtractArgs<T>,\n): void {\n  const registry = getRegistry();\n  const key = resolveInstanceKey(BlocClass, args);\n  registry.insertInstance(\n    BlocClass,\n    key,\n    instance,\n    new Map([['testing-override', 1]]),\n  );\n}\n\nexport function overrideEnsure<T extends StateContainerConstructor, R>(\n  BlocClass: T,\n  instance: InstanceType<T>,\n  fn: () => R,\n  args?: ExtractArgs<T>,\n): R {\n  return withTestRegistry(() => {\n    registerOverride(BlocClass, instance, args);\n    return fn();\n  });\n}\n\n// --- createCubitStub ---\n\ntype MethodKeys<T> = {\n  [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;\n}[keyof T];\n\nexport interface CubitStubOptions<T extends StateContainerConstructor> {\n  state?: ExtractState<T> extends Record<string, any>\n    ? Partial<ExtractState<T>>\n    : ExtractState<T>;\n  methods?: Partial<\n    Record<MethodKeys<InstanceType<T>>, (...args: any[]) => any>\n  >;\n  /**\n   * Args to pass to init(). If the bloc's Args type is not void, supplying\n   * args here causes initConfig({ args }) to be called so init() runs.\n   */\n  args?: ExtractArgs<T> extends void ? never : ExtractArgs<T>;\n  /**\n   * Deps slice to pre-wire via the core [APPLY_DEPS] path (synthetic owner\n   * \"testing-deps\"), so onDepsChanged fires during tests.\n   */\n  deps?: Partial<ExtractDeps<T>>;\n}\n\nexport function createCubitStub<T extends StateContainerConstructor>(\n  BlocClass: T,\n  options?: CubitStubOptions<T>,\n): InstanceType<T> {\n  const instance = new BlocClass() as InstanceType<T>;\n\n  // Run init() if args are supplied — goes through the same initConfig path\n  // that the registry uses, so lifecycle hooks fire correctly.\n  if (options?.args != null) {\n    instance.initConfig({ args: options.args });\n  }\n\n  if (options?.state != null) {\n    if (instance instanceof Cubit) {\n      const currentState = instance.state;\n      if (\n        typeof currentState === 'object' &&\n        currentState !== null &&\n        typeof options.state === 'object' &&\n        options.state !== null\n      ) {\n        instance.patch(options.state as any);\n      } else {\n        instance.emit(options.state as any);\n      }\n    }\n  }\n  if (options?.methods) {\n    for (const [key, impl] of Object.entries(options.methods)) {\n      if (typeof impl === 'function') {\n        (instance as any)[key] = impl;\n      }\n    }\n  }\n\n  // Pre-wire deps via the core merge path so onDepsChanged fires in tests.\n  if (options?.deps != null) {\n    (instance as any)[APPLY_DEPS](TESTING_DEPS_OWNER, options.deps);\n  }\n\n  return instance;\n}\n\n// --- withBlocState ---\n\nexport function withBlocState<T extends StateContainerConstructor>(\n  BlocClass: T,\n  state: ExtractState<T> extends Record<string, any>\n    ? Partial<ExtractState<T>>\n    : ExtractState<T>,\n  args?: ExtractArgs<T>,\n): InstanceType<T> {\n  const instance = ensure(BlocClass, { args });\n  if (instance instanceof Cubit) {\n    const currentState = instance.state;\n    if (\n      typeof currentState === 'object' &&\n      currentState !== null &&\n      typeof state === 'object' &&\n      state !== null\n    ) {\n      instance.patch(state as any);\n    } else {\n      instance.emit(state as any);\n    }\n  }\n  return instance;\n}\n\n// --- withBlocMethod ---\n\nexport function withBlocMethod<T extends StateContainerConstructor>(\n  BlocClass: T,\n  methodName: keyof InstanceType<T>,\n  impl: (...args: any[]) => any,\n  args?: ExtractArgs<T>,\n): InstanceType<T> {\n  const instance = ensure(BlocClass, { args });\n  (instance as any)[methodName] = impl;\n  return instance;\n}\n\n// --- flushBlocUpdates ---\n\n/**\n * Drain pending microtasks so any channel-flushed effects (subscribe()\n * listeners, `onSystemEvent('stateChanged')` handlers, plugin hooks) run\n * before the next assertion.\n *\n * The default `MicrotaskScheduler` coalesces emits within a tick; tests\n * that emit and then assert on listener side-effects need `await flush()`\n * (or its alias `flushBlocUpdates()`) between the two.\n */\nexport async function flush(): Promise<void> {\n  // queueMicrotask wins the race against the channel's own queued flush —\n  // we resolve after the channel has drained its current pending flush.\n  await Promise.resolve();\n  await Promise.resolve();\n}\n\n/** @deprecated Alias for `flush()`. */\nexport async function flushBlocUpdates(): Promise<void> {\n  await flush();\n}\n"],"mappings":";;;;;;AAaA,MAAM,qBAAqB;AAO3B,SAAgB,qBAA6C;CAC3D,OAAO,IAAI,uBAAuB;AACpC;AAEA,SAAgB,iBACd,IACG;CACH,MAAM,WAAW,YAAY;CAC7B,MAAM,eAAe,mBAAmB;CACxC,YAAY,YAAY;CACxB,IAAI;EACF,MAAM,SAAS,GAAG,YAAY;EAC9B,IAAI,kBAAkB,SACpB,OAAO,OAAO,MACX,UAAU;GACT,YAAY,QAAQ;GACpB,OAAO;EACT,IACC,UAAU;GACT,YAAY,QAAQ;GACpB,MAAM;EACR,CACF;EAEF,YAAY,QAAQ;EACpB,OAAO;CACT,SAAS,OAAO;EACd,YAAY,QAAQ;EACpB,MAAM;CACR;AACF;AAIA,SAAgB,gBAAsB;CACpC,IAAI;CACJ,iBAAiB;EACf,gBAAgB,YAAY;EAC5B,YAAY,IAAI,uBAAuB,CAAC;CAC1C,CAAC;CACD,gBAAgB;EACd,YAAY,aAAa;CAC3B,CAAC;AACH;AAIA,SAAgB,iBACd,WACA,UACA,MACM;CACN,MAAM,WAAW,YAAY;CAC7B,MAAM,MAAM,mBAAmB,WAAW,IAAI;CAC9C,SAAS,eACP,WACA,KACA,UACA,IAAI,IAAI,CAAC,CAAC,oBAAoB,CAAC,CAAC,CAAC,CACnC;AACF;AAEA,SAAgB,eACd,WACA,UACA,IACA,MACG;CACH,OAAO,uBAAuB;EAC5B,iBAAiB,WAAW,UAAU,IAAI;EAC1C,OAAO,GAAG;CACZ,CAAC;AACH;AA2BA,SAAgB,gBACd,WACA,SACiB;CACjB,MAAM,WAAW,IAAI,UAAU;CAI/B,IAAI,SAAS,QAAQ,MACnB,SAAS,WAAW,EAAE,MAAM,QAAQ,KAAK,CAAC;CAG5C,IAAI,SAAS,SAAS;MAChB,oBAAoB,OAAO;GAC7B,MAAM,eAAe,SAAS;GAC9B,IACE,OAAO,iBAAiB,YACxB,iBAAiB,QACjB,OAAO,QAAQ,UAAU,YACzB,QAAQ,UAAU,MAElB,SAAS,MAAM,QAAQ,KAAY;QAEnC,SAAS,KAAK,QAAQ,KAAY;EAEtC;;CAEF,IAAI,SAAS;OACN,MAAM,CAAC,KAAK,SAAS,OAAO,QAAQ,QAAQ,OAAO,GACtD,IAAI,OAAO,SAAS,YAClB,SAAkB,OAAO;CAAA;CAM/B,IAAI,SAAS,QAAQ,MACnB,SAAkB,YAAY,oBAAoB,QAAQ,IAAI;CAGhE,OAAO;AACT;AAIA,SAAgB,cACd,WACA,OAGA,MACiB;CACjB,MAAM,WAAW,OAAO,WAAW,EAAE,KAAK,CAAC;CAC3C,IAAI,oBAAoB,OAAO;EAC7B,MAAM,eAAe,SAAS;EAC9B,IACE,OAAO,iBAAiB,YACxB,iBAAiB,QACjB,OAAO,UAAU,YACjB,UAAU,MAEV,SAAS,MAAM,KAAY;OAE3B,SAAS,KAAK,KAAY;CAE9B;CACA,OAAO;AACT;AAIA,SAAgB,eACd,WACA,YACA,MACA,MACiB;CACjB,MAAM,WAAW,OAAO,WAAW,EAAE,KAAK,CAAC;CAC3C,SAAkB,cAAc;CAChC,OAAO;AACT;;;;;;;;;;AAaA,eAAsB,QAAuB;CAG3C,MAAM,QAAQ,QAAQ;CACtB,MAAM,QAAQ,QAAQ;AACxB;;AAGA,eAAsB,mBAAkC;CACtD,MAAM,MAAM;AACd"}

package/dist/types/utilities.d.ts

@@ -42,21 +42,10 @@ export type ExtractConstructorArgs<T> = T extends new (...args: infer P) => any
  */
 export type BlocInstanceType<T extends abstract new (...args: any) => any> = T extends abstract new (...args: any) => infer R ? R : any;
 /**
- * Constructor type for StateContainer classes with static registry methods.
+ * Constructor type for StateContainer classes.
  * Used for type-safe hook parameters.
  * @template TBloc - The StateContainer instance type
  */
 export type BlocConstructor<S extends object = any, T extends new (...args: any[]) => StateContainer<S, any, any> = new (...args: any[]) => StateContainer<S, any, any>> = (new (...args: any[]) => InstanceType<T>) & {
-    acquire(instanceKey?: string, ...args: any[]): InstanceType<T>;
-    borrow(instanceKey?: string, ...args: any[]): InstanceType<T> | null;
-    borrowSafe(instanceKey?: string, ...args: any[]): {
-        error: Error;
-        instance: null;
-    } | {
-        error: null;
-        instance: InstanceType<T>;
-    };
-    ensure(instanceKey?: string): InstanceType<T>;
-    release(instanceKey?: string): void;
     keepAlive?: boolean;
 };

package/dist/types.cjs

@@ -1,3 +1,3 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_branded = require("./branded-BSeA_mZO.cjs");
+const require_branded = require("./branded-BybA0_xw.cjs");
 exports.instanceId = require_branded.instanceId;

package/dist/types.js

@@ -1,2 +1,2 @@
-import { t as instanceId } from "./branded-DwtzSsg0.js";
+import { t as instanceId } from "./branded-DkbUzncc.js";
 export { instanceId };

package/dist/utils/static-props.d.ts

@@ -27,15 +27,6 @@ export declare function isKeepAliveClass<T extends StateContainerConstructor>(Ty
  * @returns true if the class has `static __excludeFromDevTools = true`
  */
 export declare function isExcludedFromDevTools<T extends StateContainerConstructor>(Type: T): boolean;
-/**
- * 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`
- */
-export declare function isIsolatedClass<T extends StateContainerConstructor>(Type: T): boolean;
 /**
  * Get the per-class equality function set via `@blac({ equality })`, if any.
  * @param Type - The class constructor to check

package/dist/watch/watch.d.ts

@@ -1,26 +1,29 @@
-import type { StateContainerConstructor } from '../types/utilities';
+import type { ExtractArgs, StateContainerConstructor } from '../types/utilities';
 declare const STOP: unique symbol;
 type StopSymbol = typeof STOP;
 declare const BLOC_REF_MARKER: unique symbol;
 /**
- * Reference to a specific bloc instance by class and instance ID.
+ * Reference to a specific bloc instance, identified by class + the resolved
+ * key derived from its `args`.
  */
 export interface BlocRef<T extends StateContainerConstructor> {
     [BLOC_REF_MARKER]: true;
     blocClass: T;
+    /** @internal The resolved instance key (derived from `args`). */
     instanceId: string;
 }
 /**
- * Create a reference to a specific bloc instance.
+ * Create a reference to a specific bloc instance, identified by its `args`.
+ * The key is derived the same way `useBloc`/`acquire` derive it.
  *
  * @example
  * ```ts
- * watch(instance(UserBloc, 'user-123'), (userBloc) => {
+ * watch(instance(UserBloc, { userId: 'user-123' }), (userBloc) => {
  *   console.log(userBloc.state.name);
  * });
  * ```
  */
-export declare function instance<T extends StateContainerConstructor>(BlocClass: T, instanceId: string): BlocRef<T>;
+export declare function instance<T extends StateContainerConstructor>(BlocClass: T, args?: ExtractArgs<T>): BlocRef<T>;
 type BlocInput = StateContainerConstructor | BlocRef<StateContainerConstructor>;
 type ExtractInstance<T> = T extends BlocRef<infer C> ? InstanceType<C> : T extends StateContainerConstructor ? InstanceType<T> : never;
 type ExtractInstances<T extends readonly BlocInput[]> = {

package/dist/{watch-DWCqXllW.js → watch-BmC-Tyqg.js}

@@ -1,32 +1,34 @@
-import { l as BLAC_DEFAULTS } from "./StateContainerRegistry-DmmzYa7S.js";
-import { t as ensure } from "./ensure-mkL-3qh8.js";
+import { t as getRegistry } from "./config-8pyOC5gv.js";
+import { n as resolveInstanceKey } from "./acquire-Don7499S.js";
 import { ALL_PATHS } from "@dirtytalk/structural";
 //#region src/watch/watch.ts
 const STOP = Symbol("watch.STOP");
 const BLOC_REF_MARKER = Symbol("BlocRef");
 /**
-* Create a reference to a specific bloc instance.
+* Create a reference to a specific bloc instance, identified by its `args`.
+* The key is derived the same way `useBloc`/`acquire` derive it.
 *
 * @example
 * ```ts
-* watch(instance(UserBloc, 'user-123'), (userBloc) => {
+* watch(instance(UserBloc, { userId: 'user-123' }), (userBloc) => {
 *   console.log(userBloc.state.name);
 * });
 * ```
 */
-function instance(BlocClass, instanceId) {
+function instance(BlocClass, args) {
 	return {
 		[BLOC_REF_MARKER]: true,
 		blocClass: BlocClass,
-		instanceId
+		instanceId: resolveInstanceKey(BlocClass, args)
 	};
 }
 function isBlocRef(input) {
 	return typeof input === "object" && input !== null && BLOC_REF_MARKER in input;
 }
 function resolveBloc(input) {
-	if (isBlocRef(input)) return ensure(input.blocClass, input.instanceId);
-	return ensure(input, BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY);
+	const registry = getRegistry();
+	if (isBlocRef(input)) return registry.ensure(input.blocClass, input.instanceId);
+	return registry.ensure(input, registry.resolveKey(input, void 0, void 0));
 }
 function isArray(input) {
 	return Array.isArray(input);
@@ -54,4 +56,4 @@ const watch = Object.assign(watchImpl, { STOP });
 //#endregion
 export { watch as n, instance as t };
 
-//# sourceMappingURL=watch-DWCqXllW.js.map
+//# sourceMappingURL=watch-BmC-Tyqg.js.map

package/dist/watch-BmC-Tyqg.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"watch-BmC-Tyqg.js","names":[],"sources":["../src/watch/watch.ts"],"sourcesContent":["import { ALL_PATHS } from '@dirtytalk/structural';\nimport { getRegistry } from '../registry';\nimport { resolveInstanceKey } from '../registry/acquire';\nimport type {\n  ExtractArgs,\n  StateContainerConstructor,\n  StateContainerInstance,\n} from '../types/utilities';\n\nconst STOP: unique symbol = Symbol('watch.STOP');\ntype StopSymbol = typeof STOP;\n\nconst BLOC_REF_MARKER = Symbol('BlocRef');\n\n/**\n * Reference to a specific bloc instance, identified by class + the resolved\n * key derived from its `args`.\n */\nexport interface BlocRef<T extends StateContainerConstructor> {\n  [BLOC_REF_MARKER]: true;\n  blocClass: T;\n  /** @internal The resolved instance key (derived from `args`). */\n  instanceId: string;\n}\n\n/**\n * Create a reference to a specific bloc instance, identified by its `args`.\n * The key is derived the same way `useBloc`/`acquire` derive it.\n *\n * @example\n * ```ts\n * watch(instance(UserBloc, { userId: 'user-123' }), (userBloc) => {\n *   console.log(userBloc.state.name);\n * });\n * ```\n */\nexport function instance<T extends StateContainerConstructor>(\n  BlocClass: T,\n  args?: ExtractArgs<T>,\n): BlocRef<T> {\n  return {\n    [BLOC_REF_MARKER]: true,\n    blocClass: BlocClass,\n    instanceId: resolveInstanceKey(BlocClass, args),\n  };\n}\n\nfunction isBlocRef(\n  input: unknown,\n): input is BlocRef<StateContainerConstructor> {\n  return (\n    typeof input === 'object' && input !== null && BLOC_REF_MARKER in input\n  );\n}\n\ntype BlocInput = StateContainerConstructor | BlocRef<StateContainerConstructor>;\n\ntype ExtractInstance<T> =\n  T extends BlocRef<infer C>\n    ? InstanceType<C>\n    : T extends StateContainerConstructor\n      ? InstanceType<T>\n      : never;\n\ntype ExtractInstances<T extends readonly BlocInput[]> = {\n  [K in keyof T]: ExtractInstance<T[K]>;\n};\n\n/**\n * Watch function signature for single bloc.\n */\nexport interface WatchSingleFn {\n  <T extends StateContainerConstructor>(\n    bloc: T | BlocRef<T>,\n    callback: (bloc: InstanceType<T>) => void | StopSymbol,\n  ): () => void;\n\n  STOP: StopSymbol;\n}\n\n/**\n * Watch function signature for multiple blocs.\n */\nexport interface WatchMultipleFn {\n  <T extends readonly BlocInput[]>(\n    blocs: T,\n    callback: (blocs: ExtractInstances<T>) => void | StopSymbol,\n  ): () => void;\n\n  STOP: StopSymbol;\n}\n\n/**\n * Combined watch function type.\n */\nexport interface WatchFn extends WatchSingleFn {\n  <T extends readonly BlocInput[]>(\n    blocs: T,\n    callback: (blocs: ExtractInstances<T>) => void | StopSymbol,\n  ): () => void;\n}\n\nfunction resolveBloc(input: BlocInput): StateContainerInstance {\n  const registry = getRegistry();\n  if (isBlocRef(input)) {\n    return registry.ensure(input.blocClass, input.instanceId);\n  }\n  return registry.ensure(\n    input,\n    registry.resolveKey(input, undefined, undefined),\n  );\n}\n\nfunction isArray(input: unknown): input is readonly BlocInput[] {\n  return Array.isArray(input);\n}\n\n/**\n * Watch one or more blocs for state changes.\n *\n * Thin wrapper around `container.channel.subscribe(ALL_PATHS, ...)`. The\n * callback fires once immediately, then on every state change of any of the\n * passed blocs. Returning `watch.STOP` from the callback tears down all\n * subscriptions.\n *\n * Note: subscriptions are microtask-deferred (per the DirtyChannel default\n * scheduler), so callbacks land asynchronously after `emit()`.\n *\n * @example Single bloc\n * ```ts\n * const unwatch = watch(UserBloc, (userBloc) => {\n *   console.log(userBloc.state.name);\n * });\n * ```\n *\n * @example Multiple blocs\n * ```ts\n * const unwatch = watch(\n *   [UserBloc, SettingsBloc] as const,\n *   ([userBloc, settingsBloc]) => {\n *     console.log(userBloc.state.name, settingsBloc.state.theme);\n *   }\n * );\n * ```\n *\n * @example With specific instance\n * ```ts\n * const unwatch = watch(\n *   instance(UserBloc, { userId: 'user-123' }),\n *   (userBloc) => {\n *     console.log(userBloc.state.name);\n *   }\n * );\n * ```\n *\n * @example Stop watching from callback\n * ```ts\n * const unwatch = watch(UserBloc, (userBloc) => {\n *   if (userBloc.state.done) {\n *     return watch.STOP;\n *   }\n * });\n * ```\n */\nfunction watchImpl<T extends StateContainerConstructor>(\n  bloc: T | BlocRef<T>,\n  callback: (bloc: InstanceType<T>) => void | StopSymbol,\n): () => void;\n\nfunction watchImpl<T extends readonly BlocInput[]>(\n  blocs: T,\n  callback: (blocs: ExtractInstances<T>) => void | StopSymbol,\n): () => void;\n\nfunction watchImpl(\n  blocsOrBloc: BlocInput | readonly BlocInput[],\n  callback: (blocsOrBloc: any) => void | StopSymbol,\n): () => void {\n  const isSingle = !isArray(blocsOrBloc);\n  const inputs = isSingle ? [blocsOrBloc] : blocsOrBloc;\n\n  const instances = inputs.map(resolveBloc);\n\n  let disposed = false;\n  const subscriptions: (() => void)[] = [];\n\n  const cleanup = () => {\n    if (disposed) return;\n    disposed = true;\n    for (const unsub of subscriptions) unsub();\n    subscriptions.length = 0;\n  };\n\n  const runCallback = () => {\n    if (disposed) return;\n    const arg = isSingle ? instances[0] : instances;\n    const result = callback(arg);\n    if (result === STOP) cleanup();\n  };\n\n  for (const inst of instances) {\n    subscriptions.push(inst.channel.subscribe(() => ALL_PATHS, runCallback));\n  }\n\n  // Fire once immediately so the consumer sees the current state.\n  runCallback();\n\n  return cleanup;\n}\n\nexport const watch: WatchFn = Object.assign(watchImpl, { STOP }) as WatchFn;\n"],"mappings":";;;;AASA,MAAM,OAAsB,OAAO,YAAY;AAG/C,MAAM,kBAAkB,OAAO,SAAS;;;;;;;;;;;;AAwBxC,SAAgB,SACd,WACA,MACY;CACZ,OAAO;GACJ,kBAAkB;EACnB,WAAW;EACX,YAAY,mBAAmB,WAAW,IAAI;CAChD;AACF;AAEA,SAAS,UACP,OAC6C;CAC7C,OACE,OAAO,UAAU,YAAY,UAAU,QAAQ,mBAAmB;AAEtE;AAiDA,SAAS,YAAY,OAA0C;CAC7D,MAAM,WAAW,YAAY;CAC7B,IAAI,UAAU,KAAK,GACjB,OAAO,SAAS,OAAO,MAAM,WAAW,MAAM,UAAU;CAE1D,OAAO,SAAS,OACd,OACA,SAAS,WAAW,OAAO,KAAA,GAAW,KAAA,CAAS,CACjD;AACF;AAEA,SAAS,QAAQ,OAA+C;CAC9D,OAAO,MAAM,QAAQ,KAAK;AAC5B;AA2DA,SAAS,UACP,aACA,UACY;CACZ,MAAM,WAAW,CAAC,QAAQ,WAAW;CAGrC,MAAM,aAFS,WAAW,CAAC,WAAW,IAAI,aAEjB,IAAI,WAAW;CAExC,IAAI,WAAW;CACf,MAAM,gBAAgC,CAAC;CAEvC,MAAM,gBAAgB;EACpB,IAAI,UAAU;EACd,WAAW;EACX,KAAK,MAAM,SAAS,eAAe,MAAM;EACzC,cAAc,SAAS;CACzB;CAEA,MAAM,oBAAoB;EACxB,IAAI,UAAU;EAGd,IADe,SADH,WAAW,UAAU,KAAK,SAE7B,MAAM,MAAM,QAAQ;CAC/B;CAEA,KAAK,MAAM,QAAQ,WACjB,cAAc,KAAK,KAAK,QAAQ,gBAAgB,WAAW,WAAW,CAAC;CAIzE,YAAY;CAEZ,OAAO;AACT;AAEA,MAAa,QAAiB,OAAO,OAAO,WAAW,EAAE,KAAK,CAAC"}

package/dist/{watch-BpwaUL8r.cjs → watch-CKWt788i.cjs}

@@ -1,32 +1,34 @@
-const require_StateContainerRegistry = require("./StateContainerRegistry-B4yVMYbx.cjs");
-const require_ensure = require("./ensure-BB6xHQAF.cjs");
+const require_config = require("./config-DVMnlHLv.cjs");
+const require_acquire = require("./acquire-DHEOEVcj.cjs");
 let _dirtytalk_structural = require("@dirtytalk/structural");
 //#region src/watch/watch.ts
 const STOP = Symbol("watch.STOP");
 const BLOC_REF_MARKER = Symbol("BlocRef");
 /**
-* Create a reference to a specific bloc instance.
+* Create a reference to a specific bloc instance, identified by its `args`.
+* The key is derived the same way `useBloc`/`acquire` derive it.
 *
 * @example
 * ```ts
-* watch(instance(UserBloc, 'user-123'), (userBloc) => {
+* watch(instance(UserBloc, { userId: 'user-123' }), (userBloc) => {
 *   console.log(userBloc.state.name);
 * });
 * ```
 */
-function instance(BlocClass, instanceId) {
+function instance(BlocClass, args) {
 	return {
 		[BLOC_REF_MARKER]: true,
 		blocClass: BlocClass,
-		instanceId
+		instanceId: require_acquire.resolveInstanceKey(BlocClass, args)
 	};
 }
 function isBlocRef(input) {
 	return typeof input === "object" && input !== null && BLOC_REF_MARKER in input;
 }
 function resolveBloc(input) {
-	if (isBlocRef(input)) return require_ensure.ensure(input.blocClass, input.instanceId);
-	return require_ensure.ensure(input, require_StateContainerRegistry.BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY);
+	const registry = require_config.getRegistry();
+	if (isBlocRef(input)) return registry.ensure(input.blocClass, input.instanceId);
+	return registry.ensure(input, registry.resolveKey(input, void 0, void 0));
 }
 function isArray(input) {
 	return Array.isArray(input);
@@ -65,4 +67,4 @@ Object.defineProperty(exports, "watch", {
 	}
 });
 
-//# sourceMappingURL=watch-BpwaUL8r.cjs.map
+//# sourceMappingURL=watch-CKWt788i.cjs.map

package/dist/watch-CKWt788i.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"watch-CKWt788i.cjs","names":["resolveInstanceKey","getRegistry","ALL_PATHS"],"sources":["../src/watch/watch.ts"],"sourcesContent":["import { ALL_PATHS } from '@dirtytalk/structural';\nimport { getRegistry } from '../registry';\nimport { resolveInstanceKey } from '../registry/acquire';\nimport type {\n  ExtractArgs,\n  StateContainerConstructor,\n  StateContainerInstance,\n} from '../types/utilities';\n\nconst STOP: unique symbol = Symbol('watch.STOP');\ntype StopSymbol = typeof STOP;\n\nconst BLOC_REF_MARKER = Symbol('BlocRef');\n\n/**\n * Reference to a specific bloc instance, identified by class + the resolved\n * key derived from its `args`.\n */\nexport interface BlocRef<T extends StateContainerConstructor> {\n  [BLOC_REF_MARKER]: true;\n  blocClass: T;\n  /** @internal The resolved instance key (derived from `args`). */\n  instanceId: string;\n}\n\n/**\n * Create a reference to a specific bloc instance, identified by its `args`.\n * The key is derived the same way `useBloc`/`acquire` derive it.\n *\n * @example\n * ```ts\n * watch(instance(UserBloc, { userId: 'user-123' }), (userBloc) => {\n *   console.log(userBloc.state.name);\n * });\n * ```\n */\nexport function instance<T extends StateContainerConstructor>(\n  BlocClass: T,\n  args?: ExtractArgs<T>,\n): BlocRef<T> {\n  return {\n    [BLOC_REF_MARKER]: true,\n    blocClass: BlocClass,\n    instanceId: resolveInstanceKey(BlocClass, args),\n  };\n}\n\nfunction isBlocRef(\n  input: unknown,\n): input is BlocRef<StateContainerConstructor> {\n  return (\n    typeof input === 'object' && input !== null && BLOC_REF_MARKER in input\n  );\n}\n\ntype BlocInput = StateContainerConstructor | BlocRef<StateContainerConstructor>;\n\ntype ExtractInstance<T> =\n  T extends BlocRef<infer C>\n    ? InstanceType<C>\n    : T extends StateContainerConstructor\n      ? InstanceType<T>\n      : never;\n\ntype ExtractInstances<T extends readonly BlocInput[]> = {\n  [K in keyof T]: ExtractInstance<T[K]>;\n};\n\n/**\n * Watch function signature for single bloc.\n */\nexport interface WatchSingleFn {\n  <T extends StateContainerConstructor>(\n    bloc: T | BlocRef<T>,\n    callback: (bloc: InstanceType<T>) => void | StopSymbol,\n  ): () => void;\n\n  STOP: StopSymbol;\n}\n\n/**\n * Watch function signature for multiple blocs.\n */\nexport interface WatchMultipleFn {\n  <T extends readonly BlocInput[]>(\n    blocs: T,\n    callback: (blocs: ExtractInstances<T>) => void | StopSymbol,\n  ): () => void;\n\n  STOP: StopSymbol;\n}\n\n/**\n * Combined watch function type.\n */\nexport interface WatchFn extends WatchSingleFn {\n  <T extends readonly BlocInput[]>(\n    blocs: T,\n    callback: (blocs: ExtractInstances<T>) => void | StopSymbol,\n  ): () => void;\n}\n\nfunction resolveBloc(input: BlocInput): StateContainerInstance {\n  const registry = getRegistry();\n  if (isBlocRef(input)) {\n    return registry.ensure(input.blocClass, input.instanceId);\n  }\n  return registry.ensure(\n    input,\n    registry.resolveKey(input, undefined, undefined),\n  );\n}\n\nfunction isArray(input: unknown): input is readonly BlocInput[] {\n  return Array.isArray(input);\n}\n\n/**\n * Watch one or more blocs for state changes.\n *\n * Thin wrapper around `container.channel.subscribe(ALL_PATHS, ...)`. The\n * callback fires once immediately, then on every state change of any of the\n * passed blocs. Returning `watch.STOP` from the callback tears down all\n * subscriptions.\n *\n * Note: subscriptions are microtask-deferred (per the DirtyChannel default\n * scheduler), so callbacks land asynchronously after `emit()`.\n *\n * @example Single bloc\n * ```ts\n * const unwatch = watch(UserBloc, (userBloc) => {\n *   console.log(userBloc.state.name);\n * });\n * ```\n *\n * @example Multiple blocs\n * ```ts\n * const unwatch = watch(\n *   [UserBloc, SettingsBloc] as const,\n *   ([userBloc, settingsBloc]) => {\n *     console.log(userBloc.state.name, settingsBloc.state.theme);\n *   }\n * );\n * ```\n *\n * @example With specific instance\n * ```ts\n * const unwatch = watch(\n *   instance(UserBloc, { userId: 'user-123' }),\n *   (userBloc) => {\n *     console.log(userBloc.state.name);\n *   }\n * );\n * ```\n *\n * @example Stop watching from callback\n * ```ts\n * const unwatch = watch(UserBloc, (userBloc) => {\n *   if (userBloc.state.done) {\n *     return watch.STOP;\n *   }\n * });\n * ```\n */\nfunction watchImpl<T extends StateContainerConstructor>(\n  bloc: T | BlocRef<T>,\n  callback: (bloc: InstanceType<T>) => void | StopSymbol,\n): () => void;\n\nfunction watchImpl<T extends readonly BlocInput[]>(\n  blocs: T,\n  callback: (blocs: ExtractInstances<T>) => void | StopSymbol,\n): () => void;\n\nfunction watchImpl(\n  blocsOrBloc: BlocInput | readonly BlocInput[],\n  callback: (blocsOrBloc: any) => void | StopSymbol,\n): () => void {\n  const isSingle = !isArray(blocsOrBloc);\n  const inputs = isSingle ? [blocsOrBloc] : blocsOrBloc;\n\n  const instances = inputs.map(resolveBloc);\n\n  let disposed = false;\n  const subscriptions: (() => void)[] = [];\n\n  const cleanup = () => {\n    if (disposed) return;\n    disposed = true;\n    for (const unsub of subscriptions) unsub();\n    subscriptions.length = 0;\n  };\n\n  const runCallback = () => {\n    if (disposed) return;\n    const arg = isSingle ? instances[0] : instances;\n    const result = callback(arg);\n    if (result === STOP) cleanup();\n  };\n\n  for (const inst of instances) {\n    subscriptions.push(inst.channel.subscribe(() => ALL_PATHS, runCallback));\n  }\n\n  // Fire once immediately so the consumer sees the current state.\n  runCallback();\n\n  return cleanup;\n}\n\nexport const watch: WatchFn = Object.assign(watchImpl, { STOP }) as WatchFn;\n"],"mappings":";;;;AASA,MAAM,OAAsB,OAAO,YAAY;AAG/C,MAAM,kBAAkB,OAAO,SAAS;;;;;;;;;;;;AAwBxC,SAAgB,SACd,WACA,MACY;CACZ,OAAO;GACJ,kBAAkB;EACnB,WAAW;EACX,YAAYA,gBAAAA,mBAAmB,WAAW,IAAI;CAChD;AACF;AAEA,SAAS,UACP,OAC6C;CAC7C,OACE,OAAO,UAAU,YAAY,UAAU,QAAQ,mBAAmB;AAEtE;AAiDA,SAAS,YAAY,OAA0C;CAC7D,MAAM,WAAWC,eAAAA,YAAY;CAC7B,IAAI,UAAU,KAAK,GACjB,OAAO,SAAS,OAAO,MAAM,WAAW,MAAM,UAAU;CAE1D,OAAO,SAAS,OACd,OACA,SAAS,WAAW,OAAO,KAAA,GAAW,KAAA,CAAS,CACjD;AACF;AAEA,SAAS,QAAQ,OAA+C;CAC9D,OAAO,MAAM,QAAQ,KAAK;AAC5B;AA2DA,SAAS,UACP,aACA,UACY;CACZ,MAAM,WAAW,CAAC,QAAQ,WAAW;CAGrC,MAAM,aAFS,WAAW,CAAC,WAAW,IAAI,aAEjB,IAAI,WAAW;CAExC,IAAI,WAAW;CACf,MAAM,gBAAgC,CAAC;CAEvC,MAAM,gBAAgB;EACpB,IAAI,UAAU;EACd,WAAW;EACX,KAAK,MAAM,SAAS,eAAe,MAAM;EACzC,cAAc,SAAS;CACzB;CAEA,MAAM,oBAAoB;EACxB,IAAI,UAAU;EAGd,IADe,SADH,WAAW,UAAU,KAAK,SAE7B,MAAM,MAAM,QAAQ;CAC/B;CAEA,KAAK,MAAM,QAAQ,WACjB,cAAc,KAAK,KAAK,QAAQ,gBAAgBC,sBAAAA,WAAW,WAAW,CAAC;CAIzE,YAAY;CAEZ,OAAO;AACT;AAEA,MAAa,QAAiB,OAAO,OAAO,WAAW,EAAE,KAAK,CAAC"}