@blac/core 2.0.15 → 2.0.17

package/dist/acquire-DHEOEVcj.cjs

@@ -0,0 +1,46 @@
+const require_config = require("./config-DVMnlHLv.cjs");
+//#region src/registry/acquire.ts
+/**
+* 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
+*/
+function acquire(BlocClass, opts) {
+	const registry = require_config.getRegistry();
+	const key = registry.resolveKey(BlocClass, void 0, opts?.args);
+	return registry.acquire(BlocClass, key, {
+		canCreate: true,
+		countRef: true,
+		refId: opts?.refId,
+		args: opts?.args
+	});
+}
+/**
+* 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.
+*/
+function resolveInstanceKey(BlocClass, args) {
+	return require_config.getRegistry().resolveKey(BlocClass, void 0, args);
+}
+//#endregion
+Object.defineProperty(exports, "acquire", {
+	enumerable: true,
+	get: function() {
+		return acquire;
+	}
+});
+Object.defineProperty(exports, "resolveInstanceKey", {
+	enumerable: true,
+	get: function() {
+		return resolveInstanceKey;
+	}
+});
+
+//# sourceMappingURL=acquire-DHEOEVcj.cjs.map

package/dist/acquire-DHEOEVcj.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"acquire-DHEOEVcj.cjs","names":["getRegistry"],"sources":["../src/registry/acquire.ts"],"sourcesContent":["import { getRegistry } from './config';\nimport type {\n  ExtractArgs,\n  StateContainerConstructor,\n} from '../types/utilities';\n\n/**\n * Acquire an instance with ref tracking (ownership semantics). Instance\n * identity is derived purely from `args` (via the class's `static key(args)`,\n * a structural hash of `args`, or the default sentinel when there are none).\n *\n * @param BlocClass - The StateContainer class constructor\n * @param opts.args - Construction/identity args; derives the instance key\n * @param opts.refId - Named reference ID for debugging; auto-generated if omitted\n */\nexport function acquire<T extends StateContainerConstructor>(\n  BlocClass: T,\n  opts?: { args?: ExtractArgs<T>; refId?: string },\n): InstanceType<T> {\n  const registry = getRegistry();\n  const key = registry.resolveKey(BlocClass, undefined, opts?.args);\n  return registry.acquire(BlocClass, key, {\n    canCreate: true,\n    countRef: true,\n    refId: opts?.refId,\n    args: opts?.args,\n  });\n}\n\n/**\n * Resolve the storage key an instance would be acquired under, given its\n * construction `args`. This is the canonical key-computation path. Callers that\n * both acquire and release against the `@internal` registry tier (e.g.\n * `@blac/react` `useBloc`) must use this once and pass the same resolved key to\n * both, so the ref is dropped under the key it was taken.\n */\nexport function resolveInstanceKey<T extends StateContainerConstructor>(\n  BlocClass: T,\n  args?: ExtractArgs<T>,\n): string {\n  return getRegistry().resolveKey(BlocClass, undefined, args);\n}\n"],"mappings":";;;;;;;;;;;AAeA,SAAgB,QACd,WACA,MACiB;CACjB,MAAM,WAAWA,eAAAA,YAAY;CAC7B,MAAM,MAAM,SAAS,WAAW,WAAW,KAAA,GAAW,MAAM,IAAI;CAChE,OAAO,SAAS,QAAQ,WAAW,KAAK;EACtC,WAAW;EACX,UAAU;EACV,OAAO,MAAM;EACb,MAAM,MAAM;CACd,CAAC;AACH;;;;;;;;AASA,SAAgB,mBACd,WACA,MACQ;CACR,OAAOA,eAAAA,YAAY,EAAE,WAAW,WAAW,KAAA,GAAW,IAAI;AAC5D"}

package/dist/acquire-Don7499S.js

@@ -0,0 +1,35 @@
+import { t as getRegistry } from "./config-8pyOC5gv.js";
+//#region src/registry/acquire.ts
+/**
+* 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
+*/
+function acquire(BlocClass, opts) {
+	const registry = getRegistry();
+	const key = registry.resolveKey(BlocClass, void 0, opts?.args);
+	return registry.acquire(BlocClass, key, {
+		canCreate: true,
+		countRef: true,
+		refId: opts?.refId,
+		args: opts?.args
+	});
+}
+/**
+* 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.
+*/
+function resolveInstanceKey(BlocClass, args) {
+	return getRegistry().resolveKey(BlocClass, void 0, args);
+}
+//#endregion
+export { resolveInstanceKey as n, acquire as t };
+
+//# sourceMappingURL=acquire-Don7499S.js.map

