@blac/core 2.0.15 → 2.0.17

package/dist/index.cjs

@@ -1,42 +1,36 @@
 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_management = require("./management-DTzcC6aD.cjs");
-const require_watch = require("./watch-BpwaUL8r.cjs");
-const require_branded = require("./branded-BSeA_mZO.cjs");
+const require_StateContainerRegistry = require("./StateContainerRegistry-DJQqLrli.cjs");
+const require_ensure = require("./ensure-Dx86f80B.cjs");
+const require_config = require("./config-sCPKPYxZ.cjs");
+const require_acquire = require("./acquire-CbMz7gWs.cjs");
+const require_management = require("./management-DAV9sN-k.cjs");
+const require_watch = require("./watch-B91opmva.cjs");
+const require_branded = require("./branded-BybA0_xw.cjs");
 let _dirtytalk_structural = require("@dirtytalk/structural");
-//#region src/registry/acquire.ts
-function acquire(BlocClass, instanceKey, refId, args) {
-	return require_config.getRegistry().acquire(BlocClass, instanceKey, {
-		canCreate: true,
-		countRef: true,
-		refId,
-		args
-	});
-}
-/**
-* 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.
-*/
-function resolveInstanceKey(BlocClass, instanceKey, args) {
-	return require_config.getRegistry().resolveKey(BlocClass, instanceKey, args);
-}
-//#endregion
 //#region src/registry/borrow.ts
