@pumped-fn/lite 2.1.3 → 2.1.5

package/dist/index.cjs

@@ -587,9 +587,8 @@ var ControllerImpl = class {
 	get() {
 		const entry = this.scope.getEntry(this.atom);
 		if (!entry || entry.state === "idle") throw new Error("Atom not resolved");
-		if (entry.state === "failed" && entry.error) throw entry.error;
-		if (entry.state === "resolving" && entry.hasValue) return entry.value;
-		if (entry.state === "resolved" && entry.hasValue) return entry.value;
+		if (entry.state === "failed") throw entry.error;
+		if (entry.hasValue) return entry.value;
 		throw new Error("Atom not resolved");
 	}
 	async resolve() {
@@ -617,8 +616,7 @@ var ScopeImpl = class {
 	resolving = /* @__PURE__ */ new Set();
 	pending = /* @__PURE__ */ new Map();
 	stateListeners = /* @__PURE__ */ new Map();
-	invalidationQueue = /* @__PURE__ */ new Set();
-	invalidationScheduled = false;
+	invalidationQueue = [];
 	invalidationChain = null;
 	chainPromise = null;
 	chainError = null;
@@ -631,48 +629,33 @@ var ScopeImpl = class {
 	resolveExts;
 	execExts;
 	ready;
-	scheduleInvalidation(atom$1) {
-		const entry = this.cache.get(atom$1);
-		if (!entry || entry.state === "idle") return;
+	scheduleInvalidation(atom$1, entry) {
+		if (!entry) {
+			entry = this.cache.get(atom$1);
+			if (!entry || entry.state === "idle") return;
+		}
 		if (entry.state === "resolving") {
 			entry.pendingInvalidate = true;
 			return;
 		}
-		this.invalidationQueue.add(atom$1);
+		if (!this.invalidationQueue.includes(atom$1)) this.invalidationQueue.push(atom$1);
 		if (!this.chainPromise) {
-			this.invalidationChain = /* @__PURE__ */ new Set();
-			this.invalidationScheduled = true;
 			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;
-				}
-			})();
+			this.chainPromise = Promise.resolve().then(() => this.processInvalidationChain().catch((error) => {
+				if (this.chainError === null) this.chainError = error;
+			}));
 		}
 	}
 	async processInvalidationChain() {
 		try {
-			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)) {
-					const chainAtoms = Array.from(this.invalidationChain);
-					chainAtoms.push(atom$1);
-					const path = chainAtoms.map((a) => a.factory?.name || "<anonymous>").join(" → ");
-					throw new Error(`Infinite invalidation loop detected: ${path}`);
-				}
-				this.invalidationChain.add(atom$1);
-				await this.doInvalidateSequential(atom$1);
+			while (this.invalidationQueue.length > 0 && !this.disposed) {
+				const atom$1 = this.invalidationQueue.shift();
+				const result = this.doInvalidateSequential(atom$1);
+				if (result) await result;
 			}
 		} finally {
 			this.invalidationChain = null;
 			this.chainPromise = null;
-			this.invalidationScheduled = false;
 		}
 	}
 	constructor(options) {
@@ -715,79 +698,68 @@ var ScopeImpl = class {
 		return entry;
 	}
 	addListener(atom$1, event, listener) {
-		this.cancelScheduledGC(atom$1);
-		const listeners = this.getOrCreateEntry(atom$1).listeners.get(event);
+		const entry = this.getOrCreateEntry(atom$1);
+		if (entry.gcScheduled) {
+			clearTimeout(entry.gcScheduled);
+			entry.gcScheduled = null;
+		}
+		const listeners = entry.listeners.get(event);
 		listeners.add(listener);
 		return () => {
 			listeners.delete(listener);
-			this.maybeScheduleGC(atom$1);
+			this.maybeScheduleGCEntry(atom$1, entry);
 		};
 	}
-	getSubscriberCount(atom$1) {
-		const entry = this.cache.get(atom$1);
-		if (!entry) return 0;
-		let count = 0;
-		for (const listeners of entry.listeners.values()) count += listeners.size;
-		return count;
+	hasSubscribers(entry) {
+		for (const listeners of entry.listeners.values()) if (listeners.size > 0) return true;
+		return false;
 	}
-	maybeScheduleGC(atom$1) {
+	maybeScheduleGCEntry(atom$1, entry) {
 		if (!this.gcOptions.enabled) return;
 		if (atom$1.keepAlive) return;
-		const entry = this.cache.get(atom$1);
-		if (!entry) return;
 		if (entry.state === "idle") return;
-		if (this.getSubscriberCount(atom$1) > 0) return;
+		if (this.hasSubscribers(entry)) return;
 		if (entry.dependents.size > 0) return;
 		if (entry.gcScheduled) return;
 		entry.gcScheduled = setTimeout(() => {
 			this.executeGC(atom$1);
 		}, this.gcOptions.graceMs);
 	}
-	cancelScheduledGC(atom$1) {
-		const entry = this.cache.get(atom$1);
-		if (entry?.gcScheduled) {
-			clearTimeout(entry.gcScheduled);
-			entry.gcScheduled = null;
-		}
-	}
 	async executeGC(atom$1) {
 		const entry = this.cache.get(atom$1);
 		if (!entry) return;
 		entry.gcScheduled = null;
-		if (this.getSubscriberCount(atom$1) > 0) return;
+		if (this.hasSubscribers(entry)) return;
 		if (entry.dependents.size > 0) return;
 		if (atom$1.keepAlive) return;
 		await this.release(atom$1);
-		if (atom$1.deps) for (const dep of Object.values(atom$1.deps)) {
+		if (atom$1.deps) for (const key in atom$1.deps) {
+			const dep = atom$1.deps[key];
 			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.maybeScheduleGCEntry(depAtom, depEntry);
 			}
 		}
 	}
-	notifyListeners(atom$1, event) {
-		const entry = this.cache.get(atom$1);
-		if (!entry) return;
+	notifyEntry(entry, event) {
 		const eventListeners = entry.listeners.get(event);
 		if (eventListeners?.size) for (const listener of [...eventListeners]) listener();
 		const allListeners = entry.listeners.get("*");
-		if (allListeners?.size) 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;
+	notifyEntryAll(entry) {
 		const allListeners = entry.listeners.get("*");
-		if (allListeners?.size) for (const listener of [...allListeners]) listener();
+		if (allListeners?.size) for (const listener of allListeners) listener();
 	}
 	emitStateChange(state, atom$1) {
+		if (this.stateListeners.size === 0) return;
 		const stateMap = this.stateListeners.get(state);
-		if (stateMap) {
-			const listeners = stateMap.get(atom$1);
-			if (listeners?.size) for (const listener of [...listeners]) listener();
-		}
+		if (!stateMap) return;
+		const listeners = stateMap.get(atom$1);
+		if (listeners?.size) for (const listener of [...listeners]) listener();
 	}
 	on(event, atom$1, listener) {
 		let stateMap = this.stateListeners.get(event);
@@ -811,14 +783,17 @@ var ScopeImpl = class {
 			}
 		};
 	}
-	async resolve(atom$1) {
-		if (this.disposed) throw new Error("Scope is disposed");
-		if (!this.initialized) await this.ready;
+	resolve(atom$1) {
+		if (this.disposed) return Promise.reject(/* @__PURE__ */ new Error("Scope is disposed"));
+		if (!this.initialized) {
+			if (!this.ready) return this.resolveAndTrack(atom$1);
+			return this.ready.then(() => this.resolve(atom$1));
+		}
 		const entry = this.cache.get(atom$1);
-		if (entry?.state === "resolved") return entry.value;
+		if (entry?.state === "resolved") return entry.resolvedPromise ?? (entry.resolvedPromise = Promise.resolve(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");
+		if (this.resolving.has(atom$1)) return Promise.reject(/* @__PURE__ */ new Error("Circular dependency detected"));
 		if (this.presets.has(atom$1)) {
 			const presetValue = this.presets.get(atom$1);
 			if (isAtom(presetValue)) return this.resolve(presetValue);
@@ -827,9 +802,12 @@ var ScopeImpl = class {
 			newEntry.value = presetValue;
 			newEntry.hasValue = true;
 			this.emitStateChange("resolved", atom$1);
-			this.notifyListeners(atom$1, "resolved");
-			return newEntry.value;
+			this.notifyEntry(newEntry, "resolved");
+			return Promise.resolve(newEntry.value);
 		}
+		return this.resolveAndTrack(atom$1);
+	}
+	async resolveAndTrack(atom$1) {
 		this.resolving.add(atom$1);
 		const promise = this.doResolve(atom$1);
 		this.pending.set(atom$1, promise);
@@ -849,7 +827,7 @@ var ScopeImpl = class {
 			entry.cleanups = [];
 			entry.state = "resolving";
 			this.emitStateChange("resolving", atom$1);
-			this.notifyListeners(atom$1, "resolving");
+			this.notifyEntry(entry, "resolving");
 		}
 		const resolvedDeps = await this.resolveDeps(atom$1.deps, void 0, atom$1);
 		const ctx = {
@@ -864,23 +842,25 @@ var ScopeImpl = class {
 			}
 		};
 		const factory = atom$1.factory;
-		const doResolve = async () => {
-			if (atom$1.deps) return factory(ctx, resolvedDeps);
-			else return factory(ctx);
-		};
 		try {
-			const event = {
-				kind: "atom",
-				target: atom$1,
-				scope: this
-			};
-			const value = await this.applyResolveExtensions(event, doResolve);
+			let value;
+			if (this.resolveExts.length === 0) value = atom$1.deps ? await factory(ctx, resolvedDeps) : await factory(ctx);
+			else {
+				const doResolve = async () => atom$1.deps ? factory(ctx, resolvedDeps) : factory(ctx);
+				const event = {
+					kind: "atom",
+					target: atom$1,
+					scope: this
+				};
+				value = await this.applyResolveExtensions(event, doResolve);
+			}
 			entry.state = "resolved";
 			entry.value = value;
 			entry.hasValue = true;
 			entry.error = void 0;
+			entry.resolvedPromise = Promise.resolve(value);
 			this.emitStateChange("resolved", atom$1);
-			this.notifyListeners(atom$1, "resolved");
+			this.notifyEntry(entry, "resolved");
 			if (entry.pendingInvalidate) {
 				entry.pendingInvalidate = false;
 				this.invalidationChain?.delete(atom$1);
@@ -896,7 +876,7 @@ var ScopeImpl = class {
 			entry.value = void 0;
 			entry.hasValue = false;
 			this.emitStateChange("failed", atom$1);
-			this.notifyAllListeners(atom$1);
+			this.notifyEntryAll(entry);
 			if (entry.pendingInvalidate) {
 				entry.pendingInvalidate = false;
 				this.invalidationChain?.delete(atom$1);
@@ -924,39 +904,61 @@ var ScopeImpl = class {
 		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 (isAtom(dep)) {
+				const cachedEntry = this.cache.get(dep);
+				if (cachedEntry?.state === "resolved") {
+					result[key] = cachedEntry.value;
+					if (dependentAtom) cachedEntry.dependents.add(dependentAtom);
+				} else 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 ?? shallowEqual;
-						let prev = ctrl.get();
-						const unsub = this.on("resolved", dep.atom, () => {
-							const next = ctrl.get();
-							if (!eq(prev, next)) this.scheduleInvalidation(dependentAtom);
-							prev = next;
-						});
-						const depEntry = this.getEntry(dependentAtom);
-						if (depEntry) depEntry.cleanups.push(unsub);
-						else unsub();
-					}
-				}));
-				else {
+				if (dep.resolve) {
+					const cachedCtrlEntry = this.cache.get(dep.atom);
+					if (cachedCtrlEntry?.state === "resolved") {
+						result[key] = ctrl;
+						if (dependentAtom) cachedCtrlEntry.dependents.add(dependentAtom);
+						if (dep.watch) {
+							const eq = dep.eq ?? shallowEqual;
+							let prev = ctrl.get();
+							const unsub = this.on("resolved", dep.atom, () => {
+								const next = ctrl.get();
+								if (!eq(prev, next)) this.scheduleInvalidation(dependentAtom);
+								prev = next;
+							});
+							const depEntry = this.getEntry(dependentAtom);
+							if (depEntry) depEntry.cleanups.push(unsub);
+							else unsub();
+						}
+					} else 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 ?? shallowEqual;
+							let prev = ctrl.get();
+							const unsub = this.on("resolved", dep.atom, () => {
+								const next = ctrl.get();
+								if (!eq(prev, next)) this.scheduleInvalidation(dependentAtom);
+								prev = next;
+							});
+							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);
@@ -1016,17 +1018,18 @@ var ScopeImpl = class {
 				localResolvingResources.add(resourceKey);
 				try {
 					const resourceDeps = await this.resolveDeps(resource$1.deps, ctx);
-					const event = {
-						kind: "resource",
-						target: resource$1,
-						ctx: storeCtx
-					};
-					const doResolve = async () => {
-						const factory = resource$1.factory;
-						if (resource$1.deps) return factory(storeCtx, resourceDeps);
-						return factory(storeCtx);
-					};
-					const value = await this.applyResolveExtensions(event, doResolve);
+					const factory = resource$1.factory;
+					let value;
+					if (this.resolveExts.length === 0) value = resource$1.deps ? await factory(storeCtx, resourceDeps) : await factory(storeCtx);
+					else {
+						const event = {
+							kind: "resource",
+							target: resource$1,
+							ctx: storeCtx
+						};
+						const doResolve = async () => resource$1.deps ? factory(storeCtx, resourceDeps) : factory(storeCtx);
+						value = await this.applyResolveExtensions(event, doResolve);
+					}
 					storeCtx.data.set(resourceKey, value);
 					return value;
 				} finally {
@@ -1088,7 +1091,7 @@ var ScopeImpl = class {
 			return;
 		}
 		entry.pendingSet = { value };
-		this.scheduleInvalidation(atom$1);
+		this.scheduleInvalidation(atom$1, entry);
 	}
 	scheduleUpdate(atom$1, fn) {
 		const entry = this.cache.get(atom$1);
@@ -1099,9 +1102,9 @@ var ScopeImpl = class {
 			return;
 		}
 		entry.pendingSet = { fn };
-		this.scheduleInvalidation(atom$1);
+		this.scheduleInvalidation(atom$1, entry);
 	}
-	async doInvalidateSequential(atom$1) {
+	doInvalidateSequential(atom$1) {
 		const entry = this.cache.get(atom$1);
 		if (!entry) return;
 		if (entry.state === "idle") return;
@@ -1109,23 +1112,27 @@ var ScopeImpl = class {
 		const pendingSet = entry.pendingSet;
 		entry.pendingSet = void 0;
 		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.value = "value" in pendingSet ? pendingSet.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);
+			entry.error = void 0;
+			entry.pendingInvalidate = false;
+			entry.resolvedPromise = void 0;
+			if (this.stateListeners.size) this.emitStateChange("resolved", atom$1);
+			this.notifyEntry(entry, "resolved");
 			return;
 		}
+		if (!this.invalidationChain) this.invalidationChain = /* @__PURE__ */ new Set();
+		if (this.invalidationChain.has(atom$1)) {
+			const chainAtoms = Array.from(this.invalidationChain);
+			chainAtoms.push(atom$1);
+			const path = chainAtoms.map((a) => a.factory?.name || "<anonymous>").join(" → ");
+			throw new Error(`Infinite invalidation loop detected: ${path}`);
+		}
+		this.invalidationChain.add(atom$1);
+		return this.doInvalidateAsync(atom$1, entry, previousValue);
+	}
+	async doInvalidateAsync(atom$1, entry, previousValue) {
 		for (let i = entry.cleanups.length - 1; i >= 0; i--) try {
 			await entry.cleanups[i]?.();
 		} catch {}
@@ -1137,7 +1144,7 @@ var ScopeImpl = class {
 		this.pending.delete(atom$1);
 		this.resolving.delete(atom$1);
 		this.emitStateChange("resolving", atom$1);
-		this.notifyListeners(atom$1, "resolving");
+		this.notifyEntry(entry, "resolving");
 		try {
 			await this.resolve(atom$1);
 		} catch (e) {
@@ -1154,15 +1161,17 @@ var ScopeImpl = class {
 		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)) {
+		if (atom$1.deps) for (const key in atom$1.deps) {
+			const dep = atom$1.deps[key];
 			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.maybeScheduleGCEntry(depAtom, depEntry);
 			}
 		}
+		this.notifyEntryAll(entry);
 		this.cache.delete(atom$1);
 		this.controllers.delete(atom$1);
 		for (const [state, stateMap] of this.stateListeners) {
@@ -1175,7 +1184,7 @@ var ScopeImpl = class {
 			await this.chainPromise;
 		} catch {}
 		this.disposed = true;
-		this.invalidationQueue.clear();
+		this.invalidationQueue.length = 0;
 		this.invalidationChain = null;
 		this.chainPromise = null;
 		for (const ext of this.extensions) if (ext.dispose) await ext.dispose(this);
@@ -1197,8 +1206,11 @@ var ScopeImpl = class {
 	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);
+		const ctxTags = options?.tags;
+		if (ctxTags && ctxTags.length > 0) for (let i = 0; i < ctxTags.length; i++) ctx.data.set(ctxTags[i].key, ctxTags[i].value);
+		if (this.tags.length > 0) {
+			for (let i = 0; i < this.tags.length; i++) if (!ctx.data.has(this.tags[i].key)) ctx.data.set(this.tags[i].key, this.tags[i].value);
+		}
 		return ctx;
 	}
 };
@@ -1252,8 +1264,11 @@ var ExecutionContextImpl = class ExecutionContextImpl {
 				execName,
 				flowName: flow$1.name
 			});
-			for (const tagged of execTags ?? []) childCtx.data.set(tagged.key, tagged.value);
-			for (const tagged of flow$1.tags ?? []) if (!childCtx.data.has(tagged.key)) childCtx.data.set(tagged.key, tagged.value);
+			if (execTags && execTags.length > 0) for (let i = 0; i < execTags.length; i++) childCtx.data.set(execTags[i].key, execTags[i].value);
+			const flowTags = flow$1.tags;
+			if (flowTags && flowTags.length > 0) {
+				for (let i = 0; i < flowTags.length; i++) if (!childCtx.data.has(flowTags[i].key)) childCtx.data.set(flowTags[i].key, flowTags[i].value);
+			}
 			try {
 				const result = presetValue !== void 0 && typeof presetValue === "function" ? await childCtx.execPresetFn(flow$1, presetValue) : await childCtx.execFlowInternal(flow$1);
 				await childCtx.close({ ok: true });
@@ -1288,18 +1303,18 @@ var ExecutionContextImpl = class ExecutionContextImpl {
 	async execFlowInternal(flow$1) {
 		const resolvedDeps = await this.scope.resolveDeps(flow$1.deps, this);
 		const factory = flow$1.factory;
-		const doExec = async () => {
-			if (flow$1.deps) return factory(this, resolvedDeps);
-			else return factory(this);
-		};
+		if (this.scope.execExts.length === 0) return flow$1.deps ? factory(this, resolvedDeps) : factory(this);
+		const doExec = async () => flow$1.deps ? factory(this, resolvedDeps) : factory(this);
 		return this.applyExecExtensions(flow$1, doExec);
 	}
 	async execFnInternal(options) {
 		const { fn, params } = options;
+		if (this.scope.execExts.length === 0) return fn(this, ...params);
 		const doExec = () => Promise.resolve(fn(this, ...params));
 		return this.applyExecExtensions(fn, doExec);
 	}
 	async execPresetFn(flow$1, fn) {
+		if (this.scope.execExts.length === 0) return fn(this);
 		const doExec = () => Promise.resolve(fn(this));
 		return this.applyExecExtensions(flow$1, doExec);
 	}
@@ -1315,9 +1330,13 @@ var ExecutionContextImpl = class ExecutionContextImpl {
 	onClose(fn) {
 		this.cleanups.push(fn);
 	}
-	async close(result = { ok: true }) {
-		if (this.closed) return;
+	close(result = { ok: true }) {
+		if (this.closed) return Promise.resolve();
 		this.closed = true;
+		if (this.cleanups.length === 0) return Promise.resolve();
+		return this.runCleanups(result);
+	}
+	async runCleanups(result) {
 		for (let i = this.cleanups.length - 1; i >= 0; i--) try {
 			await this.cleanups[i]?.(result);
 		} catch {}

package/dist/index.d.cts

@@ -238,6 +238,14 @@ declare namespace Lite {
     readonly watch?: boolean;
     readonly eq?: (a: any, b: any) => boolean;
   }
+  type WatchControllerDep<T> = ControllerDep<T> & {
+    readonly resolve: true;
+    readonly watch: true;
+  };
+  type NonWatchControllerDep<T> = ControllerDep<T> & {
+    readonly watch?: never;
+    readonly eq?: never;
+  };
   interface ControllerOptions {
     resolve?: boolean;
   }
@@ -301,6 +309,8 @@ declare namespace Lite {
     dispose?(scope: Scope): MaybePromise<void>;
   }
   type Dependency = Atom<unknown> | ControllerDep<unknown> | TagExecutor<any> | Resource<unknown>;
+  type AtomDependency = Atom<unknown> | ControllerDep<unknown> | TagExecutor<any, any>;
+  type ExecutionDependency = Atom<unknown> | NonWatchControllerDep<unknown> | TagExecutor<any, any> | Resource<unknown, Record<string, Dependency>>;
   type InferDep<D> = D extends Atom<infer T> ? T : D extends ControllerDep<infer T> ? Controller<T> : D extends TagExecutor<infer TOutput, infer _TTag> ? TOutput : D extends Resource<infer T> ? T : never;
   type InferDeps<D> = { [K in keyof D]: InferDep<D[K]> };
   type AtomFactory<T, D extends Record<string, Dependency>> = keyof D extends never ? (ctx: ResolveContext) => MaybePromise<T> : (ctx: ResolveContext, deps: InferDeps<D>) => MaybePromise<T>;
@@ -569,9 +579,7 @@ declare function atom<T>(config: {
   tags?: Lite.Tagged<any>[];
   keepAlive?: boolean;
 }): Lite.Atom<T>;
-declare function atom<T, const D extends Record<string, Lite.Atom<unknown> | Lite.ControllerDep<unknown> | {
-  mode: string;
-}>>(config: {
+declare function atom<T, const D extends Record<string, Lite.AtomDependency>>(config: {
   deps: D;
   factory: (ctx: Lite.ResolveContext, deps: Lite.InferDeps<D>) => MaybePromise<T>;
   tags?: Lite.Tagged<any>[];
@@ -700,18 +708,14 @@ declare function flow<TOutput, TInput>(config: {
   }) => MaybePromise<TOutput>;
   tags?: Lite.Tagged<any>[];
 }): Lite.Flow<TOutput, TInput>;
-declare function flow<TOutput, const D extends Record<string, Lite.Atom<unknown> | Lite.ControllerDep<unknown> | Lite.Resource<unknown, Record<string, Lite.Dependency>> | {
-  mode: string;
-}>>(config: {
+declare function flow<TOutput, const D extends Record<string, Lite.ExecutionDependency>>(config: {
   name?: string;
   parse?: undefined;
   deps: D;
   factory: (ctx: Lite.ExecutionContext, deps: Lite.InferDeps<D>) => MaybePromise<TOutput>;
   tags?: Lite.Tagged<any>[];
 }): Lite.Flow<TOutput, void>;
-declare function flow<TOutput, TInput, const D extends Record<string, Lite.Atom<unknown> | Lite.ControllerDep<unknown> | Lite.Resource<unknown, Record<string, Lite.Dependency>> | {
-  mode: string;
-}>>(config: {
+declare function flow<TOutput, TInput, const D extends Record<string, Lite.ExecutionDependency>>(config: {
   name?: string;
   parse: (raw: unknown) => MaybePromise<TInput>;
   deps: D;
@@ -720,9 +724,7 @@ declare function flow<TOutput, TInput, const D extends Record<string, Lite.Atom<
   }, deps: Lite.InferDeps<D>) => MaybePromise<TOutput>;
   tags?: Lite.Tagged<any>[];
 }): Lite.Flow<TOutput, TInput>;
-declare function flow<TOutput, TInput, const D extends Record<string, Lite.Atom<unknown> | Lite.ControllerDep<unknown> | Lite.Resource<unknown, Record<string, Lite.Dependency>> | {
-  mode: string;
-}>>(config: {
+declare function flow<TOutput, TInput, const D extends Record<string, Lite.ExecutionDependency>>(config: {
   name?: string;
   parse: Lite.Typed<TInput>;
   deps: D;
@@ -825,9 +827,7 @@ declare function resource<T>(config: {
   deps?: undefined;
   factory: (ctx: Lite.ExecutionContext) => MaybePromise<T>;
 }): Lite.Resource<T>;
-declare function resource<T, const D extends Record<string, Lite.Atom<unknown> | Lite.ControllerDep<unknown> | Lite.Resource<unknown, Record<string, Lite.Dependency>> | {
-  mode: string;
-}>>(config: {
+declare function resource<T, const D extends Record<string, Lite.ExecutionDependency>>(config: {
   name?: string;
   deps: D;
   factory: (ctx: Lite.ExecutionContext, deps: Lite.InferDeps<D>) => MaybePromise<T>;