package/dist/acquire-Don7499S.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"acquire-Don7499S.js","names":[],"sources":["../src/registry/acquire.ts"],"sourcesContent":["import { getRegistry } from './config';\nimport type {\n  ExtractArgs,\n  StateContainerConstructor,\n} from '../types/utilities';\n\n/**\n * Acquire an instance with ref tracking (ownership semantics). Instance\n * identity is derived purely from `args` (via the class's `static key(args)`,\n * a structural hash of `args`, or the default sentinel when there are none).\n *\n * @param BlocClass - The StateContainer class constructor\n * @param opts.args - Construction/identity args; derives the instance key\n * @param opts.refId - Named reference ID for debugging; auto-generated if omitted\n */\nexport function acquire<T extends StateContainerConstructor>(\n  BlocClass: T,\n  opts?: { args?: ExtractArgs<T>; refId?: string },\n): InstanceType<T> {\n  const registry = getRegistry();\n  const key = registry.resolveKey(BlocClass, undefined, opts?.args);\n  return registry.acquire(BlocClass, key, {\n    canCreate: true,\n    countRef: true,\n    refId: opts?.refId,\n    args: opts?.args,\n  });\n}\n\n/**\n * Resolve the storage key an instance would be acquired under, given its\n * construction `args`. This is the canonical key-computation path. Callers that\n * both acquire and release against the `@internal` registry tier (e.g.\n * `@blac/react` `useBloc`) must use this once and pass the same resolved key to\n * both, so the ref is dropped under the key it was taken.\n */\nexport function resolveInstanceKey<T extends StateContainerConstructor>(\n  BlocClass: T,\n  args?: ExtractArgs<T>,\n): string {\n  return getRegistry().resolveKey(BlocClass, undefined, args);\n}\n"],"mappings":";;;;;;;;;;;AAeA,SAAgB,QACd,WACA,MACiB;CACjB,MAAM,WAAW,YAAY;CAC7B,MAAM,MAAM,SAAS,WAAW,WAAW,KAAA,GAAW,MAAM,IAAI;CAChE,OAAO,SAAS,QAAQ,WAAW,KAAK;EACtC,WAAW;EACX,UAAU;EACV,OAAO,MAAM;EACb,MAAM,MAAM;CACd,CAAC;AACH;;;;;;;;AASA,SAAgB,mBACd,WACA,MACQ;CACR,OAAO,YAAY,EAAE,WAAW,WAAW,KAAA,GAAW,IAAI;AAC5D"}

package/dist/acquire-G8aB3GAx.js

@@ -0,0 +1,35 @@
+import { t as getRegistry } from "./config-Dk1FxfXj.js";
+//#region src/registry/acquire.ts
+/**
+* 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
+*/
+function acquire(BlocClass, opts) {
+	const registry = getRegistry();
+	const key = registry.resolveKey(BlocClass, void 0, opts?.args);
+	return registry.acquire(BlocClass, key, {
+		canCreate: true,
+		countRef: true,
+		refId: opts?.refId,
+		args: opts?.args
+	});
+}
+/**
+* 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.
+*/
+function resolveInstanceKey(BlocClass, args) {
+	return getRegistry().resolveKey(BlocClass, void 0, args);
+}
+//#endregion
+export { resolveInstanceKey as n, acquire as t };
+
+//# sourceMappingURL=acquire-G8aB3GAx.js.map

package/dist/acquire-G8aB3GAx.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"acquire-G8aB3GAx.js","names":[],"sources":["../src/registry/acquire.ts"],"sourcesContent":["import { getRegistry } from './config';\nimport type {\n  ExtractArgs,\n  StateContainerConstructor,\n} from '../types/utilities';\n\n/**\n * Acquire an instance with ref tracking (ownership semantics). Instance\n * identity is derived purely from `args` (via the class's `static key(args)`,\n * a structural hash of `args`, or the default sentinel when there are none).\n *\n * @param BlocClass - The StateContainer class constructor\n * @param opts.args - Construction/identity args; derives the instance key\n * @param opts.refId - Named reference ID for debugging; auto-generated if omitted\n */\nexport function acquire<T extends StateContainerConstructor>(\n  BlocClass: T,\n  opts?: { args?: ExtractArgs<T>; refId?: string },\n): InstanceType<T> {\n  const registry = getRegistry();\n  const key = registry.resolveKey(BlocClass, undefined, opts?.args);\n  return registry.acquire(BlocClass, key, {\n    canCreate: true,\n    countRef: true,\n    refId: opts?.refId,\n    args: opts?.args,\n  });\n}\n\n/**\n * Resolve the storage key an instance would be acquired under, given its\n * construction `args`. This is the canonical key-computation path. Callers that\n * both acquire and release against the `@internal` registry tier (e.g.\n * `@blac/react` `useBloc`) must use this once and pass the same resolved key to\n * both, so the ref is dropped under the key it was taken.\n */\nexport function resolveInstanceKey<T extends StateContainerConstructor>(\n  BlocClass: T,\n  args?: ExtractArgs<T>,\n): string {\n  return getRegistry().resolveKey(BlocClass, undefined, args);\n}\n"],"mappings":";;;;;;;;;;;AAeA,SAAgB,QACd,WACA,MACiB;CACjB,MAAM,WAAW,YAAY;CAC7B,MAAM,MAAM,SAAS,WAAW,WAAW,KAAA,GAAW,MAAM,IAAI;CAChE,OAAO,SAAS,QAAQ,WAAW,KAAK;EACtC,WAAW;EACX,UAAU;EACV,OAAO,MAAM;EACb,MAAM,MAAM;CACd,CAAC;AACH;;;;;;;;AASA,SAAgB,mBACd,WACA,MACQ;CACR,OAAO,YAAY,EAAE,WAAW,WAAW,KAAA,GAAW,IAAI;AAC5D"}

