@blac/react 2.0.21 → 2.1.1

package/dist/index.js

@@ -1,19 +1,17 @@
+import { n as useRegistry, t as RegistryProvider } from "./RegistryProvider-BjSXfLeK.js";
 import { createContext, useContext, useEffect, useId, useLayoutEffect, useMemo, useRef, useSyncExternalStore } from "react";
-import { APPLY_DEPS, DEP_BRAND, REMOVE_DEPS_OWNER, WITH_TRACKED_STATE, getRegistry, resolveInstanceKey } from "@blac/core";
 import { ALL_PATHS, ProxyCache, emptyPathSet, pathSetEquals, trackRender, untracked } from "@dirtytalk/structural";
 import { jsx } from "react/jsx-runtime";
+import { APPLY_DEPS, DEP_BRAND, REMOVE_DEPS_OWNER, WITH_TRACKED_STATE } from "@blac/core/internal";
 //#region src/BlocProvider.tsx
 const ProvidedArgsContext = createContext(/* @__PURE__ */ new Map());
 /**
 * Provides args to descendant `useBloc` calls for a specific bloc class via
-* React context.
-*
-* Descendants calling `useBloc(Bloc)` without their own `args` resolve to the
-* args supplied here. Own `args` on the `useBloc` call always win.
+* React context. Own `args` on the `useBloc` call always win.
 *
 * Multiple `BlocProvider` wrappers for different bloc classes compose: each
-* provider merges its entry into the inherited map, so nested providers for
-* different blocs do not interfere.
+* merges its entry into the inherited map, so nested providers for different
+* blocs do not interfere.
 *
 * @example
 * ```tsx
@@ -40,7 +38,7 @@ function BlocProvider({ bloc, args, children }) {
 	}, [
 		parentMap,
 		bloc,
-		resolveInstanceKey(bloc, args)
+		JSON.stringify(args)
 	]);
 	return /* @__PURE__ */ jsx(ProvidedArgsContext.Provider, {
 		value: mergedMap,
@@ -58,96 +56,274 @@ function useProvidedArgs(BlocClass) {
 	return useContext(ProvidedArgsContext).get(BlocClass);
 }
 //#endregion
-//#region src/RegistryProvider.tsx
-/**
-* Internal context value: a registry to use in place of the module-global
-* default (`getRegistry()`), or `null` when no provider is present.
-*/
-const RegistryContext = createContext(null);
-/**
-* Scopes descendant `useBloc` calls to a specific registry instead of the
-* module-global default.
-*
-* Useful for test isolation, SSR isolation, and micro-frontends that must
-* not share bloc instances with the host page.
-*
-* @example
-* ```tsx
-* <RegistryProvider registry={new StateContainerRegistry()}>
-*   <App />
-* </RegistryProvider>
-* ```
-* @public
-*/
-function RegistryProvider({ registry, children }) {
-	return /* @__PURE__ */ jsx(RegistryContext.Provider, {
-		value: registry,
-		children
-	});
-}
-//#endregion
 //#region src/buildTrackedProxy.ts
 function supportsTrackedState(value) {
 	return typeof value[WITH_TRACKED_STATE] === "function";
 }
+const gettersByProto = /* @__PURE__ */ new WeakMap();
+function collectGetters(proto) {
+	const cached = gettersByProto.get(proto);
+	if (cached !== void 0) return cached;
+	const getters = /* @__PURE__ */ new Map();
+	let p = proto;
+	while (p !== null && p !== Object.prototype) {
+		for (const key of Reflect.ownKeys(p)) {
+			const desc = Object.getOwnPropertyDescriptor(p, key);
+			if (desc?.get && !getters.has(key)) getters.set(key, desc.get);
+		}
+		p = Object.getPrototypeOf(p);
+	}
+	gettersByProto.set(proto, getters);
+	return getters;
+}
 /**
 * Build a per-consumer proxy for a bloc instance.
 *
-* Getters run with `this` bound to the **real instance**, not a proxy, so ES
+* Getters run with `this` bound to the real instance, not the proxy, so ES
 * `#private` fields and methods work in user blocs. Path recording is done by
-* `[WITH_TRACKED_STATE]`, which makes the instance's own `state` getter report
-* the render's tracking proxy for the duration of the call; nested getter
-* chains stay tracked because the override is still set.
+* `[WITH_TRACKED_STATE]`, which makes the instance's own `state` getter
+* report the render's tracking proxy for the call's duration; nested getter
+* chains stay tracked because the override remains set.
 *
 * One allocation per bloc acquisition (inside `useMemo`), so the proxy is
 * stable across renders.
 *
-* @param onDepHandle - Optional callback invoked when a read returns a branded
-*   dep handle. Receives the original handle and returns the value to expose in
-*   its place (the session-bound wrapper). The callback is responsible for
-*   caching wrappers per handle to avoid re-allocation.
+* @param onDepHandle - Invoked when a read returns a branded dep handle;
+*   returns the value (the session-bound wrapper) to expose in its place.
+*   Must cache wrappers per handle to avoid re-allocation.
 */
 function buildTrackedProxy(instance, trackedStateRef, onDepHandle) {
-	const getterDescs = /* @__PURE__ */ new Map();
-	let proto = Object.getPrototypeOf(instance);
-	while (proto && proto !== Object.prototype) {
-		const keys = [...Object.getOwnPropertyNames(proto), ...Object.getOwnPropertySymbols(proto)];
-		for (const key of keys) {
-			const desc = Object.getOwnPropertyDescriptor(proto, key);
-			if (desc?.get && !getterDescs.has(key)) getterDescs.set(key, desc);
-		}
-		proto = Object.getPrototypeOf(proto);
-	}
+	const getters = collectGetters(Object.getPrototypeOf(instance));
+	const tracksState = supportsTrackedState(instance);
 	const boundMethods = /* @__PURE__ */ new Map();
 	const wrapDepHandle = (value) => {
 		if (onDepHandle !== void 0 && (typeof value === "function" || typeof value === "object") && value !== null && value[DEP_BRAND] !== void 0) return onDepHandle(value);
 		return value;
 	};
-	return { proxy: new Proxy(instance, { get(target, key) {
-		const getter = getterDescs.get(key)?.get;
-		if (getter) {
-			const tracked = trackedStateRef.current;
-			const read = () => getter.call(target);
-			return wrapDepHandle(tracked == null || !supportsTrackedState(target) ? read() : target[WITH_TRACKED_STATE](tracked, read, onDepHandle));
+	return { proxy: new Proxy(instance, {
+		get(target, key) {
+			const getter = getters.get(key);
+			if (getter !== void 0) {
+				const tracked = trackedStateRef.current;
+				return wrapDepHandle(tracked == null || !tracksState ? getter.call(target) : target[WITH_TRACKED_STATE](tracked, getter, onDepHandle));
+			}
+			const value = Reflect.get(target, key, target);
+			if (typeof value === "function") {
+				const fn = value;
+				let cached = boundMethods.get(key);
+				if (cached === void 0 || cached.fn !== fn) {
+					cached = {
+						fn,
+						bound: fn.bind(target)
+					};
+					boundMethods.set(key, cached);
+				}
+				return wrapDepHandle(cached.bound);
+			}
+			return wrapDepHandle(value);
+		},
+		set(target, key, value) {
+			return Reflect.set(target, key, value, target);
 		}
-		const value = Reflect.get(target, key, target);
-		if (typeof value === "function") {
-			let bound = boundMethods.get(key);
-			if (bound === void 0) {
-				bound = value.bind(target);
-				boundMethods.set(key, bound);
+	}) };
+}
+//#endregion
+//#region src/expandWithAncestors.ts
+/**
+* Add an ancestor-watch id for every ancestor of every tracked leaf, so a
+* `patch` that replaces a parent atomically (e.g. the array `items`) wakes a
+* consumer that read a child (`items.length`).
+*
+* Ancestor-watch ids only match marks the source emits for atomic
+* replacements, never a plain-object pulse-up: `{'user.email'}` does not wake
+* when a sibling `user.name` changes. The `''` root is never added; a root
+* change already marks `ALL_PATHS`.
+*
+* Returns `paths` itself when no leaf has an ancestor.
+*/
+function expandWithAncestors(paths, interner) {
+	if (paths === ALL_PATHS) return ALL_PATHS;
+	const leafPaths = paths;
+	let expanded;
+	for (const id of leafPaths) {
+		const watch = interner.ancestorWatchIds(id);
+		if (watch.length === 0) continue;
+		expanded ??= new Set(leafPaths);
+		for (let i = 0; i < watch.length; i++) expanded.add(watch[i]);
+	}
+	return expanded ?? paths;
+}
+//#endregion
+//#region src/depSession.ts
+/**
+* The containers one `useBloc` consumer reads during a render: its primary
+* bloc plus every dep reached through `this.<handle>.track()`.
+*
+* The render records entries; the commit calls `reconcile`, which subscribes
+* and takes a ref on new deps and drops the ones no longer read. `dispose`
+* releases everything. Refs are only taken at commit, so an uncommitted render
+* never leaks one.
+*/
+var DepSession = class {
+	constructor(consumerId, onChange) {
+		this.consumerId = consumerId;
+		this.onChange = onChange;
+		this.entries = /* @__PURE__ */ new Map();
+		this.subs = /* @__PURE__ */ new Map();
+		this.lastReconciled = null;
+		this.refId = `useBloc@${consumerId}:dep`;
+	}
+	begin(primary, paths) {
+		this.entries.clear();
+		this.entries.set(primary, {
+			kind: "primary",
+			paths
+		});
+	}
+	record(dep, paths, Type, key, args) {
+		const existing = this.entries.get(dep);
+		if (existing !== void 0) existing.paths = unionPaths(existing.paths, paths);
+		else this.entries.set(dep, {
+			kind: "dep",
+			paths,
+			Type,
+			key,
+			args
+		});
+	}
+	/** Forces the next `reconcile` to run in full. */
+	invalidate() {
+		this.lastReconciled = null;
+	}
+	isUnchanged() {
+		const last = this.lastReconciled;
+		if (last === null || last.size !== this.entries.size) return false;
+		for (const [container, entry] of this.entries) {
+			const prev = last.get(container);
+			if (prev === void 0 || !sameEntry(prev, entry)) return false;
+		}
+		return true;
+	}
+	reconcile(registry) {
+		const { consumerId, refId, subs, entries } = this;
+		for (const [dep, sub] of subs) if (!entries.has(dep)) {
+			this.drop(dep, sub);
+			subs.delete(dep);
+		}
+		for (const [dep, entry] of entries) {
+			if (entry.kind === "primary") continue;
+			if (dep.$blac.disposed) {
+				this.onChange();
+				continue;
+			}
+			const interest = expandWithAncestors(entry.paths, dep.interner);
+			dep.registerConsumerPaths(consumerId, entry.paths);
+			const existing = subs.get(dep);
+			if (existing) {
+				existing.interestRef.current = interest;
+				continue;
+			}
+			if (registry.acquire(entry.Type, entry.key, {
+				canCreate: true,
+				countRef: true,
+				refId,
+				args: entry.args
+			}) !== dep) {
+				registry.release(entry.Type, entry.key, false, refId);
+				this.onChange();
+				continue;
 			}
-			return wrapDepHandle(bound);
+			const interestRef = { current: interest };
+			const unsubscribe = dep.channel.subscribe(() => interestRef.current, this.onChange);
+			subs.set(dep, {
+				unsubscribe,
+				interestRef,
+				registry,
+				Type: entry.Type,
+				key: entry.key
+			});
 		}
-		return wrapDepHandle(value);
-	} }) };
+		this.lastReconciled = new Map(entries);
+	}
+	dispose() {
+		for (const [dep, sub] of this.subs) this.drop(dep, sub);
+		this.subs.clear();
+		this.lastReconciled = null;
+	}
+	drop(dep, sub) {
+		sub.unsubscribe();
+		dep.unregisterConsumer(this.consumerId);
+		sub.registry.release(sub.Type, sub.key, false, this.refId);
+	}
+};
+function sameEntry(a, b) {
+	if (a.kind !== b.kind || !pathSetEquals(a.paths, b.paths)) return false;
+	if (a.kind === "primary" || b.kind === "primary") return true;
+	return a.key === b.key && Object.is(a.args, b.args);
+}
+function unionPaths(a, b) {
+	if (a === ALL_PATHS || b === ALL_PATHS) return ALL_PATHS;
+	const out = new Set(a);
+	for (const id of b) out.add(id);
+	return out;
+}
+/**
+* Wrap a dep handle read inside a tracked getter. During a render (`tracked`
+* is set) `.track()` records the dep's read paths into `session` and returns
+* a tracked proxy, so the dep's own getters track too. Outside a render it
+* returns the live `[state, dep]`, like the core handle.
+*
+* Args resolve per call, so one handle can reach several instances; proxies
+* are cached per resolved instance.
+*/
+function makeDepWrapper(handle, registry, session, tracked, onDepHandle) {
+	const brand = handle[DEP_BRAND];
+	const perDep = /* @__PURE__ */ new Map();
+	const proxyCache = new ProxyCache();
+	const resolve = (options) => {
+		const args = options?.args ?? brand.defaultArgs;
+		const key = registry.resolveKey(brand.Type, void 0, args);
+		return {
+			dep: registry.acquire(brand.Type, key, {
+				canCreate: true,
+				countRef: false,
+				args,
+				sweepIfUnowned: tracked.current != null
+			}),
+			key,
+			args
+		};
+	};
+	const wrapper = {
+		untracked: (options) => resolve(options).dep,
+		track: (options) => {
+			const { dep, key, args } = resolve(options);
+			if (tracked.current == null) return [dep.state, dep];
+			const result = trackRender(dep.state, dep.interner, proxyCache);
+			let cache = perDep.get(dep);
+			if (cache === void 0) {
+				const ref = { current: result.value };
+				cache = {
+					ref,
+					proxy: buildTrackedProxy(dep, ref, onDepHandle).proxy
+				};
+				perDep.set(dep, cache);
+			} else cache.ref.current = result.value;
+			session.record(dep, result.paths, brand.Type, key, args);
+			return [result.value, cache.proxy];
+		}
+	};
+	Object.defineProperty(wrapper, DEP_BRAND, {
+		value: brand,
+		enumerable: false,
+		writable: false,
+		configurable: false
+	});
+	return wrapper;
 }
 //#endregion
 //#region src/useBloc.ts
 let nextConsumerId = 0;
-const ARGS_UNSET = Symbol("blac.argsKeyUnset");
-const primaryRefId = (consumerId) => `useBloc@${consumerId}`;
-const depRefId = (consumerId) => `useBloc@${consumerId}:dep`;
 /**
 * React hook that connects a component to a state container with automatic
 * re-render on state changes.
@@ -155,8 +331,7 @@ const depRefId = (consumerId) => `useBloc@${consumerId}:dep`;
 * Two tracking modes:
 * - **Auto-tracking** (default): the returned state value is a proxy that
 *   records read paths during render. The component re-renders when any
-*   recorded path changes. Backed by `@dirtytalk/structural`'s
-*   `trackRender` + the container's path-scoped `DirtyChannel`.
+*   recorded path changes.
 * - **Manual select**: pass `options.select` to opt out of auto-tracking.
 *   The hook re-renders only when the returned array's elements change
 *   (per-index `Object.is`).
@@ -179,7 +354,7 @@ const depRefId = (consumerId) => `useBloc@${consumerId}:dep`;
 * @typeParam T - The state container constructor type (inferred from BlocClass)
 * @param BlocClass - The state container class to connect to
 * @param options - Configuration options
-* @returns Tuple of `[state, bloc, ref]`
+* @returns Tuple of `[state, bloc]`
 *
 * @example Basic usage
 * ```ts
@@ -200,77 +375,41 @@ const depRefId = (consumerId) => `useBloc@${consumerId}:dep`;
 * @public
 */
 function useBloc(BlocClass, options) {
-	const registry = useContext(RegistryContext) ?? getRegistry();
-	const consumerIdRef = useRef(null);
-	if (consumerIdRef.current === null) consumerIdRef.current = `useBloc-${nextConsumerId++}`;
-	const consumerId = consumerIdRef.current;
-	const selectRef = useRef(options?.select);
-	selectRef.current = options?.select;
-	const onMountRef = useRef(options?.onMount);
-	onMountRef.current = options?.onMount;
-	const onUnmountRef = useRef(options?.onUnmount);
-	onUnmountRef.current = options?.onUnmount;
-	const ownArgs = options?.args;
-	const ownArgsRef = useRef(ownArgs);
-	ownArgsRef.current = ownArgs;
-	const ownArgsKeyRef = useRef({
-		ref: ARGS_UNSET,
-		key: void 0
-	});
-	if (!Object.is(ownArgsKeyRef.current.ref, ownArgs)) ownArgsKeyRef.current = {
-		ref: ownArgs,
-		key: ownArgs === void 0 ? void 0 : JSON.stringify(ownArgs)
-	};
-	const ownArgsKey = ownArgsKeyRef.current.key;
-	const providerArgs = useProvidedArgs(BlocClass);
-	const providerArgsRef = useRef(providerArgs);
-	providerArgsRef.current = providerArgs;
-	const providerArgsKeyRef = useRef({
-		ref: ARGS_UNSET,
-		key: void 0
-	});
-	if (!Object.is(providerArgsKeyRef.current.ref, providerArgs)) providerArgsKeyRef.current = {
-		ref: providerArgs,
-		key: providerArgs === void 0 ? void 0 : JSON.stringify(providerArgs)
-	};
-	const providerArgsKey = providerArgsKeyRef.current.key;
-	const resolveEffectiveArgs = () => ownArgsRef.current !== void 0 ? ownArgsRef.current : providerArgsRef.current;
-	const trackedStateRef = useRef(null);
-	const proxyCacheRef = useRef(new ProxyCache());
-	const depWrapperCacheRef = useRef(/* @__PURE__ */ new Map());
-	const rebindNonceRef = useRef(0);
-	const rebindNonce = rebindNonceRef.current;
+	const registry = useRegistry();
 	const consumerRef = useRef(null);
-	consumerRef.current ??= createConsumer();
-	const consumer = consumerRef.current;
-	const ownedBlocRef = useRef(null);
-	const { bloc, instanceKey, trackedBloc } = useMemo(() => {
-		const effectiveArgs = resolveEffectiveArgs();
-		const resolvedKey = resolveInstanceKey(BlocClass, effectiveArgs);
-		const instance = registry.acquire(BlocClass, resolvedKey, {
+	const consumer = consumerRef.current ??= createConsumer();
+	const consumerId = consumer.id;
+	consumer.select = options?.select;
+	consumer.onMount = options?.onMount;
+	consumer.onUnmount = options?.onUnmount;
+	consumer.ownArgs = options?.args;
+	consumer.providerArgs = useProvidedArgs(BlocClass);
+	const effectiveArgs = resolveEffectiveArgs(consumer);
+	const instanceKey = registry.resolveKey(BlocClass, void 0, effectiveArgs);
+	const rebindNonce = consumer.rebindNonce;
+	const { bloc, trackedBloc } = useMemo(() => {
+		const instance = registry.acquire(BlocClass, instanceKey, {
 			canCreate: true,
 			countRef: false,
 			args: effectiveArgs,
 			sweepIfUnowned: true
 		});
+		const depWrappers = /* @__PURE__ */ new Map();
 		const onDepHandle = (handle) => {
-			const cache = depWrapperCacheRef.current;
-			const cached = cache.get(handle);
+			const cached = depWrappers.get(handle);
 			if (cached !== void 0) return cached;
-			const wrapper = makeDepWrapper(handle, consumerId, registry, trackedStateRef, consumer, onDepHandle);
-			cache.set(handle, wrapper);
+			const wrapper = makeDepWrapper(handle, registry, consumer.deps, consumer.tracked, onDepHandle);
+			depWrappers.set(handle, wrapper);
 			return wrapper;
 		};
-		const { proxy } = buildTrackedProxy(instance, trackedStateRef, onDepHandle);
+		const { proxy } = buildTrackedProxy(instance, consumer.tracked, onDepHandle);
 		return {
 			bloc: instance,
-			instanceKey: resolvedKey,
 			trackedBloc: proxy
 		};
 	}, [
 		BlocClass,
-		ownArgsKey,
-		providerArgsKey,
+		instanceKey,
 		rebindNonce,
 		registry
 	]);
@@ -280,7 +419,7 @@ function useBloc(BlocClass, options) {
 		const container = consumer.container;
 		const unsubscribe = container.channel.subscribe(() => consumer.interest, () => {
 			if (consumer.isSelectMode) {
-				const select = selectRef.current;
+				const select = consumer.select;
 				if (select) {
 					const next = select(container.state, container);
 					const prev = consumer.selection;
@@ -300,24 +439,25 @@ function useBloc(BlocClass, options) {
 		BlocClass,
 		instanceKey,
 		consumerId,
-		rebindNonce
+		rebindNonce,
+		registry
 	]), consumer.getSnapshot, consumer.getServerSnapshot);
 	useLayoutEffect(() => {
 		const live = registry.acquire(BlocClass, instanceKey, {
 			canCreate: true,
 			countRef: true,
-			refId: primaryRefId(consumerId),
-			args: resolveEffectiveArgs()
+			refId: consumer.primaryRefId,
+			args: resolveEffectiveArgs(consumer)
 		});
-		ownedBlocRef.current = live;
-		onMountRef.current?.(live);
+		consumer.ownedBloc = live;
+		consumer.onMount?.(live);
 		if (live !== bloc) {
-			rebindNonceRef.current++;
+			consumer.rebindNonce++;
 			consumer.bump();
 		}
 		return () => {
-			onUnmountRef.current?.(ownedBlocRef.current ?? bloc);
-			registry.release(BlocClass, instanceKey, false, primaryRefId(consumerId));
+			consumer.onUnmount?.(consumer.ownedBloc ?? bloc);
+			registry.release(BlocClass, instanceKey, false, consumer.primaryRefId);
 		};
 	}, [
 		BlocClass,
@@ -327,115 +467,48 @@ function useBloc(BlocClass, options) {
 	]);
 	const container = consumer.container;
 	const rawState = container.state;
-	const select = selectRef.current;
+	const select = consumer.select;
 	consumer.isSelectMode = select !== void 0;
 	let state;
 	if (select !== void 0) {
 		state = rawState;
-		if (consumer.selection === null) consumer.selection = select(rawState, bloc);
+		consumer.selection = select(rawState, bloc);
 		consumer.interest = ALL_PATHS;
 	} else {
-		const tracked = trackRender(rawState, container.interner, proxyCacheRef.current);
+		const tracked = trackRender(rawState, container.interner, consumer.proxyCache ??= new ProxyCache());
 		state = tracked.value;
-		trackedStateRef.current = tracked.value;
+		consumer.tracked.current = tracked.value;
 		consumer.paths = tracked.paths;
-		const session = consumer.session;
-		session.clear();
-		session.set(container, {
-			kind: "primary",
-			paths: tracked.paths
-		});
-		queueMicrotask(tracked.disarm);
+		consumer.disarm = tracked.disarm;
+		consumer.deps.begin(container, tracked.paths);
 	}
 	useLayoutEffect(() => {
-		trackedStateRef.current = null;
+		consumer.tracked.current = null;
+		const disarm = consumer.disarm;
+		if (disarm !== null) {
+			consumer.disarm = null;
+			disarm();
+		}
+		const deps = consumer.deps;
 		if (consumer.isSelectMode) {
-			consumer.lastReconcile = null;
+			deps.invalidate();
 			return;
 		}
+		if (deps.isUnchanged()) return;
 		const primary = consumer.container;
-		const paths = consumer.paths;
-		const session = consumer.session;
-		const last = consumer.lastReconcile;
-		if (last !== null && last.primaryContainer === primary && pathSetEquals(last.primaryPaths, paths)) {
-			let unchanged = last.deps.size === session.size - 1;
-			if (unchanged) for (const [depContainer, entry] of session) {
-				if (entry.kind === "primary") continue;
-				const prevEntry = last.deps.get(depContainer);
-				if (prevEntry === void 0 || prevEntry.key !== entry.key || prevEntry.refId !== entry.refId || !Object.is(prevEntry.args, entry.args) || !pathSetEquals(prevEntry.paths, entry.paths)) {
-					unchanged = false;
-					break;
-				}
-			}
-			if (unchanged) return;
-		}
-		primary.registerConsumerPaths(consumerId, paths);
-		consumer.interest = expandWithAncestors(paths, primary.interner);
-		const subs = consumer.depSubs;
-		for (const [depContainer, sub] of subs) if (!session.has(depContainer)) {
-			sub.unsubscribe();
-			depContainer.unregisterConsumer(consumerId);
-			registry.release(sub.Type, sub.key, false, sub.refId);
-			subs.delete(depContainer);
-		}
-		for (const [depContainer, entry] of session) {
-			if (entry.kind === "primary") continue;
-			const interest = expandWithAncestors(entry.paths, depContainer.interner);
-			depContainer.registerConsumerPaths(consumerId, entry.paths);
-			const existing = subs.get(depContainer);
-			if (existing) {
-				existing.interestRef.current = interest;
-				continue;
-			}
-			registry.acquire(entry.Type, entry.key, {
-				canCreate: true,
-				countRef: true,
-				refId: entry.refId,
-				args: entry.args
-			});
-			const interestRef = { current: interest };
-			const unsubscribe = depContainer.channel.subscribe(() => interestRef.current, () => consumer.bump());
-			subs.set(depContainer, {
-				unsubscribe,
-				interestRef,
-				Type: entry.Type,
-				key: entry.key,
-				refId: entry.refId,
-				args: entry.args
-			});
-		}
-		const depsSignature = /* @__PURE__ */ new Map();
-		for (const [depContainer, entry] of session) {
-			if (entry.kind === "primary") continue;
-			depsSignature.set(depContainer, {
-				paths: entry.paths,
-				key: entry.key,
-				refId: entry.refId,
-				args: entry.args
-			});
-		}
-		consumer.lastReconcile = {
-			primaryContainer: primary,
-			primaryPaths: paths,
-			deps: depsSignature
-		};
+		primary.registerConsumerPaths(consumerId, consumer.paths);
+		consumer.interest = expandWithAncestors(consumer.paths, primary.interner);
+		deps.reconcile(registry);
 	});
-	useEffect(() => {
-		const subs = consumer.depSubs;
-		return () => {
-			for (const [depContainer, sub] of subs) {
-				sub.unsubscribe();
-				depContainer.unregisterConsumer(consumerId);
-				registry.release(sub.Type, sub.key, false, sub.refId);
-			}
-			subs.clear();
-		};
-	}, [consumerId, registry]);
+	useEffect(() => () => consumer.deps.dispose(), [consumerId]);
 	return [state, trackedBloc];
 }
 const noop = () => {};
 function createConsumer() {
+	const id = `useBloc-${nextConsumerId++}`;
 	const consumer = {
+		id,
+		primaryRefId: `useBloc@${id}`,
 		container: null,
 		version: 0,
 		notify: noop,
@@ -449,144 +522,35 @@ function createConsumer() {
 		paths: emptyPathSet(),
 		isSelectMode: false,
 		selection: null,
-		session: /* @__PURE__ */ new Map(),
-		depSubs: /* @__PURE__ */ new Map(),
-		lastReconcile: null
+		deps: new DepSession(id, () => consumer.bump()),
+		select: void 0,
+		onMount: void 0,
+		onUnmount: void 0,
+		ownArgs: void 0,
+		providerArgs: void 0,
+		tracked: { current: null },
+		disarm: null,
+		proxyCache: null,
+		rebindNonce: 0,
+		ownedBloc: null
 	};
 	return consumer;
 }
-/**
-* Build the per-consumer wrapper that replaces a branded dep handle inside a
-* tracked getter's `this`. The wrapper exposes the same accessors as the core
-* handle and overrides `.track()`:
-*
-* - **Inside a render** (`trackedStateRef.current != null`): resolve (ENSURE,
-*   no ref) the dep, `trackRender` its state, merge the recorded paths into the
-*   session entry, build/reuse a tracked proxy for the dep so its OWN getters
-*   track too, and return `[trackedValue, depProxy]`. The ownership ref is taken
-*   by the layout-effect reconcile pass, not here.
-* - **Outside a render**: degrade to live `[dep.state, dep]` — matches the core
-*   base impl, safe in event handlers/effects/methods.
-*
-* `.untracked()` always returns the live instance with no subscription.
-*
-* Args resolve at call time (`options.args ?? defaultArgs`), so a single handle
-* can resolve different dep instances across calls; tracked-proxy state is
-* therefore cached per resolved instance, not per handle. Guards against a
-* container re-entering tracking within the same render (mutual A↔B deps): if
-* the dep already has a non-primary session entry this render, reuse its proxy
-* + union its paths instead of re-acquiring.
-*/
-function makeDepWrapper(handle, consumerId, registry, trackedStateRef, consumer, onDepHandle) {
-	const brand = handle[DEP_BRAND];
-	const refId = depRefId(consumerId);
-	const perDep = /* @__PURE__ */ new Map();
-	const proxyCache = new ProxyCache();
-	const resolve = (options) => {
-		const args = options?.args ?? brand.defaultArgs;
-		const key = registry.resolveKey(brand.Type, void 0, args);
-		return {
-			dep: registry.ensure(brand.Type, key, args),
-			key,
-			args
-		};
-	};
-	const wrapper = {
-		untracked: (options) => resolve(options).dep,
-		track: (options) => {
-			const { dep, key, args } = resolve(options);
-			if (trackedStateRef.current == null) return [dep.state, dep];
-			const session = consumer.session;
-			const existing = session.get(dep);
-			const tracked = trackRender(dep.state, dep.interner, proxyCache);
-			let cache = perDep.get(dep);
-			if (cache === void 0) {
-				const ref = { current: tracked.value };
-				cache = {
-					ref,
-					proxy: buildTrackedProxy(dep, ref, onDepHandle).proxy
-				};
-				perDep.set(dep, cache);
-			} else cache.ref.current = tracked.value;
-			if (existing !== void 0) existing.paths = unionPaths(existing.paths, tracked.paths);
-			else session.set(dep, {
-				kind: "dep",
-				paths: tracked.paths,
-				Type: brand.Type,
-				key,
-				refId,
-				args
-			});
-			return [tracked.value, cache.proxy];
-		}
-	};
-	Object.defineProperty(wrapper, DEP_BRAND, {
-		value: brand,
-		enumerable: false,
-		writable: false,
-		configurable: false
-	});
-	return wrapper;
-}
-/** Union two PathSets (ALL_PATHS dominates). */
-function unionPaths(a, b) {
-	if (a === ALL_PATHS || b === ALL_PATHS) return ALL_PATHS;
-	const out = new Set(a);
-	for (const id of b) out.add(id);
-	return out;
-}
+const resolveEffectiveArgs = (consumer) => consumer.ownArgs !== void 0 ? consumer.ownArgs : consumer.providerArgs;
 const shallowArrayEqual = (a, b) => {
 	if (a === b) return true;
 	if (a.length !== b.length) return false;
 	for (let i = 0; i < a.length; i++) if (!Object.is(a[i], b[i])) return false;
 	return true;
 };
-/**
-* Expand a PathSet to include an *ancestor-watch* id for every ancestor of
-* every tracked leaf.
-*
-* The auto-tracker records leaf paths (e.g. `'items.length'`), but
-* `StructuralContainer.patch` can only mark the parent (`'items'`) when it
-* replaces a value atomically (arrays, `null`, primitives — it can't see
-* inside). Without expansion, a subscriber with interest `{'items.length'}`
-* would miss a `patch`-triggered atomic-replacement of `items`.
-*
-* Ancestors are added under the interner's *ancestor-watch* lane
-* (`internAncestor`), NOT as normal ids. The source emits a matching
-* ancestor-watch mark only for paths it replaces atomically — never for a
-* plain-object structural pulse-up. So `{'items.length'}` wakes when the array
-* `items` is replaced, but `{'user.email'}` does NOT wake when a sibling
-* `user.name` changes and pulses `user` up: pulse-up `user` is a normal id and
-* the ancestor-watch `user` only intersects another ancestor-watch `user`.
-*
-* Example: leaf `'a.b.c'` adds ancestor-watch ids for `'a.b'` and `'a'` (but
-* NOT the `''` root — a root change is covered by `ALL_PATHS` from the source,
-* and `''` would wake this consumer on every field change).
-*/
-function expandWithAncestors(paths, interner) {
-	if (paths === ALL_PATHS) return ALL_PATHS;
-	const leafPaths = paths;
-	if (leafPaths.size === 0) return paths;
-	const expanded = new Set(leafPaths);
-	for (const id of leafPaths) {
-		const str = interner.lookup(id);
-		let idx = str.lastIndexOf(".");
-		while (idx > 0) {
-			const ancestor = str.slice(0, idx);
-			expanded.add(interner.internAncestor(ancestor));
-			idx = ancestor.lastIndexOf(".");
-		}
-	}
-	return expanded;
-}
 //#endregion
 //#region src/useBlocDeps.ts
 /**
 * Feed live values from the component into a bloc's `deps` lane.
 *
 * Each calling component is one owner: its slice is shallow-merged into the
-* bloc's merged `deps` view, and withdrawn when the component unmounts. The
-* bloc observes changes through `onDepsChanged`.
+* bloc's merged `deps` view and withdrawn on unmount. The bloc observes
+* changes through `onDepsChanged`.
 *
 * ```tsx
 * const [state, bloc] = useBloc(CanvasCubit);
@@ -612,6 +576,6 @@ function useBlocDeps(bloc, slice) {
 	}, [bloc, ownerId]);
 }
 //#endregion
-export { BlocProvider, RegistryProvider, untracked, useBloc, useBlocDeps, useProvidedArgs };
+export { BlocProvider, RegistryProvider, untracked, useBloc, useBlocDeps, useProvidedArgs, useRegistry };
 
 //# sourceMappingURL=index.js.map