@pumped-fn/lite 2.1.0 → 2.1.2

package/CHANGELOG.md

@@ -1,5 +1,46 @@
 # @pumped-fn/lite
 
+## 2.1.2
+
+### Patch Changes
+
+- 8ed17e7: - Fix watch and invalidation edge cases in `@pumped-fn/lite` by aligning `select()` with `Object.is`, snapshotting select listeners during notification, making watch option typing match the runtime contract, and surfacing invalidation-chain failures from `flush()` instead of leaking them as background rejections.
+  - Fix `@pumped-fn/lite-react` hook refresh behavior by keeping stale values visible during re-resolution, recomputing `useSelect` snapshots when selector or equality semantics change, tracking pending promises per controller, and suppressing non-Suspense `unhandledRejection` leaks on failed refreshes.
+
+## 2.1.1
+
+### Patch Changes
+
+- 2ce41fc: Fix 16 bugs found via adversarial triage + 5 rounds of Codex review:
+
+  **Correctness**
+
+  - `preset(atom, undefined)` now works — uses `has()` check instead of `!== undefined`
+  - `seekHas()` traverses parent chain via interface dispatch, not `instanceof`
+  - Error-path `pendingSet` only reschedules value-type sets — `fn(undefined)` no longer produces garbage
+  - `doInvalidateSequential` swallows resolve errors when pending operations exist
+  - Resource cycle detection moved to per-execution-chain WeakMap — fixes false errors with `ctx.exec()`
+  - Resource inflight check runs before circular check — sibling `ctx.exec()` no longer false-positives
+
+  **Reactive system**
+
+  - `set()`/`update()` pendingSet path skips cleanups — watch deps preserved since factory doesn't re-run
+  - Unconditional `invalidationChain.delete()` in pendingSet fast-path — prevents self-loops
+  - Copy-on-iterate on all 4 listener iteration sites — unsub during notification no longer drops siblings
+
+  **Lifecycle**
+
+  - `dispose()` awaits `chainPromise` before setting `disposed` — drains pending invalidation chain
+  - `resolve()`, `controller()`, `createContext()` throw after dispose
+  - `release()` cleans up dependents + schedules GC on freed deps
+
+  **SelectHandle**
+
+  - Eager subscription in constructor — tracks changes without active subscribers
+  - `dispose()` method for explicit teardown
+  - Re-subscribe refreshes cached value after auto-cleanup
+  - Added `seekHas()` to `ContextData` interface, `dispose()` to `SelectHandle` interface
+
 ## 2.1.0
 
 ### Minor Changes

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;
@@ -425,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
@@ -446,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) {
@@ -471,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);
 	}
@@ -516,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);
@@ -523,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 {
@@ -577,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);
@@ -594,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)) {
@@ -624,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,
@@ -716,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) {
@@ -756,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";
@@ -786,7 +818,9 @@ 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--) await entry.cleanups[i]?.();
+			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);
@@ -806,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 {
@@ -842,88 +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)) {
-			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) await ctrl.resolve();
-			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 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);
+				}
+			}));
+			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);
 					}
-				});
-				const depEntry = this.getEntry(dependentAtom);
-				if (depEntry) depEntry.cleanups.push(unsub);
-				else unsub();
-			}
-		} 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)) {
+			} 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();
@@ -934,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 = {
@@ -945,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();
@@ -976,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);
@@ -985,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);
@@ -1029,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;
@@ -1042,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);
@@ -1060,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);
@@ -1078,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);
@@ -1173,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);
@@ -1189,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();
 	}
@@ -1204,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;
@@ -236,11 +241,23 @@ declare namespace Lite {
   interface ControllerOptions {
     resolve?: boolean;
   }
-  interface ControllerDepOptions<T> {
-    resolve?: boolean;
-    watch?: boolean;
-    eq?: (a: T, b: T) => 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;
   }