@blac/core 2.0.22 → 2.1.1

package/dist/index.js

@@ -1,6 +1,33 @@
-import { _ as resetBlacConfig, a as ON_DISPOSE, c as WITH_TRACKED_STATE, d as isExcludedFromDevTools, f as isKeepAliveClass, g as getBlacConfig, h as configureBlac, i as INIT_CONFIG, l as getBlacName, n as globalRegistry, o as REMOVE_DEPS_OWNER, p as BLAC_STATIC_PROPS, r as APPLY_DEPS, t as StateContainerRegistry, v as shallowEqualState } from "./StateContainerRegistry-BsH_s0pJ.js";
-import { a as DEP_BRAND, c as getStats, i as Cubit, l as setRegistry, n as acquire, o as StateContainer, r as resolveInstanceKey, s as getRegistry, t as ensure } from "./ensure-CneMkpbI.js";
+import { _ as configureBlac, b as shallowEqualState, f as isExcludedFromDevTools, m as BLAC_STATIC_PROPS, n as globalRegistry, o as ON_DISPOSE, p as isKeepAliveClass, t as StateContainerRegistry, u as getBlacName, v as getBlacConfig, y as resetBlacConfig } from "./StateContainerRegistry-gQbEutkN.js";
+import { a as getStats, i as getRegistry, n as StateContainer, o as setRegistry } from "./StateContainer-Bh2ipNYj.js";
+import { n as acquire, r as resolveInstanceKey, t as ensure } from "./ensure-Bi_yXk6f.js";
 import { ALL_PATHS, ALL_PATHS as ALL_PATHS$1 } from "@dirtytalk/structural";