package/dist/{branded-BSeA_mZO.cjs → branded-BybA0_xw.cjs}

@@ -15,4 +15,4 @@ Object.defineProperty(exports, "instanceId", {
 	}
 });
 
-//# sourceMappingURL=branded-BSeA_mZO.cjs.map
+//# sourceMappingURL=branded-BybA0_xw.cjs.map

package/dist/{branded-BSeA_mZO.cjs.map → branded-BybA0_xw.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"branded-BSeA_mZO.cjs","names":[],"sources":["../src/types/branded.ts"],"sourcesContent":["declare const brand: unique symbol;\n\n/**\n * Utility type for creating branded/nominal types.\n * Prevents accidental type confusion between similar primitive types.\n * @template T - The base type\n * @template B - The brand identifier\n */\nexport type Brand<T, B> = T & { [brand]: B };\n\n/**\n * Branded string type for type-safe IDs.\n * @template B - The brand identifier\n */\nexport type BrandedId<B> = Brand<string, B>;\n\n/**\n * Branded string type for state container instance IDs\n */\nexport type InstanceId = Brand<string, 'InstanceId'>;\n\n/**\n * Create a branded InstanceId from a string\n * @param id - The string ID to brand\n * @returns Branded InstanceId\n */\nexport function instanceId(id: string): InstanceId {\n  return id as InstanceId;\n}\n"],"mappings":";;;;;;AA0BA,SAAgB,WAAW,IAAwB;CACjD,OAAO"}
+{"version":3,"file":"branded-BybA0_xw.cjs","names":[],"sources":["../src/types/branded.ts"],"sourcesContent":["declare const brand: unique symbol;\n\n/**\n * Utility type for creating branded/nominal types.\n * Prevents accidental type confusion between similar primitive types.\n * @template T - The base type\n * @template B - The brand identifier\n */\nexport type Brand<T, B> = T & { [brand]: B };\n\n/**\n * Branded string type for type-safe IDs.\n * @template B - The brand identifier\n */\nexport type BrandedId<B> = Brand<string, B>;\n\n/**\n * Branded string type for state container instance IDs\n */\nexport type InstanceId = Brand<string, 'InstanceId'>;\n\n/**\n * Create a branded InstanceId from a string\n * @param id - The string ID to brand\n * @returns Branded InstanceId\n */\nexport function instanceId(id: string): InstanceId {\n  return id as InstanceId;\n}\n"],"mappings":";;;;;;AA0BA,SAAgB,WAAW,IAAwB;CACjD,OAAO;AACT"}

package/dist/{branded-DwtzSsg0.js → branded-DkbUzncc.js}