-function borrow(BlocClass, instanceKey) {
-	return require_config.getRegistry().borrow(BlocClass, instanceKey);
+function resolveBorrowKey(BlocClass, target) {
+	return require_config.getRegistry().resolveKey(BlocClass, void 0, target?.args);
 }
-function borrowSafe(BlocClass, instanceKey) {
-	return require_config.getRegistry().borrowSafe(BlocClass, instanceKey);
+function borrow(BlocClass, target) {
+	return require_config.getRegistry().borrow(BlocClass, resolveBorrowKey(BlocClass, target));
+}
+function borrowSafe(BlocClass, target) {
+	return require_config.getRegistry().borrowSafe(BlocClass, resolveBorrowKey(BlocClass, target));
 }
 //#endregion
 //#region src/registry/release.ts
-function release(BlocClass, instanceKey, forceDispose = false, refId) {
-	require_config.getRegistry().release(BlocClass, instanceKey, forceDispose, refId);
+/**
+* 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
+*/
+function release(BlocClass, opts) {
+	const registry = require_config.getRegistry();
+	const key = registry.resolveKey(BlocClass, void 0, opts?.args);
+	registry.release(BlocClass, key, opts?.forceDispose ?? false, opts?.refId);
 }
 //#endregion
 //#region src/decorators/blac.ts
@@ -75,14 +69,15 @@ Object.defineProperty(exports, "ALL_PATHS", {
 		return _dirtytalk_structural.ALL_PATHS;
 	}
 });
-exports.APPLY_DEPS = require_Cubit.APPLY_DEPS;
-exports.Cubit = require_Cubit.Cubit;
-exports.EMIT = require_Cubit.EMIT;
+exports.APPLY_DEPS = require_ensure.APPLY_DEPS;
+exports.Cubit = require_ensure.Cubit;
+exports.DEP_BRAND = require_ensure.DEP_BRAND;
+exports.EMIT = require_ensure.EMIT;
 exports.PluginManager = require_StateContainerRegistry.PluginManager;
-exports.REMOVE_DEPS_OWNER = require_Cubit.REMOVE_DEPS_OWNER;
-exports.StateContainer = require_Cubit.StateContainer;
+exports.REMOVE_DEPS_OWNER = require_ensure.REMOVE_DEPS_OWNER;
+exports.StateContainer = require_ensure.StateContainer;
 exports.StateContainerRegistry = require_StateContainerRegistry.StateContainerRegistry;
-exports.acquire = acquire;
+exports.acquire = require_acquire.acquire;
 exports.blac = blac;
 exports.borrow = borrow;
 exports.borrowSafe = borrowSafe;
@@ -103,12 +98,11 @@ exports.hasInstance = require_management.hasInstance;
 exports.instance = require_watch.instance;
 exports.instanceId = require_branded.instanceId;
 exports.isExcludedFromDevTools = require_StateContainerRegistry.isExcludedFromDevTools;
-exports.isIsolatedClass = require_StateContainerRegistry.isIsolatedClass;
 exports.isKeepAliveClass = require_StateContainerRegistry.isKeepAliveClass;
 exports.register = require_management.register;
 exports.release = release;
 exports.resetBlacConfig = require_StateContainerRegistry.resetBlacConfig;
-exports.resolveInstanceKey = resolveInstanceKey;
+exports.resolveInstanceKey = require_acquire.resolveInstanceKey;
 exports.setRegistry = require_config.setRegistry;
 exports.shallowEqualState = require_StateContainerRegistry.shallowEqualState;
 exports.watch = require_watch.watch;

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["getRegistry","getRegistry","BLAC_STATIC_PROPS"],"sources":["../src/registry/acquire.ts","../src/registry/borrow.ts","../src/registry/release.ts","../src/decorators/blac.ts"],"sourcesContent":["import { getRegistry } from './config';\nimport type {\n  ExtractArgs,\n  StateContainerConstructor,\n} from '../types/utilities';\n\nexport function acquire<T extends StateContainerConstructor>(\n  BlocClass: T,\n  instanceKey?: string,\n  refId?: string,\n  args?: ExtractArgs<T>,\n): InstanceType<T> {\n  return getRegistry().acquire(BlocClass, instanceKey, {\n    canCreate: true,\n    countRef: true,\n    refId,\n    args,\n  });\n}\n\n/**\n * Resolve the storage key an instance would be acquired under, given an\n * (optional) explicit key and construction args. Callers that both acquire and\n * release (e.g. `@blac/react` `useBloc`) must use this once and pass the same\n * resolved key to both, so the ref is dropped under the key it was taken.\n */\nexport function resolveInstanceKey<T extends StateContainerConstructor>(\n  BlocClass: T,\n  instanceKey: string | undefined,\n  args?: ExtractArgs<T>,\n): string {\n  return getRegistry().resolveKey(BlocClass, instanceKey, args);\n}\n","import { getRegistry } from './config';\nimport type { StateContainerConstructor } from '../types/utilities';\n\nexport function borrow<T extends StateContainerConstructor>(\n  BlocClass: T,\n  instanceKey?: string,\n): InstanceType<T> {\n  return getRegistry().borrow(BlocClass, instanceKey);\n}\n\nexport function borrowSafe<T extends StateContainerConstructor>(\n  BlocClass: T,\n  instanceKey?: string,\n):\n  | { error: Error; instance: null }\n  | { error: null; instance: InstanceType<T> } {\n  return getRegistry().borrowSafe(BlocClass, instanceKey);\n}\n","import { getRegistry } from './config';\nimport type { StateContainerConstructor } from '../types/utilities';\n\nexport function release<T extends StateContainerConstructor>(\n  BlocClass: T,\n  instanceKey?: string,\n  forceDispose = false,\n  refId?: string,\n): void {\n  getRegistry().release(BlocClass, instanceKey, forceDispose, refId);\n}\n","import { BLAC_STATIC_PROPS } from '../constants';\nimport type { EqualityFn } from '../config';\n\n/**\n * Configuration options for the @blac decorator.\n * Only one option can be specified at a time (union type).\n */\nexport type BlacOptions =\n  /** Mark bloc to never be auto-disposed when ref count reaches 0 */\n  | { keepAlive: true }\n  /** Exclude bloc from DevTools tracking (prevents infinite loops) */\n  | { excludeFromDevTools: true }\n  /**\n   * Override the global equality check for this bloc.\n   * Return `true` to skip the emit (states considered equal).\n   */\n  | { equality: EqualityFn }\n  /**\n   * Override the default structural-hash identity key.\n   * The function receives `args` and returns the instance key string.\n   * Distinct return values → distinct instances; identical values → shared instance.\n   * Non-identity fields can be excluded so they don't fork new instances.\n   */\n  | { key: (args: any) => string };\n\n/**\n * Decorator to configure StateContainer classes.\n *\n * @example Decorator syntax (requires experimentalDecorators or TC39 decorators)\n * ```ts\n * @blac({ keepAlive: true })\n * class AuthBloc extends Cubit<AuthState> {}\n *\n * @blac({ excludeFromDevTools: true })\n * class InternalBloc extends Cubit<InternalState> {}\n * ```\n *\n * @example Function syntax (no decorator support needed)\n * ```ts\n * const AuthBloc = blac({ keepAlive: true })(\n *   class extends Cubit<AuthState> {}\n * );\n * ```\n */\nexport function blac(options: BlacOptions) {\n  return function <T extends new (...args: any[]) => any>(\n    target: T,\n    _context?: ClassDecoratorContext,\n  ): T {\n    if ('keepAlive' in options && options.keepAlive) {\n      (target as any)[BLAC_STATIC_PROPS.KEEP_ALIVE] = true;\n    }\n    if ('excludeFromDevTools' in options && options.excludeFromDevTools) {\n      (target as any)[BLAC_STATIC_PROPS.EXCLUDE_FROM_DEVTOOLS] = true;\n    }\n    if ('equality' in options && typeof options.equality === 'function') {\n      (target as any)[BLAC_STATIC_PROPS.EQUALITY] = options.equality;\n    }\n    if ('key' in options && typeof options.key === 'function') {\n      (target as any)[BLAC_STATIC_PROPS.KEY] = options.key;\n    }\n    return target;\n  };\n}\n"],"mappings":";;;;;;;;;;AAMA,SAAgB,QACd,WACA,aACA,OACA,MACiB;CACjB,OAAOA,eAAAA,aAAa,CAAC,QAAQ,WAAW,aAAa;EACnD,WAAW;EACX,UAAU;EACV;EACA;EACD,CAAC;;;;;;;;AASJ,SAAgB,mBACd,WACA,aACA,MACQ;CACR,OAAOA,eAAAA,aAAa,CAAC,WAAW,WAAW,aAAa,KAAK;;;;AC5B/D,SAAgB,OACd,WACA,aACiB;CACjB,OAAOC,eAAAA,aAAa,CAAC,OAAO,WAAW,YAAY;;AAGrD,SAAgB,WACd,WACA,aAG6C;CAC7C,OAAOA,eAAAA,aAAa,CAAC,WAAW,WAAW,YAAY;;;;ACbzD,SAAgB,QACd,WACA,aACA,eAAe,OACf,OACM;CACN,eAAA,aAAa,CAAC,QAAQ,WAAW,aAAa,cAAc,MAAM;;;;;;;;;;;;;;;;;;;;;;;ACmCpE,SAAgB,KAAK,SAAsB;CACzC,OAAO,SACL,QACA,UACG;EACH,IAAI,eAAe,WAAW,QAAQ,WACpC,OAAgBC,+BAAAA,kBAAkB,cAAc;EAElD,IAAI,yBAAyB,WAAW,QAAQ,qBAC9C,OAAgBA,+BAAAA,kBAAkB,yBAAyB;EAE7D,IAAI,cAAc,WAAW,OAAO,QAAQ,aAAa,YACvD,OAAgBA,+BAAAA,kBAAkB,YAAY,QAAQ;EAExD,IAAI,SAAS,WAAW,OAAO,QAAQ,QAAQ,YAC7C,OAAgBA,+BAAAA,kBAAkB,OAAO,QAAQ;EAEnD,OAAO"}
+{"version":3,"file":"index.cjs","names":["getRegistry","getRegistry","BLAC_STATIC_PROPS"],"sources":["../src/registry/borrow.ts","../src/registry/release.ts","../src/decorators/blac.ts"],"sourcesContent":["import { getRegistry } from './config';\nimport type {\n  ExtractArgs,\n  StateContainerConstructor,\n} from '../types/utilities';\n\n/**\n * How to identify the instance to borrow: the same `args` shape `useBloc`\n * accepts, resolved through the class's `static key(args)` so call sites use\n * the *same* shape they pass to `useBloc` instead of hand-deriving the key.\n *\n * `borrowSafe(ChannelBloc, { args: { channelId } })` and\n * `useBloc(ChannelBloc, { args: { channelId } })` therefore always agree.\n */\nexport type BorrowTarget<T extends StateContainerConstructor> = {\n  args?: ExtractArgs<T>;\n};\n\nfunction resolveBorrowKey<T extends StateContainerConstructor>(\n  BlocClass: T,\n  target: BorrowTarget<T> | undefined,\n): string {\n  return getRegistry().resolveKey(BlocClass, undefined, target?.args);\n}\n\nexport function borrow<T extends StateContainerConstructor>(\n  BlocClass: T,\n  target?: BorrowTarget<T>,\n): InstanceType<T> {\n  return getRegistry().borrow(BlocClass, resolveBorrowKey(BlocClass, target));\n}\n\nexport function borrowSafe<T extends StateContainerConstructor>(\n  BlocClass: T,\n  target?: BorrowTarget<T>,\n):\n  | { error: Error; instance: null }\n  | { error: null; instance: InstanceType<T> } {\n  return getRegistry().borrowSafe(\n    BlocClass,\n    resolveBorrowKey(BlocClass, target),\n  );\n}\n","import { getRegistry } from './config';\nimport type {\n  ExtractArgs,\n  StateContainerConstructor,\n} from '../types/utilities';\n\n/**\n * Release a reference to an instance. Instance identity is derived purely from\n * `args` (must match the `args` it was acquired with).\n *\n * @param opts.args - Construction/identity args; derives the instance key\n * @param opts.refId - The specific ref to drop; drops one arbitrary ref if omitted\n * @param opts.forceDispose - Force immediate disposal regardless of refs\n */\nexport function release<T extends StateContainerConstructor>(\n  BlocClass: T,\n  opts?: { args?: ExtractArgs<T>; refId?: string; forceDispose?: boolean },\n): void {\n  const registry = getRegistry();\n  const key = registry.resolveKey(BlocClass, undefined, opts?.args);\n  registry.release(BlocClass, key, opts?.forceDispose ?? false, opts?.refId);\n}\n","import { BLAC_STATIC_PROPS } from '../constants';\nimport type { EqualityFn } from '../config';\n\n/**\n * Configuration options for the @blac decorator.\n * Only one option can be specified at a time (union type).\n */\nexport type BlacOptions =\n  /** Mark bloc to never be auto-disposed when ref count reaches 0 */\n  | { keepAlive: true }\n  /** Exclude bloc from DevTools tracking (prevents infinite loops) */\n  | { excludeFromDevTools: true }\n  /**\n   * Override the global equality check for this bloc.\n   * Return `true` to skip the emit (states considered equal).\n   */\n  | { equality: EqualityFn }\n  /**\n   * Override the default structural-hash identity key.\n   * The function receives `args` and returns the instance key string.\n   * Distinct return values → distinct instances; identical values → shared instance.\n   * Non-identity fields can be excluded so they don't fork new instances.\n   */\n  | { key: (args: any) => string };\n\n/**\n * Decorator to configure StateContainer classes.\n *\n * @example Decorator syntax (requires experimentalDecorators or TC39 decorators)\n * ```ts\n * @blac({ keepAlive: true })\n * class AuthBloc extends Cubit<AuthState> {}\n *\n * @blac({ excludeFromDevTools: true })\n * class InternalBloc extends Cubit<InternalState> {}\n * ```\n *\n * @example Function syntax (no decorator support needed)\n * ```ts\n * const AuthBloc = blac({ keepAlive: true })(\n *   class extends Cubit<AuthState> {}\n * );\n * ```\n */\nexport function blac(options: BlacOptions) {\n  return function <T extends new (...args: any[]) => any>(\n    target: T,\n    _context?: ClassDecoratorContext,\n  ): T {\n    if ('keepAlive' in options && options.keepAlive) {\n      (target as any)[BLAC_STATIC_PROPS.KEEP_ALIVE] = true;\n    }\n    if ('excludeFromDevTools' in options && options.excludeFromDevTools) {\n      (target as any)[BLAC_STATIC_PROPS.EXCLUDE_FROM_DEVTOOLS] = true;\n    }\n    if ('equality' in options && typeof options.equality === 'function') {\n      (target as any)[BLAC_STATIC_PROPS.EQUALITY] = options.equality;\n    }\n    if ('key' in options && typeof options.key === 'function') {\n      (target as any)[BLAC_STATIC_PROPS.KEY] = options.key;\n    }\n    return target;\n  };\n}\n"],"mappings":";;;;;;;;;;AAkBA,SAAS,iBACP,WACA,QACQ;CACR,OAAOA,eAAAA,YAAY,EAAE,WAAW,WAAW,KAAA,GAAW,QAAQ,IAAI;AACpE;AAEA,SAAgB,OACd,WACA,QACiB;CACjB,OAAOA,eAAAA,YAAY,EAAE,OAAO,WAAW,iBAAiB,WAAW,MAAM,CAAC;AAC5E;AAEA,SAAgB,WACd,WACA,QAG6C;CAC7C,OAAOA,eAAAA,YAAY,EAAE,WACnB,WACA,iBAAiB,WAAW,MAAM,CACpC;AACF;;;;;;;;;;;AC5BA,SAAgB,QACd,WACA,MACM;CACN,MAAM,WAAWC,eAAAA,YAAY;CAC7B,MAAM,MAAM,SAAS,WAAW,WAAW,KAAA,GAAW,MAAM,IAAI;CAChE,SAAS,QAAQ,WAAW,KAAK,MAAM,gBAAgB,OAAO,MAAM,KAAK;AAC3E;;;;;;;;;;;;;;;;;;;;;;ACuBA,SAAgB,KAAK,SAAsB;CACzC,OAAO,SACL,QACA,UACG;EACH,IAAI,eAAe,WAAW,QAAQ,WACpC,OAAgBC,+BAAAA,kBAAkB,cAAc;EAElD,IAAI,yBAAyB,WAAW,QAAQ,qBAC9C,OAAgBA,+BAAAA,kBAAkB,yBAAyB;EAE7D,IAAI,cAAc,WAAW,OAAO,QAAQ,aAAa,YACvD,OAAgBA,+BAAAA,kBAAkB,YAAY,QAAQ;EAExD,IAAI,SAAS,WAAW,OAAO,QAAQ,QAAQ,YAC7C,OAAgBA,+BAAAA,kBAAkB,OAAO,QAAQ;EAEnD,OAAO;CACT;AACF"}

package/dist/index.d.cts

@@ -1,6 +1,6 @@
 export { configureBlac, getBlacConfig, resetBlacConfig, shallowEqualState, type BlacConfig, type EqualityFn, } from './config';
-export { StateContainer } from './core/StateContainer';
-export type { HydrationStatus, StateContainerConfig, SystemEvent, SystemEventPayloads, } from './core/StateContainer';
+export { StateContainer, DEP_BRAND } from './core/StateContainer';
+export type { HydrationStatus, StateContainerConfig, SystemEvent, SystemEventPayloads, DepHandle, } from './core/StateContainer';
 export { Cubit } from './core/Cubit';
 /**
  * @internal symbols — read by framework adapters (`@blac/react` via the
@@ -14,10 +14,11 @@ export { EMIT, APPLY_DEPS, REMOVE_DEPS_OWNER } from './core/symbols';
 export { ALL_PATHS } from '@dirtytalk/structural';
 export type { PathSet } from '@dirtytalk/structural';
 export { acquire, resolveInstanceKey, borrow, borrowSafe, ensure, release, clear, clearAll, register, hasInstance, getRefCount, getRefIds, getAll, forEach, getRegistry, setRegistry, getStats, } from './registry';
+export type { BorrowTarget } from './registry';
 export { globalRegistry, StateContainerRegistry, } from './core/StateContainerRegistry';
 export type { LifecycleEvent, LifecycleListener, InstanceEntry, } from './core/StateContainerRegistry';
 export { blac, type BlacOptions } from './decorators';
-export { isKeepAliveClass, isExcludedFromDevTools, isIsolatedClass, } from './utils/static-props';
+export { isKeepAliveClass, isExcludedFromDevTools } from './utils/static-props';
 export { getPluginManager } from './core/StateContainerRegistry';
 export type { BlacPlugin, BlacPluginWithInit, PluginContext, PluginConfig, InstanceMetadata, } from './plugin/BlacPlugin';
 export { PluginManager } from './plugin/PluginManager';

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export { configureBlac, getBlacConfig, resetBlacConfig, shallowEqualState, type BlacConfig, type EqualityFn, } from './config';
-export { StateContainer } from './core/StateContainer';
-export type { HydrationStatus, StateContainerConfig, SystemEvent, SystemEventPayloads, } from './core/StateContainer';
+export { StateContainer, DEP_BRAND } from './core/StateContainer';
+export type { HydrationStatus, StateContainerConfig, SystemEvent, SystemEventPayloads, DepHandle, } from './core/StateContainer';
 export { Cubit } from './core/Cubit';
 /**
  * @internal symbols — read by framework adapters (`@blac/react` via the
@@ -14,10 +14,11 @@ export { EMIT, APPLY_DEPS, REMOVE_DEPS_OWNER } from './core/symbols';
 export { ALL_PATHS } from '@dirtytalk/structural';
 export type { PathSet } from '@dirtytalk/structural';
 export { acquire, resolveInstanceKey, borrow, borrowSafe, ensure, release, clear, clearAll, register, hasInstance, getRefCount, getRefIds, getAll, forEach, getRegistry, setRegistry, getStats, } from './registry';
+export type { BorrowTarget } from './registry';
 export { globalRegistry, StateContainerRegistry, } from './core/StateContainerRegistry';
 export type { LifecycleEvent, LifecycleListener, InstanceEntry, } from './core/StateContainerRegistry';
 export { blac, type BlacOptions } from './decorators';
-export { isKeepAliveClass, isExcludedFromDevTools, isIsolatedClass, } from './utils/static-props';
+export { isKeepAliveClass, isExcludedFromDevTools } from './utils/static-props';
 export { getPluginManager } from './core/StateContainerRegistry';
 export type { BlacPlugin, BlacPluginWithInit, PluginContext, PluginConfig, InstanceMetadata, } from './plugin/BlacPlugin';
 export { PluginManager } from './plugin/PluginManager';

package/dist/index.js

@@ -1,41 +1,35 @@
-import { a as isExcludedFromDevTools, c as PluginManager, d as configureBlac, f as getBlacConfig, m as shallowEqualState, n as getPluginManager, o as isIsolatedClass, p as resetBlacConfig, r as globalRegistry, s as isKeepAliveClass, t as StateContainerRegistry, u as BLAC_STATIC_PROPS } from "./StateContainerRegistry-DmmzYa7S.js";
-import { a as REMOVE_DEPS_OWNER, i as EMIT, n as StateContainer, r as APPLY_DEPS, t as Cubit } from "./Cubit-VJuu2tt9.js";
-import { n as getStats, r as setRegistry, t as getRegistry } from "./config-DoHx0Xsl.js";
-import { t as ensure } from "./ensure-mkL-3qh8.js";
-import { a as getAll, c as hasInstance, i as forEach, n as clearAll, o as getRefCount, r as register, s as getRefIds, t as clear } from "./management-H4m3ciJO.js";
-import { n as watch, t as instance } from "./watch-DWCqXllW.js";
-import { t as instanceId } from "./branded-DwtzSsg0.js";
+import { a as isExcludedFromDevTools, c as PluginManager, d as resetBlacConfig, f as shallowEqualState, l as configureBlac, n as getPluginManager, o as isKeepAliveClass, r as globalRegistry, s as BLAC_STATIC_PROPS, t as StateContainerRegistry, u as getBlacConfig } from "./StateContainerRegistry-B1GYx9Xo.js";
+import { a as APPLY_DEPS, i as StateContainer, n as Cubit, o as EMIT, r as DEP_BRAND, s as REMOVE_DEPS_OWNER, t as ensure } from "./ensure-DzqGej43.js";
+import { n as getStats, r as setRegistry, t as getRegistry } from "./config-Dk1FxfXj.js";
+import { n as resolveInstanceKey, t as acquire } from "./acquire-G8aB3GAx.js";
+import { a as getAll, c as hasInstance, i as forEach, n as clearAll, o as getRefCount, r as register, s as getRefIds, t as clear } from "./management-444tdCBG.js";
+import { n as watch, t as instance } from "./watch-DPVUwPUY.js";
+import { t as instanceId } from "./branded-DkbUzncc.js";
 import { ALL_PATHS } from "@dirtytalk/structural";
-//#region src/registry/acquire.ts
-function acquire(BlocClass, instanceKey, refId, args) {
-	return getRegistry().acquire(BlocClass, instanceKey, {
-		canCreate: true,
-		countRef: true,
-		refId,
-		args
-	});
-}
-/**
-* 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.
-*/
-function resolveInstanceKey(BlocClass, instanceKey, args) {
-	return getRegistry().resolveKey(BlocClass, instanceKey, args);
-}
-//#endregion
 //#region src/registry/borrow.ts
-function borrow(BlocClass, instanceKey) {
-	return getRegistry().borrow(BlocClass, instanceKey);
+function resolveBorrowKey(BlocClass, target) {
+	return getRegistry().resolveKey(BlocClass, void 0, target?.args);
 }
-function borrowSafe(BlocClass, instanceKey) {
-	return getRegistry().borrowSafe(BlocClass, instanceKey);
+function borrow(BlocClass, target) {
+	return getRegistry().borrow(BlocClass, resolveBorrowKey(BlocClass, target));
+}
+function borrowSafe(BlocClass, target) {
+	return getRegistry().borrowSafe(BlocClass, resolveBorrowKey(BlocClass, target));
 }
 //#endregion
 //#region src/registry/release.ts
-function release(BlocClass, instanceKey, forceDispose = false, refId) {
-	getRegistry().release(BlocClass, instanceKey, forceDispose, refId);
+/**
+* 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
+*/
+function release(BlocClass, opts) {
+	const registry = getRegistry();
+	const key = registry.resolveKey(BlocClass, void 0, opts?.args);
+	registry.release(BlocClass, key, opts?.forceDispose ?? false, opts?.refId);
 }
 //#endregion
 //#region src/decorators/blac.ts
@@ -68,6 +62,6 @@ function blac(options) {
 	};
 }
 //#endregion
-export { ALL_PATHS, APPLY_DEPS, Cubit, EMIT, PluginManager, REMOVE_DEPS_OWNER, StateContainer, StateContainerRegistry, acquire, blac, borrow, borrowSafe, clear, clearAll, configureBlac, ensure, forEach, getAll, getBlacConfig, getPluginManager, getRefCount, getRefIds, getRegistry, getStats, globalRegistry, hasInstance, instance, instanceId, isExcludedFromDevTools, isIsolatedClass, isKeepAliveClass, register, release, resetBlacConfig, resolveInstanceKey, setRegistry, shallowEqualState, watch };
+export { ALL_PATHS, APPLY_DEPS, Cubit, DEP_BRAND, EMIT, PluginManager, REMOVE_DEPS_OWNER, StateContainer, StateContainerRegistry, acquire, blac, borrow, borrowSafe, clear, clearAll, configureBlac, ensure, forEach, getAll, getBlacConfig, getPluginManager, getRefCount, getRefIds, getRegistry, getStats, globalRegistry, hasInstance, instance, instanceId, isExcludedFromDevTools, isKeepAliveClass, register, release, resetBlacConfig, resolveInstanceKey, setRegistry, shallowEqualState, watch };
 
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../src/registry/acquire.ts","../src/registry/borrow.ts","../src/registry/release.ts","../src/decorators/blac.ts"],"sourcesContent":["import { getRegistry } from './config';\nimport type {\n  ExtractArgs,\n  StateContainerConstructor,\n} from '../types/utilities';\n\nexport function acquire<T extends StateContainerConstructor>(\n  BlocClass: T,\n  instanceKey?: string,\n  refId?: string,\n  args?: ExtractArgs<T>,\n): InstanceType<T> {\n  return getRegistry().acquire(BlocClass, instanceKey, {\n    canCreate: true,\n    countRef: true,\n    refId,\n    args,\n  });\n}\n\n/**\n * Resolve the storage key an instance would be acquired under, given an\n * (optional) explicit key and construction args. Callers that both acquire and\n * release (e.g. `@blac/react` `useBloc`) must use this once and pass the same\n * resolved key to both, so the ref is dropped under the key it was taken.\n */\nexport function resolveInstanceKey<T extends StateContainerConstructor>(\n  BlocClass: T,\n  instanceKey: string | undefined,\n  args?: ExtractArgs<T>,\n): string {\n  return getRegistry().resolveKey(BlocClass, instanceKey, args);\n}\n","import { getRegistry } from './config';\nimport type { StateContainerConstructor } from '../types/utilities';\n\nexport function borrow<T extends StateContainerConstructor>(\n  BlocClass: T,\n  instanceKey?: string,\n): InstanceType<T> {\n  return getRegistry().borrow(BlocClass, instanceKey);\n}\n\nexport function borrowSafe<T extends StateContainerConstructor>(\n  BlocClass: T,\n  instanceKey?: string,\n):\n  | { error: Error; instance: null }\n  | { error: null; instance: InstanceType<T> } {\n  return getRegistry().borrowSafe(BlocClass, instanceKey);\n}\n","import { getRegistry } from './config';\nimport type { StateContainerConstructor } from '../types/utilities';\n\nexport function release<T extends StateContainerConstructor>(\n  BlocClass: T,\n  instanceKey?: string,\n  forceDispose = false,\n  refId?: string,\n): void {\n  getRegistry().release(BlocClass, instanceKey, forceDispose, refId);\n}\n","import { BLAC_STATIC_PROPS } from '../constants';\nimport type { EqualityFn } from '../config';\n\n/**\n * Configuration options for the @blac decorator.\n * Only one option can be specified at a time (union type).\n */\nexport type BlacOptions =\n  /** Mark bloc to never be auto-disposed when ref count reaches 0 */\n  | { keepAlive: true }\n  /** Exclude bloc from DevTools tracking (prevents infinite loops) */\n  | { excludeFromDevTools: true }\n  /**\n   * Override the global equality check for this bloc.\n   * Return `true` to skip the emit (states considered equal).\n   */\n  | { equality: EqualityFn }\n  /**\n   * Override the default structural-hash identity key.\n   * The function receives `args` and returns the instance key string.\n   * Distinct return values → distinct instances; identical values → shared instance.\n   * Non-identity fields can be excluded so they don't fork new instances.\n   */\n  | { key: (args: any) => string };\n\n/**\n * Decorator to configure StateContainer classes.\n *\n * @example Decorator syntax (requires experimentalDecorators or TC39 decorators)\n * ```ts\n * @blac({ keepAlive: true })\n * class AuthBloc extends Cubit<AuthState> {}\n *\n * @blac({ excludeFromDevTools: true })\n * class InternalBloc extends Cubit<InternalState> {}\n * ```\n *\n * @example Function syntax (no decorator support needed)\n * ```ts\n * const AuthBloc = blac({ keepAlive: true })(\n *   class extends Cubit<AuthState> {}\n * );\n * ```\n */\nexport function blac(options: BlacOptions) {\n  return function <T extends new (...args: any[]) => any>(\n    target: T,\n    _context?: ClassDecoratorContext,\n  ): T {\n    if ('keepAlive' in options && options.keepAlive) {\n      (target as any)[BLAC_STATIC_PROPS.KEEP_ALIVE] = true;\n    }\n    if ('excludeFromDevTools' in options && options.excludeFromDevTools) {\n      (target as any)[BLAC_STATIC_PROPS.EXCLUDE_FROM_DEVTOOLS] = true;\n    }\n    if ('equality' in options && typeof options.equality === 'function') {\n      (target as any)[BLAC_STATIC_PROPS.EQUALITY] = options.equality;\n    }\n    if ('key' in options && typeof options.key === 'function') {\n      (target as any)[BLAC_STATIC_PROPS.KEY] = options.key;\n    }\n    return target;\n  };\n}\n"],"mappings":";;;;;;;;;AAMA,SAAgB,QACd,WACA,aACA,OACA,MACiB;CACjB,OAAO,aAAa,CAAC,QAAQ,WAAW,aAAa;EACnD,WAAW;EACX,UAAU;EACV;EACA;EACD,CAAC;;;;;;;;AASJ,SAAgB,mBACd,WACA,aACA,MACQ;CACR,OAAO,aAAa,CAAC,WAAW,WAAW,aAAa,KAAK;;;;AC5B/D,SAAgB,OACd,WACA,aACiB;CACjB,OAAO,aAAa,CAAC,OAAO,WAAW,YAAY;;AAGrD,SAAgB,WACd,WACA,aAG6C;CAC7C,OAAO,aAAa,CAAC,WAAW,WAAW,YAAY;;;;ACbzD,SAAgB,QACd,WACA,aACA,eAAe,OACf,OACM;CACN,aAAa,CAAC,QAAQ,WAAW,aAAa,cAAc,MAAM;;;;;;;;;;;;;;;;;;;;;;;ACmCpE,SAAgB,KAAK,SAAsB;CACzC,OAAO,SACL,QACA,UACG;EACH,IAAI,eAAe,WAAW,QAAQ,WACpC,OAAgB,kBAAkB,cAAc;EAElD,IAAI,yBAAyB,WAAW,QAAQ,qBAC9C,OAAgB,kBAAkB,yBAAyB;EAE7D,IAAI,cAAc,WAAW,OAAO,QAAQ,aAAa,YACvD,OAAgB,kBAAkB,YAAY,QAAQ;EAExD,IAAI,SAAS,WAAW,OAAO,QAAQ,QAAQ,YAC7C,OAAgB,kBAAkB,OAAO,QAAQ;EAEnD,OAAO"}
+{"version":3,"file":"index.js","names":[],"sources":["../src/registry/borrow.ts","../src/registry/release.ts","../src/decorators/blac.ts"],"sourcesContent":["import { getRegistry } from './config';\nimport type {\n  ExtractArgs,\n  StateContainerConstructor,\n} from '../types/utilities';\n\n/**\n * How to identify the instance to borrow: the same `args` shape `useBloc`\n * accepts, resolved through the class's `static key(args)` so call sites use\n * the *same* shape they pass to `useBloc` instead of hand-deriving the key.\n *\n * `borrowSafe(ChannelBloc, { args: { channelId } })` and\n * `useBloc(ChannelBloc, { args: { channelId } })` therefore always agree.\n */\nexport type BorrowTarget<T extends StateContainerConstructor> = {\n  args?: ExtractArgs<T>;\n};\n\nfunction resolveBorrowKey<T extends StateContainerConstructor>(\n  BlocClass: T,\n  target: BorrowTarget<T> | undefined,\n): string {\n  return getRegistry().resolveKey(BlocClass, undefined, target?.args);\n}\n\nexport function borrow<T extends StateContainerConstructor>(\n  BlocClass: T,\n  target?: BorrowTarget<T>,\n): InstanceType<T> {\n  return getRegistry().borrow(BlocClass, resolveBorrowKey(BlocClass, target));\n}\n\nexport function borrowSafe<T extends StateContainerConstructor>(\n  BlocClass: T,\n  target?: BorrowTarget<T>,\n):\n  | { error: Error; instance: null }\n  | { error: null; instance: InstanceType<T> } {\n  return getRegistry().borrowSafe(\n    BlocClass,\n    resolveBorrowKey(BlocClass, target),\n  );\n}\n","import { getRegistry } from './config';\nimport type {\n  ExtractArgs,\n  StateContainerConstructor,\n} from '../types/utilities';\n\n/**\n * Release a reference to an instance. Instance identity is derived purely from\n * `args` (must match the `args` it was acquired with).\n *\n * @param opts.args - Construction/identity args; derives the instance key\n * @param opts.refId - The specific ref to drop; drops one arbitrary ref if omitted\n * @param opts.forceDispose - Force immediate disposal regardless of refs\n */\nexport function release<T extends StateContainerConstructor>(\n  BlocClass: T,\n  opts?: { args?: ExtractArgs<T>; refId?: string; forceDispose?: boolean },\n): void {\n  const registry = getRegistry();\n  const key = registry.resolveKey(BlocClass, undefined, opts?.args);\n  registry.release(BlocClass, key, opts?.forceDispose ?? false, opts?.refId);\n}\n","import { BLAC_STATIC_PROPS } from '../constants';\nimport type { EqualityFn } from '../config';\n\n/**\n * Configuration options for the @blac decorator.\n * Only one option can be specified at a time (union type).\n */\nexport type BlacOptions =\n  /** Mark bloc to never be auto-disposed when ref count reaches 0 */\n  | { keepAlive: true }\n  /** Exclude bloc from DevTools tracking (prevents infinite loops) */\n  | { excludeFromDevTools: true }\n  /**\n   * Override the global equality check for this bloc.\n   * Return `true` to skip the emit (states considered equal).\n   */\n  | { equality: EqualityFn }\n  /**\n   * Override the default structural-hash identity key.\n   * The function receives `args` and returns the instance key string.\n   * Distinct return values → distinct instances; identical values → shared instance.\n   * Non-identity fields can be excluded so they don't fork new instances.\n   */\n  | { key: (args: any) => string };\n\n/**\n * Decorator to configure StateContainer classes.\n *\n * @example Decorator syntax (requires experimentalDecorators or TC39 decorators)\n * ```ts\n * @blac({ keepAlive: true })\n * class AuthBloc extends Cubit<AuthState> {}\n *\n * @blac({ excludeFromDevTools: true })\n * class InternalBloc extends Cubit<InternalState> {}\n * ```\n *\n * @example Function syntax (no decorator support needed)\n * ```ts\n * const AuthBloc = blac({ keepAlive: true })(\n *   class extends Cubit<AuthState> {}\n * );\n * ```\n */\nexport function blac(options: BlacOptions) {\n  return function <T extends new (...args: any[]) => any>(\n    target: T,\n    _context?: ClassDecoratorContext,\n  ): T {\n    if ('keepAlive' in options && options.keepAlive) {\n      (target as any)[BLAC_STATIC_PROPS.KEEP_ALIVE] = true;\n    }\n    if ('excludeFromDevTools' in options && options.excludeFromDevTools) {\n      (target as any)[BLAC_STATIC_PROPS.EXCLUDE_FROM_DEVTOOLS] = true;\n    }\n    if ('equality' in options && typeof options.equality === 'function') {\n      (target as any)[BLAC_STATIC_PROPS.EQUALITY] = options.equality;\n    }\n    if ('key' in options && typeof options.key === 'function') {\n      (target as any)[BLAC_STATIC_PROPS.KEY] = options.key;\n    }\n    return target;\n  };\n}\n"],"mappings":";;;;;;;;;AAkBA,SAAS,iBACP,WACA,QACQ;CACR,OAAO,YAAY,EAAE,WAAW,WAAW,KAAA,GAAW,QAAQ,IAAI;AACpE;AAEA,SAAgB,OACd,WACA,QACiB;CACjB,OAAO,YAAY,EAAE,OAAO,WAAW,iBAAiB,WAAW,MAAM,CAAC;AAC5E;AAEA,SAAgB,WACd,WACA,QAG6C;CAC7C,OAAO,YAAY,EAAE,WACnB,WACA,iBAAiB,WAAW,MAAM,CACpC;AACF;;;;;;;;;;;AC5BA,SAAgB,QACd,WACA,MACM;CACN,MAAM,WAAW,YAAY;CAC7B,MAAM,MAAM,SAAS,WAAW,WAAW,KAAA,GAAW,MAAM,IAAI;CAChE,SAAS,QAAQ,WAAW,KAAK,MAAM,gBAAgB,OAAO,MAAM,KAAK;AAC3E;;;;;;;;;;;;;;;;;;;;;;ACuBA,SAAgB,KAAK,SAAsB;CACzC,OAAO,SACL,QACA,UACG;EACH,IAAI,eAAe,WAAW,QAAQ,WACpC,OAAgB,kBAAkB,cAAc;EAElD,IAAI,yBAAyB,WAAW,QAAQ,qBAC9C,OAAgB,kBAAkB,yBAAyB;EAE7D,IAAI,cAAc,WAAW,OAAO,QAAQ,aAAa,YACvD,OAAgB,kBAAkB,YAAY,QAAQ;EAExD,IAAI,SAAS,WAAW,OAAO,QAAQ,QAAQ,YAC7C,OAAgB,kBAAkB,OAAO,QAAQ;EAEnD,OAAO;CACT;AACF"}

package/dist/management-444tdCBG.js

@@ -0,0 +1,38 @@
+import { t as getRegistry } from "./config-Dk1FxfXj.js";
+//#region src/registry/queries.ts
+function hasInstance(BlocClass, opts) {
+	const registry = getRegistry();
+	const key = registry.resolveKey(BlocClass, void 0, opts?.args);
+	return registry.hasInstance(BlocClass, key);
+}
+function getRefCount(BlocClass, opts) {
+	const registry = getRegistry();
+	const key = registry.resolveKey(BlocClass, void 0, opts?.args);
+	return registry.getRefCount(BlocClass, key);
+}
+function getRefIds(BlocClass, opts) {
+	const registry = getRegistry();
+	const key = registry.resolveKey(BlocClass, void 0, opts?.args);
+	return registry.getRefIds(BlocClass, key);
+}
+function getAll(BlocClass) {
+	return getRegistry().getAll(BlocClass);
+}
+function forEach(BlocClass, callback) {
+	getRegistry().forEach(BlocClass, callback);
+}
+//#endregion
+//#region src/registry/management.ts
+function clear(BlocClass) {
+	getRegistry().clear(BlocClass);
+}
+function clearAll() {
+	getRegistry().clearAll();
+}
+function register(BlocClass) {
+	getRegistry().register(BlocClass);
+}
+//#endregion
+export { getAll as a, hasInstance as c, forEach as i, clearAll as n, getRefCount as o, register as r, getRefIds as s, clear as t };
+
+//# sourceMappingURL=management-444tdCBG.js.map

package/dist/management-444tdCBG.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"management-444tdCBG.js","names":[],"sources":["../src/registry/queries.ts","../src/registry/management.ts"],"sourcesContent":["import { getRegistry } from './config';\nimport type {\n  ExtractArgs,\n  StateContainerConstructor,\n  InstanceReadonlyState,\n} from '../types/utilities';\n\nexport function hasInstance<T extends StateContainerConstructor>(\n  BlocClass: T,\n  opts?: { args?: ExtractArgs<T> },\n): boolean {\n  const registry = getRegistry();\n  const key = registry.resolveKey(BlocClass, undefined, opts?.args);\n  return registry.hasInstance(BlocClass, key);\n}\n\nexport function getRefCount<T extends StateContainerConstructor>(\n  BlocClass: T,\n  opts?: { args?: ExtractArgs<T> },\n): number {\n  const registry = getRegistry();\n  const key = registry.resolveKey(BlocClass, undefined, opts?.args);\n  return registry.getRefCount(BlocClass, key);\n}\n\nexport function getRefIds<T extends StateContainerConstructor>(\n  BlocClass: T,\n  opts?: { args?: ExtractArgs<T> },\n): string[] {\n  const registry = getRegistry();\n  const key = registry.resolveKey(BlocClass, undefined, opts?.args);\n  return registry.getRefIds(BlocClass, key);\n}\n\nexport function getAll<T extends StateContainerConstructor>(\n  BlocClass: T,\n): InstanceReadonlyState<T>[] {\n  return getRegistry().getAll(BlocClass);\n}\n\nexport function forEach<T extends StateContainerConstructor>(\n  BlocClass: T,\n  callback: (instance: InstanceReadonlyState<T>) => void,\n): void {\n  getRegistry().forEach(BlocClass, callback);\n}\n","import { getRegistry } from './config';\nimport type { StateContainerConstructor } from '../types/utilities';\n\nexport function clear<T extends StateContainerConstructor>(BlocClass: T): void {\n  getRegistry().clear(BlocClass);\n}\n\nexport function clearAll(): void {\n  getRegistry().clearAll();\n}\n\nexport function register<T extends StateContainerConstructor>(\n  BlocClass: T,\n): void {\n  getRegistry().register(BlocClass);\n}\n"],"mappings":";;AAOA,SAAgB,YACd,WACA,MACS;CACT,MAAM,WAAW,YAAY;CAC7B,MAAM,MAAM,SAAS,WAAW,WAAW,KAAA,GAAW,MAAM,IAAI;CAChE,OAAO,SAAS,YAAY,WAAW,GAAG;AAC5C;AAEA,SAAgB,YACd,WACA,MACQ;CACR,MAAM,WAAW,YAAY;CAC7B,MAAM,MAAM,SAAS,WAAW,WAAW,KAAA,GAAW,MAAM,IAAI;CAChE,OAAO,SAAS,YAAY,WAAW,GAAG;AAC5C;AAEA,SAAgB,UACd,WACA,MACU;CACV,MAAM,WAAW,YAAY;CAC7B,MAAM,MAAM,SAAS,WAAW,WAAW,KAAA,GAAW,MAAM,IAAI;CAChE,OAAO,SAAS,UAAU,WAAW,GAAG;AAC1C;AAEA,SAAgB,OACd,WAC4B;CAC5B,OAAO,YAAY,EAAE,OAAO,SAAS;AACvC;AAEA,SAAgB,QACd,WACA,UACM;CACN,YAAY,EAAE,QAAQ,WAAW,QAAQ;AAC3C;;;AC1CA,SAAgB,MAA2C,WAAoB;CAC7E,YAAY,EAAE,MAAM,SAAS;AAC/B;AAEA,SAAgB,WAAiB;CAC/B,YAAY,EAAE,SAAS;AACzB;AAEA,SAAgB,SACd,WACM;CACN,YAAY,EAAE,SAAS,SAAS;AAClC"}

package/dist/management-7jLjVHJd.js

@@ -0,0 +1,38 @@
+import { t as getRegistry } from "./config-8pyOC5gv.js";
+//#region src/registry/queries.ts
+function hasInstance(BlocClass, opts) {
+	const registry = getRegistry();
+	const key = registry.resolveKey(BlocClass, void 0, opts?.args);
+	return registry.hasInstance(BlocClass, key);
+}
+function getRefCount(BlocClass, opts) {
+	const registry = getRegistry();
+	const key = registry.resolveKey(BlocClass, void 0, opts?.args);
+	return registry.getRefCount(BlocClass, key);
+}
+function getRefIds(BlocClass, opts) {
+	const registry = getRegistry();
+	const key = registry.resolveKey(BlocClass, void 0, opts?.args);
+	return registry.getRefIds(BlocClass, key);
+}
+function getAll(BlocClass) {
+	return getRegistry().getAll(BlocClass);
+}
+function forEach(BlocClass, callback) {
+	getRegistry().forEach(BlocClass, callback);
+}
+//#endregion
+//#region src/registry/management.ts
+function clear(BlocClass) {
+	getRegistry().clear(BlocClass);
+}
+function clearAll() {
+	getRegistry().clearAll();
+}
+function register(BlocClass) {
+	getRegistry().register(BlocClass);
+}
+//#endregion
+export { getAll as a, hasInstance as c, forEach as i, clearAll as n, getRefCount as o, register as r, getRefIds as s, clear as t };
+
+//# sourceMappingURL=management-7jLjVHJd.js.map

package/dist/management-7jLjVHJd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"management-7jLjVHJd.js","names":[],"sources":["../src/registry/queries.ts","../src/registry/management.ts"],"sourcesContent":["import { getRegistry } from './config';\nimport type {\n  ExtractArgs,\n  StateContainerConstructor,\n  InstanceReadonlyState,\n} from '../types/utilities';\n\nexport function hasInstance<T extends StateContainerConstructor>(\n  BlocClass: T,\n  opts?: { args?: ExtractArgs<T> },\n): boolean {\n  const registry = getRegistry();\n  const key = registry.resolveKey(BlocClass, undefined, opts?.args);\n  return registry.hasInstance(BlocClass, key);\n}\n\nexport function getRefCount<T extends StateContainerConstructor>(\n  BlocClass: T,\n  opts?: { args?: ExtractArgs<T> },\n): number {\n  const registry = getRegistry();\n  const key = registry.resolveKey(BlocClass, undefined, opts?.args);\n  return registry.getRefCount(BlocClass, key);\n}\n\nexport function getRefIds<T extends StateContainerConstructor>(\n  BlocClass: T,\n  opts?: { args?: ExtractArgs<T> },\n): string[] {\n  const registry = getRegistry();\n  const key = registry.resolveKey(BlocClass, undefined, opts?.args);\n  return registry.getRefIds(BlocClass, key);\n}\n\nexport function getAll<T extends StateContainerConstructor>(\n  BlocClass: T,\n): InstanceReadonlyState<T>[] {\n  return getRegistry().getAll(BlocClass);\n}\n\nexport function forEach<T extends StateContainerConstructor>(\n  BlocClass: T,\n  callback: (instance: InstanceReadonlyState<T>) => void,\n): void {\n  getRegistry().forEach(BlocClass, callback);\n}\n","import { getRegistry } from './config';\nimport type { StateContainerConstructor } from '../types/utilities';\n\nexport function clear<T extends StateContainerConstructor>(BlocClass: T): void {\n  getRegistry().clear(BlocClass);\n}\n\nexport function clearAll(): void {\n  getRegistry().clearAll();\n}\n\nexport function register<T extends StateContainerConstructor>(\n  BlocClass: T,\n): void {\n  getRegistry().register(BlocClass);\n}\n"],"mappings":";;AAOA,SAAgB,YACd,WACA,MACS;CACT,MAAM,WAAW,YAAY;CAC7B,MAAM,MAAM,SAAS,WAAW,WAAW,KAAA,GAAW,MAAM,IAAI;CAChE,OAAO,SAAS,YAAY,WAAW,GAAG;AAC5C;AAEA,SAAgB,YACd,WACA,MACQ;CACR,MAAM,WAAW,YAAY;CAC7B,MAAM,MAAM,SAAS,WAAW,WAAW,KAAA,GAAW,MAAM,IAAI;CAChE,OAAO,SAAS,YAAY,WAAW,GAAG;AAC5C;AAEA,SAAgB,UACd,WACA,MACU;CACV,MAAM,WAAW,YAAY;CAC7B,MAAM,MAAM,SAAS,WAAW,WAAW,KAAA,GAAW,MAAM,IAAI;CAChE,OAAO,SAAS,UAAU,WAAW,GAAG;AAC1C;AAEA,SAAgB,OACd,WAC4B;CAC5B,OAAO,YAAY,EAAE,OAAO,SAAS;AACvC;AAEA,SAAgB,QACd,WACA,UACM;CACN,YAAY,EAAE,QAAQ,WAAW,QAAQ;AAC3C;;;AC1CA,SAAgB,MAA2C,WAAoB;CAC7E,YAAY,EAAE,MAAM,SAAS;AAC/B;AAEA,SAAgB,WAAiB;CAC/B,YAAY,EAAE,SAAS;AACzB;AAEA,SAAgB,SACd,WACM;CACN,YAAY,EAAE,SAAS,SAAS;AAClC"}

package/dist/{management-DTzcC6aD.cjs → management-DAV9sN-k.cjs}

@@ -1,13 +1,19 @@
-const require_config = require("./config-B_4xXpvK.cjs");
+const require_config = require("./config-sCPKPYxZ.cjs");
 //#region src/registry/queries.ts
-function hasInstance(BlocClass, instanceKey) {
-	return require_config.getRegistry().hasInstance(BlocClass, instanceKey);
+function hasInstance(BlocClass, opts) {
+	const registry = require_config.getRegistry();
+	const key = registry.resolveKey(BlocClass, void 0, opts?.args);
+	return registry.hasInstance(BlocClass, key);
 }
-function getRefCount(BlocClass, instanceKey) {
-	return require_config.getRegistry().getRefCount(BlocClass, instanceKey);
+function getRefCount(BlocClass, opts) {
+	const registry = require_config.getRegistry();
+	const key = registry.resolveKey(BlocClass, void 0, opts?.args);
+	return registry.getRefCount(BlocClass, key);
 }
-function getRefIds(BlocClass, instanceKey) {
-	return require_config.getRegistry().getRefIds(BlocClass, instanceKey);
+function getRefIds(BlocClass, opts) {
+	const registry = require_config.getRegistry();
+	const key = registry.resolveKey(BlocClass, void 0, opts?.args);
+	return registry.getRefIds(BlocClass, key);
 }
 function getAll(BlocClass) {
 	return require_config.getRegistry().getAll(BlocClass);
@@ -76,4 +82,4 @@ Object.defineProperty(exports, "register", {
 	}
 });
 
-//# sourceMappingURL=management-DTzcC6aD.cjs.map
+//# sourceMappingURL=management-DAV9sN-k.cjs.map

package/dist/management-DAV9sN-k.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"management-DAV9sN-k.cjs","names":["getRegistry"],"sources":["../src/registry/queries.ts","../src/registry/management.ts"],"sourcesContent":["import { getRegistry } from './config';\nimport type {\n  ExtractArgs,\n  StateContainerConstructor,\n  InstanceReadonlyState,\n} from '../types/utilities';\n\nexport function hasInstance<T extends StateContainerConstructor>(\n  BlocClass: T,\n  opts?: { args?: ExtractArgs<T> },\n): boolean {\n  const registry = getRegistry();\n  const key = registry.resolveKey(BlocClass, undefined, opts?.args);\n  return registry.hasInstance(BlocClass, key);\n}\n\nexport function getRefCount<T extends StateContainerConstructor>(\n  BlocClass: T,\n  opts?: { args?: ExtractArgs<T> },\n): number {\n  const registry = getRegistry();\n  const key = registry.resolveKey(BlocClass, undefined, opts?.args);\n  return registry.getRefCount(BlocClass, key);\n}\n\nexport function getRefIds<T extends StateContainerConstructor>(\n  BlocClass: T,\n  opts?: { args?: ExtractArgs<T> },\n): string[] {\n  const registry = getRegistry();\n  const key = registry.resolveKey(BlocClass, undefined, opts?.args);\n  return registry.getRefIds(BlocClass, key);\n}\n\nexport function getAll<T extends StateContainerConstructor>(\n  BlocClass: T,\n): InstanceReadonlyState<T>[] {\n  return getRegistry().getAll(BlocClass);\n}\n\nexport function forEach<T extends StateContainerConstructor>(\n  BlocClass: T,\n  callback: (instance: InstanceReadonlyState<T>) => void,\n): void {\n  getRegistry().forEach(BlocClass, callback);\n}\n","import { getRegistry } from './config';\nimport type { StateContainerConstructor } from '../types/utilities';\n\nexport function clear<T extends StateContainerConstructor>(BlocClass: T): void {\n  getRegistry().clear(BlocClass);\n}\n\nexport function clearAll(): void {\n  getRegistry().clearAll();\n}\n\nexport function register<T extends StateContainerConstructor>(\n  BlocClass: T,\n): void {\n  getRegistry().register(BlocClass);\n}\n"],"mappings":";;AAOA,SAAgB,YACd,WACA,MACS;CACT,MAAM,WAAWA,eAAAA,YAAY;CAC7B,MAAM,MAAM,SAAS,WAAW,WAAW,KAAA,GAAW,MAAM,IAAI;CAChE,OAAO,SAAS,YAAY,WAAW,GAAG;AAC5C;AAEA,SAAgB,YACd,WACA,MACQ;CACR,MAAM,WAAWA,eAAAA,YAAY;CAC7B,MAAM,MAAM,SAAS,WAAW,WAAW,KAAA,GAAW,MAAM,IAAI;CAChE,OAAO,SAAS,YAAY,WAAW,GAAG;AAC5C;AAEA,SAAgB,UACd,WACA,MACU;CACV,MAAM,WAAWA,eAAAA,YAAY;CAC7B,MAAM,MAAM,SAAS,WAAW,WAAW,KAAA,GAAW,MAAM,IAAI;CAChE,OAAO,SAAS,UAAU,WAAW,GAAG;AAC1C;AAEA,SAAgB,OACd,WAC4B;CAC5B,OAAOA,eAAAA,YAAY,EAAE,OAAO,SAAS;AACvC;AAEA,SAAgB,QACd,WACA,UACM;CACN,eAAA,YAAY,EAAE,QAAQ,WAAW,QAAQ;AAC3C;;;AC1CA,SAAgB,MAA2C,WAAoB;CAC7E,eAAA,YAAY,EAAE,MAAM,SAAS;AAC/B;AAEA,SAAgB,WAAiB;CAC/B,eAAA,YAAY,EAAE,SAAS;AACzB;AAEA,SAAgB,SACd,WACM;CACN,eAAA,YAAY,EAAE,SAAS,SAAS;AAClC"}

package/dist/management-GcnNJjnm.cjs

@@ -0,0 +1,85 @@
+const require_config = require("./config-DVMnlHLv.cjs");
+//#region src/registry/queries.ts
+function hasInstance(BlocClass, opts) {
+	const registry = require_config.getRegistry();
+	const key = registry.resolveKey(BlocClass, void 0, opts?.args);
+	return registry.hasInstance(BlocClass, key);
+}
+function getRefCount(BlocClass, opts) {
+	const registry = require_config.getRegistry();
+	const key = registry.resolveKey(BlocClass, void 0, opts?.args);
+	return registry.getRefCount(BlocClass, key);
+}
+function getRefIds(BlocClass, opts) {
+	const registry = require_config.getRegistry();
+	const key = registry.resolveKey(BlocClass, void 0, opts?.args);
+	return registry.getRefIds(BlocClass, key);
+}
+function getAll(BlocClass) {
+	return require_config.getRegistry().getAll(BlocClass);
+}
+function forEach(BlocClass, callback) {
+	require_config.getRegistry().forEach(BlocClass, callback);
+}
+//#endregion
+//#region src/registry/management.ts
+function clear(BlocClass) {
+	require_config.getRegistry().clear(BlocClass);
+}
+function clearAll() {
+	require_config.getRegistry().clearAll();
+}
+function register(BlocClass) {
+	require_config.getRegistry().register(BlocClass);
+}
+//#endregion
+Object.defineProperty(exports, "clear", {
+	enumerable: true,
+	get: function() {
+		return clear;
+	}
+});
+Object.defineProperty(exports, "clearAll", {
+	enumerable: true,
+	get: function() {
+		return clearAll;
+	}
+});
+Object.defineProperty(exports, "forEach", {
+	enumerable: true,
+	get: function() {
+		return forEach;
+	}
+});
+Object.defineProperty(exports, "getAll", {
+	enumerable: true,
+	get: function() {
+		return getAll;
+	}
+});
+Object.defineProperty(exports, "getRefCount", {
+	enumerable: true,
+	get: function() {
+		return getRefCount;
+	}
+});
+Object.defineProperty(exports, "getRefIds", {
+	enumerable: true,
+	get: function() {
+		return getRefIds;
+	}
+});
+Object.defineProperty(exports, "hasInstance", {
+	enumerable: true,
+	get: function() {
+		return hasInstance;
+	}
+});
+Object.defineProperty(exports, "register", {
+	enumerable: true,
+	get: function() {
+		return register;
+	}
+});
+
+//# sourceMappingURL=management-GcnNJjnm.cjs.map

package/dist/management-GcnNJjnm.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"management-GcnNJjnm.cjs","names":["getRegistry"],"sources":["../src/registry/queries.ts","../src/registry/management.ts"],"sourcesContent":["import { getRegistry } from './config';\nimport type {\n  ExtractArgs,\n  StateContainerConstructor,\n  InstanceReadonlyState,\n} from '../types/utilities';\n\nexport function hasInstance<T extends StateContainerConstructor>(\n  BlocClass: T,\n  opts?: { args?: ExtractArgs<T> },\n): boolean {\n  const registry = getRegistry();\n  const key = registry.resolveKey(BlocClass, undefined, opts?.args);\n  return registry.hasInstance(BlocClass, key);\n}\n\nexport function getRefCount<T extends StateContainerConstructor>(\n  BlocClass: T,\n  opts?: { args?: ExtractArgs<T> },\n): number {\n  const registry = getRegistry();\n  const key = registry.resolveKey(BlocClass, undefined, opts?.args);\n  return registry.getRefCount(BlocClass, key);\n}\n\nexport function getRefIds<T extends StateContainerConstructor>(\n  BlocClass: T,\n  opts?: { args?: ExtractArgs<T> },\n): string[] {\n  const registry = getRegistry();\n  const key = registry.resolveKey(BlocClass, undefined, opts?.args);\n  return registry.getRefIds(BlocClass, key);\n}\n\nexport function getAll<T extends StateContainerConstructor>(\n  BlocClass: T,\n): InstanceReadonlyState<T>[] {\n  return getRegistry().getAll(BlocClass);\n}\n\nexport function forEach<T extends StateContainerConstructor>(\n  BlocClass: T,\n  callback: (instance: InstanceReadonlyState<T>) => void,\n): void {\n  getRegistry().forEach(BlocClass, callback);\n}\n","import { getRegistry } from './config';\nimport type { StateContainerConstructor } from '../types/utilities';\n\nexport function clear<T extends StateContainerConstructor>(BlocClass: T): void {\n  getRegistry().clear(BlocClass);\n}\n\nexport function clearAll(): void {\n  getRegistry().clearAll();\n}\n\nexport function register<T extends StateContainerConstructor>(\n  BlocClass: T,\n): void {\n  getRegistry().register(BlocClass);\n}\n"],"mappings":";;AAOA,SAAgB,YACd,WACA,MACS;CACT,MAAM,WAAWA,eAAAA,YAAY;CAC7B,MAAM,MAAM,SAAS,WAAW,WAAW,KAAA,GAAW,MAAM,IAAI;CAChE,OAAO,SAAS,YAAY,WAAW,GAAG;AAC5C;AAEA,SAAgB,YACd,WACA,MACQ;CACR,MAAM,WAAWA,eAAAA,YAAY;CAC7B,MAAM,MAAM,SAAS,WAAW,WAAW,KAAA,GAAW,MAAM,IAAI;CAChE,OAAO,SAAS,YAAY,WAAW,GAAG;AAC5C;AAEA,SAAgB,UACd,WACA,MACU;CACV,MAAM,WAAWA,eAAAA,YAAY;CAC7B,MAAM,MAAM,SAAS,WAAW,WAAW,KAAA,GAAW,MAAM,IAAI;CAChE,OAAO,SAAS,UAAU,WAAW,GAAG;AAC1C;AAEA,SAAgB,OACd,WAC4B;CAC5B,OAAOA,eAAAA,YAAY,EAAE,OAAO,SAAS;AACvC;AAEA,SAAgB,QACd,WACA,UACM;CACN,eAAA,YAAY,EAAE,QAAQ,WAAW,QAAQ;AAC3C;;;AC1CA,SAAgB,MAA2C,WAAoB;CAC7E,eAAA,YAAY,EAAE,MAAM,SAAS;AAC/B;AAEA,SAAgB,WAAiB;CAC/B,eAAA,YAAY,EAAE,SAAS;AACzB;AAEA,SAAgB,SACd,WACM;CACN,eAAA,YAAY,EAAE,SAAS,SAAS;AAClC"}

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-DJQqLrli.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-B1GYx9Xo.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';