@blac/core 2.1.0 → 2.1.1

package/dist/acquire-C4WAS13G.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"acquire-C4WAS13G.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-C7beGI55.cjs

@@ -1,46 +0,0 @@
-const require_config = require("./config-hWTayX76.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-C7beGI55.cjs.map

package/dist/acquire-C7beGI55.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"acquire-C7beGI55.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-CE0uq0Dx.cjs

@@ -1,46 +0,0 @@
-const require_config = require("./config-D34BkraU.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-CE0uq0Dx.cjs.map

package/dist/acquire-CE0uq0Dx.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"acquire-CE0uq0Dx.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-CU0u8BMn.js

@@ -1,35 +0,0 @@
-import { t as getRegistry } from "./config-D2A8ZYRM.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-CU0u8BMn.js.map

package/dist/acquire-CU0u8BMn.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"acquire-CU0u8BMn.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-CbMz7gWs.cjs

@@ -1,46 +0,0 @@
-const require_config = require("./config-sCPKPYxZ.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-CbMz7gWs.cjs.map

package/dist/acquire-CbMz7gWs.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"acquire-CbMz7gWs.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-CkgLJ8WL.cjs

@@ -1,46 +0,0 @@
-const require_config = require("./config-C1T6Jw7n.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-CkgLJ8WL.cjs.map

package/dist/acquire-CkgLJ8WL.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"acquire-CkgLJ8WL.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-CwB083au.js

@@ -1,35 +0,0 @@
-import { t as getRegistry } from "./config-COT4Xkbc.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-CwB083au.js.map

package/dist/acquire-CwB083au.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"acquire-CwB083au.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-DHEOEVcj.cjs

@@ -1,46 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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-DTvfYJ0y.js

@@ -1,35 +0,0 @@
-import { t as getRegistry } from "./config-ZVy_yFZ3.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-DTvfYJ0y.js.map

package/dist/acquire-DTvfYJ0y.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"acquire-DTvfYJ0y.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-DXEQDZGr.js

@@ -1,35 +0,0 @@
-import { t as getRegistry } from "./config-D6BoWWPv.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-DXEQDZGr.js.map

package/dist/acquire-DXEQDZGr.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"acquire-DXEQDZGr.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-Dg-uXwjF.js

@@ -1,35 +0,0 @@
-import { t as getRegistry } from "./config-DVM_ESQt.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-Dg-uXwjF.js.map

package/dist/acquire-Dg-uXwjF.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"acquire-Dg-uXwjF.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-Don7499S.js

@@ -1,35 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,35 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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-BybA0_xw.cjs

@@ -1,18 +0,0 @@
-//#region src/types/branded.ts
-/**
-* Create a branded InstanceId from a string
-* @param id - The string ID to brand
-* @returns Branded InstanceId
-*/
-function instanceId(id) {
-	return id;
-}
-//#endregion
-Object.defineProperty(exports, "instanceId", {
-	enumerable: true,
-	get: function() {
-		return instanceId;
-	}
-});
-
-//# sourceMappingURL=branded-BybA0_xw.cjs.map

package/dist/branded-BybA0_xw.cjs.map

@@ -1 +0,0 @@
-{"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-DkbUzncc.js

@@ -1,13 +0,0 @@
-//#region src/types/branded.ts
-/**
-* Create a branded InstanceId from a string
-* @param id - The string ID to brand
-* @returns Branded InstanceId
-*/
-function instanceId(id) {
-	return id;
-}
-//#endregion
-export { instanceId as t };
-
-//# sourceMappingURL=branded-DkbUzncc.js.map

package/dist/branded-DkbUzncc.js.map

@@ -1 +0,0 @@
-{"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-8pyOC5gv.js

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