@blac/core 2.0.18 → 2.0.20

package/dist/ensure-VuiNPccZ.cjs

@@ -0,0 +1,559 @@
+const require_StateContainerRegistry = require("./StateContainerRegistry-lIwo-0m3.cjs");
+const require_config = require("./config-B1l8ZGlU.cjs");
+let _dirtytalk_structural = require("@dirtytalk/structural");
+//#region src/utils/idGenerator.ts
+/**
+* Generate simple ID with timestamp and random (no counter tracking)
+*
+* Format: `${prefix}:${timestamp}_${random}`
+*
+* @param prefix - Prefix for the ID
+* @returns Branded ID string
+*
+* @example
+* ```ts
+* const id = generateSimpleId('CounterBloc');
+* // Returns: "CounterBloc:1698765432100_a3k9d7f2q"
+* ```
+*/
+function generateSimpleId(prefix, affix) {
+	if (affix) return `${prefix}:${affix}`;
+	return `${prefix}:${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+}
+//#endregion
+//#region src/core/meta.ts
+/**
+* Non-enumerable brand carried on every `$blac` object produced by
+* {@link createMeta}. Used by the clobber guard in `StateContainer` to detect
+* a subclass class-field shadowing the base's own `$blac` property, and by the
+* meta tests. Intentionally NOT re-exported from the package barrel.
+*/
+const META_BRAND = Symbol("blac.meta");
+const EMPTY_DEPS = /* @__PURE__ */ new Map();
+/**
+* Build the frozen, branded `$blac` meta object for a container.
+*
+* Called from a `StateContainer` field initializer (`$blac = createMeta(this)`).
+* Only the back-reference is captured at this point; every getter/method reads
+* the container's `_`-private fields lazily on access, so field-initializer
+* ordering relative to those private fields is irrelevant.
+*
+* The getters close over `container` (the real instance), never over a
+* `this`-receiver — this is what keeps `$blac` reads safe through
+* `buildTrackedProxy`.
+*/
+function createMeta(container) {
+	const c = container;
+	const meta = {
+		get name() {
+			return c._name;
+		},
+		get id() {
+			return c._instanceId;
+		},
+		get debug() {
+			return c._debug;
+		},
+		get createdAt() {
+			return c._createdAt;
+		},
+		get disposed() {
+			return c._disposed;
+		},
+		get dependencies() {
+			return c._dependencies ?? EMPTY_DEPS;
+		},
+		hydration: Object.freeze({
+			get status() {
+				return c._hydrationStatus;
+			},
+			get error() {
+				return c._hydrationError;
+			},
+			get isHydrated() {
+				return c._hydrationStatus === "hydrated";
+			},
+			get changedWhileHydrating() {
+				return c._changedWhileHydrating;
+			},
+			begin() {
+				c._beginHydration();
+			},
+			apply(next) {
+				return c._applyHydratedState(next);
+			},
+			finish() {
+				c._finishHydration();
+			},
+			fail(error) {
+				c._failHydration(error);
+			},
+			wait() {
+				return c._waitForHydration();
+			}
+		})
+	};
+	Object.defineProperty(meta, META_BRAND, {
+		value: true,
+		enumerable: false,
+		writable: false,
+		configurable: false
+	});
+	return Object.freeze(meta);
+}
+//#endregion
+//#region src/core/StateContainer.ts
+/**
+* Brand symbol carried (non-enumerable) on every handle returned by
+* `depend()`. Framework adapters (`@blac/react`) use this to detect handles
+* inside a tracked-proxy and swap in a session-bound wrapper.
+*
+* @internal — exported for `@blac/react`; not part of the public API.
+*/
+const DEP_BRAND = Symbol("blac.depHandle");
+/**
+* Shallow per-key `Object.is` comparison of two plain records. Keys are
+* considered: a key present in one but not the other (regardless of value)
+* makes the records unequal. Used to detect real deps changes.
+*/
+function shallowEqualRecord(a, b) {
+	if (a === b) return true;
+	const aKeys = Object.keys(a);
+	if (aKeys.length !== Object.keys(b).length) return false;
+	for (const key of aKeys) {
+		if (!(key in b)) return false;
+		if (!Object.is(a[key], b[key])) return false;
+	}
+	return true;
+}
+/**
+* BlaC's lifecycle/identity/dependency layer on top of `StructuralContainer`.
+*
+* StructuralContainer provides:
+*   - `state` getter
+*   - `emit` / `patch` / `update` (path-tracked, microtask-flushed)
+*   - `channel` (the underlying `DirtyChannel`)
+*   - `registerConsumerPaths` / `unregisterConsumer` (for fine-grained consumers)
+*   - per-class `PathInterner`
+*
+* StateContainer layers on:
+*   - identity / lifecycle / hydration (exposed via `$blac: BlacMeta`)
+*   - cross-bloc deps (`depend()`, `$blac.dependencies`)
+*   - per-consumer deps slices (`APPLY_DEPS` / `REMOVE_DEPS_OWNER` / `onDepsChanged`)
+*   - registry integration (config-driven equality, emit-rate circuit breaker)
+*
+* Subscribers can attach via:
+*   - `onSystemEvent('stateChanged' | 'dispose' | 'hydrationChanged', cb)` —
+*     coarse lifecycle events.
+*   - `this.channel.subscribe(interest, cb)` — path-scoped.
+*/
+var StateContainer = class extends _dirtytalk_structural.StructuralContainer {
+	static {
+		this.__excludeFromDevTools = false;
+	}
+	get deps() {
+		return this._deps;
+	}
+	/**
+	* @internal Apply one owner's (consumer's) deps slice. Shallow-merges the
+	* slice, reconciles keys the owner dropped since its last apply (other
+	* owners' keys untouched), dev-warns on cross-owner key collisions, then
+	* recomputes the merged view and fires onDepsChanged if it changed.
+	*
+	* Idempotent: re-applying an identical slice for the same owner is a no-op.
+	*/
+	[require_StateContainerRegistry.APPLY_DEPS](ownerId, slice) {
+		if (this._disposed) return;
+		const owners = this._depsByOwner ??= /* @__PURE__ */ new Map();
+		const prevSlice = owners.get(ownerId);
+		if (prevSlice && shallowEqualRecord(prevSlice, slice)) return;
+		if (process.env.NODE_ENV !== "production") for (const key of Object.keys(slice)) for (const [otherOwner, otherSlice] of owners) {
+			if (otherOwner === ownerId) continue;
+			if (key in otherSlice && otherSlice[key] !== slice[key]) console.warn(`[${this._name}] multiple owners writing dep \`${String(key)}\`; last write wins`);
+		}
+		owners.set(ownerId, { ...slice });
+		this.reconcileDeps();
+	}
+	/**
+	* @internal Withdraw an owner's entire deps slice (consumer unmounted).
+	*/
+	[require_StateContainerRegistry.REMOVE_DEPS_OWNER](ownerId) {
+		if (this._disposed) return;
+		if (!this._depsByOwner?.delete(ownerId)) return;
+		this.reconcileDeps();
+	}
+	reconcileDeps() {
+		const prev = this._deps;
+		const next = {};
+		if (this._depsByOwner) for (const slice of this._depsByOwner.values()) Object.assign(next, slice);
+		for (const key of Object.keys(prev)) if (!(key in next)) next[key] = void 0;
+		if (shallowEqualRecord(prev, next)) return;
+		this._deps = next;
+		this.onDepsChanged(next, prev);
+		this._registry.emit("depsChanged", this, prev, next);
+	}
+	onDepsChanged(_next, _prev) {}
+	get args() {
+		return this._config.args;
+	}
+	/**
+	* Declare a cross-bloc dependency. Returns a branded handle with two
+	* accessors — the dep instance is resolved against the registry on each call,
+	* which keeps the surface immune to dep-instance churn:
+	*
+	* - `handle.track(options?)` — reactive read. Returns `[state, instance]`.
+	*   Inside a getter reached through the React proxy this subscribes the
+	*   reading component to the dep's changes (base impl: live, no subscription).
+	* - `handle.untracked(options?)` — returns the live instance with no tracking,
+	*   for imperative method calls and one-off reads.
+	*
+	* `defaultArgs` resolves the dep instance when an accessor is called without
+	* its own `args`; per-call `options.args` overrides it and can derive from
+	* current state. This does NOT auto-resubscribe outside the React proxy;
+	* non-React consumers needing updates should subscribe explicitly.
+	*/
+	depend(Type, defaultArgs) {
+		if (!this._dependencies) this._dependencies = /* @__PURE__ */ new Map();
+		this._dependencies.set(Type, this._registry.resolveKey(Type, void 0, defaultArgs));
+		const resolve = (args) => {
+			const effectiveArgs = args ?? defaultArgs;
+			const key = this._registry.resolveKey(Type, void 0, effectiveArgs);
+			return this._registry.ensure(Type, key, effectiveArgs);
+		};
+		const handle = {
+			track: (options) => {
+				const instance = resolve(options?.args);
+				return [instance.state, instance];
+			},
+			untracked: (options) => resolve(options?.args)
+		};
+		Object.defineProperty(handle, DEP_BRAND, {
+			value: {
+				Type,
+				defaultArgs
+			},
+			enumerable: false,
+			writable: false,
+			configurable: false
+		});
+		return handle;
+	}
+	constructor(initialState, options) {
+		super(initialState, options);
+		this._depsByOwner = null;
+		this._deps = {};
+		this._disposed = false;
+		this._hydrationStatus = "idle";
+		this._changedWhileHydrating = false;
+		this._hydrationPromise = null;
+		this._hydrationPromiseSettled = false;
+		this._config = {};
+		this._initCalled = false;
+		this._emitWindowStart = 0;
+		this._emitCount = 0;
+		this._emitRateWarned = false;
+		this._systemEventHandlers = /* @__PURE__ */ new Map();
+		this._dependencies = null;
+		this._pendingChange = null;
+		this._bridgeUnsub = null;
+		this._registry = require_config.getRegistry();
+		this._equalityFn = require_StateContainerRegistry.getBlacConfig().equality;
+		this._name = this.constructor.name;
+		this._debug = false;
+		this._instanceId = generateSimpleId(this.constructor.name, "main");
+		this._createdAt = Date.now();
+		this.$blac = createMeta(this);
+		this.onSystemEvent = (event, handler) => {
+			let handlers = this._systemEventHandlers.get(event);
+			if (!handlers) {
+				handlers = /* @__PURE__ */ new Set();
+				this._systemEventHandlers.set(event, handlers);
+			}
+			handlers.add(handler);
+			return () => {
+				handlers?.delete(handler);
+			};
+		};
+		this._bridgeUnsub = this.channel.subscribe(() => _dirtytalk_structural.ALL_PATHS, () => this._drainPending());
+	}
+	/**
+	* Called once after construction with the args passed at acquire time, before the first
+	* state snapshot is read by any consumer. Override to seed args-derived state (via
+	* this.emit(...)) or kick off loads.
+	*/
+	init(_args) {}
+	/**
+	* @internal Framework-only configuration entry point (registry + testing
+	* helpers). Writes the `_`-private identity fields directly, resolves
+	* per-class equality, emits the registry `created` event, and runs `init()`
+	* once. See {@link INIT_CONFIG}.
+	*/
+	[require_StateContainerRegistry.INIT_CONFIG](config) {
+		this._config = { ...config };
+		this._name = this._config.name || this.constructor.name;
+		this._debug = this._config.debug ?? false;
+		this._instanceId = generateSimpleId(this.constructor.name, this._config.instanceId);
+		const perClass = require_StateContainerRegistry.getClassEquality(this.constructor);
+		this._equalityFn = perClass ?? require_StateContainerRegistry.getBlacConfig().equality;
+		this._registry.emit("created", this);
+		if (!this._initCalled) {
+			this._initCalled = true;
+			this.init(this._config.args);
+		}
+		if (process.env.NODE_ENV !== "production") {
+			if (!this.$blac?.[META_BRAND]) console.warn(`[blac] ${this.constructor.name} appears to declare its own \`$blac\` member, which shadows the reserved meta namespace. \`$blac\` is reserved by StateContainer — remove the subclass field.`);
+		}
+	}
+	dispose() {
+		if (this._disposed) return;
+		if (this._debug) console.log(`[${this._name}] Disposing...`);
+		if (this._depsByOwner) {
+			this._depsByOwner.clear();
+			this.reconcileDeps();
+		}
+		this._disposed = true;
+		if (this._hydrationStatus === "hydrating") this._failHydration(/* @__PURE__ */ new Error(`Hydration cancelled because ${this._name} was disposed`));
+		this.emitSystemEvent("dispose", void 0);
+		this._bridgeUnsub?.();
+		this._bridgeUnsub = null;
+		this._systemEventHandlers.clear();
+		this._pendingChange = null;
+		this._registry.emit("disposed", this);
+		if (this._debug) console.log(`[${this._name}] Disposed successfully`);
+	}
+	emit(next) {
+		this.applyState(next, "default");
+	}
+	/**
+	* Override of `StructuralContainer.patch` that routes through the
+	* StateContainer concerns: disposed guard, dev-only emit-rate check,
+	* `_changedWhileHydrating` flag, pending-change capture (so `stateChanged`
+	* system events see the merged prev/next), and the registry-level
+	* `stateChanged` notification. We still call
+	* `super.patch` so path-marking semantics (the whole point of patch) are
+	* preserved.
+	*/
+	patch(partial) {
+		if (this._disposed) throw new Error(`Cannot emit state from disposed container ${this._name}`);
+		const partialKeys = Object.keys(partial);
+		if (partialKeys.length === 0) return;
+		const prev = this.state;
+		let allEqual = true;
+		for (const key of partialKeys) if (!Object.is(prev[key], partial[key])) {
+			allEqual = false;
+			break;
+		}
+		if (allEqual) return;
+		if (process.env.NODE_ENV !== "production") this._checkEmitRate();
+		super.patch(partial);
+		const next = this.state;
+		if (Object.is(prev, next)) return;
+		if (this._hydrationStatus === "hydrating") this._changedWhileHydrating = true;
+		if (this._pendingChange) this._pendingChange.next = next;
+		else this._pendingChange = {
+			prev,
+			next
+		};
+		if (this._registry.hasStateChangedListeners) this._registry.notifyStateChanged(this, prev, next);
+	}
+	applyState(next, source) {
+		if (this._disposed) throw new Error(`Cannot emit state from disposed container ${this._name}`);
+		const prev = this.state;
+		if (prev === next) return;
+		if (this._equalityFn(prev, next)) return;
+		if (process.env.NODE_ENV !== "production") this._checkEmitRate();
+		if (this._hydrationStatus === "hydrating" && source !== "hydration") this._changedWhileHydrating = true;
+		if (this._pendingChange) this._pendingChange.next = next;
+		else this._pendingChange = {
+			prev,
+			next
+		};
+		super.emit(next);
+		if (this._registry.hasStateChangedListeners) this._registry.notifyStateChanged(this, prev, next);
+	}
+	/**
+	* Called by the channel-bridge subscriber on each flush. Drains the
+	* pending change (if any) into the 'stateChanged' system event.
+	* No pending change == flush from a no-op patch == skip.
+	*/
+	_drainPending() {
+		const pending = this._pendingChange;
+		if (!pending) return;
+		this._pendingChange = null;
+		const handlers = this._systemEventHandlers.get("stateChanged");
+		if (handlers && handlers.size > 0) {
+			const payload = {
+				state: pending.next,
+				previousState: pending.prev
+			};
+			let count = 0;
+			const size = handlers.size;
+			for (const handler of handlers) {
+				if (++count > size) break;
+				try {
+					handler(payload);
+				} catch (error) {
+					console.error(`[${this._name}] Error in system event handler:`, error);
+				}
+			}
+		}
+	}
+	_beginHydration() {
+		if (this._disposed) throw new Error(`Cannot begin hydration for disposed container ${this._name}`);
+		this._changedWhileHydrating = false;
+		this._hydrationError = void 0;
+		this._hydrationPromise = null;
+		this._resolveHydrationPromise = void 0;
+		this._rejectHydrationPromise = void 0;
+		this._hydrationPromiseSettled = false;
+		this.ensureHydrationPromise();
+		this.setHydrationStatus("hydrating");
+	}
+	_applyHydratedState(next) {
+		if (this._disposed) return false;
+		if (this._hydrationStatus !== "hydrating" || this._changedWhileHydrating) return false;
+		this.applyState(next, "hydration");
+		return true;
+	}
+	_finishHydration() {
+		if (this._hydrationStatus !== "hydrating") {
+			if (this._hydrationStatus === "hydrated") return;
+			if (this._hydrationStatus === "error") this.ensureHydrationPromise();
+		}
+		this.setHydrationStatus("hydrated");
+		this.resolveHydration();
+	}
+	_failHydration(error) {
+		const err = error instanceof Error ? error : /* @__PURE__ */ new Error(`Hydration failed: ${String(error)}`);
+		this._hydrationError = err;
+		this.setHydrationStatus("error", err);
+		this.rejectHydration(err);
+	}
+	_waitForHydration() {
+		if (this._hydrationStatus === "idle" || this._hydrationStatus === "hydrated") return Promise.resolve();
+		if (this._hydrationStatus === "error") return Promise.reject(this._hydrationError ?? /* @__PURE__ */ new Error(`Hydration failed for container ${this._name}`));
+		return this.ensureHydrationPromise();
+	}
+	setHydrationStatus(status, error) {
+		const previousStatus = this._hydrationStatus;
+		this._hydrationStatus = status;
+		this._hydrationError = error;
+		this.emitSystemEvent("hydrationChanged", {
+			status,
+			previousStatus,
+			error,
+			changedWhileHydrating: this._changedWhileHydrating
+		});
+		this._registry.emit("hydrationChanged", this, status, previousStatus);
+	}
+	ensureHydrationPromise() {
+		if (!this._hydrationPromise || this._hydrationPromiseSettled) {
+			this._hydrationPromiseSettled = false;
+			this._hydrationPromise = new Promise((resolve, reject) => {
+				this._resolveHydrationPromise = () => {
+					if (this._hydrationPromiseSettled) return;
+					this._hydrationPromiseSettled = true;
+					resolve();
+				};
+				this._rejectHydrationPromise = (error) => {
+					if (this._hydrationPromiseSettled) return;
+					this._hydrationPromiseSettled = true;
+					reject(error);
+				};
+			});
+			this._hydrationPromise.catch(() => {});
+		}
+		return this._hydrationPromise;
+	}
+	resolveHydration() {
+		this._resolveHydrationPromise?.();
+	}
+	rejectHydration(error) {
+		this.ensureHydrationPromise();
+		this._rejectHydrationPromise?.(error);
+	}
+	emitSystemEvent(event, payload) {
+		const handlers = this._systemEventHandlers.get(event);
+		if (!handlers) return;
+		for (const handler of handlers) try {
+			handler(payload);
+		} catch (error) {
+			console.error(`[${this._name}] Error in system event handler:`, error);
+		}
+	}
+	/**
+	* Dev-only soft circuit breaker. Counts real state changes in a rolling 1s
+	* window and warns once if the rate exceeds `maxEmitsPerSecond` — the
+	* signature of a runaway loop (RAF/animation or emit-on-every-commit) pushing
+	* high-frequency data through state, which freezes subscribers/plugins.
+	*/
+	_checkEmitRate() {
+		const limit = require_StateContainerRegistry.getBlacConfig().maxEmitsPerSecond;
+		if (!(limit > 0) || !Number.isFinite(limit) || this._emitRateWarned) return;
+		const now = Date.now();
+		if (now - this._emitWindowStart >= 1e3) {
+			this._emitWindowStart = now;
+			this._emitCount = 1;
+			return;
+		}
+		this._emitCount++;
+		if (this._emitCount > limit) {
+			this._emitRateWarned = true;
+			console.warn(`[${this._name}] emitted more than ${limit} state changes in under a second. This is usually a runaway loop pushing high-frequency data through state (e.g. \`emit\`/\`patch\` inside a requestAnimationFrame loop, or an effect that emits on every render). It can freeze the app by saturating subscribers and plugins (logging/devtools). Keep high-frequency work imperative and emit only coarse/throttled state, or raise \`configureBlac({ maxEmitsPerSecond })\`. (This warning fires once.)`);
+		}
+	}
+};
+//#endregion
+//#region src/core/Cubit.ts
+/**
+* `Cubit<S>` is a `StateContainer<S>` with `emit` / `patch` exposed as
+* public mutation surface. Today it adds nothing structurally beyond
+* `StateContainer` — both are inherited from the underlying
+* `StructuralContainer<S>`. Kept as a real class (not a type alias) because
+* downstream code does `instance instanceof Cubit` checks.
+*
+* The class body is intentionally empty: a no-op `emit` override would
+* still go through `applyState`, and `patch` is inherited from
+* `StructuralContainer` (path-diffed, microtask-flushed). A caller that
+* wants "skip if no real change" patch semantics can wrap `patch`
+* themselves or call `emit` after a manual equality check.
+*/
+var Cubit = class extends StateContainer {};
+//#endregion
+//#region src/registry/ensure.ts
+/**
+* Ensure an instance exists without taking ownership (no ref added). Instance
+* identity is derived purely from `args`, matching `acquire`.
+*/
+function ensure(BlocClass, opts) {
+	const registry = require_config.getRegistry();
+	const key = registry.resolveKey(BlocClass, void 0, opts?.args);
+	return registry.ensure(BlocClass, key, opts?.args);
+}
+//#endregion
+Object.defineProperty(exports, "Cubit", {
+	enumerable: true,
+	get: function() {
+		return Cubit;
+	}
+});
+Object.defineProperty(exports, "DEP_BRAND", {
+	enumerable: true,
+	get: function() {
+		return DEP_BRAND;
+	}
+});
+Object.defineProperty(exports, "StateContainer", {
+	enumerable: true,
+	get: function() {
+		return StateContainer;
+	}
+});
+Object.defineProperty(exports, "ensure", {
+	enumerable: true,
+	get: function() {
+		return ensure;
+	}
+});
+
+//# sourceMappingURL=ensure-VuiNPccZ.cjs.map

