@pumped-fn/lite 2.0.0 → 2.1.2

package/dist/index.cjs

@@ -88,7 +88,7 @@ function getAtomsForTag(tag$1) {
 	return live;
 }
 function tag(options) {
-	const key = Symbol.for(`@pumped-fn/lite/tag/${options.label}`);
+	const key = Symbol(`@pumped-fn/lite/tag/${options.label}`);
 	const hasDefault = "default" in options;
 	const defaultValue = hasDefault ? options.default : void 0;
 	const parse = options.parse;
@@ -263,20 +263,33 @@ function isAtom(value) {
 * The Controller provides full lifecycle control: get, resolve, release, invalidate, and subscribe.
 *
 * @param atom - The Atom to wrap
-* @param options - Optional configuration. Use { resolve: true } to auto-resolve before factory runs.
+* @param options - Optional configuration:
+*   - `resolve: true` — auto-resolves the dep before the parent factory runs; `config.get()` is safe.
+*   - `watch: true` — atom deps only; requires `resolve: true`; automatically re-runs the parent factory
+*     when the dep resolves to a new value (value-equality gated via `Object.is` by default). Replaces
+*     manual `ctx.cleanup(ctx.scope.on('resolved', dep, () => ctx.invalidate()))` wiring. Watch
+*     listeners are auto-cleaned on re-resolve, release, and dispose.
+*   - `eq` — custom equality function `(a: T, b: T) => boolean`; only used with `watch: true`.
 * @returns A ControllerDep that resolves to a Controller for the Atom
 *
 * @example
 * ```typescript
-* const configAtom = atom({ factory: () => fetchConfig() })
+* // resolve only
 * const serverAtom = atom({
 *   deps: { config: controller(configAtom, { resolve: true }) },
-*   factory: (ctx, { config }) => {
-*     // config.get() is safe - already resolved
-*     const unsub = config.on('resolved', () => ctx.invalidate())
-*     ctx.cleanup(unsub)
-*     return createServer(config.get().port)
-*   }
+*   factory: (_, { config }) => createServer(config.get().port),
+* })
+*
+* // watch: re-runs parent when dep value changes
+* const profileAtom = atom({
+*   deps: { token: controller(tokenAtom, { resolve: true, watch: true }) },
+*   factory: (_, { token }) => ({ id: `user-${token.get().jwt}` }),
+* })
+*
+* // watch with custom equality
+* const derivedAtom = atom({
+*   deps: { src: controller(srcAtom, { resolve: true, watch: true, eq: (a, b) => a.id === b.id }) },
+*   factory: (_, { src }) => src.get().name,
 * })
 * ```
 */
@@ -284,7 +297,9 @@ function controller(atom$1, options) {
 	return {
 		[controllerDepSymbol]: true,
 		atom: atom$1,
-		resolve: options?.resolve
+		resolve: options?.resolve,
+		watch: options?.watch,
+		eq: options?.eq
 	};
 }
 /**
@@ -410,12 +425,14 @@ function isResource(value) {
 //#endregion
 //#region src/service.ts
 function service(config) {
-	return {
+	const atomInstance = {
 		[atomSymbol]: true,
 		factory: config.factory,
 		deps: config.deps,
 		tags: config.tags
 	};
+	if (config.tags?.length) registerAtomToTags(atomInstance, config.tags);
+	return atomInstance;
 }
 
 //#endregion
@@ -431,7 +448,7 @@ function getResourceKey(resource$1) {
 	return key;
 }
 const inflightResources = /* @__PURE__ */ new WeakMap();
-const resolvingResources = /* @__PURE__ */ new Set();
+const resolvingResourcesMap = /* @__PURE__ */ new WeakMap();
 var ContextDataImpl = class {
 	map = /* @__PURE__ */ new Map();
 	constructor(parentData) {
@@ -456,6 +473,10 @@ var ContextDataImpl = class {
 		if (this.map.has(key)) return this.map.get(key);
 		return this.parentData?.seek(key);
 	}
+	seekHas(key) {
+		if (this.map.has(key)) return true;
+		return this.parentData?.seekHas(key) ?? false;
+	}
 	getTag(tag$1) {
 		return this.map.get(tag$1.key);
 	}
@@ -501,6 +522,16 @@ var SelectHandleImpl = class {
 		return this.currentValue;
 	}
 	subscribe(listener) {
+		if (!this.ctrlUnsub) {
+			this.currentValue = this.selector(this.ctrl.get());
+			this.ctrlUnsub = this.ctrl.on("resolved", () => {
+				const nextValue = this.selector(this.ctrl.get());
+				if (!this.eq(this.currentValue, nextValue)) {
+					this.currentValue = nextValue;
+					this.notifyListeners();
+				}
+			});
+		}
 		this.listeners.add(listener);
 		return () => {
 			this.listeners.delete(listener);
@@ -508,12 +539,15 @@ var SelectHandleImpl = class {
 		};
 	}
 	notifyListeners() {
-		for (const listener of this.listeners) listener();
+		for (const listener of [...this.listeners]) listener();
+	}
+	dispose() {
+		this.listeners.clear();
+		this.cleanup();
 	}
 	cleanup() {
 		this.ctrlUnsub?.();
 		this.ctrlUnsub = null;
-		this.listeners.clear();
 	}
 };
 var ControllerImpl = class {
@@ -562,11 +596,15 @@ var ScopeImpl = class {
 	invalidationScheduled = false;
 	invalidationChain = null;
 	chainPromise = null;
+	chainError = null;
 	initialized = false;
+	disposed = false;
 	controllers = /* @__PURE__ */ new Map();
 	gcOptions;
 	extensions;
 	tags;
+	resolveExts;
+	execExts;
 	ready;
 	scheduleInvalidation(atom$1) {
 		const entry = this.cache.get(atom$1);
@@ -579,16 +617,22 @@ var ScopeImpl = class {
 		if (!this.chainPromise) {
 			this.invalidationChain = /* @__PURE__ */ new Set();
 			this.invalidationScheduled = true;
-			this.chainPromise = new Promise((resolve, reject) => {
-				queueMicrotask(() => {
-					this.processInvalidationChain().then(resolve).catch(reject);
+			this.chainError = null;
+			this.chainPromise = (async () => {
+				await new Promise((resolve) => {
+					queueMicrotask(resolve);
 				});
-			});
+				try {
+					await this.processInvalidationChain();
+				} catch (error) {
+					if (this.chainError === null) this.chainError = error;
+				}
+			})();
 		}
 	}
 	async processInvalidationChain() {
 		try {
-			while (this.invalidationQueue.size > 0) {
+			while (this.invalidationQueue.size > 0 && !this.disposed) {
 				const atom$1 = this.invalidationQueue.values().next().value;
 				this.invalidationQueue.delete(atom$1);
 				if (this.invalidationChain.has(atom$1)) {
@@ -609,6 +653,8 @@ var ScopeImpl = class {
 	constructor(options) {
 		this.extensions = options?.extensions ?? [];
 		this.tags = options?.tags ?? [];
+		this.resolveExts = this.extensions.filter((e) => e.wrapResolve);
+		this.execExts = this.extensions.filter((e) => e.wrapExec);
 		for (const p of options?.presets ?? []) this.presets.set(p.target, p.value);
 		this.gcOptions = {
 			enabled: options?.gc?.enabled ?? true,
@@ -701,21 +747,21 @@ var ScopeImpl = class {
 		const entry = this.cache.get(atom$1);
 		if (!entry) return;
 		const eventListeners = entry.listeners.get(event);
-		if (eventListeners) for (const listener of eventListeners) listener();
+		if (eventListeners?.size) for (const listener of [...eventListeners]) listener();
 		const allListeners = entry.listeners.get("*");
-		if (allListeners) for (const listener of allListeners) listener();
+		if (allListeners?.size) for (const listener of [...allListeners]) listener();
 	}
 	notifyAllListeners(atom$1) {
 		const entry = this.cache.get(atom$1);
 		if (!entry) return;
 		const allListeners = entry.listeners.get("*");
-		if (allListeners) for (const listener of allListeners) listener();
+		if (allListeners?.size) for (const listener of [...allListeners]) listener();
 	}
 	emitStateChange(state, atom$1) {
 		const stateMap = this.stateListeners.get(state);
 		if (stateMap) {
 			const listeners = stateMap.get(atom$1);
-			if (listeners) for (const listener of listeners) listener();
+			if (listeners?.size) for (const listener of [...listeners]) listener();
 		}
 	}
 	on(event, atom$1, listener) {
@@ -741,14 +787,15 @@ var ScopeImpl = class {
 		};
 	}
 	async resolve(atom$1) {
+		if (this.disposed) throw new Error("Scope is disposed");
 		if (!this.initialized) await this.ready;
 		const entry = this.cache.get(atom$1);
 		if (entry?.state === "resolved") return entry.value;
 		const pendingPromise = this.pending.get(atom$1);
 		if (pendingPromise) return pendingPromise;
 		if (this.resolving.has(atom$1)) throw new Error("Circular dependency detected");
-		const presetValue = this.presets.get(atom$1);
-		if (presetValue !== void 0) {
+		if (this.presets.has(atom$1)) {
+			const presetValue = this.presets.get(atom$1);
 			if (isAtom(presetValue)) return this.resolve(presetValue);
 			const newEntry = this.getOrCreateEntry(atom$1);
 			newEntry.state = "resolved";
@@ -771,6 +818,10 @@ var ScopeImpl = class {
 	async doResolve(atom$1) {
 		const entry = this.getOrCreateEntry(atom$1);
 		if (!(entry.state === "resolving")) {
+			for (let i = entry.cleanups.length - 1; i >= 0; i--) try {
+				await entry.cleanups[i]?.();
+			} catch {}
+			entry.cleanups = [];
 			entry.state = "resolving";
 			this.emitStateChange("resolving", atom$1);
 			this.notifyListeners(atom$1, "resolving");
@@ -789,7 +840,7 @@ var ScopeImpl = class {
 		};
 		const factory = atom$1.factory;
 		const doResolve = async () => {
-			if (atom$1.deps && Object.keys(atom$1.deps).length > 0) return factory(ctx, resolvedDeps);
+			if (atom$1.deps) return factory(ctx, resolvedDeps);
 			else return factory(ctx);
 		};
 		try {
@@ -825,70 +876,103 @@ var ScopeImpl = class {
 				entry.pendingInvalidate = false;
 				this.invalidationChain?.delete(atom$1);
 				this.scheduleInvalidation(atom$1);
-			}
+			} else if (entry.pendingSet && "value" in entry.pendingSet) {
+				this.invalidationChain?.delete(atom$1);
+				this.scheduleInvalidation(atom$1);
+			} else entry.pendingSet = void 0;
 			throw entry.error;
 		}
 	}
 	async applyResolveExtensions(event, doResolve) {
 		let next = doResolve;
-		for (let i = this.extensions.length - 1; i >= 0; i--) {
-			const ext = this.extensions[i];
-			if (ext?.wrapResolve) {
-				const currentNext = next;
-				next = ext.wrapResolve.bind(ext, currentNext, event);
-			}
+		for (let i = this.resolveExts.length - 1; i >= 0; i--) {
+			const ext = this.resolveExts[i];
+			const currentNext = next;
+			next = ext.wrapResolve.bind(ext, currentNext, event);
 		}
 		return next();
 	}
 	async resolveDeps(deps, ctx, dependentAtom) {
 		if (!deps) return {};
 		const result = {};
-		for (const [key, dep] of Object.entries(deps)) if (isAtom(dep)) {
-			result[key] = await this.resolve(dep);
-			if (dependentAtom) {
-				const depEntry = this.getEntry(dep);
-				if (depEntry) depEntry.dependents.add(dependentAtom);
-			}
-		} else if (isControllerDep(dep)) {
-			const ctrl = new ControllerImpl(dep.atom, this);
-			if (dep.resolve) await ctrl.resolve();
-			result[key] = ctrl;
-			if (dependentAtom) {
-				const depEntry = this.getEntry(dep.atom);
-				if (depEntry) depEntry.dependents.add(dependentAtom);
-			}
-		} else if (tagExecutorSymbol in dep) {
-			const tagExecutor = dep;
-			switch (tagExecutor.mode) {
-				case "required": {
-					const value = ctx ? ctx.data.seekTag(tagExecutor.tag) : tagExecutor.tag.find(this.tags);
-					if (value !== void 0) result[key] = value;
-					else if (tagExecutor.tag.hasDefault) result[key] = tagExecutor.tag.defaultValue;
-					else throw new Error(`Tag "${tagExecutor.tag.label}" not found`);
-					break;
+		const parallel = [];
+		const deferredResources = [];
+		for (const key in deps) {
+			const dep = deps[key];
+			if (isAtom(dep)) parallel.push(this.resolve(dep).then((value) => {
+				result[key] = value;
+				if (dependentAtom) {
+					const depEntry = this.getEntry(dep);
+					if (depEntry) depEntry.dependents.add(dependentAtom);
 				}
-				case "optional":
-					result[key] = (ctx ? ctx.data.seekTag(tagExecutor.tag) : tagExecutor.tag.find(this.tags)) ?? tagExecutor.tag.defaultValue;
-					break;
-				case "all":
-					result[key] = ctx ? this.collectFromHierarchy(ctx, tagExecutor.tag) : tagExecutor.tag.collect(this.tags);
-					break;
-			}
-		} else if (isResource(dep)) {
+			}));
+			else if (isControllerDep(dep)) {
+				if (dep.watch) {
+					if (!dependentAtom) throw new Error("controller({ watch: true }) is only supported in atom dependencies");
+					if (!dep.resolve) throw new Error("controller({ watch: true }) requires resolve: true");
+				}
+				const ctrl = this.controller(dep.atom);
+				if (dep.resolve) parallel.push(ctrl.resolve().then(() => {
+					result[key] = ctrl;
+					if (dependentAtom) {
+						const depEntry = this.getEntry(dep.atom);
+						if (depEntry) depEntry.dependents.add(dependentAtom);
+					}
+					if (dep.watch) {
+						const eq = dep.eq ?? Object.is;
+						let prev = ctrl.get();
+						const unsub = this.on("resolved", dep.atom, () => {
+							const next = ctrl.get();
+							if (!eq(prev, next)) {
+								prev = next;
+								this.scheduleInvalidation(dependentAtom);
+							}
+						});
+						const depEntry = this.getEntry(dependentAtom);
+						if (depEntry) depEntry.cleanups.push(unsub);
+						else unsub();
+					}
+				}));
+				else {
+					result[key] = ctrl;
+					if (dependentAtom) {
+						const depEntry = this.getEntry(dep.atom);
+						if (depEntry) depEntry.dependents.add(dependentAtom);
+					}
+				}
+			} else if (tagExecutorSymbol in dep) {
+				const tagExecutor = dep;
+				switch (tagExecutor.mode) {
+					case "required": {
+						const value = ctx ? ctx.data.seekTag(tagExecutor.tag) : tagExecutor.tag.find(this.tags);
+						if (value !== void 0) result[key] = value;
+						else if (tagExecutor.tag.hasDefault) result[key] = tagExecutor.tag.defaultValue;
+						else throw new Error(`Tag "${tagExecutor.tag.label}" not found`);
+						break;
+					}
+					case "optional":
+						result[key] = (ctx ? ctx.data.seekTag(tagExecutor.tag) : tagExecutor.tag.find(this.tags)) ?? tagExecutor.tag.defaultValue;
+						break;
+					case "all":
+						result[key] = ctx ? this.collectFromHierarchy(ctx, tagExecutor.tag) : tagExecutor.tag.collect(this.tags);
+						break;
+				}
+			} else if (isResource(dep)) deferredResources.push([key, dep]);
+		}
+		if (parallel.length === 1) await parallel[0];
+		else if (parallel.length > 1) await Promise.all(parallel);
+		for (const [key, resource$1] of deferredResources) {
 			if (!ctx) throw new Error("Resource deps require an ExecutionContext");
-			const resource$1 = dep;
 			const resourceKey = getResourceKey(resource$1);
 			const storeCtx = ctx.parent ?? ctx;
 			if (storeCtx.data.has(resourceKey)) {
 				result[key] = storeCtx.data.get(resourceKey);
 				continue;
 			}
-			const existingSeek = ctx.data.seek(resourceKey);
-			if (existingSeek !== void 0 || ctx.data.has(resourceKey)) {
-				result[key] = existingSeek;
+			if (ctx.data.seekHas(resourceKey)) {
+				result[key] = ctx.data.seek(resourceKey);
 				continue;
 			}
-			if (resolvingResources.has(resourceKey)) throw new Error(`Circular resource dependency detected: ${resource$1.name ?? "anonymous"}`);
 			let flights = inflightResources.get(storeCtx.data);
 			if (!flights) {
 				flights = /* @__PURE__ */ new Map();
@@ -899,8 +983,14 @@ var ScopeImpl = class {
 				result[key] = await inflight;
 				continue;
 			}
+			let localResolvingResources = resolvingResourcesMap.get(storeCtx.data);
+			if (!localResolvingResources) {
+				localResolvingResources = /* @__PURE__ */ new Set();
+				resolvingResourcesMap.set(storeCtx.data, localResolvingResources);
+			}
+			if (localResolvingResources.has(resourceKey)) throw new Error(`Circular resource dependency detected: ${resource$1.name ?? "anonymous"}`);
 			const resolve = async () => {
-				resolvingResources.add(resourceKey);
+				localResolvingResources.add(resourceKey);
 				try {
 					const resourceDeps = await this.resolveDeps(resource$1.deps, ctx);
 					const event = {
@@ -910,14 +1000,14 @@ var ScopeImpl = class {
 					};
 					const doResolve = async () => {
 						const factory = resource$1.factory;
-						if (resource$1.deps && Object.keys(resource$1.deps).length > 0) return factory(storeCtx, resourceDeps);
+						if (resource$1.deps) return factory(storeCtx, resourceDeps);
 						return factory(storeCtx);
 					};
 					const value = await this.applyResolveExtensions(event, doResolve);
 					storeCtx.data.set(resourceKey, value);
 					return value;
 				} finally {
-					resolvingResources.delete(resourceKey);
+					localResolvingResources.delete(resourceKey);
 				}
 			};
 			const promise = resolve();
@@ -941,6 +1031,7 @@ var ScopeImpl = class {
 		return results;
 	}
 	controller(atom$1, options) {
+		if (this.disposed) throw new Error("Scope is disposed");
 		let ctrl = this.controllers.get(atom$1);
 		if (!ctrl) {
 			ctrl = new ControllerImpl(atom$1, this);
@@ -950,7 +1041,7 @@ var ScopeImpl = class {
 		return ctrl;
 	}
 	select(atom$1, selector, options) {
-		return new SelectHandleImpl(this.controller(atom$1), selector, options?.eq ?? ((a, b) => a === b));
+		return new SelectHandleImpl(this.controller(atom$1), selector, options?.eq ?? Object.is);
 	}
 	getFlowPreset(flow$1) {
 		return this.presets.get(flow$1);
@@ -994,10 +1085,27 @@ var ScopeImpl = class {
 		const previousValue = entry.value;
 		const pendingSet = entry.pendingSet;
 		entry.pendingSet = void 0;
-		for (let i = entry.cleanups.length - 1; i >= 0; i--) {
-			const cleanup = entry.cleanups[i];
-			if (cleanup) await cleanup();
+		if (pendingSet) {
+			entry.state = "resolving";
+			entry.value = previousValue;
+			entry.error = void 0;
+			entry.pendingInvalidate = false;
+			this.pending.delete(atom$1);
+			this.resolving.delete(atom$1);
+			this.emitStateChange("resolving", atom$1);
+			this.notifyListeners(atom$1, "resolving");
+			if ("value" in pendingSet) entry.value = pendingSet.value;
+			else entry.value = pendingSet.fn(previousValue);
+			entry.state = "resolved";
+			entry.hasValue = true;
+			this.emitStateChange("resolved", atom$1);
+			this.notifyListeners(atom$1, "resolved");
+			this.invalidationChain?.delete(atom$1);
+			return;
 		}
+		for (let i = entry.cleanups.length - 1; i >= 0; i--) try {
+			await entry.cleanups[i]?.();
+		} catch {}
 		entry.cleanups = [];
 		entry.state = "resolving";
 		entry.value = previousValue;
@@ -1007,16 +1115,11 @@ var ScopeImpl = class {
 		this.resolving.delete(atom$1);
 		this.emitStateChange("resolving", atom$1);
 		this.notifyListeners(atom$1, "resolving");
-		if (pendingSet) {
-			if ("value" in pendingSet) entry.value = pendingSet.value;
-			else entry.value = pendingSet.fn(previousValue);
-			entry.state = "resolved";
-			entry.hasValue = true;
-			this.emitStateChange("resolved", atom$1);
-			this.notifyListeners(atom$1, "resolved");
-			return;
+		try {
+			await this.resolve(atom$1);
+		} catch (e) {
+			if (!entry.pendingSet && !entry.pendingInvalidate) throw e;
 		}
-		await this.resolve(atom$1);
 	}
 	async release(atom$1) {
 		const entry = this.cache.get(atom$1);
@@ -1025,14 +1128,33 @@ var ScopeImpl = class {
 			clearTimeout(entry.gcScheduled);
 			entry.gcScheduled = null;
 		}
-		for (let i = entry.cleanups.length - 1; i >= 0; i--) {
-			const cleanup = entry.cleanups[i];
-			if (cleanup) await cleanup();
+		for (let i = entry.cleanups.length - 1; i >= 0; i--) try {
+			await entry.cleanups[i]?.();
+		} catch {}
+		if (atom$1.deps) for (const dep of Object.values(atom$1.deps)) {
+			const depAtom = isAtom(dep) ? dep : isControllerDep(dep) ? dep.atom : null;
+			if (!depAtom) continue;
+			const depEntry = this.cache.get(depAtom);
+			if (depEntry) {
+				depEntry.dependents.delete(atom$1);
+				this.maybeScheduleGC(depAtom);
+			}
 		}
 		this.cache.delete(atom$1);
 		this.controllers.delete(atom$1);
+		for (const [state, stateMap] of this.stateListeners) {
+			stateMap.delete(atom$1);
+			if (stateMap.size === 0) this.stateListeners.delete(state);
+		}
 	}
 	async dispose() {
+		if (this.chainPromise) try {
+			await this.chainPromise;
+		} catch {}
+		this.disposed = true;
+		this.invalidationQueue.clear();
+		this.invalidationChain = null;
+		this.chainPromise = null;
 		for (const ext of this.extensions) if (ext.dispose) await ext.dispose(this);
 		for (const entry of this.cache.values()) if (entry.gcScheduled) {
 			clearTimeout(entry.gcScheduled);
@@ -1043,8 +1165,14 @@ var ScopeImpl = class {
 	}
 	async flush() {
 		if (this.chainPromise) await this.chainPromise;
+		if (this.chainError !== null) {
+			const error = this.chainError;
+			this.chainError = null;
+			throw error;
+		}
 	}
 	createContext(options) {
+		if (this.disposed) throw new Error("Scope is disposed");
 		const ctx = new ExecutionContextImpl(this, options);
 		for (const tagged of options?.tags ?? []) ctx.data.set(tagged.key, tagged.value);
 		for (const tagged of this.tags) if (!ctx.data.has(tagged.key)) ctx.data.set(tagged.key, tagged.value);
@@ -1138,7 +1266,7 @@ var ExecutionContextImpl = class ExecutionContextImpl {
 		const resolvedDeps = await this.scope.resolveDeps(flow$1.deps, this);
 		const factory = flow$1.factory;
 		const doExec = async () => {
-			if (flow$1.deps && Object.keys(flow$1.deps).length > 0) return factory(this, resolvedDeps);
+			if (flow$1.deps) return factory(this, resolvedDeps);
 			else return factory(this);
 		};
 		return this.applyExecExtensions(flow$1, doExec);
@@ -1154,12 +1282,10 @@ var ExecutionContextImpl = class ExecutionContextImpl {
 	}
 	async applyExecExtensions(target, doExec) {
 		let next = doExec;
-		for (let i = this.scope.extensions.length - 1; i >= 0; i--) {
-			const ext = this.scope.extensions[i];
-			if (ext?.wrapExec) {
-				const currentNext = next;
-				next = ext.wrapExec.bind(ext, currentNext, target, this);
-			}
+		for (let i = this.scope.execExts.length - 1; i >= 0; i--) {
+			const ext = this.scope.execExts[i];
+			const currentNext = next;
+			next = ext.wrapExec.bind(ext, currentNext, target, this);
 		}
 		return next();
 	}
@@ -1169,10 +1295,9 @@ var ExecutionContextImpl = class ExecutionContextImpl {
 	async close(result = { ok: true }) {
 		if (this.closed) return;
 		this.closed = true;
-		for (let i = this.cleanups.length - 1; i >= 0; i--) {
-			const cleanup = this.cleanups[i];
-			if (cleanup) await cleanup(result);
-		}
+		for (let i = this.cleanups.length - 1; i >= 0; i--) try {
+			await this.cleanups[i]?.(result);
+		} catch {}
 	}
 };
 /**

package/dist/index.d.cts

@@ -89,6 +89,10 @@ declare namespace Lite {
      * Returns first match or undefined (ignores tag defaults).
      */
     seekTag<T>(tag: Tag<T, boolean>): T | undefined;
+    /**
+     * Check if key exists locally or in parent chain.
+     */
+    seekHas(key: string | symbol): boolean;
     /** Get value by tag, returns undefined if not stored */
     getTag<T>(tag: Tag<T, boolean>): T | undefined;
     /** Set value by tag */
@@ -198,6 +202,7 @@ declare namespace Lite {
   interface SelectHandle<S> {
     get(): S;
     subscribe(listener: () => void): () => void;
+    dispose(): void;
   }
   interface Tag<T, HasDefault extends boolean = false> {
     readonly [tagSymbol]: true;
@@ -230,10 +235,29 @@ declare namespace Lite {
     readonly [controllerDepSymbol]: true;
     readonly atom: Atom<T>;
     readonly resolve?: boolean;
+    readonly watch?: boolean;
+    readonly eq?: (a: any, b: any) => boolean;
   }
   interface ControllerOptions {
     resolve?: boolean;
   }
+  type ControllerDepOptions<T> = {
+    resolve: true;
+    watch: true;
+    eq: (a: T, b: T) => boolean;
+  } | {
+    resolve: true;
+    watch: true;
+    eq?: never;
+  } | {
+    resolve: true;
+    watch?: never;
+    eq?: never;
+  } | {
+    resolve?: never;
+    watch?: never;
+    eq?: never;
+  };
   interface Typed<T> {
     readonly [typedSymbol]: true;
   }
@@ -572,24 +596,37 @@ declare function isAtom(value: unknown): value is Lite.Atom<unknown>;
  * The Controller provides full lifecycle control: get, resolve, release, invalidate, and subscribe.
  *
  * @param atom - The Atom to wrap
- * @param options - Optional configuration. Use { resolve: true } to auto-resolve before factory runs.
+ * @param options - Optional configuration:
+ *   - `resolve: true` — auto-resolves the dep before the parent factory runs; `config.get()` is safe.
+ *   - `watch: true` — atom deps only; requires `resolve: true`; automatically re-runs the parent factory
+ *     when the dep resolves to a new value (value-equality gated via `Object.is` by default). Replaces
+ *     manual `ctx.cleanup(ctx.scope.on('resolved', dep, () => ctx.invalidate()))` wiring. Watch
+ *     listeners are auto-cleaned on re-resolve, release, and dispose.
+ *   - `eq` — custom equality function `(a: T, b: T) => boolean`; only used with `watch: true`.
  * @returns A ControllerDep that resolves to a Controller for the Atom
  *
  * @example
  * ```typescript
- * const configAtom = atom({ factory: () => fetchConfig() })
+ * // resolve only
  * const serverAtom = atom({
  *   deps: { config: controller(configAtom, { resolve: true }) },
- *   factory: (ctx, { config }) => {
- *     // config.get() is safe - already resolved
- *     const unsub = config.on('resolved', () => ctx.invalidate())
- *     ctx.cleanup(unsub)
- *     return createServer(config.get().port)
- *   }
+ *   factory: (_, { config }) => createServer(config.get().port),
+ * })
+ *
+ * // watch: re-runs parent when dep value changes
+ * const profileAtom = atom({
+ *   deps: { token: controller(tokenAtom, { resolve: true, watch: true }) },
+ *   factory: (_, { token }) => ({ id: `user-${token.get().jwt}` }),
+ * })
+ *
+ * // watch with custom equality
+ * const derivedAtom = atom({
+ *   deps: { src: controller(srcAtom, { resolve: true, watch: true, eq: (a, b) => a.id === b.id }) },
+ *   factory: (_, { src }) => src.get().name,
  * })
  * ```
  */
-declare function controller<T>(atom: Lite.Atom<T>, options?: Lite.ControllerOptions): Lite.ControllerDep<T>;
+declare function controller<T>(atom: Lite.Atom<T>, options?: Lite.ControllerDepOptions<T>): Lite.ControllerDep<T>;
 /**
  * Type guard to check if a value is a ControllerDep wrapper.
  *