+//#region src/core/Cubit.ts
+/**
+* `Cubit<S>` is a `StateContainer<S>` that exposes mutation publicly.
+*
+* That is the whole difference, and it is a real one: on `StateContainer`
+* `emit` / `patch` / `update` are `protected`, so a container mutates itself
+* from its own methods and callers go through the API it chooses to publish.
+* `Cubit` re-declares the three as `public` for the cases where a caller
+* legitimately drives state from outside — test helpers, devtools
+* time-travel, benchmarks.
+*
+* Reach for `StateContainer` when business logic should live in the class,
+* and `Cubit` when the caller owns the transitions.
+*/
+var Cubit = class extends StateContainer {
+	emit(next) {
+		super.emit(next);
+	}
+	patch(partial) {
+		super.patch(partial);
+	}
+	update(fn) {
+		super.update(fn);
+	}
+};
+//#endregion
 //#region src/registry/borrow.ts
 function resolveBorrowKey(BlocClass, target) {
 	return getRegistry().resolveKey(BlocClass, void 0, target?.args);
@@ -104,11 +131,11 @@ function register(BlocClass) {
 */
 function blac(options) {
 	return function(target, _context) {
-		if ("keepAlive" in options && options.keepAlive) target[BLAC_STATIC_PROPS.KEEP_ALIVE] = true;
-		if ("excludeFromDevTools" in options && options.excludeFromDevTools) target[BLAC_STATIC_PROPS.EXCLUDE_FROM_DEVTOOLS] = true;
-		if ("equality" in options && typeof options.equality === "function") target[BLAC_STATIC_PROPS.EQUALITY] = options.equality;
-		if ("key" in options && typeof options.key === "function") target[BLAC_STATIC_PROPS.KEY] = options.key;
-		if ("name" in options && typeof options.name === "string") target[BLAC_STATIC_PROPS.BLAC_NAME] = options.name;
+		if (options.keepAlive !== void 0) target[BLAC_STATIC_PROPS.KEEP_ALIVE] = options.keepAlive;
+		if (options.excludeFromDevTools) target[BLAC_STATIC_PROPS.EXCLUDE_FROM_DEVTOOLS] = true;
+		if (typeof options.equality === "function") target[BLAC_STATIC_PROPS.EQUALITY] = options.equality;
+		if (typeof options.key === "function") target[BLAC_STATIC_PROPS.KEY] = options.key;
+		if (typeof options.name === "string") target[BLAC_STATIC_PROPS.BLAC_NAME] = options.name;
 		return target;
 	};
 }
@@ -138,8 +165,7 @@ function instance(BlocClass, args) {
 function isBlocRef(input) {
 	return typeof input === "object" && input !== null && BLOC_REF_MARKER in input;
 }
-function toWatchTarget(input) {
-	const registry = getRegistry();
+function toWatchTarget(registry, input) {
 	if (isBlocRef(input)) return {
 		blocClass: input.blocClass,
 		key: input.instanceId,
@@ -157,8 +183,8 @@ let watchRefSeq = 0;
 * through so a not-yet-created instance is initialized correctly. The
 * caller is responsible for releasing `refId` in cleanup.
 */
-function resolveBloc(target, refId) {
-	return getRegistry().acquire(target.blocClass, target.key, {
+function resolveBloc(registry, target, refId) {
+	return registry.acquire(target.blocClass, target.key, {
 		countRef: true,
 		refId,
 		args: target.args
@@ -168,8 +194,7 @@ function resolveBloc(target, refId) {
 * Passive lookup for `{ create: false }`: never creates the instance and
 * never takes a ref. Returns `undefined` when no instance currently exists.
 */
-function resolveBlocPassive(target) {
-	const registry = getRegistry();
+function resolveBlocPassive(registry, target) {
 	try {
 		return registry.acquire(target.blocClass, target.key, {
 			canCreate: false,
@@ -188,10 +213,11 @@ function watchImpl(blocsOrBloc, callback, options) {
 	const inputs = isSingle ? [blocsOrBloc] : blocsOrBloc;
 	const registry = getRegistry();
 	const create = options?.create ?? true;
-	const targets = inputs.map(toWatchTarget);
+	const targets = inputs.map((input) => toWatchTarget(registry, input));
 	const refIds = targets.map(() => `_watch_${watchRefSeq++}`);
+	const resolveAt = (index) => create ? resolveBloc(registry, targets[index], refIds[index]) : resolveBlocPassive(registry, targets[index]);
 	let disposed = false;
-	const instances = targets.map((target, i) => create ? resolveBloc(target, refIds[i]) : resolveBlocPassive(target));
+	const instances = [];
 	const channelUnsubs = [];
 	const disposedUnsubs = [];
 	const cleanup = () => {
@@ -201,7 +227,7 @@ function watchImpl(blocsOrBloc, callback, options) {
 		for (const unsub of disposedUnsubs) unsub?.();
 		channelUnsubs.length = 0;
 		disposedUnsubs.length = 0;
-		if (create) for (let i = 0; i < targets.length; i++) registry.release(targets[i].blocClass, targets[i].key, false, refIds[i]);
+		if (create) for (let i = 0; i < instances.length; i++) registry.release(targets[i].blocClass, targets[i].key, false, refIds[i]);
 	};
 	const runCallback = () => {
 		if (disposed) return;
@@ -213,7 +239,7 @@ function watchImpl(blocsOrBloc, callback, options) {
 	};
 	const resubscribeAt = (index) => {
 		if (disposed) return;
-		instances[index] = create ? resolveBloc(targets[index], refIds[index]) : resolveBlocPassive(targets[index]);
+		instances[index] = resolveAt(index);
 		subscribeAt(index);
 		subscribeDisposeAt(index);
 		runCallback();
@@ -225,23 +251,24 @@ function watchImpl(blocsOrBloc, callback, options) {
 			queueMicrotask(() => resubscribeAt(index));
 		});
 	};
-	for (let i = 0; i < instances.length; i++) subscribeAt(i);
-	for (let i = 0; i < instances.length; i++) subscribeDisposeAt(i);
-	runCallback();
+	try {
+		for (let i = 0; i < targets.length; i++) instances.push(resolveAt(i));
+		for (let i = 0; i < instances.length; i++) subscribeAt(i);
+		for (let i = 0; i < instances.length; i++) subscribeDisposeAt(i);
+		runCallback();
+	} catch (error) {
+		cleanup();
+		throw error;
+	}
 	return cleanup;
 }
 const watch = Object.assign(watchImpl, { STOP });
 //#endregion
 //#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 { ALL_PATHS, APPLY_DEPS, Cubit, DEP_BRAND, INIT_CONFIG, ON_DISPOSE, REMOVE_DEPS_OWNER, StateContainer, StateContainerRegistry, WITH_TRACKED_STATE, acquire, blac, borrow, borrowSafe, clear, clearAll, configureBlac, ensure, forEach, getAll, getBlacConfig, getBlacName, getRefCount, getRefIds, getRegistry, getStats, globalRegistry, hasInstance, instance, instanceId, isExcludedFromDevTools, isKeepAliveClass, register, release, resetBlacConfig, resolveInstanceKey, setRegistry, shallowEqualState, watch };
+export { ALL_PATHS, Cubit, StateContainer, StateContainerRegistry, acquire, blac, borrow, borrowSafe, clear, clearAll, configureBlac, ensure, forEach, getAll, getBlacConfig, getBlacName, 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":["ALL_PATHS"],"sources":["../src/registry/borrow.ts","../src/registry/release.ts","../src/registry/queries.ts","../src/registry/management.ts","../src/decorators/blac.ts","../src/watch/watch.ts","../src/types/branded.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` derives the instance key (must match acquire);\n *   `refId` picks the ref to drop, otherwise one arbitrary ref goes;\n *   `forceDispose` disposes immediately regardless of remaining 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 { getRegistry } from './config';\nimport type {\n  ExtractArgs,\n  StateContainerConstructor,\n  InstanceReadonlyState,\n} from '../types/utilities';\n\n/**\n * @public\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\n/**\n * @public\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\n/**\n * @public\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\n/**\n * @public\n */\nexport function getAll<T extends StateContainerConstructor>(\n  BlocClass: T,\n): InstanceReadonlyState<T>[] {\n  return getRegistry().getAll(BlocClass);\n}\n\n/**\n * @public\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\n/**\n * @public\n */\nexport function register<T extends StateContainerConstructor>(\n  BlocClass: T,\n): void {\n  getRegistry().register(BlocClass);\n}\n","import { BLAC_STATIC_PROPS } from '../constants';\nimport type { EqualityFn } from '../config';\n\n/**\n * Configuration options for the `@blac` decorator. Any combination may be\n * given at once.\n */\nexport interface 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   * Explicit, minification-safe identity for this bloc class. Falls back to\n   * `constructor.name` when unset, which collides across classes once a\n   * minifier shortens class names.\n   */\n  name?: string;\n}\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 * @blac({ keepAlive: true, key: (args) => args.userId })\n * class UserBloc extends Cubit<UserState> {}\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    if ('name' in options && typeof options.name === 'string') {\n      (target as any)[BLAC_STATIC_PROPS.BLAC_NAME] = options.name;\n    }\n    return target;\n  };\n}\n","import { ALL_PATHS } from '@dirtytalk/structural';\nimport { ON_DISPOSE } from '../core/symbols';\nimport { getRegistry } from '../registry';\nimport { resolveInstanceKey } from '../registry/acquire';\nimport type {\n  ExtractArgs,\n  StateContainerConstructor,\n  StateContainerInstance,\n} from '../types/utilities';\n\nconst STOP: unique symbol = Symbol('watch.STOP');\ntype StopSymbol = typeof STOP;\n\nconst BLOC_REF_MARKER = Symbol('BlocRef');\n\n/**\n * Reference to a specific bloc instance, identified by class + the resolved\n * key derived from its `args`.\n */\nexport interface BlocRef<T extends StateContainerConstructor> {\n  [BLOC_REF_MARKER]: true;\n  blocClass: T;\n  /** @internal The resolved instance key (derived from `args`). */\n  instanceId: string;\n  /**\n   * @internal The `args` used to derive `instanceId`. Forwarded to\n   * `registry.acquire` so a not-yet-created instance is initialized with\n   * these args instead of `undefined`.\n   */\n  args?: unknown;\n}\n\n/**\n * Create a reference to a specific bloc instance, identified by its `args`.\n * The key is derived the same way `useBloc`/`acquire` derive it.\n *\n * @example\n * ```ts\n * watch(instance(UserBloc, { userId: 'user-123' }), (userBloc) => {\n *   console.log(userBloc.state.name);\n * });\n * ```\n */\nexport function instance<T extends StateContainerConstructor>(\n  BlocClass: T,\n  args?: ExtractArgs<T>,\n): BlocRef<T> {\n  return {\n    [BLOC_REF_MARKER]: true,\n    blocClass: BlocClass,\n    instanceId: resolveInstanceKey(BlocClass, args),\n    args,\n  };\n}\n\nfunction isBlocRef(\n  input: unknown,\n): input is BlocRef<StateContainerConstructor> {\n  return (\n    typeof input === 'object' && input !== null && BLOC_REF_MARKER in input\n  );\n}\n\ntype BlocInput = StateContainerConstructor | BlocRef<StateContainerConstructor>;\n\n/**\n * Options for `watch`.\n */\nexport interface WatchOptions {\n  /**\n   * When `false`, `watch` observes passively instead of owning the instance:\n   * it does not create a missing instance, and it does not take a real\n   * ownership ref on an existing one (so it never keeps an otherwise-\n   * unreferenced instance alive).\n   *\n   * If the instance does not exist yet when `watch` is called, the callback\n   * simply never fires for it — `watch` does not poll or wait for a later\n   * creation. Call `watch` again once the instance is known to exist (e.g.\n   * after some other owner has acquired it).\n   *\n   * Defaults to `true`.\n   */\n  create?: boolean;\n}\n\ntype ExtractInstance<T> =\n  T extends BlocRef<infer C>\n    ? InstanceType<C>\n    : T extends StateContainerConstructor\n      ? InstanceType<T>\n      : never;\n\ntype ExtractInstances<T extends readonly BlocInput[]> = {\n  [K in keyof T]: ExtractInstance<T[K]>;\n};\n\n/**\n * Watch function signature for single bloc.\n */\nexport interface WatchSingleFn {\n  <T extends StateContainerConstructor>(\n    bloc: T | BlocRef<T>,\n    callback: (bloc: InstanceType<T>) => void | StopSymbol,\n    options?: WatchOptions,\n  ): () => void;\n\n  STOP: StopSymbol;\n}\n\n/**\n * Watch function signature for multiple blocs.\n */\nexport interface WatchMultipleFn {\n  <T extends readonly BlocInput[]>(\n    blocs: T,\n    callback: (blocs: ExtractInstances<T>) => void | StopSymbol,\n    options?: WatchOptions,\n  ): () => void;\n\n  STOP: StopSymbol;\n}\n\n/**\n * Combined watch function type.\n */\nexport interface WatchFn extends WatchSingleFn {\n  <T extends readonly BlocInput[]>(\n    blocs: T,\n    callback: (blocs: ExtractInstances<T>) => void | StopSymbol,\n    options?: WatchOptions,\n  ): () => void;\n}\n\n/**\n * Class + resolved key + args needed to (re-)acquire a specific instance.\n * `watch` keeps this around per input so it can re-acquire the same logical\n * instance if the underlying container is disposed elsewhere.\n */\ninterface WatchTarget {\n  blocClass: StateContainerConstructor;\n  key: string;\n  args: unknown;\n}\n\nfunction toWatchTarget(input: BlocInput): WatchTarget {\n  const registry = getRegistry();\n  if (isBlocRef(input)) {\n    return {\n      blocClass: input.blocClass,\n      key: input.instanceId,\n      args: input.args,\n    };\n  }\n  return {\n    blocClass: input,\n    key: registry.resolveKey(input, undefined, undefined),\n    args: undefined,\n  };\n}\n\nlet watchRefSeq = 0;\n\n/**\n * Acquire a real ref (countRef: true) for the target, carrying its `args`\n * through so a not-yet-created instance is initialized correctly. The\n * caller is responsible for releasing `refId` in cleanup.\n */\nfunction resolveBloc(\n  target: WatchTarget,\n  refId: string,\n): StateContainerInstance {\n  const registry = getRegistry();\n  return registry.acquire(target.blocClass, target.key, {\n    countRef: true,\n    refId,\n    args: target.args,\n  });\n}\n\n/**\n * Passive lookup for `{ create: false }`: never creates the instance and\n * never takes a ref. Returns `undefined` when no instance currently exists.\n */\nfunction resolveBlocPassive(\n  target: WatchTarget,\n): StateContainerInstance | undefined {\n  const registry = getRegistry();\n  try {\n    return registry.acquire(target.blocClass, target.key, {\n      canCreate: false,\n      countRef: false,\n      args: target.args,\n    });\n  } catch {\n    return undefined;\n  }\n}\n\nfunction isArray(input: unknown): input is readonly BlocInput[] {\n  return Array.isArray(input);\n}\n\n/**\n * Watch one or more blocs for state changes.\n *\n * Thin wrapper around `container.channel.subscribe(ALL_PATHS, ...)`. The\n * callback fires once immediately, then on every state change of any of the\n * passed blocs. Returning `watch.STOP` from the callback tears down all\n * subscriptions.\n *\n * Note: subscriptions are microtask-deferred (per the DirtyChannel default\n * scheduler), so callbacks land asynchronously after `emit()`.\n *\n * By default `watch` creates the instance if it does not exist and holds a\n * real ownership ref until `unwatch`, matching `acquire`. Pass\n * `{ create: false }` to observe passively instead — see `WatchOptions`.\n *\n * @example Single bloc\n * ```ts\n * const unwatch = watch(UserBloc, (userBloc) => {\n *   console.log(userBloc.state.name);\n * });\n * ```\n *\n * @example Multiple blocs\n * ```ts\n * const unwatch = watch(\n *   [UserBloc, SettingsBloc] as const,\n *   ([userBloc, settingsBloc]) => {\n *     console.log(userBloc.state.name, settingsBloc.state.theme);\n *   }\n * );\n * ```\n *\n * @example With specific instance\n * ```ts\n * const unwatch = watch(\n *   instance(UserBloc, { userId: 'user-123' }),\n *   (userBloc) => {\n *     console.log(userBloc.state.name);\n *   }\n * );\n * ```\n *\n * @example Stop watching from callback\n * ```ts\n * const unwatch = watch(UserBloc, (userBloc) => {\n *   if (userBloc.state.done) {\n *     return watch.STOP;\n *   }\n * });\n * ```\n */\nfunction watchImpl<T extends StateContainerConstructor>(\n  bloc: T | BlocRef<T>,\n  callback: (bloc: InstanceType<T>) => void | StopSymbol,\n  options?: WatchOptions,\n): () => void;\n\nfunction watchImpl<T extends readonly BlocInput[]>(\n  blocs: T,\n  callback: (blocs: ExtractInstances<T>) => void | StopSymbol,\n  options?: WatchOptions,\n): () => void;\n\nfunction watchImpl(\n  blocsOrBloc: BlocInput | readonly BlocInput[],\n  callback: (blocsOrBloc: any) => void | StopSymbol,\n  options?: WatchOptions,\n): () => void {\n  const isSingle = !isArray(blocsOrBloc);\n  const inputs = isSingle ? [blocsOrBloc] : blocsOrBloc;\n  const registry = getRegistry();\n  const create = options?.create ?? true;\n\n  const targets = inputs.map(toWatchTarget);\n  const refIds = targets.map(() => `_watch_${watchRefSeq++}`);\n\n  let disposed = false;\n  const instances: Array<StateContainerInstance | undefined> = targets.map(\n    (target, i) =>\n      create ? resolveBloc(target, refIds[i]) : resolveBlocPassive(target),\n  );\n  const channelUnsubs: Array<(() => void) | undefined> = [];\n  const disposedUnsubs: Array<(() => void) | undefined> = [];\n\n  const cleanup = () => {\n    if (disposed) return;\n    disposed = true;\n    for (const unsub of channelUnsubs) unsub?.();\n    for (const unsub of disposedUnsubs) unsub?.();\n    channelUnsubs.length = 0;\n    disposedUnsubs.length = 0;\n    if (create) {\n      for (let i = 0; i < targets.length; i++) {\n        registry.release(\n          targets[i].blocClass,\n          targets[i].key,\n          false,\n          refIds[i],\n        );\n      }\n    }\n  };\n\n  const runCallback = () => {\n    if (disposed) return;\n    if (instances.some((i) => i === undefined)) return;\n    const arg = isSingle ? instances[0] : instances;\n    const result = callback(arg);\n    if (result === STOP) cleanup();\n  };\n\n  const subscribeAt = (index: number) => {\n    channelUnsubs[index] = instances[index]?.channel.subscribe(\n      () => ALL_PATHS,\n      runCallback,\n    );\n  };\n\n  // On external dispose, tear down the stale subscription and re-acquire +\n  // resubscribe (microtask-deferred, so it never runs mid-mutation of the\n  // registry that triggered the dispose, e.g. `clearAll()`), then notify.\n  const resubscribeAt = (index: number) => {\n    if (disposed) return;\n    instances[index] = create\n      ? resolveBloc(targets[index], refIds[index])\n      : resolveBlocPassive(targets[index]);\n    subscribeAt(index);\n    subscribeDisposeAt(index);\n    runCallback();\n  };\n\n  const subscribeDisposeAt = (index: number) => {\n    disposedUnsubs[index] = instances[index]?.[ON_DISPOSE](() => {\n      channelUnsubs[index]?.();\n      channelUnsubs[index] = undefined;\n      queueMicrotask(() => resubscribeAt(index));\n    });\n  };\n\n  for (let i = 0; i < instances.length; i++) {\n    subscribeAt(i);\n  }\n\n  for (let i = 0; i < instances.length; i++) {\n    subscribeDisposeAt(i);\n  }\n\n  // Fire once immediately so the consumer sees the current state.\n  runCallback();\n\n  return cleanup;\n}\n\nexport const watch: WatchFn = Object.assign(watchImpl, { STOP }) as WatchFn;\n","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 * @typeParam T - The base type\n * @typeParam B - The brand identifier\n */\nexport type Brand<T, B> = T & { [brand]: B };\n\n/**\n * Branded string type for type-safe IDs.\n * @typeParam 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":"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"}
+{"version":3,"file":"index.js","names":["ALL_PATHS"],"sources":["../src/core/Cubit.ts","../src/registry/borrow.ts","../src/registry/release.ts","../src/registry/queries.ts","../src/registry/management.ts","../src/decorators/blac.ts","../src/watch/watch.ts","../src/types/branded.ts"],"sourcesContent":["import { StateContainer } from './StateContainer';\nimport type { DeepPartial } from '@dirtytalk/structural';\n\n/**\n * `Cubit<S>` is a `StateContainer<S>` that exposes mutation publicly.\n *\n * That is the whole difference, and it is a real one: on `StateContainer`\n * `emit` / `patch` / `update` are `protected`, so a container mutates itself\n * from its own methods and callers go through the API it chooses to publish.\n * `Cubit` re-declares the three as `public` for the cases where a caller\n * legitimately drives state from outside — test helpers, devtools\n * time-travel, benchmarks.\n *\n * Reach for `StateContainer` when business logic should live in the class,\n * and `Cubit` when the caller owns the transitions.\n */\nexport abstract class Cubit<\n  S extends object = any,\n  Args = void,\n  Deps extends object = Record<string, never>,\n> extends StateContainer<S, Args, Deps> {\n  override emit(next: S): void {\n    super.emit(next);\n  }\n\n  override patch(partial: DeepPartial<S>): void {\n    super.patch(partial);\n  }\n\n  override update(fn: (state: S) => S): void {\n    super.update(fn);\n  }\n}\n","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` derives the instance key (must match acquire);\n *   `refId` picks the ref to drop, otherwise one arbitrary ref goes;\n *   `forceDispose` disposes immediately regardless of remaining 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 { getRegistry } from './config';\nimport type {\n  ExtractArgs,\n  StateContainerConstructor,\n  InstanceReadonlyState,\n} from '../types/utilities';\n\n/**\n * @public\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\n/**\n * @public\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\n/**\n * @public\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\n/**\n * @public\n */\nexport function getAll<T extends StateContainerConstructor>(\n  BlocClass: T,\n): InstanceReadonlyState<T>[] {\n  return getRegistry().getAll(BlocClass);\n}\n\n/**\n * @public\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\n/**\n * @public\n */\nexport function register<T extends StateContainerConstructor>(\n  BlocClass: T,\n): void {\n  getRegistry().register(BlocClass);\n}\n","import { BLAC_STATIC_PROPS } from '../constants';\nimport type { EqualityFn } from '../config';\n\n/**\n * Configuration options for the `@blac` decorator. Any combination may be\n * given at once.\n */\nexport interface BlacOptions {\n  /**\n   * Keep the bloc alive when its ref count reaches 0. `false` turns off a\n   * `keepAlive` inherited from a base class.\n   */\n  keepAlive?: boolean;\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   * Explicit, minification-safe identity for this bloc class. Falls back to\n   * `constructor.name` when unset, which collides across classes once a\n   * minifier shortens class names.\n   */\n  name?: string;\n}\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 * @blac({ keepAlive: true, key: (args) => args.userId })\n * class UserBloc extends Cubit<UserState> {}\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 (options.keepAlive !== undefined) {\n      (target as any)[BLAC_STATIC_PROPS.KEEP_ALIVE] = options.keepAlive;\n    }\n    if (options.excludeFromDevTools) {\n      (target as any)[BLAC_STATIC_PROPS.EXCLUDE_FROM_DEVTOOLS] = true;\n    }\n    if (typeof options.equality === 'function') {\n      (target as any)[BLAC_STATIC_PROPS.EQUALITY] = options.equality;\n    }\n    if (typeof options.key === 'function') {\n      (target as any)[BLAC_STATIC_PROPS.KEY] = options.key;\n    }\n    if (typeof options.name === 'string') {\n      (target as any)[BLAC_STATIC_PROPS.BLAC_NAME] = options.name;\n    }\n    return target;\n  };\n}\n","import { ALL_PATHS } from '@dirtytalk/structural';\nimport { ON_DISPOSE } from '../core/symbols';\nimport { getRegistry } from '../registry';\nimport { resolveInstanceKey } from '../registry/acquire';\nimport type { StateContainerRegistry } from '../core/StateContainerRegistry';\nimport type {\n  ExtractArgs,\n  StateContainerConstructor,\n  StateContainerInstance,\n} from '../types/utilities';\n\nconst STOP: unique symbol = Symbol('watch.STOP');\ntype StopSymbol = typeof STOP;\n\nconst BLOC_REF_MARKER = Symbol('BlocRef');\n\n/**\n * Reference to a specific bloc instance, identified by class + the resolved\n * key derived from its `args`.\n */\nexport interface BlocRef<T extends StateContainerConstructor> {\n  [BLOC_REF_MARKER]: true;\n  blocClass: T;\n  /** @internal The resolved instance key (derived from `args`). */\n  instanceId: string;\n  /**\n   * @internal The `args` used to derive `instanceId`. Forwarded to\n   * `registry.acquire` so a not-yet-created instance is initialized with\n   * these args instead of `undefined`.\n   */\n  args?: unknown;\n}\n\n/**\n * Create a reference to a specific bloc instance, identified by its `args`.\n * The key is derived the same way `useBloc`/`acquire` derive it.\n *\n * @example\n * ```ts\n * watch(instance(UserBloc, { userId: 'user-123' }), (userBloc) => {\n *   console.log(userBloc.state.name);\n * });\n * ```\n */\nexport function instance<T extends StateContainerConstructor>(\n  BlocClass: T,\n  args?: ExtractArgs<T>,\n): BlocRef<T> {\n  return {\n    [BLOC_REF_MARKER]: true,\n    blocClass: BlocClass,\n    instanceId: resolveInstanceKey(BlocClass, args),\n    args,\n  };\n}\n\nfunction isBlocRef(\n  input: unknown,\n): input is BlocRef<StateContainerConstructor> {\n  return (\n    typeof input === 'object' && input !== null && BLOC_REF_MARKER in input\n  );\n}\n\ntype BlocInput = StateContainerConstructor | BlocRef<StateContainerConstructor>;\n\n/**\n * Options for `watch`.\n */\nexport interface WatchOptions {\n  /**\n   * When `false`, `watch` observes passively: it neither creates a missing\n   * instance nor takes a real ownership ref on an existing one. If the\n   * instance does not exist yet, the callback simply never fires — `watch`\n   * does not poll; call it again once the instance exists.\n   *\n   * Defaults to `true`.\n   */\n  create?: boolean;\n}\n\ntype ExtractInstance<T> =\n  T extends BlocRef<infer C>\n    ? InstanceType<C>\n    : T extends StateContainerConstructor\n      ? InstanceType<T>\n      : never;\n\ntype ExtractInstances<T extends readonly BlocInput[]> = {\n  [K in keyof T]: ExtractInstance<T[K]>;\n};\n\n/**\n * Watch function signature for single bloc.\n */\nexport interface WatchSingleFn {\n  <T extends StateContainerConstructor>(\n    bloc: T | BlocRef<T>,\n    callback: (bloc: InstanceType<T>) => void | StopSymbol,\n    options?: WatchOptions,\n  ): () => void;\n\n  STOP: StopSymbol;\n}\n\n/**\n * Watch function signature for multiple blocs.\n */\nexport interface WatchMultipleFn {\n  <T extends readonly BlocInput[]>(\n    blocs: T,\n    callback: (blocs: ExtractInstances<T>) => void | StopSymbol,\n    options?: WatchOptions,\n  ): () => void;\n\n  STOP: StopSymbol;\n}\n\n/**\n * Combined watch function type.\n */\nexport interface WatchFn extends WatchSingleFn {\n  <T extends readonly BlocInput[]>(\n    blocs: T,\n    callback: (blocs: ExtractInstances<T>) => void | StopSymbol,\n    options?: WatchOptions,\n  ): () => void;\n}\n\n/**\n * Class + resolved key + args needed to (re-)acquire a specific instance.\n * `watch` keeps this around per input so it can re-acquire the same logical\n * instance if the underlying container is disposed elsewhere.\n */\ninterface WatchTarget {\n  blocClass: StateContainerConstructor;\n  key: string;\n  args: unknown;\n}\n\nfunction toWatchTarget(\n  registry: StateContainerRegistry,\n  input: BlocInput,\n): WatchTarget {\n  if (isBlocRef(input)) {\n    return {\n      blocClass: input.blocClass,\n      key: input.instanceId,\n      args: input.args,\n    };\n  }\n  return {\n    blocClass: input,\n    key: registry.resolveKey(input, undefined, undefined),\n    args: undefined,\n  };\n}\n\nlet watchRefSeq = 0;\n\n/**\n * Acquire a real ref (countRef: true) for the target, carrying its `args`\n * through so a not-yet-created instance is initialized correctly. The\n * caller is responsible for releasing `refId` in cleanup.\n */\nfunction resolveBloc(\n  registry: StateContainerRegistry,\n  target: WatchTarget,\n  refId: string,\n): StateContainerInstance {\n  return registry.acquire(target.blocClass, target.key, {\n    countRef: true,\n    refId,\n    args: target.args,\n  });\n}\n\n/**\n * Passive lookup for `{ create: false }`: never creates the instance and\n * never takes a ref. Returns `undefined` when no instance currently exists.\n */\nfunction resolveBlocPassive(\n  registry: StateContainerRegistry,\n  target: WatchTarget,\n): StateContainerInstance | undefined {\n  try {\n    return registry.acquire(target.blocClass, target.key, {\n      canCreate: false,\n      countRef: false,\n      args: target.args,\n    });\n  } catch {\n    return undefined;\n  }\n}\n\nfunction isArray(input: unknown): input is readonly BlocInput[] {\n  return Array.isArray(input);\n}\n\n/**\n * Watch one or more blocs for state changes.\n *\n * Thin wrapper around `container.channel.subscribe(ALL_PATHS, ...)`. The\n * callback fires once immediately, then on every state change of any of the\n * passed blocs. Returning `watch.STOP` from the callback tears down all\n * subscriptions. Subscriptions are microtask-deferred, so callbacks land\n * asynchronously after `emit()`.\n *\n * By default `watch` creates the instance if it does not exist and holds a\n * real ownership ref until `unwatch`, matching `acquire`. Pass\n * `{ create: false }` to observe passively instead — see `WatchOptions`.\n *\n * @example Single bloc\n * ```ts\n * const unwatch = watch(UserBloc, (userBloc) => {\n *   console.log(userBloc.state.name);\n * });\n * ```\n *\n * @example Multiple blocs\n * ```ts\n * const unwatch = watch(\n *   [UserBloc, SettingsBloc] as const,\n *   ([userBloc, settingsBloc]) => {\n *     console.log(userBloc.state.name, settingsBloc.state.theme);\n *   }\n * );\n * ```\n *\n * @example With specific instance\n * ```ts\n * const unwatch = watch(\n *   instance(UserBloc, { userId: 'user-123' }),\n *   (userBloc) => {\n *     console.log(userBloc.state.name);\n *   }\n * );\n * ```\n *\n * @example Stop watching from callback\n * ```ts\n * const unwatch = watch(UserBloc, (userBloc) => {\n *   if (userBloc.state.done) {\n *     return watch.STOP;\n *   }\n * });\n * ```\n */\nfunction watchImpl<T extends StateContainerConstructor>(\n  bloc: T | BlocRef<T>,\n  callback: (bloc: InstanceType<T>) => void | StopSymbol,\n  options?: WatchOptions,\n): () => void;\n\nfunction watchImpl<T extends readonly BlocInput[]>(\n  blocs: T,\n  callback: (blocs: ExtractInstances<T>) => void | StopSymbol,\n  options?: WatchOptions,\n): () => void;\n\nfunction watchImpl(\n  blocsOrBloc: BlocInput | readonly BlocInput[],\n  callback: (blocsOrBloc: any) => void | StopSymbol,\n  options?: WatchOptions,\n): () => void {\n  const isSingle = !isArray(blocsOrBloc);\n  const inputs = isSingle ? [blocsOrBloc] : blocsOrBloc;\n  const registry = getRegistry();\n  const create = options?.create ?? true;\n\n  const targets = inputs.map((input) => toWatchTarget(registry, input));\n  const refIds = targets.map(() => `_watch_${watchRefSeq++}`);\n  const resolveAt = (index: number) =>\n    create\n      ? resolveBloc(registry, targets[index], refIds[index])\n      : resolveBlocPassive(registry, targets[index]);\n\n  let disposed = false;\n  const instances: Array<StateContainerInstance | undefined> = [];\n  const channelUnsubs: Array<(() => void) | undefined> = [];\n  const disposedUnsubs: Array<(() => void) | undefined> = [];\n\n  const cleanup = () => {\n    if (disposed) return;\n    disposed = true;\n    for (const unsub of channelUnsubs) unsub?.();\n    for (const unsub of disposedUnsubs) unsub?.();\n    channelUnsubs.length = 0;\n    disposedUnsubs.length = 0;\n    if (create) {\n      for (let i = 0; i < instances.length; i++) {\n        registry.release(\n          targets[i].blocClass,\n          targets[i].key,\n          false,\n          refIds[i],\n        );\n      }\n    }\n  };\n\n  const runCallback = () => {\n    if (disposed) return;\n    if (instances.some((i) => i === undefined)) return;\n    const arg = isSingle ? instances[0] : instances;\n    const result = callback(arg);\n    if (result === STOP) cleanup();\n  };\n\n  const subscribeAt = (index: number) => {\n    channelUnsubs[index] = instances[index]?.channel.subscribe(\n      () => ALL_PATHS,\n      runCallback,\n    );\n  };\n\n  // On external dispose, tear down the stale subscription and re-acquire +\n  // resubscribe (microtask-deferred, so it never runs mid-mutation of the\n  // registry that triggered the dispose, e.g. `clearAll()`), then notify.\n  const resubscribeAt = (index: number) => {\n    if (disposed) return;\n    instances[index] = resolveAt(index);\n    subscribeAt(index);\n    subscribeDisposeAt(index);\n    runCallback();\n  };\n\n  const subscribeDisposeAt = (index: number) => {\n    disposedUnsubs[index] = instances[index]?.[ON_DISPOSE](() => {\n      channelUnsubs[index]?.();\n      channelUnsubs[index] = undefined;\n      queueMicrotask(() => resubscribeAt(index));\n    });\n  };\n\n  try {\n    for (let i = 0; i < targets.length; i++) instances.push(resolveAt(i));\n    for (let i = 0; i < instances.length; i++) subscribeAt(i);\n    for (let i = 0; i < instances.length; i++) subscribeDisposeAt(i);\n    // Fire once immediately so the consumer sees the current state.\n    runCallback();\n  } catch (error) {\n    cleanup();\n    throw error;\n  }\n\n  return cleanup;\n}\n\nexport const watch: WatchFn = Object.assign(watchImpl, { STOP }) as WatchFn;\n","declare const brand: unique symbol;\n\n/**\n * Nominal type helper, preventing accidental confusion between similar\n * primitive types.\n * @typeParam T - The base type\n * @typeParam B - The brand identifier\n */\nexport type Brand<T, B> = T & { [brand]: B };\n\n/**\n * Branded string type for type-safe IDs.\n * @typeParam B - The brand identifier\n */\nexport type BrandedId<B> = Brand<string, B>;\n\n/** Branded string type for state container instance IDs. */\nexport type InstanceId = Brand<string, 'InstanceId'>;\n\nexport function instanceId(id: string): InstanceId {\n  return id as InstanceId;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAgBA,IAAsB,QAAtB,cAIU,eAA8B;CACtC,KAAc,MAAe;EAC3B,MAAM,KAAK,IAAI;CACjB;CAEA,MAAe,SAA+B;EAC5C,MAAM,MAAM,OAAO;CACrB;CAEA,OAAgB,IAA2B;EACzC,MAAM,OAAO,EAAE;CACjB;AACF;;;ACdA,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;;;;;;ACXA,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;;;;AAKA,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;;;;AAKA,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;;;;AAKA,SAAgB,OACd,WAC4B;CAC5B,OAAO,YAAY,EAAE,OAAO,SAAS;AACvC;;;;AAKA,SAAgB,QACd,WACA,UACM;CACN,YAAY,EAAE,QAAQ,WAAW,QAAQ;AAC3C;;;ACzDA,SAAgB,MAA2C,WAAoB;CAC7E,YAAY,EAAE,MAAM,SAAS;AAC/B;AAEA,SAAgB,WAAiB;CAC/B,YAAY,EAAE,SAAS;AACzB;;;;AAKA,SAAgB,SACd,WACM;CACN,YAAY,EAAE,SAAS,SAAS;AAClC;;;;;;;;;;;;;;;;;;;;;;;;;ACuCA,SAAgB,KAAK,SAAsB;CACzC,OAAO,SACL,QACA,UACG;EACH,IAAI,QAAQ,cAAc,KAAA,GACxB,OAAgB,kBAAkB,cAAc,QAAQ;EAE1D,IAAI,QAAQ,qBACV,OAAgB,kBAAkB,yBAAyB;EAE7D,IAAI,OAAO,QAAQ,aAAa,YAC9B,OAAgB,kBAAkB,YAAY,QAAQ;EAExD,IAAI,OAAO,QAAQ,QAAQ,YACzB,OAAgB,kBAAkB,OAAO,QAAQ;EAEnD,IAAI,OAAO,QAAQ,SAAS,UAC1B,OAAgB,kBAAkB,aAAa,QAAQ;EAEzD,OAAO;CACT;AACF;;;ACpEA,MAAM,OAAsB,OAAO,YAAY;AAG/C,MAAM,kBAAkB,OAAO,SAAS;;;;;;;;;;;;AA8BxC,SAAgB,SACd,WACA,MACY;CACZ,OAAO;GACJ,kBAAkB;EACnB,WAAW;EACX,YAAY,mBAAmB,WAAW,IAAI;EAC9C;CACF;AACF;AAEA,SAAS,UACP,OAC6C;CAC7C,OACE,OAAO,UAAU,YAAY,UAAU,QAAQ,mBAAmB;AAEtE;AA8EA,SAAS,cACP,UACA,OACa;CACb,IAAI,UAAU,KAAK,GACjB,OAAO;EACL,WAAW,MAAM;EACjB,KAAK,MAAM;EACX,MAAM,MAAM;CACd;CAEF,OAAO;EACL,WAAW;EACX,KAAK,SAAS,WAAW,OAAO,KAAA,GAAW,KAAA,CAAS;EACpD,MAAM,KAAA;CACR;AACF;AAEA,IAAI,cAAc;;;;;;AAOlB,SAAS,YACP,UACA,QACA,OACwB;CACxB,OAAO,SAAS,QAAQ,OAAO,WAAW,OAAO,KAAK;EACpD,UAAU;EACV;EACA,MAAM,OAAO;CACf,CAAC;AACH;;;;;AAMA,SAAS,mBACP,UACA,QACoC;CACpC,IAAI;EACF,OAAO,SAAS,QAAQ,OAAO,WAAW,OAAO,KAAK;GACpD,WAAW;GACX,UAAU;GACV,MAAM,OAAO;EACf,CAAC;CACH,QAAQ;EACN;CACF;AACF;AAEA,SAAS,QAAQ,OAA+C;CAC9D,OAAO,MAAM,QAAQ,KAAK;AAC5B;AA+DA,SAAS,UACP,aACA,UACA,SACY;CACZ,MAAM,WAAW,CAAC,QAAQ,WAAW;CACrC,MAAM,SAAS,WAAW,CAAC,WAAW,IAAI;CAC1C,MAAM,WAAW,YAAY;CAC7B,MAAM,SAAS,SAAS,UAAU;CAElC,MAAM,UAAU,OAAO,KAAK,UAAU,cAAc,UAAU,KAAK,CAAC;CACpE,MAAM,SAAS,QAAQ,UAAU,UAAU,eAAe;CAC1D,MAAM,aAAa,UACjB,SACI,YAAY,UAAU,QAAQ,QAAQ,OAAO,MAAM,IACnD,mBAAmB,UAAU,QAAQ,MAAM;CAEjD,IAAI,WAAW;CACf,MAAM,YAAuD,CAAC;CAC9D,MAAM,gBAAiD,CAAC;CACxD,MAAM,iBAAkD,CAAC;CAEzD,MAAM,gBAAgB;EACpB,IAAI,UAAU;EACd,WAAW;EACX,KAAK,MAAM,SAAS,eAAe,QAAQ;EAC3C,KAAK,MAAM,SAAS,gBAAgB,QAAQ;EAC5C,cAAc,SAAS;EACvB,eAAe,SAAS;EACxB,IAAI,QACF,KAAK,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,KACpC,SAAS,QACP,QAAQ,GAAG,WACX,QAAQ,GAAG,KACX,OACA,OAAO,EACT;CAGN;CAEA,MAAM,oBAAoB;EACxB,IAAI,UAAU;EACd,IAAI,UAAU,MAAM,MAAM,MAAM,KAAA,CAAS,GAAG;EAG5C,IADe,SADH,WAAW,UAAU,KAAK,SAE7B,MAAM,MAAM,QAAQ;CAC/B;CAEA,MAAM,eAAe,UAAkB;EACrC,cAAc,SAAS,UAAU,QAAQ,QAAQ,gBACzCA,aACN,WACF;CACF;CAKA,MAAM,iBAAiB,UAAkB;EACvC,IAAI,UAAU;EACd,UAAU,SAAS,UAAU,KAAK;EAClC,YAAY,KAAK;EACjB,mBAAmB,KAAK;EACxB,YAAY;CACd;CAEA,MAAM,sBAAsB,UAAkB;EAC5C,eAAe,SAAS,UAAU,SAAS,kBAAkB;GAC3D,cAAc,SAAS;GACvB,cAAc,SAAS,KAAA;GACvB,qBAAqB,cAAc,KAAK,CAAC;EAC3C,CAAC;CACH;CAEA,IAAI;EACF,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK,UAAU,KAAK,UAAU,CAAC,CAAC;EACpE,KAAK,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK,YAAY,CAAC;EACxD,KAAK,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK,mBAAmB,CAAC;EAE/D,YAAY;CACd,SAAS,OAAO;EACd,QAAQ;EACR,MAAM;CACR;CAEA,OAAO;AACT;AAEA,MAAa,QAAiB,OAAO,OAAO,WAAW,EAAE,KAAK,CAAC;;;AC3U/D,SAAgB,WAAW,IAAwB;CACjD,OAAO;AACT"}

package/dist/internal.cjs

@@ -0,0 +1,10 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_StateContainerRegistry = require("./StateContainerRegistry-DjQQtlCW.cjs");
+const require_StateContainer = require("./StateContainer-BUyuxKb3.cjs");
+exports.APPLY_DEPS = require_StateContainerRegistry.APPLY_DEPS;
+exports.DEP_BRAND = require_StateContainer.DEP_BRAND;
+exports.INIT_CONFIG = require_StateContainerRegistry.INIT_CONFIG;
+exports.INSERT_INSTANCE = require_StateContainerRegistry.INSERT_INSTANCE;
+exports.ON_DISPOSE = require_StateContainerRegistry.ON_DISPOSE;
+exports.REMOVE_DEPS_OWNER = require_StateContainerRegistry.REMOVE_DEPS_OWNER;
+exports.WITH_TRACKED_STATE = require_StateContainerRegistry.WITH_TRACKED_STATE;

package/dist/internal.d.cts

@@ -0,0 +1,8 @@
+/**
+ * Framework hooks used by `@blac/react` and the testing helpers. Not public
+ * API; may change in any release.
+ *
+ * @packageDocumentation
+ */
+export { DEP_BRAND } from './core/StateContainer';
+export { APPLY_DEPS, REMOVE_DEPS_OWNER, INIT_CONFIG, INSERT_INSTANCE, ON_DISPOSE, WITH_TRACKED_STATE, } from './core/symbols';

package/dist/internal.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Framework hooks used by `@blac/react` and the testing helpers. Not public
+ * API; may change in any release.
+ *
+ * @packageDocumentation
+ */
+export { DEP_BRAND } from './core/StateContainer';
+export { APPLY_DEPS, REMOVE_DEPS_OWNER, INIT_CONFIG, INSERT_INSTANCE, ON_DISPOSE, WITH_TRACKED_STATE, } from './core/symbols';

package/dist/internal.js

@@ -0,0 +1,3 @@
+import { a as INSERT_INSTANCE, i as INIT_CONFIG, l as WITH_TRACKED_STATE, o as ON_DISPOSE, r as APPLY_DEPS, s as REMOVE_DEPS_OWNER } from "./StateContainerRegistry-gQbEutkN.js";
+import { t as DEP_BRAND } from "./StateContainer-Bh2ipNYj.js";
+export { APPLY_DEPS, DEP_BRAND, INIT_CONFIG, INSERT_INSTANCE, ON_DISPOSE, REMOVE_DEPS_OWNER, WITH_TRACKED_STATE };

package/dist/plugin/BlacPlugin.d.ts

@@ -17,15 +17,10 @@ export interface InstanceMetadata {
     args?: unknown;
 }
 /**
- * Per-event context delivered to plugin hooks.
- *
- * `PluginContext` is per-container — it identifies the bloc, not the event.
- * Per-event data (e.g. the changed `PathSet`) is passed via dedicated method
- * arguments, never via the context object.
- *
- * The `container` field is the focal bloc for the event. For `onInstall`
- * (which fires once at install time, not bound to any container) the
- * `container` field is `undefined`.
+ * Per-event context delivered to plugin hooks. Identifies the focal
+ * container for the event (`undefined` only for `onInstall`, which fires
+ * once at install time before any container is known); per-event data (e.g.
+ * the changed `PathSet`) is passed via method arguments, not this object.
  */
 export interface PluginContext {
     /**
@@ -53,21 +48,10 @@ export interface PluginContext {
 /**
  * BlaC plugin hook surface.
  *
- * State-change events carry the `PathSet` of paths that changed in the flush.
- * Lifecycle events (`onCreated`, `onDestroyed`) are not tied to a state change
- * and so do not carry `paths`.
- *
- * Hook firing model:
- * - `onCreated` fires synchronously when a container is first acquired.
- * - `onStateChange` fires once per channel flush (microtask-coalesced).
- *   `prev` is the state before the first emit of the flush; `next` is the
- *   state at flush time; `paths` is the set of paths marked during the flush.
- * - `onDestroyed` fires synchronously when a container is disposed (after
- *   its system 'dispose' event).
- *
- * The ref/deps hooks (`onRefAcquired`, `onRefReleased`, `onDepsChanged`) are
- * devtools-only — they drive devtools-connect and are orthogonal to the
- * state-change event payload.
+ * `onStateChange` fires once per channel flush (microtask-coalesced) with
+ * the changed `PathSet`; lifecycle hooks (`onCreated`, `onDestroyed`) fire
+ * synchronously and carry no `paths`. The ref/deps hooks (`onRefAcquired`,
+ * `onRefReleased`, `onDepsChanged`) are devtools-only.
  */
 export interface BlacPlugin {
     readonly name: string;

package/dist/plugin/PluginManager.d.ts

@@ -3,25 +3,16 @@ import type { BlacPlugin, PluginConfig } from './BlacPlugin';
 /**
  * Manages plugin lifecycle for the BlaC state management system.
  *
- * The manager hooks into two surfaces:
+ * Hooks into registry lifecycle events (synchronous) and per-container
+ * channel flushes (microtask-coalesced): while at least one installed
+ * plugin implements `onStateChange`, the manager subscribes each container
+ * with `ALL_PATHS` interest and dispatches
+ * `onStateChange(ctx, prev, next, paths)` on every flush.
  *
- * 1. **Registry lifecycle events** (`created`, `disposed`, `refAcquired`,
- *    `refReleased`, `depsChanged`, `activated`, `deactivated`) — synchronous,
- *    fired by the registry.
- *
- * 2. **Per-container channel flushes** — microtask-coalesced. For each
- *    container, the manager subscribes once at create-time with
- *    `ALL_PATHS` interest and stashes `prevState`. On every flush it
- *    captures the new state + the changed `PathSet` and dispatches
- *    `onStateChange(ctx, prev, next, paths)` to every enabled plugin.
- *
- * The `ALL_PATHS` subscription cost: plugins counted as a consumer with
- * `ALL_PATHS` interest will defeat the single-consumer-skip optimization
- * in `StructuralContainer`. This is the intended trade-off — devtools /
- * persist plugins genuinely want every change, and stateful plugins
- * (logging) can decode `paths` via `container.interner.lookup(id)` to log
- * only relevant fields. Plugins that want low overhead should remain
- * uninstalled or environment-gated.
+ * `ALL_PATHS` interest defeats the single-consumer-skip optimization in
+ * `StructuralContainer` — an intended trade-off for plugins that genuinely
+ * want every change (devtools/persist). Plugins that want low overhead
+ * should remain uninstalled or environment-gated.
  *
  * @example
  * ```ts
@@ -34,19 +25,18 @@ export declare class PluginManager {
     private registry;
     private lifecycleUnsubscribers;
     /**
-     * Per-container channel-bridge bookkeeping. Subscribed at `created`,
-     * torn down at `disposed` and at `destroy()`. Holds the rolling `prevState`
-     * snapshot the manager hands plugins on each flush.
+     * Per-container channel-bridge bookkeeping, subscribed at `created` and
+     * torn down at `disposed`/`destroy()`. Holds the rolling `prevState`
+     * snapshot handed to plugins on each flush.
      *
-     * Strong, not a WeakMap, because `destroy()` has to enumerate the live
-     * bridges to unsubscribe them. Safe: entries are removed on `disposed`, and
-     * the owning registry holds its own strong reference over that same window.
+     * Strong, not a `WeakMap`, because `destroy()` must enumerate live bridges
+     * to unsubscribe them; entries are removed on `disposed`, so this never
+     * outlives the registry's own reference.
      */
     private containerBridges;
     /**
-     * One `PluginContext` per container. The context closes over `registry` and
-     * `container` only — both stable for the container's lifetime — so it is
-     * safe to reuse instead of rebuilding its method table on every dispatch.
+     * One `PluginContext` per container, safe to reuse since it closes only
+     * over `registry`/`container`, both stable for the container's lifetime.
      */
     private contextCache;
     /**
@@ -92,59 +82,46 @@ export declare class PluginManager {
     /**
      * Wire registry lifecycle events into plugin dispatch.
      *
-     * `onStateChange` is NOT wired through `registry.on('stateChanged', …)` —
-     * that event lacks the `PathSet` payload. Instead, on each `created` we
-     * subscribe to the container's channel directly so we get
-     * `(paths)` and capture `(prev, next)` via the per-container snapshot.
+     * `onStateChange` is not wired through `registry.on('stateChanged', …)` —
+     * that event lacks the `PathSet` payload. Instead each `created` subscribes
+     * to the container's channel directly for `paths`, pairing it with
+     * `(prev, next)` from the per-container snapshot.
      */
     private setupLifecycleHooks;
     /**
-     * Subscribe to the container's channel with `ALL_PATHS` interest, so we
-     * fire on every flush. Capture `prev` from the snapshot taken on the
-     * previous flush (or at create-time for the first flush) and pass the
-     * channel's `paths` argument straight through to plugins.
-     *
-     * Per-container bookkeeping is stored in `containerBridges`, a strong `Map`
-     * keyed by the container. Entries are removed explicitly — on the
-     * container's `disposed` event, or for all of them in `destroy()`.
+     * Subscribe to the container's channel with `ALL_PATHS` interest so it
+     * fires on every flush. `prev` is the snapshot from the previous flush (or
+     * create-time for the first); the channel's `paths` is passed straight
+     * through to plugins.
      */
     private attachStateBridge;
     private detachStateBridge;
+    private hasStateChangePlugin;
+    private detachAllStateBridges;
     /**
-     * Backfill a newly-installed plugin with the app's existing instances.
-     *
-     * Iterates every registered `Type` and its live instances (`getAll`
-     * already skips disposed), attaching the state bridge (idempotent — see
-     * `attachStateBridge`) and, if the plugin implements `onCreated`, invoking
-     * it directly for each instance. Scoped to this single plugin only — the
-     * broadcast `notifyPlugins` would re-notify *every* plugin of *every*
-     * instance, which is wrong here.
+     * Backfill a newly-installed plugin with existing instances: attach the
+     * state bridge (idempotent) if it implements `onStateChange`, and invoke
+     * `onCreated` for each. Scoped to this plugin only — `notifyPlugins` would
+     * wrongly re-notify every plugin of every instance.
      */
     private backfillPlugin;
     /**
-     * Channel-flush callback. Snapshots `next`, hands `(prev, next, paths)`
-     * to every enabled plugin's `onStateChange`, then updates `prevState`
-     * for the next flush.
-     *
-     * Note: `prev` is captured once and reused across plugins — every
-     * plugin sees the same `prev`/`next`/`paths` regardless of dispatch
-     * order, matching the "snapshot prev once per flush" invariant.
+     * Channel-flush callback. Hands `(prev, next, paths)` to every enabled
+     * plugin's `onStateChange`, then updates `prevState` for the next flush.
+     * `prev` is captured once and reused across plugins, so every plugin sees
+     * the same values regardless of dispatch order.
      */
     private dispatchStateChange;
     /**
-     * Notify all plugins of a lifecycle event.
-     *
-     * Builds a fresh `PluginContext` per dispatch (instance becomes
-     * `ctx.container`), so plugins can reach the focal bloc through
-     * `ctx.container`. The context is built lazily on the first matching
-     * hook and reused for every other plugin in this dispatch — zero
-     * builds if no enabled plugin implements `hookName`.
+     * Notify all plugins of a lifecycle event. Builds a `PluginContext` lazily
+     * on the first matching hook and reuses it for the rest of this dispatch —
+     * zero builds if no enabled plugin implements `hookName`.
      */
     private notifyPlugins;
     /**
      * Get the `PluginContext` for a focal container, building it once and
-     * reusing it thereafter. Eviction is handled by the `WeakMap`: the context
-     * dies with the container. `undefined` (install-time) is never cached.
+     * reusing it thereafter (evicted via the `WeakMap` when the container
+     * dies). `undefined` (install-time) is never cached.
      */
     private buildContext;
     private createContext;
@@ -153,7 +130,7 @@ export declare class PluginManager {
      */
     private shouldEnablePlugin;
     /**
-     * Get current environment
+     * Same rule as `IS_DEV`: an unknown environment counts as production.
      */
     private getCurrentEnvironment;
 }