@blac/react 2.0.22 → 2.1.2

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,34 +56,6 @@ 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";
@@ -106,53 +76,265 @@ function collectGetters(proto) {
 	gettersByProto.set(proto, getters);
 	return getters;
 }
+var BlocHandler = class {
+	constructor(getters, tracksState, trackedStateRef, onDepHandle) {
+		this.getters = getters;
+		this.tracksState = tracksState;
+		this.trackedStateRef = trackedStateRef;
+		this.onDepHandle = onDepHandle;
+		this.boundMethods = void 0;
+	}
+	get(target, key) {
+		const getter = this.getters.get(key);
+		if (getter !== void 0) {
+			const tracked = this.trackedStateRef.current;
+			return this.wrapDepHandle(tracked == null || !this.tracksState ? getter.call(target) : target[WITH_TRACKED_STATE](tracked, getter, this.onDepHandle));
+		}
+		const value = Reflect.get(target, key, target);
+		if (typeof value === "function") {
+			const fn = value;
+			this.boundMethods ??= /* @__PURE__ */ new Map();
+			let cached = this.boundMethods.get(key);
+			if (cached === void 0 || cached.fn !== fn) {
+				cached = {
+					fn,
+					bound: fn.bind(target)
+				};
+				this.boundMethods.set(key, cached);
+			}
+			return this.wrapDepHandle(cached.bound);
+		}
+		return this.wrapDepHandle(value);
+	}
+	set(target, key, value) {
+		return Reflect.set(target, key, value, target);
+	}
+	wrapDepHandle(value) {
+		if (this.onDepHandle !== void 0 && (typeof value === "function" || typeof value === "object") && value !== null && value[DEP_BRAND] !== void 0) return this.onDepHandle(value);
+		return value;
+	}
+};
 /**
 * 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 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 = 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 handler = new BlocHandler(collectGetters(Object.getPrototypeOf(instance)), supportsTrackedState(instance), trackedStateRef, onDepHandle);
+	return new Proxy(instance, handler);
+}
+//#endregion
+//#region src/depSession.ts
+const NO_PATHS$1 = emptyPathSet();
+/**
+* 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.primary = null;
+		this.primaryPaths = NO_PATHS$1;
+		this.entries = null;
+		this.subs = null;
+		this.reconciled = false;
+		this.lastPrimary = null;
+		this.lastPrimaryPaths = NO_PATHS$1;
+		this.lastEntries = null;
+		this.disarms = null;
+	}
+	get refId() {
+		return `useBloc@${this.consumerId}:dep`;
+	}
+	begin(primary, paths) {
+		this.entries?.clear();
+		if (this.disarms !== null) this.disarms.length = 0;
+		this.primary = primary;
+		this.primaryPaths = paths;
+	}
+	record(dep, paths, Type, key, args, disarm) {
+		(this.disarms ??= []).push(disarm);
+		if (dep === this.primary) {
+			this.primaryPaths = unionPaths(this.primaryPaths, paths);
+			return;
 		}
-		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);
+		const entries = this.entries ??= /* @__PURE__ */ new Map();
+		const existing = entries.get(dep);
+		if (existing !== void 0) existing.paths = unionPaths(existing.paths, paths);
+		else entries.set(dep, {
+			paths,
+			Type,
+			key,
+			args
+		});
+	}
+	/** Stops every dep tracked this render from recording further reads. */
+	disarm() {
+		const disarms = this.disarms;
+		if (disarms === null) return;
+		for (const disarm of disarms) disarm();
+		disarms.length = 0;
+	}
+	/** Forces the next `reconcile` to run in full. */
+	invalidate() {
+		this.reconciled = false;
+	}
+	isUnchanged() {
+		if (!this.reconciled || this.lastPrimary !== this.primary || !pathSetEquals(this.lastPrimaryPaths, this.primaryPaths)) return false;
+		const last = this.lastEntries;
+		const entries = this.entries;
+		if ((last?.size ?? 0) !== (entries?.size ?? 0)) return false;
+		if (last === null || entries === null) return true;
+		for (const [container, entry] of entries) {
+			const prev = last.get(container);
+			if (prev === void 0 || !sameEntry(prev, entry)) return false;
+		}
+		return true;
+	}
+	reconcile(registry) {
+		const { consumerId } = this;
+		const entries = this.entries;
+		this.reconciled = true;
+		this.lastPrimary = this.primary;
+		this.lastPrimaryPaths = this.primaryPaths;
+		this.lastEntries = entries === null || entries.size === 0 ? null : new Map(entries);
+		const subs = this.subs;
+		if (subs !== null) {
+			for (const [dep, sub] of subs) if (entries?.has(dep) !== true) {
+				this.drop(dep, sub);
+				subs.delete(dep);
 			}
-			return wrapDepHandle(bound);
 		}
-		return wrapDepHandle(value);
-	} }) };
+		if (entries === null) return;
+		for (const [dep, entry] of entries) {
+			if (dep.$blac.disposed) {
+				this.onChange();
+				continue;
+			}
+			dep.registerConsumerPaths(consumerId, entry.paths);
+			const existing = subs?.get(dep);
+			if (existing) {
+				existing.subscription.setInterest(entry.paths);
+				continue;
+			}
+			const refId = this.refId;
+			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;
+			}
+			const subscription = dep.subscribePaths(this.onChange);
+			subscription.setInterest(entry.paths);
+			(this.subs ??= /* @__PURE__ */ new Map()).set(dep, {
+				subscription,
+				registry,
+				Type: entry.Type,
+				key: entry.key
+			});
+		}
+	}
+	dispose() {
+		const subs = this.subs;
+		if (subs !== null) {
+			for (const [dep, sub] of subs) this.drop(dep, sub);
+			subs.clear();
+		}
+		this.reconciled = false;
+	}
+	drop(dep, sub) {
+		sub.subscription.unsubscribe();
+		dep.unregisterConsumer(this.consumerId);
+		sub.registry.release(sub.Type, sub.key, false, this.refId);
+	}
+};
+function sameEntry(a, b) {
+	return pathSetEquals(a.paths, b.paths) && 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)
+				};
+				perDep.set(dep, cache);
+			} else cache.ref.current = result.value;
+			session.record(dep, result.paths, brand.Type, key, args, result.disarm);
+			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");
 /**
 * React hook that connects a component to a state container with automatic
 * re-render on state changes.
@@ -160,8 +342,7 @@ const ARGS_UNSET = Symbol("blac.argsKeyUnset");
 * 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`).
@@ -184,7 +365,7 @@ const ARGS_UNSET = Symbol("blac.argsKeyUnset");
 * @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
@@ -205,230 +386,57 @@ const ARGS_UNSET = Symbol("blac.argsKeyUnset");
 * @public
 */
 function useBloc(BlocClass, options) {
-	const registry = useContext(RegistryContext) ?? getRegistry();
+	const registry = useRegistry();
 	const consumerRef = useRef(null);
 	const consumer = consumerRef.current ??= createConsumer();
-	const consumerId = consumer.id;
 	consumer.select = options?.select;
 	consumer.onMount = options?.onMount;
 	consumer.onUnmount = options?.onUnmount;
-	const ownArgs = options?.args;
-	consumer.ownArgs = ownArgs;
-	if (!Object.is(consumer.ownArgsKeyFor, ownArgs)) {
-		consumer.ownArgsKeyFor = ownArgs;
-		consumer.ownArgsKey = ownArgs === void 0 ? void 0 : JSON.stringify(ownArgs);
-	}
-	const ownArgsKey = consumer.ownArgsKey;
-	const providerArgs = useProvidedArgs(BlocClass);
-	consumer.providerArgs = providerArgs;
-	if (!Object.is(consumer.providerArgsKeyFor, providerArgs)) {
-		consumer.providerArgsKeyFor = providerArgs;
-		consumer.providerArgsKey = providerArgs === void 0 ? void 0 : JSON.stringify(providerArgs);
-	}
-	const providerArgsKey = consumer.providerArgsKey;
-	const rebindNonce = consumer.rebindNonce;
-	const { bloc, instanceKey, trackedBloc } = useMemo(() => {
-		const effectiveArgs = resolveEffectiveArgs(consumer);
-		const resolvedKey = resolveInstanceKey(BlocClass, effectiveArgs);
-		const instance = registry.acquire(BlocClass, resolvedKey, {
-			canCreate: true,
-			countRef: false,
-			args: effectiveArgs,
-			sweepIfUnowned: true
-		});
-		const onDepHandle = (handle) => {
-			const cache = consumer.depWrappers ??= /* @__PURE__ */ new Map();
-			const cached = cache.get(handle);
-			if (cached !== void 0) return cached;
-			const wrapper = makeDepWrapper(handle, registry, consumer, onDepHandle);
-			cache.set(handle, wrapper);
-			return wrapper;
-		};
-		const { proxy } = buildTrackedProxy(instance, consumer.tracked, onDepHandle);
-		return {
-			bloc: instance,
-			instanceKey: resolvedKey,
-			trackedBloc: proxy
-		};
-	}, [
-		BlocClass,
-		ownArgsKey,
-		providerArgsKey,
-		rebindNonce,
-		registry
-	]);
-	consumer.container = bloc;
-	useSyncExternalStore(useMemo(() => (onStoreChange) => {
-		consumer.notify = onStoreChange;
-		const container = consumer.container;
-		const unsubscribe = container.channel.subscribe(() => consumer.interest, () => {
-			if (consumer.isSelectMode) {
-				const select = consumer.select;
-				if (select) {
-					const next = select(container.state, container);
-					const prev = consumer.selection;
-					if (prev !== null && shallowArrayEqual(prev, next)) return;
-					consumer.selection = next;
-				}
-			}
-			consumer.bump();
-		});
-		container.registerConsumerPaths(consumerId, consumer.paths);
-		return () => {
-			consumer.notify = noop;
-			unsubscribe();
-			container.unregisterConsumer(consumerId);
-		};
-	}, [
-		BlocClass,
-		instanceKey,
-		consumerId,
-		rebindNonce
-	]), consumer.getSnapshot, consumer.getServerSnapshot);
-	useLayoutEffect(() => {
-		const live = registry.acquire(BlocClass, instanceKey, {
-			canCreate: true,
-			countRef: true,
-			refId: consumer.primaryRefId,
-			args: resolveEffectiveArgs(consumer)
-		});
-		consumer.ownedBloc = live;
-		consumer.onMount?.(live);
-		if (live !== bloc) {
-			consumer.rebindNonce++;
-			consumer.bump();
-		}
-		return () => {
-			consumer.onUnmount?.(consumer.ownedBloc ?? bloc);
-			registry.release(BlocClass, instanceKey, false, consumer.primaryRefId);
-		};
-	}, [
-		BlocClass,
-		instanceKey,
-		consumerId,
-		registry
-	]);
+	consumer.ownArgs = options?.args;
+	consumer.providerArgs = useProvidedArgs(BlocClass);
+	const effectiveArgs = resolveEffectiveArgs(consumer);
+	const instanceKey = registry.resolveKey(BlocClass, void 0, effectiveArgs);
+	if (consumer.BlocClass !== BlocClass || consumer.instanceKey !== instanceKey || consumer.registry !== registry || consumer.boundNonce !== consumer.rebindNonce) bind(consumer, BlocClass, instanceKey, registry, effectiveArgs);
+	useSyncExternalStore(consumer.subscribe, consumer.getSnapshot, consumer.getSnapshot);
 	const container = consumer.container;
 	const rawState = container.state;
+	consumer.renderedState = rawState;
 	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.interest = ALL_PATHS;
+		consumer.selection = select(rawState, container);
+		setInterest(consumer, ALL_PATHS);
 	} else {
 		const tracked = trackRender(rawState, container.interner, consumer.proxyCache ??= new ProxyCache());
 		state = tracked.value;
 		consumer.tracked.current = tracked.value;
 		consumer.paths = tracked.paths;
 		consumer.disarm = tracked.disarm;
-		const session = consumer.session;
-		session.clear();
-		session.set(container, {
-			kind: "primary",
-			paths: tracked.paths
-		});
+		consumer.deps.begin(container, tracked.paths);
 	}