@@ -10,4 +10,4 @@ function instanceId(id) {
 //#endregion
 export { instanceId as t };
 
-//# sourceMappingURL=branded-DwtzSsg0.js.map
+//# sourceMappingURL=branded-DkbUzncc.js.map

package/dist/{branded-DwtzSsg0.js.map → branded-DkbUzncc.js.map}

@@ -1 +1 @@
-{"version":3,"file":"branded-DwtzSsg0.js","names":[],"sources":["../src/types/branded.ts"],"sourcesContent":["declare const brand: unique symbol;\n\n/**\n * Utility type for creating branded/nominal types.\n * Prevents accidental type confusion between similar primitive types.\n * @template T - The base type\n * @template B - The brand identifier\n */\nexport type Brand<T, B> = T & { [brand]: B };\n\n/**\n * Branded string type for type-safe IDs.\n * @template B - The brand identifier\n */\nexport type BrandedId<B> = Brand<string, B>;\n\n/**\n * Branded string type for state container instance IDs\n */\nexport type InstanceId = Brand<string, 'InstanceId'>;\n\n/**\n * Create a branded InstanceId from a string\n * @param id - The string ID to brand\n * @returns Branded InstanceId\n */\nexport function instanceId(id: string): InstanceId {\n  return id as InstanceId;\n}\n"],"mappings":";;;;;;AA0BA,SAAgB,WAAW,IAAwB;CACjD,OAAO"}
+{"version":3,"file":"branded-DkbUzncc.js","names":[],"sources":["../src/types/branded.ts"],"sourcesContent":["declare const brand: unique symbol;\n\n/**\n * Utility type for creating branded/nominal types.\n * Prevents accidental type confusion between similar primitive types.\n * @template T - The base type\n * @template B - The brand identifier\n */\nexport type Brand<T, B> = T & { [brand]: B };\n\n/**\n * Branded string type for type-safe IDs.\n * @template B - The brand identifier\n */\nexport type BrandedId<B> = Brand<string, B>;\n\n/**\n * Branded string type for state container instance IDs\n */\nexport type InstanceId = Brand<string, 'InstanceId'>;\n\n/**\n * Create a branded InstanceId from a string\n * @param id - The string ID to brand\n * @returns Branded InstanceId\n */\nexport function instanceId(id: string): InstanceId {\n  return id as InstanceId;\n}\n"],"mappings":";;;;;;AA0BA,SAAgB,WAAW,IAAwB;CACjD,OAAO;AACT"}

package/dist/{config-DoHx0Xsl.js → config-8pyOC5gv.js}

@@ -1,4 +1,4 @@
-import { r as globalRegistry } from "./StateContainerRegistry-DmmzYa7S.js";
+import { r as globalRegistry } from "./StateContainerRegistry-B_ViBLvJ.js";
 //#region src/registry/config.ts
 let _registry = globalRegistry;
 function getRegistry() {
@@ -13,4 +13,4 @@ function getStats() {
 //#endregion
 export { getStats as n, setRegistry as r, getRegistry as t };
 
-//# sourceMappingURL=config-DoHx0Xsl.js.map
+//# sourceMappingURL=config-8pyOC5gv.js.map

package/dist/{config-0ZD9i3wy.js.map → config-8pyOC5gv.js.map}

@@ -1 +1 @@
-{"version":3,"file":"config-0ZD9i3wy.js","names":[],"sources":["../src/registry/config.ts"],"sourcesContent":["import {\n  globalRegistry,\n  StateContainerRegistry,\n} from '../core/StateContainerRegistry';\n\nlet _registry = globalRegistry;\n\nexport function getRegistry(): StateContainerRegistry {\n  return _registry;\n}\n\nexport function setRegistry(registry: StateContainerRegistry): void {\n  _registry = registry;\n}\n\nexport function getStats(): {\n  registeredTypes: number;\n  totalInstances: number;\n  typeBreakdown: Record<string, number>;\n} {\n  return _registry.getStats();\n}\n"],"mappings":";;AAKA,IAAI,YAAY;AAEhB,SAAgB,cAAsC;AACpD,QAAO;;AAGT,SAAgB,YAAY,UAAwC;AAClE,aAAY;;AAGd,SAAgB,WAId;AACA,QAAO,UAAU,UAAU"}
+{"version":3,"file":"config-8pyOC5gv.js","names":[],"sources":["../src/registry/config.ts"],"sourcesContent":["import {\n  globalRegistry,\n  StateContainerRegistry,\n} from '../core/StateContainerRegistry';\n\nlet _registry = globalRegistry;\n\nexport function getRegistry(): StateContainerRegistry {\n  return _registry;\n}\n\nexport function setRegistry(registry: StateContainerRegistry): void {\n  _registry = registry;\n}\n\nexport function getStats(): {\n  registeredTypes: number;\n  totalInstances: number;\n  typeBreakdown: Record<string, number>;\n} {\n  return _registry.getStats();\n}\n"],"mappings":";;AAKA,IAAI,YAAY;AAEhB,SAAgB,cAAsC;CACpD,OAAO;AACT;AAEA,SAAgB,YAAY,UAAwC;CAClE,YAAY;AACd;AAEA,SAAgB,WAId;CACA,OAAO,UAAU,SAAS;AAC5B"}

package/dist/{config-B_4xXpvK.cjs → config-DVMnlHLv.cjs}

@@ -1,5 +1,5 @@
 //#region src/registry/config.ts
-let _registry = require("./StateContainerRegistry-B4yVMYbx.cjs").globalRegistry;
+let _registry = require("./StateContainerRegistry-FWKzPfS-.cjs").globalRegistry;
 function getRegistry() {
 	return _registry;
 }
@@ -29,4 +29,4 @@ Object.defineProperty(exports, "setRegistry", {
 	}
 });
 
-//# sourceMappingURL=config-B_4xXpvK.cjs.map
+//# sourceMappingURL=config-DVMnlHLv.cjs.map

package/dist/{config-B3NIwDQv.cjs.map → config-DVMnlHLv.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"config-B3NIwDQv.cjs","names":["globalRegistry"],"sources":["../src/registry/config.ts"],"sourcesContent":["import {\n  globalRegistry,\n  StateContainerRegistry,\n} from '../core/StateContainerRegistry';\n\nlet _registry = globalRegistry;\n\nexport function getRegistry(): StateContainerRegistry {\n  return _registry;\n}\n\nexport function setRegistry(registry: StateContainerRegistry): void {\n  _registry = registry;\n}\n\nexport function getStats(): {\n  registeredTypes: number;\n  totalInstances: number;\n  typeBreakdown: Record<string, number>;\n} {\n  return _registry.getStats();\n}\n"],"mappings":";AAKA,IAAI,6DAAYA;AAEhB,SAAgB,cAAsC;AACpD,QAAO;;AAGT,SAAgB,YAAY,UAAwC;AAClE,aAAY;;AAGd,SAAgB,WAId;AACA,QAAO,UAAU,UAAU"}
+{"version":3,"file":"config-DVMnlHLv.cjs","names":["globalRegistry"],"sources":["../src/registry/config.ts"],"sourcesContent":["import {\n  globalRegistry,\n  StateContainerRegistry,\n} from '../core/StateContainerRegistry';\n\nlet _registry = globalRegistry;\n\nexport function getRegistry(): StateContainerRegistry {\n  return _registry;\n}\n\nexport function setRegistry(registry: StateContainerRegistry): void {\n  _registry = registry;\n}\n\nexport function getStats(): {\n  registeredTypes: number;\n  totalInstances: number;\n  typeBreakdown: Record<string, number>;\n} {\n  return _registry.getStats();\n}\n"],"mappings":";AAKA,IAAI,2DAAYA,EAAAA;AAEhB,SAAgB,cAAsC;CACpD,OAAO;AACT;AAEA,SAAgB,YAAY,UAAwC;CAClE,YAAY;AACd;AAEA,SAAgB,WAId;CACA,OAAO,UAAU,SAAS;AAC5B"}

package/dist/{config-C8xqVHTf.js → config-Dk1FxfXj.js}

@@ -1,16 +1,16 @@
-import { r as globalRegistry } from './StateContainerRegistry-WznfcA-Q.js';
+import { r as globalRegistry } from "./StateContainerRegistry-B1GYx9Xo.js";
 //#region src/registry/config.ts
 let _registry = globalRegistry;
 function getRegistry() {
-  return _registry;
+	return _registry;
 }
 function setRegistry(registry) {
-  _registry = registry;
+	_registry = registry;
 }
 function getStats() {
-  return _registry.getStats();
+	return _registry.getStats();
 }
 //#endregion
 export { getStats as n, setRegistry as r, getRegistry as t };
 
-//# sourceMappingURL=config-C8xqVHTf.js.map
+//# sourceMappingURL=config-Dk1FxfXj.js.map

package/dist/{config-BKGHop0V.js.map → config-Dk1FxfXj.js.map}

@@ -1 +1 @@
-{"version":3,"file":"config-BKGHop0V.js","names":[],"sources":["../src/registry/config.ts"],"sourcesContent":["import {\n  globalRegistry,\n  StateContainerRegistry,\n} from '../core/StateContainerRegistry';\n\nlet _registry = globalRegistry;\n\nexport function getRegistry(): StateContainerRegistry {\n  return _registry;\n}\n\nexport function setRegistry(registry: StateContainerRegistry): void {\n  _registry = registry;\n}\n\nexport function getStats(): {\n  registeredTypes: number;\n  totalInstances: number;\n  typeBreakdown: Record<string, number>;\n} {\n  return _registry.getStats();\n}\n"],"mappings":";;AAKA,IAAI,YAAY;AAEhB,SAAgB,cAAsC;AACpD,QAAO;;AAGT,SAAgB,YAAY,UAAwC;AAClE,aAAY;;AAGd,SAAgB,WAId;AACA,QAAO,UAAU,UAAU"}
+{"version":3,"file":"config-Dk1FxfXj.js","names":[],"sources":["../src/registry/config.ts"],"sourcesContent":["import {\n  globalRegistry,\n  StateContainerRegistry,\n} from '../core/StateContainerRegistry';\n\nlet _registry = globalRegistry;\n\nexport function getRegistry(): StateContainerRegistry {\n  return _registry;\n}\n\nexport function setRegistry(registry: StateContainerRegistry): void {\n  _registry = registry;\n}\n\nexport function getStats(): {\n  registeredTypes: number;\n  totalInstances: number;\n  typeBreakdown: Record<string, number>;\n} {\n  return _registry.getStats();\n}\n"],"mappings":";;AAKA,IAAI,YAAY;AAEhB,SAAgB,cAAsC;CACpD,OAAO;AACT;AAEA,SAAgB,YAAY,UAAwC;CAClE,YAAY;AACd;AAEA,SAAgB,WAId;CACA,OAAO,UAAU,SAAS;AAC5B"}

package/dist/config-sCPKPYxZ.cjs

@@ -0,0 +1,32 @@
+//#region src/registry/config.ts
+let _registry = require("./StateContainerRegistry-DJQqLrli.cjs").globalRegistry;
+function getRegistry() {
+	return _registry;
+}
+function setRegistry(registry) {
+	_registry = registry;
+}
+function getStats() {
+	return _registry.getStats();
+}
+//#endregion
+Object.defineProperty(exports, "getRegistry", {
+	enumerable: true,
+	get: function() {
+		return getRegistry;
+	}
+});
+Object.defineProperty(exports, "getStats", {
+	enumerable: true,
+	get: function() {
+		return getStats;
+	}
+});
+Object.defineProperty(exports, "setRegistry", {
+	enumerable: true,
+	get: function() {
+		return setRegistry;
+	}
+});
+
+//# sourceMappingURL=config-sCPKPYxZ.cjs.map

package/dist/{config-BPj08-8h.cjs.map → config-sCPKPYxZ.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"config-BPj08-8h.cjs","names":["globalRegistry"],"sources":["../src/registry/config.ts"],"sourcesContent":["import {\n  globalRegistry,\n  StateContainerRegistry,\n} from '../core/StateContainerRegistry';\n\nlet _registry = globalRegistry;\n\nexport function getRegistry(): StateContainerRegistry {\n  return _registry;\n}\n\nexport function setRegistry(registry: StateContainerRegistry): void {\n  _registry = registry;\n}\n\nexport function getStats(): {\n  registeredTypes: number;\n  totalInstances: number;\n  typeBreakdown: Record<string, number>;\n} {\n  return _registry.getStats();\n}\n"],"mappings":";AAKA,IAAI,6DAAYA;AAEhB,SAAgB,cAAsC;AACpD,QAAO;;AAGT,SAAgB,YAAY,UAAwC;AAClE,aAAY;;AAGd,SAAgB,WAId;AACA,QAAO,UAAU,UAAU"}
+{"version":3,"file":"config-sCPKPYxZ.cjs","names":["globalRegistry"],"sources":["../src/registry/config.ts"],"sourcesContent":["import {\n  globalRegistry,\n  StateContainerRegistry,\n} from '../core/StateContainerRegistry';\n\nlet _registry = globalRegistry;\n\nexport function getRegistry(): StateContainerRegistry {\n  return _registry;\n}\n\nexport function setRegistry(registry: StateContainerRegistry): void {\n  _registry = registry;\n}\n\nexport function getStats(): {\n  registeredTypes: number;\n  totalInstances: number;\n  typeBreakdown: Record<string, number>;\n} {\n  return _registry.getStats();\n}\n"],"mappings":";AAKA,IAAI,2DAAYA,EAAAA;AAEhB,SAAgB,cAAsC;CACpD,OAAO;AACT;AAEA,SAAgB,YAAY,UAAwC;CAClE,YAAY;AACd;AAEA,SAAgB,WAId;CACA,OAAO,UAAU,SAAS;AAC5B"}

package/dist/constants.d.cts

@@ -29,11 +29,6 @@ export declare const BLAC_STATIC_PROPS: {
      * Exclude a bloc from DevTools reporting (prevents infinite loops)
      */
     readonly EXCLUDE_FROM_DEVTOOLS: "__excludeFromDevTools";
-    /**
-     * Mark a bloc so each `useBloc` call site gets its own per-mount instance.
-     * The React adapter auto-keys via `useId()` when this is set.
-     */
-    readonly ISOLATED: "isolated";
     /**
      * Per-class equality function used to short-circuit `emit`/`patch` when the
      * new state is structurally equal to the previous state. Falls back to the

package/dist/constants.d.ts

@@ -29,11 +29,6 @@ export declare const BLAC_STATIC_PROPS: {
      * Exclude a bloc from DevTools reporting (prevents infinite loops)
      */
     readonly EXCLUDE_FROM_DEVTOOLS: "__excludeFromDevTools";
-    /**
-     * Mark a bloc so each `useBloc` call site gets its own per-mount instance.
-     * The React adapter auto-keys via `useId()` when this is set.
-     */
-    readonly ISOLATED: "isolated";
     /**
      * Per-class equality function used to short-circuit `emit`/`patch` when the
      * new state is structurally equal to the previous state. Falls back to the

package/dist/core/StateContainer.d.ts

@@ -1,6 +1,42 @@
 import { StructuralContainer, type DeepPartial, type StructuralContainerOptions } from '@dirtytalk/structural';
-import type { StateContainerConstructor } from '../types/utilities';
+import type { ExtractArgs, ExtractState, StateContainerConstructor } from '../types/utilities';
 import { APPLY_DEPS, EMIT, REMOVE_DEPS_OWNER } from './symbols';
+/**
+ * Brand symbol carried (non-enumerable) on every handle returned by
+ * `depend()`. Framework adapters (`@blac/react`) use this to detect handles
+ * inside a tracked-proxy and swap in a session-bound wrapper.
+ *
+ * @internal — exported for `@blac/react`; not part of the public API.
+ */
+export declare const DEP_BRAND: unique symbol;
+/**
+ * Per-access options for a {@link DepHandle}. `args` resolves the specific dep
+ * instance for this call; omit it to fall back to the default args passed to
+ * `depend()`. Args resolve at call time so they can derive from current state.
+ */
+export interface DepAccessOptions<T extends StateContainerConstructor> {
+    args?: ExtractArgs<T>;
+}
+/**
+ * Branded handle returned by `StateContainer.depend()`. Two intention-revealing
+ * accessors, no callable surface:
+ *
+ * - `handle.track(options?)` — base impl: returns `[instance.state, instance]`
+ *   live with no subscription. The React layer replaces `.track()` per-consumer
+ *   so that cross-bloc state changes trigger re-renders of the reading component.
+ * - `handle.untracked(options?)` — returns the live dep instance with no
+ *   tracking. Use for imperative calls (`.untracked().doThing()`) and one-off
+ *   state reads that should not subscribe the reader.
+ * - `handle[DEP_BRAND]` — carries `{ Type, defaultArgs }` for framework use.
+ */
+export interface DepHandle<T extends StateContainerConstructor> {
+    track(options?: DepAccessOptions<T>): [ExtractState<T>, InstanceType<T>];
+    untracked(options?: DepAccessOptions<T>): InstanceType<T>;
+    readonly [DEP_BRAND]: {
+        Type: T;
+        defaultArgs?: ExtractArgs<T>;
+    };
+}
 export interface StateContainerConfig {
     name?: string;
     debug?: boolean;
@@ -101,17 +137,22 @@ export declare abstract class StateContainer<S extends object = any, Args = void
     get dependencies(): ReadonlyMap<StateContainerConstructor, string>;
     get args(): Args | undefined;
     /**
-     * Declare a cross-bloc dependency. Returns a getter so callers write
-     * `this.user()` lazily — the dep is resolved against the registry on each
-     * call, which keeps the surface immune to dep-instance churn.
+     * Declare a cross-bloc dependency. Returns a branded handle with two
+     * accessors — the dep instance is resolved against the registry on each call,
+     * which keeps the surface immune to dep-instance churn:
+     *
+     * - `handle.track(options?)` — reactive read. Returns `[state, instance]`.
+     *   Inside a getter reached through the React proxy this subscribes the
+     *   reading component to the dep's changes (base impl: live, no subscription).
+     * - `handle.untracked(options?)` — returns the live instance with no tracking,
+     *   for imperative method calls and one-off reads.
      *
-     * Note: this does NOT auto-resubscribe to the dep's channel. Consumers that
-     * need reactive updates from a dep should subscribe explicitly (typically
-     * via the framework adapter / `useBloc`'s tracker). A naive auto-bridge
-     * here would cycle on mutual deps; the channel's same-tick coalescing
-     * limits the blast radius but a true mutual cycle is still a user bug.
+     * `defaultArgs` resolves the dep instance when an accessor is called without
+     * its own `args`; per-call `options.args` overrides it and can derive from
+     * current state. This does NOT auto-resubscribe outside the React proxy;
+     * non-React consumers needing updates should subscribe explicitly.
      */
-    protected depend<T extends StateContainerConstructor>(Type: T, instanceKey?: string): () => InstanceType<T>;
+    protected depend<T extends StateContainerConstructor>(Type: T, defaultArgs?: ExtractArgs<T>): DepHandle<T>;
     constructor(initialState: S, options?: StructuralContainerOptions);
     /**
      * Called once after construction with the args passed at acquire time, before the first

package/dist/core/StateContainerRegistry.d.ts

@@ -103,15 +103,18 @@ export declare class StateContainerRegistry {
      * Acquire an instance with ref tracking (ownership semantics).
      * Creates a new instance if one doesn't exist, or returns existing and adds a ref.
      * You must call `release()` with the same refId when done.
+     *
+     * @internal Internal key tier. Public callers use the args-based `acquire`
+     *   wrapper; `useBloc`/`compat`/`watch` address a pre-resolved key here.
      * @param Type - The StateContainer class constructor
-     * @param instanceKey - Instance key (defaults to 'default')
+     * @param instanceKey - Pre-resolved instance key (defaults to 'default')
      * @param options - Acquisition options
      * @param options.canCreate - Whether to create new instance if not found (default: true)
      * @param options.countRef - Whether to add a reference (default: true)
      * @param options.refId - Named reference ID for debugging; auto-generated if omitted
      * @returns The state container instance
      */
-    acquire<T extends StateContainerConstructor = StateContainerConstructor>(Type: T, instanceKey?: string | undefined, options?: {
+    acquire<T extends StateContainerConstructor = StateContainerConstructor>(Type: T, instanceKey?: string, options?: {
         canCreate?: boolean;
         countRef?: boolean;
         refId?: string;
@@ -120,8 +123,10 @@ export declare class StateContainerRegistry {
     /**
      * Borrow an existing instance without adding a ref (borrowing semantics).
      * Tracks cross-bloc dependency for reactive updates.
+     *
+     * @internal Internal key tier; public callers use the args-based `borrow`.
      * @param Type - The StateContainer class constructor
-     * @param instanceKey - Instance key (defaults to 'default')
+     * @param instanceKey - Pre-resolved instance key (defaults to 'default')
      * @returns The state container instance
      * @throws Error if instance doesn't exist
      */
@@ -129,8 +134,10 @@ export declare class StateContainerRegistry {
     /**
      * Safely borrow an existing instance (borrowing semantics with error handling).
      * Returns discriminated union for type-safe conditional access.
+     *
+     * @internal Internal key tier; public callers use the args-based `borrowSafe`.
      * @param Type - The StateContainer class constructor
-     * @param instanceKey - Instance key (defaults to 'default')
+     * @param instanceKey - Pre-resolved instance key (defaults to 'default')
      * @returns Discriminated union with either the instance or an error
      */
     borrowSafe<T extends StateContainerConstructor = StateContainerConstructor>(Type: T, instanceKey?: string): {
@@ -147,19 +154,23 @@ export declare class StateContainerRegistry {
      *
      * Use this in bloc-to-bloc communication when you need to ensure an instance exists
      * but don't want to claim ownership (no ref added).
+     *
+     * @internal Internal key tier; public callers use the args-based `ensure`.
      * @param Type - The StateContainer class constructor
-     * @param instanceKey - Explicit instance key, or undefined to derive from `args`
+     * @param instanceKey - Pre-resolved instance key, or undefined to derive from `args`
      *   (`static key(args)` / structural hash), matching `acquire`.
      * @param args - Construction args; used for keying when no explicit key is given
      * @returns The state container instance
      */
-    ensure<T extends StateContainerConstructor = StateContainerConstructor>(Type: T, instanceKey?: string | undefined, args?: unknown): InstanceType<T>;
+    ensure<T extends StateContainerConstructor = StateContainerConstructor>(Type: T, instanceKey?: string, args?: unknown): InstanceType<T>;
     /**
      * Release a reference to an instance.
      * Removes the ref and disposes when refs is empty (unless keepAlive).
      * Releasing an already-removed refId is a no-op (idempotent).
+     *
+     * @internal Internal key tier; public callers use the args-based `release`.
      * @param Type - The StateContainer class constructor
-     * @param instanceKey - Instance key (defaults to 'default')
+     * @param instanceKey - Pre-resolved instance key (defaults to 'default')
      * @param forceDispose - Force immediate disposal regardless of refs
      * @param refId - The specific ref to remove; removes one arbitrary ref if omitted
      */
@@ -184,22 +195,28 @@ export declare class StateContainerRegistry {
     clear<T extends StateContainerConstructor>(Type: T): void;
     /**
      * Get reference count for an instance (number of active refs).
+     *
+     * @internal Internal key tier; public callers use the args-based `getRefCount`.
      * @param Type - The StateContainer class constructor
-     * @param instanceKey - Instance key (defaults to 'default')
+     * @param instanceKey - Pre-resolved instance key (defaults to 'default')
      * @returns Current ref count (0 if instance doesn't exist)
      */
     getRefCount<T extends StateContainerConstructor>(Type: T, instanceKey?: string): number;
     /**
      * Get all active reference IDs for an instance.
+     *
+     * @internal Internal key tier; public callers use the args-based `getRefIds`.
      * @param Type - The StateContainer class constructor
-     * @param instanceKey - Instance key (defaults to 'default')
+     * @param instanceKey - Pre-resolved instance key (defaults to 'default')
      * @returns Array of ref ID strings (empty if instance doesn't exist)
      */
     getRefIds<T extends StateContainerConstructor>(Type: T, instanceKey?: string): string[];
     /**
      * Check if an instance exists.
+     *
+     * @internal Internal key tier; public callers use the args-based `hasInstance`.
      * @param Type - The StateContainer class constructor
-     * @param instanceKey - Instance key (defaults to 'default')
+     * @param instanceKey - Pre-resolved instance key (defaults to 'default')
      * @returns true if instance exists
      */
     hasInstance<T extends StateContainerConstructor>(Type: T, instanceKey?: string): boolean;

package/dist/debug.cjs

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

package/dist/debug.js

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

package/dist/{Cubit-CWP8Ddzx.cjs → ensure-CLQEx0Nn.cjs}

@@ -1,5 +1,5 @@
-const require_StateContainerRegistry = require("./StateContainerRegistry-B4yVMYbx.cjs");
-const require_config = require("./config-B_4xXpvK.cjs");
+const require_StateContainerRegistry = require("./StateContainerRegistry-FWKzPfS-.cjs");
+const require_config = require("./config-DVMnlHLv.cjs");
 let _dirtytalk_structural = require("@dirtytalk/structural");
 //#region src/utils/idGenerator.ts
 /**
@@ -155,10 +155,11 @@ var StateContainer = class extends _dirtytalk_structural.StructuralContainer {
 	* here would cycle on mutual deps; the channel's same-tick coalescing
 	* limits the blast radius but a true mutual cycle is still a user bug.
 	*/
-	depend(Type, instanceKey) {
+	depend(Type, args) {
 		if (!this._dependencies) this._dependencies = /* @__PURE__ */ new Map();
-		this._dependencies.set(Type, instanceKey ?? require_StateContainerRegistry.BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY);
-		return () => this._registry.ensure(Type, instanceKey);
+		const key = this._registry.resolveKey(Type, void 0, args);
+		this._dependencies.set(Type, key);
+		return () => this._registry.ensure(Type, key, args);
 	}
 	constructor(initialState, options) {
 		super(initialState, options);
@@ -476,6 +477,17 @@ var StateContainer = class extends _dirtytalk_structural.StructuralContainer {
 */
 var Cubit = class extends StateContainer {};
 //#endregion
+//#region src/registry/ensure.ts
+/**
+* Ensure an instance exists without taking ownership (no ref added). Instance
+* identity is derived purely from `args`, matching `acquire`.
+*/
+function ensure(BlocClass, opts) {
+	const registry = require_config.getRegistry();
+	const key = registry.resolveKey(BlocClass, void 0, opts?.args);
+	return registry.ensure(BlocClass, key, opts?.args);
+}
+//#endregion
 Object.defineProperty(exports, "APPLY_DEPS", {
 	enumerable: true,
 	get: function() {
@@ -506,5 +518,11 @@ Object.defineProperty(exports, "StateContainer", {
 		return StateContainer;
 	}
 });
+Object.defineProperty(exports, "ensure", {
+	enumerable: true,
+	get: function() {
+		return ensure;
+	}
+});
 
-//# sourceMappingURL=Cubit-CWP8Ddzx.cjs.map
+//# sourceMappingURL=ensure-CLQEx0Nn.cjs.map