@blac/core 2.0.22 → 2.1.1

package/dist/StateContainer-j16zciex.cjs

@@ -0,0 +1,667 @@
+const require_StateContainerRegistry = require("./StateContainerRegistry-C8jxrcqk.cjs");
+let _dirtytalk_structural = require("@dirtytalk/structural");
+//#region src/utils/idGenerator.ts
+/**
+* Build an instance id: `${prefix}:${affix}` when an affix is given (the
+* registry passes the instance key), otherwise `${prefix}:${timestamp}_${random}`.
+*
+* Ids are not unique: same-named classes share an id for the same affix, and
+* the lazy `$blac.id` of an unregistered instance is always `${prefix}:main`.
+*
+* @example
+* ```ts
+* generateSimpleId('CounterBloc', 'default'); // "CounterBloc:default"
+* generateSimpleId('CounterBloc'); // "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/registry/config.ts
+let _registry = require_StateContainerRegistry.globalRegistry;
+/**
+* The registry every plain helper (`acquire`, `ensure`, `watch`, …) uses.
+* `RegistryProvider` from `@blac/react` does not change it; components use
+* `useRegistry()` for the provider's registry.
+* @public
+*/
+function getRegistry() {
+	return _registry;
+}
+/**
+* @public
+*/
+function setRegistry(registry) {
+	_registry = registry;
+}
+/**
+* @public
+*/
+function getStats() {
+	return _registry.getStats();
+}
+//#endregion
+//#region src/core/meta.ts
+/**
+* `$blac` meta namespace for `StateContainer`.
+*
+* `BlacMeta` and `BlacHydration` are classes whose accessors live on the
+* prototype and read the container through one `#private` back-reference, so
+* a container allocates a single small object here instead of a literal with
+* seven closures. Members are therefore not own-enumerable: `Object.keys` and
+* `JSON.stringify` see an empty object. Read the fields by name.
+*/
+/**
+* Non-enumerable brand carried on every `$blac` object. 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();
+/**
+* Hydration sub-surface of {@link BlacMeta}. Exposes the container's
+* hydration state machine — the `begin`/`apply`/`finish`/`fail`/`wait`
+* methods and the `status`/`error`/`isHydrated`/`changedWhileHydrating`
+* getters — namespaced under `$blac`.
+*/
+var BlacHydration = class {
+	#c;
+	/** @internal */
+	constructor(container) {
+		this.#c = container;
+		Object.freeze(this);
+	}
+	get status() {
+		return this.#c._hydrationStatus;
+	}
+	get error() {
+		return this.#c._hydrationError;
+	}
+	get isHydrated() {
+		return this.#c._hydrationStatus === "hydrated";
+	}
+	get changedWhileHydrating() {
+		return this.#c._changedWhileHydrating;
+	}
+	begin() {
+		this.#c._beginHydration();
+	}
+	apply(next) {
+		return this.#c._applyHydratedState(next);
+	}
+	finish() {
+		this.#c._finishHydration();
+	}
+	fail(error) {
+		this.#c._failHydration(error);
+	}
+	wait() {
+		return this.#c._waitForHydration();
+	}
+};
+/**
+* The reserved `$blac` instance member on every `StateContainer`. Gathers the
+* container's identity/lifecycle/hydration surface (`name`, `id`, `debug`,
+* `createdAt`, `disposed`, `dependencies`, and the hydration methods) under one
+* namespace, keeping the generic names free for userland blocs.
+*
+* Allocated once per container and frozen. Every accessor reads the
+* container's current `_`-private fields live — values are never snapshotted.
+*/
+var BlacMeta = class {
+	#c;
+	#hydration;
+	/** @internal Called from the `StateContainer` field initializer. */
+	constructor(container) {
+		this.#c = container;
+		Object.freeze(this);
+	}
+	get name() {
+		return this.#c._name;
+	}
+	get id() {
+		const c = this.#c;
+		return c._instanceId ??= generateSimpleId(require_StateContainerRegistry.getBlacName(c.constructor), "main");
+	}
+	get debug() {
+		return this.#c._debug;
+	}
+	get createdAt() {
+		return this.#c._createdAt;
+	}
+	get disposed() {
+		return this.#c._disposed;
+	}
+	get dependencies() {
+		return this.#c._dependencies ?? EMPTY_DEPS;
+	}
+	/** Built on first access; identity-stable afterwards. */
+	get hydration() {
+		return this.#hydration ??= new BlacHydration(this.#c);
+	}
+};
+Object.defineProperty(BlacMeta.prototype, META_BRAND, {
+	value: true,
+	enumerable: false,
+	writable: false,
+	configurable: false
+});
+//#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 from `@blac/core/internal` for `@blac/react`.
+*/
+const DEP_BRAND = Symbol("blac.depHandle");
+const EMPTY_RECORD = Object.freeze({});
+let deactivatedReason;
+let stateChangeCount = 0;
+/** @internal */
+function getStateChangeCount() {
+	return stateChangeCount;
+}
+/**
+* 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`
+* (which provides `state`, `emit`/`patch`/`update`, and `channel`).
+* StateContainer adds identity/lifecycle/hydration (`$blac: BlacMeta`),
+* cross-bloc deps (`depend()`), per-consumer deps slices, and registry
+* integration. Subscribe via `onSystemEvent(...)` for coarse lifecycle
+* events or `this.channel.subscribe(...)` for path-scoped ones.
+*/
+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 (require_StateContainerRegistry.IS_DEV) 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();
+	}
+	/**
+	* @internal Subscribe to this instance's own disposal. Delegates to the
+	* per-instance `'dispose'` system event — used by `watch()` in place of
+	* filtering the global registry `'disposed'` event.
+	*/
+	[require_StateContainerRegistry.ON_DISPOSE](handler) {
+		return this.onSystemEvent("dispose", handler);
+	}
+	/**
+	* @internal Drive the 0↔1 ownership transition. Idempotent: repeated calls
+	* with the same value are no-ops, so the registry can call it from every
+	* acquire/release without tracking edges itself.
+	*
+	* Returns which real transition (if any) just happened, so the registry can
+	* emit the matching `activated`/`deactivated` plugin event without exposing
+	* `_activation` itself — `'none'` for an idempotent no-op call.
+	*/
+	[require_StateContainerRegistry.SET_ACTIVE](active) {
+		if (this._disposed) return "none";
+		if (active === (this._activation !== null)) return "none";
+		if (active) {
+			this._activation = new AbortController();
+			this.onActivate(this._activation.signal);
+			return {
+				kind: "activated",
+				signal: this._activation.signal
+			};
+		}
+		this._abortActivation();
+		this.onDeactivate();
+		return "deactivated";
+	}
+	_abortActivation() {
+		this._activation?.abort(deactivatedReason ??= new DOMException("The bloc was deactivated", "AbortError"));
+		this._activation = null;
+	}
+	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 state() {
+		return this._stateOverride ?? super.state;
+	}
+	/**
+	* @internal Run `fn` (with `this` = this instance, so a prototype getter can
+	* be passed directly) while `state` reports `tracked` and dep handles read
+	* off `this` route through `onDepHandle`. Restored in `finally`, and
+	* nestable — getters reading other getters stay in tracked context.
+	*
+	* The dep hook lives here rather than in the adapter's proxy because getters
+	* now run with `this` = the real instance (so ES `#private` works), which
+	* means a `this.someDep` read never passes through the proxy's trap.
+	*/
+	[require_StateContainerRegistry.WITH_TRACKED_STATE](tracked, fn, onDepHandle) {
+		const prevState = this._stateOverride;
+		const prevHook = this._depHandleHook;
+		this._stateOverride = tracked;
+		this._depHandleHook = onDepHandle;
+		try {
+			return fn.call(this);
+		} finally {
+			this._stateOverride = prevState;
+			this._depHandleHook = prevHook;
+		}
+	}
+	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);
+			if (this._disposed && require_StateContainerRegistry.IS_DEV) console.warn(`[blac] ${this._name}: dependency accessed after dispose. Guard with \`if (this.$blac.disposed) return\` after each \`await\`.`);
+			return this._registry.acquire(Type, key, {
+				canCreate: true,
+				countRef: false,
+				args: effectiveArgs,
+				dependent: this._disposed ? void 0 : this,
+				sweepIfUnowned: this._disposed
+			});
+		};
+		const handle = {
+			track: (options) => {
+				const wrapped = this._depHandleHook?.(handle);
+				if (wrapped !== void 0 && wrapped !== handle) return wrapped.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 = EMPTY_RECORD;
+		this._disposed = false;
+		this._hydrationStatus = "idle";
+		this._changedWhileHydrating = false;
+		this._hydrationPromise = null;
+		this._hydrationPromiseSettled = false;
+		this._config = EMPTY_RECORD;
+		this._initCalled = false;
+		this._activation = null;
+		this._emitWindowStart = 0;
+		this._emitCount = 0;
+		this._emitRateWarned = false;
+		this._systemEventHandlers = null;
+		this._dependencies = null;
+		this._pendingChange = null;
+		this._bridgeUnsub = null;
+		this._registry = getRegistry();
+		this._equalityFn = require_StateContainerRegistry.getClassEquality(this.constructor) ?? require_StateContainerRegistry.getBlacConfig().equality;
+		this._name = require_StateContainerRegistry.getBlacName(this.constructor);
+		this._debug = false;
+		this._createdAt = Date.now();
+		this.$blac = new BlacMeta(this);
+	}
+	/**
+	* 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) {}
+	/**
+	* Called when this instance goes from unowned to owned (first ref or first
+	* `depend()` dependent). Override to start work that should only run while
+	* something is actually using the instance — fetches, timers, listeners.
+	*
+	* `signal` aborts on the matching `onDeactivate` and on dispose, so
+	* async work started here can be cancelled without extra bookkeeping.
+	*
+	* Runs before the first `useBlocDeps` slice is applied, so `this.deps` is
+	* empty on first activation — use `onDepsChanged` for deps-driven work.
+	*/
+	onActivate(_signal) {}
+	/**
+	* Called when this instance goes from owned back to unowned while surviving
+	* in the registry (i.e. `keepAlive`). A disposed instance does NOT get this
+	* callback — `dispose()` is the teardown path for that case.
+	*/
+	onDeactivate() {}
+	/**
+	* @internal Framework-only configuration entry point (registry + testing
+	* helpers). Writes the `_`-private identity fields directly, emits the
+	* registry `created` event, and runs `init()` once. See `INIT_CONFIG`.
+	*/
+	[require_StateContainerRegistry.INIT_CONFIG](config) {
+		this._config = { ...config };
+		const className = require_StateContainerRegistry.getBlacName(this.constructor);
+		this._name = this._config.name || className;
+		this._debug = this._config.debug ?? false;
+		this._instanceId = generateSimpleId(className, this._config.instanceId);
+		this._registry = this._config.registry ?? this._registry;
+		if (!this._initCalled) {
+			this._initCalled = true;
+			this.init(this._config.args);
+		}
+		this._registry.emit("created", this);
+		if (require_StateContainerRegistry.IS_DEV) {
+			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._abortActivation();
+		this._systemEventHandlers = null;
+		this._pendingChange = null;
+		this._registry.emit("disposed", this);
+		super.dispose();
+		if (this._debug) console.log(`[${this._name}] Disposed successfully`);
+	}
+	emit(next) {
+		this.applyState(next, "default");
+	}
+	/** @see emit for the StateContainer concerns layered onto `super.patch`. */
+	patch(partial) {
+		if (this._disposed) {
+			this._warnDisposedMutation("patch");
+			return;
+		}
+		const prev = super.state;
+		super.patch(partial);
+		const next = super.state;
+		if (Object.is(prev, next)) return;
+		this._recordChange(prev, next, "default");
+	}
+	applyState(next, source) {
+		if (this._disposed) {
+			this._warnDisposedMutation("emit");
+			return;
+		}
+		const prev = super.state;
+		if (prev === next) return;
+		if (this._equalityFn(prev, next)) return;
+		this._recordChange(prev, next, source);
+		super.emit(next);
+	}
+	/** Bookkeeping shared by every real state change (`emit`, `patch`, hydration). */
+	_recordChange(prev, next, source) {
+		stateChangeCount++;
+		if (require_StateContainerRegistry.IS_DEV && !this._emitRateWarned) this._checkEmitRate();
+		if (this._hydrationStatus === "hydrating" && source !== "hydration") this._changedWhileHydrating = true;
+		if (this._bridgeUnsub !== null) if (this._pendingChange) this._pendingChange.next = next;
+		else this._pendingChange = {
+			prev,
+			next
+		};
+		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;
+		this.emitSystemEvent("stateChanged", {
+			state: pending.next,
+			previousState: pending.prev
+		});
+	}
+	_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");
+	}
+	_warnDisposedMutation(op) {
+		if (require_StateContainerRegistry.IS_DEV) console.warn(`[blac] ${this._name}: ${op}() after dispose ignored. This usually means an async method resolved after the last consumer unmounted. Guard with \`if (this.$blac.disposed) return\` after each \`await\`, or abort the work from \`onSystemEvent('dispose', ...)\`.`);
+	}
+	_applyHydratedState(next) {
+		if (this._disposed) return false;
+		if (this._hydrationStatus !== "hydrating" || this._changedWhileHydrating) {
+			if (require_StateContainerRegistry.IS_DEV && this._changedWhileHydrating) console.warn(`[blac] ${this._name}: persisted state discarded because the container emitted while hydrating.`);
+			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);
+	}
+	onSystemEvent(event, handler) {
+		if (this._disposed) return () => {};
+		const all = this._systemEventHandlers ??= /* @__PURE__ */ new Map();
+		let handlers = all.get(event);
+		if (!handlers) {
+			handlers = /* @__PURE__ */ new Set();
+			all.set(event, handlers);
+		}
+		handlers.add(handler);
+		if (event === "stateChanged" && this._bridgeUnsub === null) this._bridgeUnsub = this.channel.subscribe(() => _dirtytalk_structural.ALL_PATHS, () => this._drainPending());
+		return () => {
+			handlers?.delete(handler);
+			if (event === "stateChanged" && handlers?.size === 0) {
+				this._bridgeUnsub?.();
+				this._bridgeUnsub = null;
+				this._pendingChange = null;
+			}
+		};
+	}
+	emitSystemEvent(event, payload) {
+		const handlers = this._systemEventHandlers?.get(event);
+		if (!handlers) return;
+		let remaining = handlers.size;
+		for (const handler of handlers) {
+			if (remaining-- === 0) break;
+			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)) 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
+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, "getRegistry", {
+	enumerable: true,
+	get: function() {
+		return getRegistry;
+	}
+});
+Object.defineProperty(exports, "getStateChangeCount", {
+	enumerable: true,
+	get: function() {
+		return getStateChangeCount;
+	}
+});
+Object.defineProperty(exports, "getStats", {
+	enumerable: true,
+	get: function() {
+		return getStats;
+	}
+});
+Object.defineProperty(exports, "setRegistry", {
+	enumerable: true,
+	get: function() {
+		return setRegistry;
+	}
+});
+
+//# sourceMappingURL=StateContainer-j16zciex.cjs.map