-	useLayoutEffect(() => {
-		consumer.tracked.current = null;
-		const disarm = consumer.disarm;
-		if (disarm !== null) {
-			consumer.disarm = null;
-			disarm();
-		}
-		if (consumer.isSelectMode) {
-			consumer.lastReconcile = null;
-			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
-		};
-	});
-	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]);
-	return [state, trackedBloc];
+	useLayoutEffect(consumer.commit);
+	useLayoutEffect(consumer.mount, NO_DEPS);
+	return [state, consumer.trackedBloc];
 }
 const noop = () => {};
+const NO_PATHS = emptyPathSet();
+const NO_DEPS = [];
 function createConsumer() {
 	const id = `useBloc-${nextConsumerId++}`;
 	const consumer = {
 		id,
 		primaryRefId: `useBloc@${id}`,
-		depRefId: `useBloc@${id}:dep`,
+		BlocClass: null,
+		instanceKey: "",
+		registry: null,
 		container: null,
+		trackedBloc: null,
+		subscribe: null,
+		boundNonce: 0,
+		rebindNonce: 0,
+		renderedState: void 0,
 		version: 0,
 		notify: noop,
 		bump: () => {
@@ -436,164 +444,159 @@ function createConsumer() {
 			consumer.notify();
 		},
 		getSnapshot: () => consumer.version,
-		getServerSnapshot: () => consumer.version,
-		interest: emptyPathSet(),
-		paths: emptyPathSet(),
+		onChange: () => onChange(consumer),
+		unsubscribe: () => unsubscribe(consumer),
+		commit: () => commit(consumer),
+		mount: () => teardown,
+		interest: NO_PATHS,
+		subscription: null,
+		subscribedTo: null,
+		paths: NO_PATHS,
 		isSelectMode: false,
 		selection: null,
-		session: /* @__PURE__ */ new Map(),
-		depSubs: /* @__PURE__ */ new Map(),
-		lastReconcile: null,
+		deps: null,
 		select: void 0,
 		onMount: void 0,
 		onUnmount: void 0,
 		ownArgs: void 0,
-		ownArgsKeyFor: ARGS_UNSET,
-		ownArgsKey: void 0,
 		providerArgs: void 0,
-		providerArgsKeyFor: ARGS_UNSET,
-		providerArgsKey: void 0,
 		tracked: { current: null },
 		disarm: null,
 		proxyCache: null,
-		depWrappers: null,
-		rebindNonce: 0,
+		ownedClass: null,
+		ownedKey: "",
+		ownedRegistry: null,
 		ownedBloc: null
 	};
+	const teardown = () => {
+		release(consumer);
+		consumer.deps.dispose();
+	};
+	consumer.deps = new DepSession(id, consumer.bump);
 	return consumer;
 }
-const resolveEffectiveArgs = (consumer) => consumer.ownArgs !== void 0 ? consumer.ownArgs : consumer.providerArgs;
-/**
-* 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** (`consumer.tracked.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, registry, consumer, onDepHandle) {
-	const brand = handle[DEP_BRAND];
-	const refId = consumer.depRefId;
-	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
-		};
+function bind(consumer, BlocClass, instanceKey, registry, args) {
+	const instance = registry.acquire(BlocClass, instanceKey, {
+		canCreate: true,
+		countRef: false,
+		args,
+		sweepIfUnowned: true
+	});
+	let depWrappers;
+	const onDepHandle = (handle) => {
+		depWrappers ??= /* @__PURE__ */ new Map();
+		const cached = depWrappers.get(handle);
+		if (cached !== void 0) return cached;
+		const wrapper = makeDepWrapper(handle, registry, consumer.deps, consumer.tracked, onDepHandle);
+		depWrappers.set(handle, wrapper);
+		return wrapper;
 	};