package/dist/ensure-VuiNPccZ.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensure-VuiNPccZ.cjs","names":["StructuralContainer","APPLY_DEPS","REMOVE_DEPS_OWNER","getRegistry","getBlacConfig","ALL_PATHS","INIT_CONFIG","getClassEquality","getRegistry"],"sources":["../src/utils/idGenerator.ts","../src/core/meta.ts","../src/core/StateContainer.ts","../src/core/Cubit.ts","../src/registry/ensure.ts"],"sourcesContent":["/**\n * Centralized ID Generation\n *\n * Provides consistent, collision-resistant ID generation for all BlaC subsystems.\n * Uses timestamp + counter + random suffix for uniqueness.\n */\n\n// Global counter map for ID generation\nconst globalCounters = new Map<string, number>();\n\n/**\n * Creates an ID generator with isolated counter state\n *\n * @param prefix - Prefix for generated IDs\n * @returns Object with next(), nextSimple(), and reset() methods\n *\n * @example\n * ```ts\n * const generator = createIdGenerator('sub');\n * const id1 = generator.next(); // \"sub:1698765432100_1_a3k9d7f2q\"\n * const id2 = generator.next(); // \"sub:1698765432101_2_b4n8e9g3r\"\n * ```\n */\nexport function createIdGenerator(prefix: string) {\n  let counter = 0;\n  return {\n    next: () =>\n      `${prefix}:${Date.now()}_${++counter}_${Math.random().toString(36).substring(2, 11)}`,\n    nextSimple: () => `${prefix}:${++counter}`,\n    reset: () => {\n      counter = 0;\n    },\n  };\n}\n\n/**\n * Generate ID with timestamp, counter, and random suffix (tree-shakeable)\n *\n * Format: `${prefix}:${timestamp}_${counter}_${random}`\n *\n * @param prefix - Prefix for the ID (e.g., 'sub', 'consumer', 'stage')\n * @returns Branded ID string\n *\n * @example\n * const id = generateId('sub');\n * // Returns: \"sub:1698765432100_1_a3k9d7f2q\"\n */\nexport function generateId(prefix: string): string {\n  const counter = (globalCounters.get(prefix) ?? 0) + 1;\n  globalCounters.set(prefix, counter);\n  const timestamp = Date.now();\n  const random = Math.random().toString(36).substring(2, 11);\n  return `${prefix}:${timestamp}_${counter}_${random}`;\n}\n\n/**\n * Generate simple ID with timestamp and random (no counter tracking)\n *\n * Format: `${prefix}:${timestamp}_${random}`\n *\n * @param prefix - Prefix for the ID\n * @returns Branded ID string\n *\n * @example\n * ```ts\n * const id = generateSimpleId('CounterBloc');\n * // Returns: \"CounterBloc:1698765432100_a3k9d7f2q\"\n * ```\n */\nexport function generateSimpleId(prefix: string, affix?: string): string {\n  if (affix) {\n    return `${prefix}:${affix}`;\n  }\n  const timestamp = Date.now();\n  const random = Math.random().toString(36).substring(2, 11);\n  return `${prefix}:${timestamp}_${random}`;\n}\n\n/**\n * Reset all counters for testing purposes\n * @internal\n */\nexport function __resetIdCounters(): void {\n  globalCounters.clear();\n}\n","/**\n * `$blac` meta namespace for `StateContainer`.\n *\n * ──────────────────────────────────────────────────────────────────────────\n * CONSTRAINT — NO ES `#private` FIELDS, ANYWHERE IN THIS FILE.\n *\n * `@blac/react`'s `buildTrackedProxy` invokes prototype getters with a\n * `Proxy(instance)` as the `this`-receiver. Accessing an ES `#private` field\n * through a proxy receiver throws (`#x` brand checks fail on the proxy). The\n * whole point of this meta object is to be proxy-safe: every getter/method\n * here closes over the *real* container instance captured at `createMeta`\n * time, NEVER over a `this`-receiver. Do not \"modernize\" the `_`-prefixed\n * TS-private reads below into `#private` access.\n * ──────────────────────────────────────────────────────────────────────────\n */\n\nimport type { HydrationStatus } from './StateContainer';\nimport type { StateContainerConstructor } from '../types/utilities';\n\n/**\n * Hydration sub-surface of {@link BlacMeta}. Exposes the container's\n * hydration state machine — the `begin`/`apply`/`finish`/`fail`/`wait`\n * methods and the `status`/`error`/`isHydrated`/`changedWhileHydrating`\n * getters — namespaced under `$blac`.\n */\nexport interface BlacHydration<S extends object> {\n  readonly status: HydrationStatus;\n  readonly error: Error | undefined;\n  readonly isHydrated: boolean;\n  readonly changedWhileHydrating: boolean;\n  begin(): void;\n  apply(next: S): boolean;\n  finish(): void;\n  fail(error: Error): void;\n  wait(): Promise<void>;\n}\n\n/**\n * The reserved `$blac` instance member on every `StateContainer`. Gathers the\n * container's identity/lifecycle/hydration surface (`name`, `id`, `debug`,\n * `createdAt`, `disposed`, `dependencies`, and the hydration methods) under one\n * namespace, keeping the generic names free for userland blocs.\n *\n * The object is allocated once per container, frozen, branded, and exposes\n * live getters that read the container's current `_`-private fields — values\n * are never snapshotted.\n */\nexport interface BlacMeta<S extends object = any> {\n  readonly name: string;\n  readonly id: string;\n  readonly debug: boolean;\n  readonly createdAt: number;\n  readonly disposed: boolean;\n  readonly dependencies: ReadonlyMap<StateContainerConstructor, string>;\n  readonly hydration: BlacHydration<S>;\n}\n\n/**\n * Non-enumerable brand carried on every `$blac` object produced by\n * {@link createMeta}. Used by the clobber guard in `StateContainer` to detect\n * a subclass class-field shadowing the base's own `$blac` property, and by the\n * meta tests. Intentionally NOT re-exported from the package barrel.\n */\nexport const META_BRAND = Symbol('blac.meta');\n\nconst EMPTY_DEPS: ReadonlyMap<StateContainerConstructor, string> = new Map();\n\n/**\n * Narrow view of the parts of `StateContainer` the meta getters read. The\n * container's fields are TS-private (compile-time only), so they are not\n * reachable cross-module by name; `createMeta` performs a single internal cast\n * to this shape. This is purely a typing bridge — zero runtime indirection.\n *\n * The `$blac.hydration` surface delegates to these `_`-private methods, so the\n * container has a single source of truth for the hydration state machine.\n */\ninterface MetaInternals<S extends object> {\n  _name: string;\n  _instanceId: string;\n  _debug: boolean;\n  _createdAt: number;\n  _disposed: boolean;\n  _hydrationStatus: HydrationStatus;\n  _hydrationError: Error | undefined;\n  _changedWhileHydrating: boolean;\n  _dependencies: Map<StateContainerConstructor, string> | null;\n  _beginHydration(): void;\n  _applyHydratedState(next: S): boolean;\n  _finishHydration(): void;\n  _failHydration(error: Error): void;\n  _waitForHydration(): Promise<void>;\n}\n\n/**\n * Build the frozen, branded `$blac` meta object for a container.\n *\n * Called from a `StateContainer` field initializer (`$blac = createMeta(this)`).\n * Only the back-reference is captured at this point; every getter/method reads\n * the container's `_`-private fields lazily on access, so field-initializer\n * ordering relative to those private fields is irrelevant.\n *\n * The getters close over `container` (the real instance), never over a\n * `this`-receiver — this is what keeps `$blac` reads safe through\n * `buildTrackedProxy`.\n */\nexport function createMeta<S extends object>(container: object): BlacMeta<S> {\n  const c = container as unknown as MetaInternals<S>;\n\n  const hydration: BlacHydration<S> = Object.freeze({\n    get status() {\n      return c._hydrationStatus;\n    },\n    get error() {\n      return c._hydrationError;\n    },\n    get isHydrated() {\n      return c._hydrationStatus === 'hydrated';\n    },\n    get changedWhileHydrating() {\n      return c._changedWhileHydrating;\n    },\n    begin() {\n      c._beginHydration();\n    },\n    apply(next: S) {\n      return c._applyHydratedState(next);\n    },\n    finish() {\n      c._finishHydration();\n    },\n    fail(error: Error) {\n      c._failHydration(error);\n    },\n    wait() {\n      return c._waitForHydration();\n    },\n  });\n\n  const meta: BlacMeta<S> = {\n    get name() {\n      return c._name;\n    },\n    get id() {\n      return c._instanceId;\n    },\n    get debug() {\n      return c._debug;\n    },\n    get createdAt() {\n      return c._createdAt;\n    },\n    get disposed() {\n      return c._disposed;\n    },\n    get dependencies() {\n      return c._dependencies ?? EMPTY_DEPS;\n    },\n    hydration,\n  };\n\n  Object.defineProperty(meta, META_BRAND, {\n    value: true,\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  });\n\n  return Object.freeze(meta);\n}\n","import {\n  ALL_PATHS,\n  StructuralContainer,\n  type DeepPartial,\n  type StructuralContainerOptions,\n} from '@dirtytalk/structural';\nimport { generateSimpleId } from '../utils/idGenerator';\nimport { getRegistry } from '../registry/config';\nimport type {\n  ExtractArgs,\n  ExtractState,\n  StateContainerConstructor,\n} from '../types/utilities';\nimport { APPLY_DEPS, INIT_CONFIG, REMOVE_DEPS_OWNER } from './symbols';\nimport { type EqualityFn, getBlacConfig } from '../config';\nimport { getClassEquality } from '../utils/static-props';\nimport { type BlacMeta, createMeta, META_BRAND } from './meta';\n\n/**\n * Brand symbol carried (non-enumerable) on every handle returned by\n * `depend()`. Framework adapters (`@blac/react`) use this to detect handles\n * inside a tracked-proxy and swap in a session-bound wrapper.\n *\n * @internal — exported for `@blac/react`; not part of the public API.\n */\nexport const DEP_BRAND = Symbol('blac.depHandle');\n\n/**\n * Per-access options for a {@link DepHandle}. `args` resolves the specific dep\n * instance for this call; omit it to fall back to the default args passed to\n * `depend()`. Args resolve at call time so they can derive from current state.\n */\nexport interface DepAccessOptions<T extends StateContainerConstructor> {\n  args?: ExtractArgs<T>;\n}\n\n/**\n * Branded handle returned by `StateContainer.depend()`. Two intention-revealing\n * accessors, no callable surface:\n *\n * - `handle.track(options?)` — base impl: returns `[instance.state, instance]`\n *   live with no subscription. The React layer replaces `.track()` per-consumer\n *   so that cross-bloc state changes trigger re-renders of the reading component.\n * - `handle.untracked(options?)` — returns the live dep instance with no\n *   tracking. Use for imperative calls (`.untracked().doThing()`) and one-off\n *   state reads that should not subscribe the reader.\n * - `handle[DEP_BRAND]` — carries `{ Type, defaultArgs }` for framework use.\n */\nexport interface DepHandle<T extends StateContainerConstructor> {\n  track(options?: DepAccessOptions<T>): [ExtractState<T>, InstanceType<T>];\n  untracked(options?: DepAccessOptions<T>): InstanceType<T>;\n  readonly [DEP_BRAND]: { Type: T; defaultArgs?: ExtractArgs<T> };\n}\n\nexport interface StateContainerConfig {\n  name?: string;\n  debug?: boolean;\n  instanceId?: string;\n  /** Args passed at acquire time; forwarded to init(). */\n  args?: unknown;\n}\n\nexport type HydrationStatus = 'idle' | 'hydrating' | 'hydrated' | 'error';\n\nexport type SystemEvent = 'stateChanged' | 'dispose' | 'hydrationChanged';\n\nexport interface SystemEventPayloads<S> {\n  stateChanged: { state: S; previousState: S };\n  dispose: void;\n  hydrationChanged: {\n    status: HydrationStatus;\n    previousStatus: HydrationStatus;\n    error?: Error;\n    changedWhileHydrating: boolean;\n  };\n}\n\ntype SystemEventHandler<S, E extends SystemEvent> = (\n  payload: SystemEventPayloads<S>[E],\n) => void;\n\n/**\n * Shallow per-key `Object.is` comparison of two plain records. Keys are\n * considered: a key present in one but not the other (regardless of value)\n * makes the records unequal. Used to detect real deps changes.\n */\nfunction shallowEqualRecord(\n  a: Record<string, unknown>,\n  b: Record<string, unknown>,\n): boolean {\n  if (a === b) return true;\n  const aKeys = Object.keys(a);\n  if (aKeys.length !== Object.keys(b).length) return false;\n  for (const key of aKeys) {\n    if (!(key in b)) return false;\n    if (!Object.is(a[key], b[key])) return false;\n  }\n  return true;\n}\n\n/**\n * BlaC's lifecycle/identity/dependency layer on top of `StructuralContainer`.\n *\n * StructuralContainer provides:\n *   - `state` getter\n *   - `emit` / `patch` / `update` (path-tracked, microtask-flushed)\n *   - `channel` (the underlying `DirtyChannel`)\n *   - `registerConsumerPaths` / `unregisterConsumer` (for fine-grained consumers)\n *   - per-class `PathInterner`\n *\n * StateContainer layers on:\n *   - identity / lifecycle / hydration (exposed via `$blac: BlacMeta`)\n *   - cross-bloc deps (`depend()`, `$blac.dependencies`)\n *   - per-consumer deps slices (`APPLY_DEPS` / `REMOVE_DEPS_OWNER` / `onDepsChanged`)\n *   - registry integration (config-driven equality, emit-rate circuit breaker)\n *\n * Subscribers can attach via:\n *   - `onSystemEvent('stateChanged' | 'dispose' | 'hydrationChanged', cb)` —\n *     coarse lifecycle events.\n *   - `this.channel.subscribe(interest, cb)` — path-scoped.\n */\nexport abstract class StateContainer<\n  S extends object = any,\n  Args = void,\n  Deps extends object = Record<string, never>,\n> extends StructuralContainer<S> {\n  static __excludeFromDevTools = false;\n\n  /** @internal phantom — the args type this bloc is constructed with (see init()) */\n  declare readonly __args: Args;\n  /** @internal phantom — the injected deps type */\n  declare readonly __deps: Deps;\n\n  // ---------------------------------------------------------------------------\n  // Per-consumer deps slices (APPLY_DEPS / REMOVE_DEPS_OWNER)\n  //\n  // Framework adapters wire these per consumer:\n  // `@blac/react/src/useBloc.ts` reads APPLY_DEPS / REMOVE_DEPS_OWNER.\n  // ---------------------------------------------------------------------------\n\n  private _depsByOwner: Map<string, Partial<Deps>> | null = null;\n  private _deps: Partial<Deps> = {};\n\n  get deps(): Readonly<Deps> {\n    return this._deps as Readonly<Deps>;\n  }\n\n  /**\n   * @internal Apply one owner's (consumer's) deps slice. Shallow-merges the\n   * slice, reconciles keys the owner dropped since its last apply (other\n   * owners' keys untouched), dev-warns on cross-owner key collisions, then\n   * recomputes the merged view and fires onDepsChanged if it changed.\n   *\n   * Idempotent: re-applying an identical slice for the same owner is a no-op.\n   */\n  [APPLY_DEPS](ownerId: string, slice: Partial<Deps>): void {\n    if (this._disposed) return;\n\n    const owners = (this._depsByOwner ??= new Map());\n    const prevSlice = owners.get(ownerId);\n\n    if (prevSlice && shallowEqualRecord(prevSlice, slice)) {\n      return;\n    }\n\n    if (process.env.NODE_ENV !== 'production') {\n      for (const key of Object.keys(slice) as (keyof Deps)[]) {\n        for (const [otherOwner, otherSlice] of owners) {\n          if (otherOwner === ownerId) continue;\n          if (\n            key in otherSlice &&\n            (otherSlice as Record<keyof Deps, unknown>)[key] !==\n              (slice as Record<keyof Deps, unknown>)[key]\n          ) {\n            console.warn(\n              `[${this._name}] multiple owners writing dep \\`${String(\n                key,\n              )}\\`; last write wins`,\n            );\n          }\n        }\n      }\n    }\n\n    owners.set(ownerId, { ...slice });\n    this.reconcileDeps();\n  }\n\n  /**\n   * @internal Withdraw an owner's entire deps slice (consumer unmounted).\n   */\n  [REMOVE_DEPS_OWNER](ownerId: string): void {\n    if (this._disposed) return;\n    if (!this._depsByOwner?.delete(ownerId)) return;\n    this.reconcileDeps();\n  }\n\n  private reconcileDeps(): void {\n    const prev = this._deps;\n    const next: Partial<Deps> = {};\n    if (this._depsByOwner) {\n      for (const slice of this._depsByOwner.values()) {\n        Object.assign(next, slice);\n      }\n    }\n    for (const key of Object.keys(prev) as (keyof Deps)[]) {\n      if (!(key in next)) {\n        (next as Record<keyof Deps, unknown>)[key] = undefined;\n      }\n    }\n\n    if (shallowEqualRecord(prev, next)) return;\n\n    this._deps = next;\n    this.onDepsChanged(next as Readonly<Deps>, prev as Readonly<Deps>);\n    this._registry.emit(\n      'depsChanged',\n      this,\n      prev as Readonly<Record<string, unknown>>,\n      next as Readonly<Record<string, unknown>>,\n    );\n  }\n\n  protected onDepsChanged(_next: Readonly<Deps>, _prev: Readonly<Deps>): void {}\n\n  // ---------------------------------------------------------------------------\n  // Identity / lifecycle\n  // ---------------------------------------------------------------------------\n\n  private _disposed = false;\n  private _hydrationStatus: HydrationStatus = 'idle';\n  private _hydrationError?: Error;\n  private _changedWhileHydrating = false;\n  private _hydrationPromise: Promise<void> | null = null;\n  private _resolveHydrationPromise?: () => void;\n  private _rejectHydrationPromise?: (error: Error) => void;\n  private _hydrationPromiseSettled = false;\n  private _config: StateContainerConfig = {};\n  private _initCalled = false;\n\n  // Dev-only emit-rate circuit breaker state (see configureBlac.maxEmitsPerSecond).\n  private _emitWindowStart = 0;\n  private _emitCount = 0;\n  private _emitRateWarned = false;\n\n  // System-event handlers (stateChanged | dispose | hydrationChanged).\n  private readonly _systemEventHandlers = new Map<\n    SystemEvent,\n    Set<SystemEventHandler<S, any>>\n  >();\n\n  // Cross-bloc dependencies recorded by depend(). Map<DepCtor, instanceKey>.\n  private _dependencies: Map<StateContainerConstructor, string> | null = null;\n\n  // Pending state-change capture; set by emit(), drained by the channel-bridge\n  // callback on flush. Coalesced: multiple emits in one tick collapse to one\n  // (prev = the first prev, next = the latest next).\n  private _pendingChange: { prev: S; next: S } | null = null;\n\n  // Unsubscribe from the internal bridge that turns channel flushes into\n  // 'stateChanged' system events.\n  private _bridgeUnsub: (() => void) | null = null;\n\n  private _registry = getRegistry();\n  private _equalityFn: EqualityFn = getBlacConfig().equality;\n\n  // Identity fields. TS-private (compile-time only) — proxy-safe, unlike ES\n  // `#private`. The `$blac` meta getters close over these.\n  private _name: string = this.constructor.name;\n  private _debug: boolean = false;\n  private _instanceId: string = generateSimpleId(this.constructor.name, 'main');\n  private _createdAt: number = Date.now();\n\n  /**\n   * Reserved meta namespace: identity (`name`/`id`/`debug`/`createdAt`),\n   * lifecycle (`disposed`/`dependencies`), and the `hydration` sub-surface.\n   * Own, frozen, branded data property — `buildTrackedProxy` only intercepts\n   * prototype getters, so this own property and its closure-based getters are\n   * proxy-safe. See {@link createMeta}.\n   */\n  readonly $blac: BlacMeta<S> = createMeta<S>(this);\n\n  get args(): Args | undefined {\n    return this._config.args as Args | undefined;\n  }\n\n  /**\n   * Declare a cross-bloc dependency. Returns a branded handle with two\n   * accessors — the dep instance is resolved against the registry on each call,\n   * which keeps the surface immune to dep-instance churn:\n   *\n   * - `handle.track(options?)` — reactive read. Returns `[state, instance]`.\n   *   Inside a getter reached through the React proxy this subscribes the\n   *   reading component to the dep's changes (base impl: live, no subscription).\n   * - `handle.untracked(options?)` — returns the live instance with no tracking,\n   *   for imperative method calls and one-off reads.\n   *\n   * `defaultArgs` resolves the dep instance when an accessor is called without\n   * its own `args`; per-call `options.args` overrides it and can derive from\n   * current state. This does NOT auto-resubscribe outside the React proxy;\n   * non-React consumers needing updates should subscribe explicitly.\n   */\n  protected depend<T extends StateContainerConstructor>(\n    Type: T,\n    defaultArgs?: ExtractArgs<T>,\n  ): DepHandle<T> {\n    if (!this._dependencies) {\n      this._dependencies = new Map();\n    }\n    this._dependencies.set(\n      Type,\n      this._registry.resolveKey(Type, undefined, defaultArgs),\n    );\n\n    const resolve = (args?: ExtractArgs<T>): InstanceType<T> => {\n      const effectiveArgs = args ?? defaultArgs;\n      const key = this._registry.resolveKey(Type, undefined, effectiveArgs);\n      return this._registry.ensure(Type, key, effectiveArgs);\n    };\n\n    const handle = {\n      track: (\n        options?: DepAccessOptions<T>,\n      ): [ExtractState<T>, InstanceType<T>] => {\n        const instance = resolve(options?.args);\n        return [instance.state as ExtractState<T>, instance];\n      },\n      untracked: (options?: DepAccessOptions<T>): InstanceType<T> =>\n        resolve(options?.args),\n    } as DepHandle<T>;\n\n    Object.defineProperty(handle, DEP_BRAND, {\n      value: { Type, defaultArgs },\n      enumerable: false,\n      writable: false,\n      configurable: false,\n    });\n\n    return handle;\n  }\n\n  constructor(initialState: S, options?: StructuralContainerOptions) {\n    super(initialState, options);\n\n    // Bridge channel flushes -> 'stateChanged' system event.\n    // Interest is ALL_PATHS so we wake on every flush. Coalesced via\n    // `_pendingChange`: if no emit happened (e.g. a no-op patch), the bridge\n    // sees null and skips.\n    this._bridgeUnsub = this.channel.subscribe(\n      () => ALL_PATHS,\n      () => this._drainPending(),\n    );\n  }\n\n  /**\n   * Called once after construction with the args passed at acquire time, before the first\n   * state snapshot is read by any consumer. Override to seed args-derived state (via\n   * this.emit(...)) or kick off loads.\n   */\n  protected init(_args: Args): void {}\n\n  /**\n   * @internal Framework-only configuration entry point (registry + testing\n   * helpers). Writes the `_`-private identity fields directly, resolves\n   * per-class equality, emits the registry `created` event, and runs `init()`\n   * once. See {@link INIT_CONFIG}.\n   */\n  [INIT_CONFIG](config: StateContainerConfig): void {\n    this._config = { ...config };\n    this._name = this._config.name || this.constructor.name;\n    this._debug = this._config.debug ?? false;\n    this._instanceId = generateSimpleId(\n      this.constructor.name,\n      this._config.instanceId,\n    );\n    const perClass = getClassEquality(\n      this.constructor as StateContainerConstructor,\n    );\n    this._equalityFn = perClass ?? getBlacConfig().equality;\n    this._registry.emit('created', this);\n    if (!this._initCalled) {\n      this._initCalled = true;\n      this.init(this._config.args as Args);\n    }\n\n    // Clobber guard: a subclass class-field `$blac = ...` initializes after\n    // `super()` and would overwrite the base's own meta property. Dev-only.\n    if (process.env.NODE_ENV !== 'production') {\n      if (!(this.$blac as unknown as Record<symbol, unknown>)?.[META_BRAND]) {\n        console.warn(\n          `[blac] ${this.constructor.name} appears to declare its own \\`$blac\\` ` +\n            `member, which shadows the reserved meta namespace. \\`$blac\\` is ` +\n            `reserved by StateContainer — remove the subclass field.`,\n        );\n      }\n    }\n  }\n\n  // ---------------------------------------------------------------------------\n  // Lifecycle: dispose\n  // ---------------------------------------------------------------------------\n\n  dispose(): void {\n    if (this._disposed) return;\n\n    if (this._debug) {\n      console.log(`[${this._name}] Disposing...`);\n    }\n\n    // Reconcile to an empty deps view so a final onDepsChanged(next, prev)\n    // fires with all keys absent (undefined). After this, APPLY_DEPS /\n    // REMOVE_DEPS_OWNER are guarded by _disposed.\n    if (this._depsByOwner) {\n      this._depsByOwner.clear();\n      this.reconcileDeps();\n    }\n\n    this._disposed = true;\n\n    if (this._hydrationStatus === 'hydrating') {\n      this._failHydration(\n        new Error(`Hydration cancelled because ${this._name} was disposed`),\n      );\n    }\n\n    this.emitSystemEvent('dispose', undefined as void);\n\n    // Tear down the channel bridge so we don't leak a subscription.\n    this._bridgeUnsub?.();\n    this._bridgeUnsub = null;\n\n    this._systemEventHandlers.clear();\n    this._pendingChange = null;\n\n    this._registry.emit('disposed', this);\n\n    if (this._debug) {\n      console.log(`[${this._name}] Disposed successfully`);\n    }\n  }\n\n  // ---------------------------------------------------------------------------\n  // Mutation: emit / patch / update.\n  //\n  // We override `emit` to layer in:\n  //   - disposed guard\n  //   - equality-fn short-circuit (consults getBlacConfig().equality or the\n  //     per-class override via @blac decorator)\n  //   - emit-rate circuit breaker (dev-only)\n  //   - `_changedWhileHydrating` flag tracking\n  //   - registry-level stateChanged notification (microtask-deferred)\n  //   - pending-change capture so the channel-bridge callback can fire the\n  //     'stateChanged' system event with prev/next.\n  //\n  // The actual change-detection (path diff, channel mark, single-consumer\n  // skip) is delegated to `super.emit`.\n  // ---------------------------------------------------------------------------\n\n  override emit(next: S): void {\n    this.applyState(next, 'default');\n  }\n\n  /**\n   * Override of `StructuralContainer.patch` that routes through the\n   * StateContainer concerns: disposed guard, dev-only emit-rate check,\n   * `_changedWhileHydrating` flag, pending-change capture (so `stateChanged`\n   * system events see the merged prev/next), and the registry-level\n   * `stateChanged` notification. We still call\n   * `super.patch` so path-marking semantics (the whole point of patch) are\n   * preserved.\n   */\n  override patch(partial: DeepPartial<S>): void {\n    if (this._disposed) {\n      throw new Error(\n        `Cannot emit state from disposed container ${this._name}`,\n      );\n    }\n    const partialKeys = Object.keys(partial as object);\n    if (partialKeys.length === 0) return;\n\n    const prev = this.state;\n\n    // Pre-spread skip: if every top-level key in `partial` is already\n    // `Object.is`-equal to the current state's value at that key, the\n    // merge is a structural no-op — skip entirely (per-key Object.is\n    // short-circuit). This is\n    // shallow on purpose; deep no-op detection lives in `super.patch`'s\n    // path-diff path which still wakes consumers if anything truly moved.\n    let allEqual = true;\n    for (const key of partialKeys) {\n      if (\n        !Object.is(\n          (prev as Record<string, unknown>)[key],\n          (partial as Record<string, unknown>)[key],\n        )\n      ) {\n        allEqual = false;\n        break;\n      }\n    }\n    if (allEqual) return;\n\n    if (process.env.NODE_ENV !== 'production') {\n      this._checkEmitRate();\n    }\n\n    super.patch(partial);\n\n    const next = this.state;\n    if (Object.is(prev, next)) return;\n\n    if (this._hydrationStatus === 'hydrating') {\n      this._changedWhileHydrating = true;\n    }\n\n    if (this._pendingChange) {\n      this._pendingChange.next = next;\n    } else {\n      this._pendingChange = { prev, next };\n    }\n\n    if (this._registry.hasStateChangedListeners) {\n      this._registry.notifyStateChanged(this, prev, next);\n    }\n  }\n\n  private applyState(next: S, source: 'default' | 'hydration'): void {\n    if (this._disposed) {\n      throw new Error(\n        `Cannot emit state from disposed container ${this._name}`,\n      );\n    }\n\n    const prev = this.state;\n    if (prev === next) return;\n    if (this._equalityFn(prev, next)) return;\n\n    if (process.env.NODE_ENV !== 'production') {\n      this._checkEmitRate();\n    }\n\n    if (this._hydrationStatus === 'hydrating' && source !== 'hydration') {\n      this._changedWhileHydrating = true;\n    }\n\n    // Coalesce: keep the first prev seen this tick, take the latest next.\n    if (this._pendingChange) {\n      this._pendingChange.next = next;\n    } else {\n      this._pendingChange = { prev, next };\n    }\n\n    super.emit(next);\n\n    if (this._registry.hasStateChangedListeners) {\n      this._registry.notifyStateChanged(this, prev, next);\n    }\n  }\n\n  /**\n   * Called by the channel-bridge subscriber on each flush. Drains the\n   * pending change (if any) into the 'stateChanged' system event.\n   * No pending change == flush from a no-op patch == skip.\n   */\n  private _drainPending(): void {\n    const pending = this._pendingChange;\n    if (!pending) return;\n    this._pendingChange = null;\n\n    // Iterate against a fixed-size snapshot so a handler that subscribes a\n    // new handler mid-drain does not get the late one called in this flush.\n    const handlers = this._systemEventHandlers.get('stateChanged');\n    if (handlers && handlers.size > 0) {\n      const payload = { state: pending.next, previousState: pending.prev };\n      let count = 0;\n      const size = handlers.size;\n      for (const handler of handlers) {\n        if (++count > size) break;\n        try {\n          handler(payload);\n        } catch (error) {\n          console.error(\n            `[${this._name}] Error in system event handler:`,\n            error,\n          );\n        }\n      }\n    }\n  }\n\n  // ---------------------------------------------------------------------------\n  // Hydration\n  // ---------------------------------------------------------------------------\n\n  // The hydration state machine lives in these `_`-private impls. The\n  // `$blac.hydration` surface delegates here, so there is a single source\n  // of truth for the hydration state machine.\n\n  private _beginHydration(): void {\n    if (this._disposed) {\n      throw new Error(\n        `Cannot begin hydration for disposed container ${this._name}`,\n      );\n    }\n\n    this._changedWhileHydrating = false;\n    this._hydrationError = undefined;\n    this._hydrationPromise = null;\n    this._resolveHydrationPromise = undefined;\n    this._rejectHydrationPromise = undefined;\n    this._hydrationPromiseSettled = false;\n    void this.ensureHydrationPromise();\n    this.setHydrationStatus('hydrating');\n  }\n\n  private _applyHydratedState(next: S): boolean {\n    if (this._disposed) {\n      return false;\n    }\n\n    if (this._hydrationStatus !== 'hydrating' || this._changedWhileHydrating) {\n      return false;\n    }\n\n    this.applyState(next, 'hydration');\n    return true;\n  }\n\n  private _finishHydration(): void {\n    if (this._hydrationStatus !== 'hydrating') {\n      if (this._hydrationStatus === 'hydrated') {\n        return;\n      }\n      if (this._hydrationStatus === 'error') {\n        void this.ensureHydrationPromise();\n      }\n    }\n\n    this.setHydrationStatus('hydrated');\n    this.resolveHydration();\n  }\n\n  private _failHydration(error: Error): void {\n    const err =\n      error instanceof Error\n        ? error\n        : new Error(`Hydration failed: ${String(error)}`);\n\n    this._hydrationError = err;\n    this.setHydrationStatus('error', err);\n    this.rejectHydration(err);\n  }\n\n  private _waitForHydration(): Promise<void> {\n    if (\n      this._hydrationStatus === 'idle' ||\n      this._hydrationStatus === 'hydrated'\n    ) {\n      return Promise.resolve();\n    }\n\n    if (this._hydrationStatus === 'error') {\n      return Promise.reject(\n        this._hydrationError ??\n          new Error(`Hydration failed for container ${this._name}`),\n      );\n    }\n\n    return this.ensureHydrationPromise();\n  }\n\n  private setHydrationStatus(status: HydrationStatus, error?: Error): void {\n    const previousStatus = this._hydrationStatus;\n    this._hydrationStatus = status;\n    this._hydrationError = error;\n\n    this.emitSystemEvent('hydrationChanged', {\n      status,\n      previousStatus,\n      error,\n      changedWhileHydrating: this._changedWhileHydrating,\n    });\n    this._registry.emit('hydrationChanged', this, status, previousStatus);\n  }\n\n  private ensureHydrationPromise(): Promise<void> {\n    if (!this._hydrationPromise || this._hydrationPromiseSettled) {\n      this._hydrationPromiseSettled = false;\n      this._hydrationPromise = new Promise<void>((resolve, reject) => {\n        this._resolveHydrationPromise = () => {\n          if (this._hydrationPromiseSettled) return;\n          this._hydrationPromiseSettled = true;\n          resolve();\n        };\n        this._rejectHydrationPromise = (error: Error) => {\n          if (this._hydrationPromiseSettled) return;\n          this._hydrationPromiseSettled = true;\n          reject(error);\n        };\n      });\n      this._hydrationPromise.catch(() => {});\n    }\n\n    return this._hydrationPromise;\n  }\n\n  private resolveHydration(): void {\n    this._resolveHydrationPromise?.();\n  }\n\n  private rejectHydration(error: Error): void {\n    void this.ensureHydrationPromise();\n    this._rejectHydrationPromise?.(error);\n  }\n\n  // ---------------------------------------------------------------------------\n  // System events\n  // ---------------------------------------------------------------------------\n\n  protected onSystemEvent = <E extends SystemEvent>(\n    event: E,\n    handler: SystemEventHandler<S, E>,\n  ): (() => void) => {\n    let handlers = this._systemEventHandlers.get(event);\n    if (!handlers) {\n      handlers = new Set();\n      this._systemEventHandlers.set(event, handlers);\n    }\n    handlers.add(handler as SystemEventHandler<S, any>);\n\n    return () => {\n      handlers?.delete(handler as SystemEventHandler<S, any>);\n    };\n  };\n\n  private emitSystemEvent<E extends SystemEvent>(\n    event: E,\n    payload: SystemEventPayloads<S>[E],\n  ): void {\n    const handlers = this._systemEventHandlers.get(event);\n    if (!handlers) return;\n\n    for (const handler of handlers) {\n      try {\n        handler(payload);\n      } catch (error) {\n        console.error(`[${this._name}] Error in system event handler:`, error);\n      }\n    }\n  }\n\n  // ---------------------------------------------------------------------------\n  // Emit-rate circuit breaker (dev-only)\n  // ---------------------------------------------------------------------------\n\n  /**\n   * Dev-only soft circuit breaker. Counts real state changes in a rolling 1s\n   * window and warns once if the rate exceeds `maxEmitsPerSecond` — the\n   * signature of a runaway loop (RAF/animation or emit-on-every-commit) pushing\n   * high-frequency data through state, which freezes subscribers/plugins.\n   */\n  private _checkEmitRate(): void {\n    const limit = getBlacConfig().maxEmitsPerSecond;\n    if (!(limit > 0) || !Number.isFinite(limit) || this._emitRateWarned) return;\n\n    const now = Date.now();\n    if (now - this._emitWindowStart >= 1000) {\n      this._emitWindowStart = now;\n      this._emitCount = 1;\n      return;\n    }\n\n    this._emitCount++;\n    if (this._emitCount > limit) {\n      this._emitRateWarned = true;\n      console.warn(\n        `[${this._name}] emitted more than ${limit} state changes in under a second. ` +\n          `This is usually a runaway loop pushing high-frequency data through state ` +\n          `(e.g. \\`emit\\`/\\`patch\\` inside a requestAnimationFrame loop, or an effect ` +\n          `that emits on every render). It can freeze the app by saturating ` +\n          `subscribers and plugins (logging/devtools). Keep high-frequency work ` +\n          `imperative and emit only coarse/throttled state, or raise ` +\n          `\\`configureBlac({ maxEmitsPerSecond })\\`. (This warning fires once.)`,\n      );\n    }\n  }\n}\n","import { StateContainer } from './StateContainer';\n\n/**\n * `Cubit<S>` is a `StateContainer<S>` with `emit` / `patch` exposed as\n * public mutation surface. Today it adds nothing structurally beyond\n * `StateContainer` — both are inherited from the underlying\n * `StructuralContainer<S>`. Kept as a real class (not a type alias) because\n * downstream code does `instance instanceof Cubit` checks.\n *\n * The class body is intentionally empty: a no-op `emit` override would\n * still go through `applyState`, and `patch` is inherited from\n * `StructuralContainer` (path-diffed, microtask-flushed). A caller that\n * wants \"skip if no real change\" patch semantics can wrap `patch`\n * themselves or call `emit` after a manual equality check.\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","import { getRegistry } from './config';\nimport type {\n  ExtractArgs,\n  StateContainerConstructor,\n} from '../types/utilities';\n\n/**\n * Ensure an instance exists without taking ownership (no ref added). Instance\n * identity is derived purely from `args`, matching `acquire`.\n */\nexport function ensure<T extends StateContainerConstructor>(\n  BlocClass: T,\n  opts?: { args?: ExtractArgs<T> },\n): InstanceType<T> {\n  const registry = getRegistry();\n  const key = registry.resolveKey(BlocClass, undefined, opts?.args);\n  return registry.ensure(BlocClass, key, opts?.args);\n}\n"],"mappings":"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"}