-	const wrapper = {
-		untracked: (options) => resolve(options).dep,
-		track: (options) => {
-			const { dep, key, args } = resolve(options);
-			if (consumer.tracked.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];
+	consumer.BlocClass = BlocClass;
+	consumer.instanceKey = instanceKey;
+	consumer.registry = registry;
+	consumer.boundNonce = consumer.rebindNonce;
+	consumer.container = instance;
+	consumer.trackedBloc = buildTrackedProxy(instance, consumer.tracked, onDepHandle);
+	consumer.subscribe = (onStoreChange) => subscribe(consumer, onStoreChange);
+}
+function subscribe(consumer, onStoreChange) {
+	consumer.notify = onStoreChange;
+	const container = consumer.container;
+	const subscription = container.subscribePaths(consumer.onChange);
+	subscription.setInterest(consumer.interest);
+	consumer.subscription = subscription;
+	consumer.subscribedTo = container;
+	container.registerConsumerPaths(consumer.id, consumer.paths);
+	return consumer.unsubscribe;
+}
+function unsubscribe(consumer) {
+	consumer.notify = noop;
+	consumer.subscription?.unsubscribe();
+	consumer.subscription = null;
+	consumer.subscribedTo?.unregisterConsumer(consumer.id);
+	consumer.subscribedTo = null;
+}
+function onChange(consumer) {
+	if (consumer.isSelectMode) {
+		const select = consumer.select;
+		const container = consumer.subscribedTo;
+		if (select && container !== null) {
+			const next = select(container.state, container);
+			const prev = consumer.selection;
+			if (prev !== null && shallowArrayEqual(prev, next)) return;
+			consumer.selection = next;
 		}
-	};
-	Object.defineProperty(wrapper, DEP_BRAND, {
-		value: brand,
-		enumerable: false,
-		writable: false,
-		configurable: false
+	}
+	consumer.bump();
+}
+function claim(consumer) {
+	const { BlocClass, instanceKey, registry } = consumer;
+	if (consumer.ownedClass === BlocClass && consumer.ownedKey === instanceKey && consumer.ownedRegistry === registry) return;
+	release(consumer);
+	const live = registry.acquire(BlocClass, instanceKey, {
+		canCreate: true,
+		countRef: true,
+		refId: consumer.primaryRefId,
+		args: resolveEffectiveArgs(consumer)
 	});
-	return wrapper;
+	consumer.ownedClass = BlocClass;
+	consumer.ownedKey = instanceKey;
+	consumer.ownedRegistry = registry;
+	consumer.ownedBloc = live;
+	consumer.onMount?.(live);
+	if (live !== consumer.container) {
+		consumer.rebindNonce++;
+		consumer.bump();
+	}
 }
-/** 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;
+function release(consumer) {
+	const { ownedClass, ownedRegistry } = consumer;
+	if (ownedClass === null || ownedRegistry === null) return;
+	consumer.onUnmount?.(consumer.ownedBloc);
+	consumer.ownedClass = null;
+	consumer.ownedRegistry = null;
+	ownedRegistry.release(ownedClass, consumer.ownedKey, false, consumer.primaryRefId);
 }
+function commit(consumer) {
+	claim(consumer);
+	consumer.tracked.current = null;
+	const disarm = consumer.disarm;
+	if (disarm !== null) {
+		consumer.disarm = null;
+		disarm();
+	}
+	const deps = consumer.deps;
+	deps.disarm();
+	if (consumer.isSelectMode) {
+		deps.invalidate();
+		return;
+	}
+	const primary = consumer.container;
+	if (primary.state !== consumer.renderedState) consumer.bump();
+	if (deps.isUnchanged()) return;
+	primary.registerConsumerPaths(consumer.id, consumer.paths);
+	setInterest(consumer, consumer.paths);
+	deps.reconcile(consumer.registry);
+}
+const setInterest = (consumer, interest) => {
+	consumer.interest = interest;
+	consumer.subscription?.setInterest(interest);
+};
+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
-* (`ancestorWatchIds`), 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).
-*
-* Returns `paths` itself when no leaf has an ancestor (top-level fields only);
-* the set is frozen by then (see `Consumer.disarm`), so sharing it is safe.
-*/
-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/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);
@@ -619,6 +622,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