@kontsedal/olas-core 0.0.1-rc.1 → 0.0.2

package/dist/{root-Bazp5_Ik.cjs → root-XKEsSmcd.cjs}

@@ -212,16 +212,41 @@ function untracked(fn) {
 //#endregion
 //#region src/utils.ts
 /**
-* True iff `err` is an AbortError. Used to filter superseded latest-wins
-* mutations and aborted fetches from genuine failures.
+* True iff `err` looks like an AbortError. Matches the standard `DOMException`
+* shape thrown by `AbortController` AND any object whose `name === 'AbortError'`
+* — that covers axios / msw / user-thrown plain Errors that signal abort.
 *
-* Spec: §20.12 — checks `err instanceof DOMException && err.name === 'AbortError'`.
-* Node 17+ exposes a global DOMException, so this works server-side too.
+* Spec: §20.12. Node 17+ exposes a global DOMException, so the instanceof
+* branch works server-side; the name-based branch is the portable fallback.
 */
 function isAbortError(err) {
 	if (typeof DOMException !== "undefined" && err instanceof DOMException) return err.name === "AbortError";
+	if (err != null && typeof err === "object" && "name" in err) return err.name === "AbortError";
 	return false;
 }
+/**
+* `setTimeout` wrapped in a promise that rejects with `AbortError` if the
+* passed signal fires. Internal — used by the retry loops in `Entry`,
+* `InfiniteEntry`, and `Mutation` so a slow backoff never blocks a supersede.
+*/
+function abortableSleep(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal.aborted) {
+			reject(new DOMException("Aborted", "AbortError"));
+			return;
+		}
+		const timer = setTimeout(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			clearTimeout(timer);
+			signal.removeEventListener("abort", onAbort);
+			reject(new DOMException("Aborted", "AbortError"));
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
 //#endregion
 //#region src/query/entry.ts
 /**
@@ -250,18 +275,37 @@ var Entry = class {
 	nextSnapshotId = 0;
 	disposed = false;
 	events;
+	onSuccessData;
 	fetchStartTime = 0;
+	/**
+	* Promises returned by `firstValue()` that haven't settled. Rejected on
+	* `dispose()` so awaiters (most notably `prefetch` and `subscription.firstValue`)
+	* don't hang when the controller tree is torn down mid-fetch.
+	*/
+	pendingFirstValueRejects = [];
 	constructor(options) {
 		this.fetcherProvider = options.fetcher;
 		this.staleTime = options.staleTime ?? 0;
 		this.retry = options.retry ?? 0;
 		this.retryDelay = options.retryDelay ?? 1e3;
 		this.events = options.events ?? {};
+		this.onSuccessData = options.onSuccessData;
 		this.data = signal(options.initialData);
 		if (options.initialData !== void 0) {
 			this.status = signal("success");
-			this.scheduleStaleness();
-			this.isStale.set(this.staleTime === 0);
+			if (this.staleTime === 0) this.isStale.set(true);
+			else {
+				const last = options.initialUpdatedAt;
+				const alreadyStale = last === void 0 || Date.now() - last >= this.staleTime;
+				this.isStale.set(alreadyStale);
+				if (!alreadyStale) {
+					const remaining = this.staleTime - (Date.now() - last);
+					this.staleTimer = setTimeout(() => {
+						this.staleTimer = null;
+						if (!this.disposed) this.isStale.set(true);
+					}, remaining);
+				}
+			}
 		} else this.status = signal("idle");
 		this.lastUpdatedAt = signal(options.initialUpdatedAt);
 	}
@@ -294,7 +338,7 @@ var Entry = class {
 			} catch (err) {
 				if (myId !== this.currentFetchId || this.disposed || isAbortError(err)) throw err;
 				if (!this.shouldRetry(attempt, err)) return this.applyFailure(err);
-				await abortableSleep$2(this.computeDelay(attempt), abort.signal);
+				await abortableSleep(this.computeDelay(attempt), abort.signal);
 				attempt += 1;
 			}
 		}
@@ -323,6 +367,7 @@ var Entry = class {
 		try {
 			this.events.onFetchSuccess?.(Date.now() - this.fetchStartTime);
 		} catch {}
+		this.onSuccessData?.(result);
 		return result;
 	}
 	applyFailure(err) {
@@ -401,26 +446,24 @@ var Entry = class {
 			}
 		};
 	}
-	finalizeSnapshot(snapshot) {
-		const id = snapshotIds.get(snapshot);
-		if (id === void 0) return;
-		const record = this.snapshots.find((s) => s.live && s.id === id);
-		if (!record) return;
-		record.live = false;
-		this.snapshots = this.snapshots.filter((s) => s !== record);
-		if (!this.snapshots.some((s) => s.live)) this.hasPendingMutations.set(false);
-	}
 	firstValue() {
+		if (this.disposed) return Promise.reject(new DOMException("Entry disposed", "AbortError"));
 		if (this.status.peek() === "success") return Promise.resolve(this.data.peek());
 		if (this.status.peek() === "error") return Promise.reject(this.error.peek());
 		return new Promise((resolve, reject) => {
+			const tracked = (err) => {
+				this.pendingFirstValueRejects = this.pendingFirstValueRejects.filter((f) => f !== tracked);
+				reject(err);
+			};
+			this.pendingFirstValueRejects.push(tracked);
 			const unsub = this.status.subscribe((s) => {
 				if (s === "success") {
 					unsub();
+					this.pendingFirstValueRejects = this.pendingFirstValueRejects.filter((f) => f !== tracked);
 					resolve(this.data.peek());
 				} else if (s === "error") {
 					unsub();
-					reject(this.error.peek());
+					tracked(this.error.peek());
 				}
 			});
 		});
@@ -443,27 +486,14 @@ var Entry = class {
 		}
 		this.currentAbort?.abort();
 		this.currentAbort = null;
+		if (this.pendingFirstValueRejects.length > 0) {
+			const disposed = new DOMException("Entry disposed", "AbortError");
+			const rejects = this.pendingFirstValueRejects;
+			this.pendingFirstValueRejects = [];
+			for (const fn of rejects) fn(disposed);
+		}
 	}
 };
-const snapshotIds = /* @__PURE__ */ new WeakMap();
-function abortableSleep$2(ms, signal) {
-	return new Promise((resolve, reject) => {
-		if (signal.aborted) {
-			reject(new DOMException("Aborted", "AbortError"));
-			return;
-		}
-		const timer = setTimeout(() => {
-			signal.removeEventListener("abort", onAbort);
-			resolve();
-		}, ms);
-		const onAbort = () => {
-			clearTimeout(timer);
-			signal.removeEventListener("abort", onAbort);
-			reject(new DOMException("Aborted", "AbortError"));
-		};
-		signal.addEventListener("abort", onAbort, { once: true });
-	});
-}
 //#endregion
 //#region src/query/focus-online.ts
 const focusSubs = /* @__PURE__ */ new Set();
@@ -539,6 +569,8 @@ var InfiniteEntry = class {
 	snapshots = [];
 	nextSnapshotId = 0;
 	disposed = false;
+	/** Mirrors `Entry.pendingFirstValueRejects` — see that field for context. */
+	pendingFirstValueRejects = [];
 	fetcher;
 	initialPageParam;
 	getNextPageParam;
@@ -547,6 +579,13 @@ var InfiniteEntry = class {
 	retry;
 	retryDelay;
 	itemsOf;
+	/**
+	* Mirrors `Entry.onSuccessData`. Fires from `applyFetchSuccess`-equivalent
+	* branches AFTER `pages.set(...)` settles. Used by `InfiniteClientEntry`
+	* to emit `SetDataEvent { kind: 'infinite', source: 'fetch' }` for
+	* `QueryClientPlugin`s (e.g. entity normalization).
+	*/
+	onSuccessData;
 	constructor(opts) {
 		this.fetcher = opts.fetcher;
 		this.initialPageParam = opts.initialPageParam;
@@ -556,6 +595,7 @@ var InfiniteEntry = class {
 		this.staleTime = opts.staleTime ?? 0;
 		this.retry = opts.retry ?? 0;
 		this.retryDelay = opts.retryDelay ?? 1e3;
+		this.onSuccessData = opts.onSuccessData;
 		this.pageParams = signal([]);
 		this.data = computed(() => {
 			const ps = this.pages.value;
@@ -607,6 +647,7 @@ var InfiniteEntry = class {
 				this.isStale.set(this.staleTime === 0);
 			});
 			if (this.staleTime > 0) this.scheduleStaleness();
+			this.onSuccessData?.(this.pages.peek());
 		}, "initial");
 	}
 	fetchNextPage() {
@@ -633,6 +674,7 @@ var InfiniteEntry = class {
 				this.isFetching.set(false);
 				this.lastUpdatedAt.set(Date.now());
 			});
+			this.onSuccessData?.(this.pages.peek());
 		}, "next").then(() => {});
 	}
 	fetchPreviousPage() {
@@ -660,36 +702,46 @@ var InfiniteEntry = class {
 				this.isFetching.set(false);
 				this.lastUpdatedAt.set(Date.now());
 			});
+			this.onSuccessData?.(this.pages.peek());
 		}, "prev").then(() => {});
 	}
 	async runFetch(myId, signal, pageParam, onSuccess, direction) {
 		let attempt = 0;
-		while (true) {
-			if (myId !== this.currentFetchId || this.disposed) throw new DOMException("Superseded", "AbortError");
-			try {
-				const page = await this.fetcher({
-					pageParam,
-					signal
-				});
+		let succeeded = false;
+		try {
+			while (true) {
 				if (myId !== this.currentFetchId || this.disposed) throw new DOMException("Superseded", "AbortError");
-				onSuccess(page, pageParam);
-				return page;
-			} catch (err) {
-				if (myId !== this.currentFetchId || this.disposed || isAbortError(err)) throw err;
-				if (!(typeof this.retry === "number" ? attempt < this.retry : this.retry(attempt, err))) {
-					batch(() => {
-						this.error.set(err);
-						this.status.set("error");
-						this.isLoading.set(false);
-						this.isFetching.set(false);
-						if (direction === "next") this.isFetchingNextPage.set(false);
-						if (direction === "prev") this.isFetchingPreviousPage.set(false);
+				try {
+					const page = await this.fetcher({
+						pageParam,
+						signal
 					});
-					throw err;
+					if (myId !== this.currentFetchId || this.disposed) throw new DOMException("Superseded", "AbortError");
+					onSuccess(page, pageParam);
+					succeeded = true;
+					return page;
+				} catch (err) {
+					if (myId !== this.currentFetchId || this.disposed || isAbortError(err)) throw err;
+					if (!(typeof this.retry === "number" ? attempt < this.retry : this.retry(attempt, err))) {
+						batch(() => {
+							this.error.set(err);
+							this.status.set("error");
+							this.isLoading.set(false);
+							this.isFetching.set(false);
+							if (direction === "next") this.isFetchingNextPage.set(false);
+							if (direction === "prev") this.isFetchingPreviousPage.set(false);
+						});
+						throw err;
+					}
+					await abortableSleep(typeof this.retryDelay === "function" ? this.retryDelay(attempt) : this.retryDelay, signal);
+					attempt += 1;
 				}
-				await abortableSleep$1(typeof this.retryDelay === "function" ? this.retryDelay(attempt) : this.retryDelay, signal);
-				attempt += 1;
 			}
+		} finally {
+			if (!succeeded) batch(() => {
+				if (direction === "next") this.isFetchingNextPage.set(false);
+				if (direction === "prev") this.isFetchingPreviousPage.set(false);
+			});
 		}
 	}
 	refetch() {
@@ -749,16 +801,23 @@ var InfiniteEntry = class {
 		};
 	}
 	firstValue() {
+		if (this.disposed) return Promise.reject(new DOMException("Entry disposed", "AbortError"));
 		if (this.status.peek() === "success") return Promise.resolve(this.pages.peek());
 		if (this.status.peek() === "error") return Promise.reject(this.error.peek());
 		return new Promise((resolve, reject) => {
+			const tracked = (err) => {
+				this.pendingFirstValueRejects = this.pendingFirstValueRejects.filter((f) => f !== tracked);
+				reject(err);
+			};
+			this.pendingFirstValueRejects.push(tracked);
 			const unsub = this.status.subscribe((s) => {
 				if (s === "success") {
 					unsub();
+					this.pendingFirstValueRejects = this.pendingFirstValueRejects.filter((f) => f !== tracked);
 					resolve(this.pages.peek());
 				} else if (s === "error") {
 					unsub();
-					reject(this.error.peek());
+					tracked(this.error.peek());
 				}
 			});
 		});
@@ -784,26 +843,14 @@ var InfiniteEntry = class {
 		}
 		this.currentAbort?.abort();
 		this.currentAbort = null;
+		if (this.pendingFirstValueRejects.length > 0) {
+			const disposed = new DOMException("Entry disposed", "AbortError");
+			const rejects = this.pendingFirstValueRejects;
+			this.pendingFirstValueRejects = [];
+			for (const fn of rejects) fn(disposed);
+		}
 	}
 };
-function abortableSleep$1(ms, signal) {
-	return new Promise((resolve, reject) => {
-		if (signal.aborted) {
-			reject(new DOMException("Aborted", "AbortError"));
-			return;
-		}
-		const timer = setTimeout(() => {
-			signal.removeEventListener("abort", onAbort);
-			resolve();
-		}, ms);
-		const onAbort = () => {
-			clearTimeout(timer);
-			signal.removeEventListener("abort", onAbort);
-			reject(new DOMException("Aborted", "AbortError"));
-		};
-		signal.addEventListener("abort", onAbort, { once: true });
-	});
-}
 //#endregion
 //#region src/query/keys.ts
 /**
@@ -870,7 +917,7 @@ var ClientEntry = class {
 	refetchInterval;
 	refetchOnWindowFocus;
 	refetchOnReconnect;
-	constructor(client, query, callArgs, keyArgs, spec, hydrated) {
+	constructor(client, query, callArgs, keyArgs, spec, hydrated, onFetchSuccess) {
 		this.client = client;
 		this.query = query;
 		this.callArgs = callArgs;
@@ -893,7 +940,8 @@ var ClientEntry = class {
 			retryDelay: spec.retryDelay,
 			initialData: hydrated?.data,
 			initialUpdatedAt: hydrated?.lastUpdatedAt,
-			events: void 0
+			events: void 0,
+			onSuccessData: onFetchSuccess
 		});
 	}
 	acquire() {
@@ -993,7 +1041,7 @@ var InfiniteClientEntry = class {
 	intervalTimer = null;
 	gcTime;
 	refetchInterval;
-	constructor(client, query, callArgs, keyArgs, spec) {
+	constructor(client, query, callArgs, keyArgs, spec, onFetchSuccess) {
 		this.client = client;
 		this.query = query;
 		this.callArgs = callArgs;
@@ -1014,7 +1062,8 @@ var InfiniteClientEntry = class {
 			itemsOf: spec.itemsOf,
 			staleTime: spec.staleTime,
 			retry: spec.retry,
-			retryDelay: spec.retryDelay
+			retryDelay: spec.retryDelay,
+			onSuccessData: onFetchSuccess
 		});
 	}
 	acquire() {
@@ -1130,6 +1179,9 @@ var QueryClient = class {
 			applyRemoteInvalidate(queryId, keyArgs) {
 				self.applyRemoteInvalidate(queryId, keyArgs);
 			},
+			setEntryData(queryId, keyArgs, updater) {
+				self.setEntryData(queryId, keyArgs, updater);
+			},
 			subscribedKeys(queryId) {
 				return self.subscribedKeysFor(queryId);
 			}
@@ -1146,7 +1198,24 @@ var QueryClient = class {
 			});
 		}
 	}
-	emitSetData(query, keyArgs, data, kind) {
+	/**
+	* Emit a `SetDataEvent` to every installed plugin. The `source` field
+	* tells layered plugins where the write originated:
+	* - `'set'`: explicit `client.setData`, including mutations and plugin-
+	*   initiated `setEntryData` calls (e.g. entity backpropagation).
+	* - `'fetch'`: a query fetcher resolved successfully (`Entry.applySuccess`
+	*   reaches this through `onSuccessData`), or hydrated data was first
+	*   bound (a per-tab arrival of pre-fetched data; cross-tab skips
+	*   `'fetch'` so this stays a per-tab concern).
+	* - `'remote'`: `applyRemoteSetData` — cross-tab / server-push. Mirrors
+	*   `isRemote === true`.
+	*
+	* Private — fetcher-success emission goes through the `onFetchSuccess`
+	* closure that `bindEntry` builds and hands to each new `ClientEntry`.
+	* Hydrated emission goes through this method directly from `bindEntry`.
+	* Mutation / remote paths call it from within QueryClient methods.
+	*/
+	emitSetData(query, keyArgs, data, kind, source) {
 		if (this.plugins.length === 0) return;
 		const queryId = query.__spec.queryId;
 		if (queryId == null) return;
@@ -1155,7 +1224,8 @@ var QueryClient = class {
 			keyArgs,
 			data,
 			kind,
-			isRemote: this.applyingRemote
+			isRemote: this.applyingRemote,
+			source
 		};
 		for (const plugin of this.plugins) if (plugin.onSetData) {
 			const cb = plugin.onSetData;
@@ -1233,11 +1303,44 @@ var QueryClient = class {
 		this.applyingRemote = true;
 		try {
 			entry.entry.setData(() => data);
-			this.emitSetData(internal, entry.keyArgs, data, "data");
+			this.emitSetData(internal, entry.keyArgs, data, "data", "remote");
 		} finally {
 			this.applyingRemote = false;
 		}
 	}
+	/**
+	* Local-originated `setData` keyed by `queryId + keyArgs`. Plugin-facing
+	* (exposed via `QueryClientPluginApi.setEntryData`); used by the
+	* `@kontsedal/olas-entities` plugin to backpropagate entity patches into
+	* every query holding the entity, without forcing the plugin to recover
+	* the original `callArgs`.
+	*
+	* Drops silently in the same cases as `applyRemoteSetData` (unknown
+	* queryId / infinite query / no local entry). Emits `SetDataEvent` with
+	* `isRemote: false`, `source: 'set'` — cross-tab WILL rebroadcast.
+	*/
+	setEntryData(queryId, keyArgs, updater) {
+		const query = lookupRegisteredQuery(queryId);
+		if (!query) return;
+		const hash = stableHash(keyArgs);
+		if (query.__olas === "query") {
+			const internal = query;
+			const map = this.maps.get(internal);
+			if (!map) return;
+			const entry = map.get(hash);
+			if (!entry) return;
+			entry.entry.setData(updater);
+			this.emitSetData(internal, entry.keyArgs, entry.entry.data.peek(), "data", "set");
+			return;
+		}
+		const internal = query;
+		const map = this.infiniteMaps.get(internal);
+		if (!map) return;
+		const entry = map.get(hash);
+		if (!entry) return;
+		entry.entry.setData(updater);
+		this.emitSetData(internal, entry.keyArgs, entry.entry.pages.peek(), "infinite", "set");
+	}
 	applyRemoteInvalidate(queryId, keyArgs) {
 		const query = lookupRegisteredQuery(queryId);
 		if (!query) return;
@@ -1251,6 +1354,7 @@ var QueryClient = class {
 		this.applyingRemote = true;
 		try {
 			entry.entry.invalidate().catch((err) => {
+				if (isAbortError(err)) return;
 				dispatchError(this.onError, err, {
 					kind: "cache",
 					controllerPath: [],
@@ -1346,9 +1450,11 @@ var QueryClient = class {
 		if (!entry) {
 			const hydrated = this.hydratedData.get(hash);
 			if (hydrated) this.hydratedData.delete(hash);
-			entry = new ClientEntry(this, internal, args, keyArgs, internal.__spec, hydrated);
+			const onFetchSuccess = internal.__spec.queryId != null ? (data) => this.emitSetData(internal, keyArgs, data, "data", "fetch") : void 0;
+			entry = new ClientEntry(this, internal, args, keyArgs, internal.__spec, hydrated, onFetchSuccess);
 			map.set(hash, entry);
 			entry.scheduleGcIfOrphan();
+			if (hydrated !== void 0) this.emitSetData(internal, keyArgs, hydrated.data, "data", "fetch");
 		}
 		return entry;
 	}
@@ -1371,6 +1477,7 @@ var QueryClient = class {
 		const entry = map.get(hash);
 		if (!entry) return;
 		entry.entry.invalidate().catch((err) => {
+			if (isAbortError(err)) return;
 			dispatchError(this.onError, err, {
 				kind: "cache",
 				controllerPath: [],
@@ -1385,6 +1492,7 @@ var QueryClient = class {
 		if (!map) return;
 		for (const [hash, entry] of map) {
 			entry.entry.invalidate().catch((err) => {
+				if (isAbortError(err)) return;
 				dispatchError(this.onError, err, {
 					kind: "cache",
 					controllerPath: [],
@@ -1397,7 +1505,7 @@ var QueryClient = class {
 	setData(query, args, updater) {
 		const entry = this.bindEntry(query, args);
 		const snapshot = entry.entry.setData(updater);
-		this.emitSetData(entry.query, entry.keyArgs, entry.entry.data.peek(), "data");
+		this.emitSetData(entry.query, entry.keyArgs, entry.entry.data.peek(), "data", "set");
 		return snapshot;
 	}
 	bindInfiniteEntry(query, args) {
@@ -1413,7 +1521,8 @@ var QueryClient = class {
 		const hash = stableHash(keyArgs);
 		let entry = map.get(hash);
 		if (!entry) {
-			entry = new InfiniteClientEntry(this, internal, args, keyArgs, internal.__spec);
+			const onFetchSuccess = internal.__spec.queryId != null ? (pages) => this.emitSetData(internal, keyArgs, pages, "infinite", "fetch") : void 0;
+			entry = new InfiniteClientEntry(this, internal, args, keyArgs, internal.__spec, onFetchSuccess);
 			map.set(hash, entry);
 			entry.scheduleGcIfOrphan();
 		}
@@ -1438,6 +1547,7 @@ var QueryClient = class {
 		const entry = map.get(hash);
 		if (!entry) return;
 		entry.entry.invalidate().catch((err) => {
+			if (isAbortError(err)) return;
 			dispatchError(this.onError, err, {
 				kind: "cache",
 				controllerPath: [],
@@ -1452,6 +1562,7 @@ var QueryClient = class {
 		if (!map) return;
 		for (const entry of map.values()) {
 			entry.entry.invalidate().catch((err) => {
+				if (isAbortError(err)) return;
 				dispatchError(this.onError, err, {
 					kind: "cache",
 					controllerPath: [],
@@ -1464,7 +1575,7 @@ var QueryClient = class {
 	setInfiniteData(query, args, updater) {
 		const entry = this.bindInfiniteEntry(query, args);
 		const snapshot = entry.entry.setData(updater);
-		this.emitSetData(entry.query, entry.keyArgs, entry.entry.pages.peek(), "infinite");
+		this.emitSetData(entry.query, entry.keyArgs, entry.entry.pages.peek(), "infinite", "set");
 		return snapshot;
 	}
 	prefetchInfinite(query, args) {
@@ -1521,12 +1632,25 @@ function waitUntilFalse(sig) {
 //#endregion
 //#region src/emitter.ts
 var EmitterImpl = class {
+	onError;
 	handlers = /* @__PURE__ */ new Set();
 	disposed = false;
+	constructor(onError) {
+		this.onError = onError;
+	}
 	emit(value) {
 		if (this.disposed) return;
 		const snapshot = Array.from(this.handlers);
-		for (const handler of snapshot) handler(value);
+		for (const handler of snapshot) try {
+			handler(value);
+		} catch (err) {
+			if (this.onError) try {
+				this.onError(err);
+			} catch {
+				console.error("[olas] emitter handler threw and reporter threw:", err);
+			}
+			else console.error("[olas] emitter handler threw:", err);
+		}
 	}
 	on(handler) {
 		if (this.disposed) return () => {};
@@ -1558,9 +1682,14 @@ var EmitterImpl = class {
 * (or the emitter is disposed). Use this for emitters that live outside any
 * single controller — typically in deps. Use `ctx.emitter()` for emitters that
 * should auto-clean with a controller.
+*
+* Pass `onError` to receive emit-time handler throws (spec §20.6 — one
+* throwing handler must not block the rest of the fan-out). `ctx.emitter()`
+* wires this to the root's `onError` so deps-level emitters get isolation
+* by default when constructed via `ctx`.
 */
-function createEmitter() {
-	const impl = new EmitterImpl();
+function createEmitter(options) {
+	const impl = new EmitterImpl(options?.onError);
 	return {
 		emit: ((value) => impl.emit(value)),
 		on: (handler) => impl.on(handler),
@@ -1587,9 +1716,11 @@ var FieldImpl = class {
 	runId = 0;
 	disposed = false;
 	devtoolsOwner = null;
-	constructor(initial, validators = []) {
+	onValidatorError = null;
+	constructor(initial, validators = [], options) {
 		this.initial = initial;
 		this.validators = validators;
+		this.onValidatorError = options?.onValidatorError ?? null;
 		this.value$ = signal(initial);
 		this.errors$ = signal([]);
 		this.touched$ = signal(false);
@@ -1601,6 +1732,13 @@ var FieldImpl = class {
 			this.runValidators();
 		});
 	}
+	/**
+	* Internal hook for `ctx.field` / `createForm` to route synchronous
+	* validator throws through `root.onError`. See `ValidatorErrorReporter`.
+	*/
+	bindValidatorErrorReporter(reporter) {
+		this.onValidatorError = reporter;
+	}
 	get value() {
 		return this.value$.value;
 	}
@@ -1707,10 +1845,15 @@ var FieldImpl = class {
 		const myId = ++this.runId;
 		const syncErrors = [];
 		const asyncPromises = [];
-		for (const validator of this.validators) {
+		for (const validator of this.validators) try {
 			const result = validator(value, abort.signal);
 			if (result instanceof Promise) asyncPromises.push(result);
 			else if (result != null) syncErrors.push(result);
+		} catch (err) {
+			try {
+				this.onValidatorError?.(err);
+			} catch {}
+			syncErrors.push(err instanceof Error ? err.message : String(err));
 		}
 		if (syncErrors.length > 0) {
 			batch(() => {
@@ -1758,8 +1901,18 @@ function bindFieldDevtoolsOwner(field, owner) {
 	const impl = field;
 	if (typeof impl.bindDevtoolsOwner === "function") impl.bindDevtoolsOwner(owner);
 }
-function createField(initial, validators) {
-	return new FieldImpl(initial, validators);
+/**
+* Internal — install a synchronous-validator-throw reporter on a `Field`
+* (matched structurally to keep the public `Field<T>` surface stable).
+* Called by `ctx.field` and `bindTreeToDevtools` so leaves inside a form/
+* field-array tree get the same reporting as a standalone field.
+*/
+function bindFieldValidatorErrorReporter(field, reporter) {
+	const impl = field;
+	if (typeof impl.bindValidatorErrorReporter === "function") impl.bindValidatorErrorReporter(reporter);
+}
+function createField(initial, validators, options) {
+	return new FieldImpl(initial, validators, options);
 }
 /**
 * Wrap an async validator with a debounce. The debounce timer resets on every
@@ -1806,17 +1959,40 @@ var FormImpl = class {
 	validators;
 	options;
 	validatorDispose = null;
+	initialDispose = null;
 	currentValidatorRun = 0;
 	currentValidatorAbort = null;
 	disposed = false;
-	constructor(schema, options) {
+	onValidatorError = null;
+	/** Internal — wire a sync-throw reporter for the top-level validators. */
+	bindValidatorErrorReporter(reporter) {
+		this.onValidatorError = reporter;
+	}
+	constructor(schema, options, internalOptions) {
 		this.fields = schema;
 		this.options = options;
 		this.validators = options?.validators ?? [];
-		if (options?.initial !== void 0) {
-			const ini = typeof options.initial === "function" ? options.initial() : options.initial;
-			if (ini !== void 0) this.applyPartial(ini, true);
-		}
+		this.onValidatorError = internalOptions?.onValidatorError ?? null;
+		if (options?.initial !== void 0) if (typeof options.initial === "function") {
+			const initialFn = options.initial;
+			const mode = options.resetOnInitialChange ?? "when-clean";
+			let firstRun = true;
+			this.initialDispose = effect(() => {
+				const ini = initialFn();
+				if (ini === void 0) return;
+				untracked(() => {
+					if (this.disposed) return;
+					if (firstRun) {
+						firstRun = false;
+						this.applyPartial(ini, true);
+						return;
+					}
+					if (mode === "never") return;
+					if (mode === "when-clean" && this.isDirty.peek()) return;
+					this.applyPartial(ini, true);
+				});
+			});
+		} else this.applyPartial(options.initial, true);
 		this.value = computed(() => this.computeValue());
 		this.errors = computed(() => this.computeErrors());
 		this.isDirty = computed(() => this.computeBool("isDirty"));
@@ -1873,12 +2049,28 @@ var FormImpl = class {
 		for (const [k, val] of Object.entries(partial)) {
 			const child = this.fields[k];
 			if (!child) continue;
+			if (val === void 0) continue;
 			if (isForm(child)) if (asInitial) child.resetWithInitial(val);
 			else child.set(val);
 			else if (isFieldArray(child)) {
 				const arr = child;
-				arr.clear();
-				for (const itemVal of val) arr.add(itemVal);
+				const newValues = val;
+				if (asInitial) {
+					arr.clear();
+					for (const itemVal of newValues) arr.add(itemVal);
+					arr.replaceInitialItems(newValues);
+				} else {
+					const current = arr.items.peek();
+					const overlap = Math.min(current.length, newValues.length);
+					for (let i = 0; i < overlap; i++) {
+						const item = current[i];
+						const v = newValues[i];
+						if (isForm(item)) item.set(v);
+						else item.set(v);
+					}
+					for (let i = current.length; i < newValues.length; i++) arr.add(newValues[i]);
+					for (let i = current.length - 1; i >= newValues.length; i--) arr.remove(i);
+				}
 			} else {
 				const f = child;
 				if (asInitial) f.setAsInitial(val);
@@ -1915,6 +2107,7 @@ var FormImpl = class {
 		for (const child of Object.values(this.fields)) if (isForm(child) || isFieldArray(child)) tasks.push(child.validate());
 		else tasks.push(child.revalidate());
 		await Promise.all(tasks);
+		if (this.validators.length > 0) this.runTopLevelValidators();
 		if (this.topLevelValidating$.peek()) await new Promise((resolve) => {
 			const unsub = this.topLevelValidating$.subscribe((v) => {
 				if (!v) {
@@ -1929,6 +2122,7 @@ var FormImpl = class {
 		if (this.disposed) return;
 		this.disposed = true;
 		this.validatorDispose?.();
+		this.initialDispose?.();
 		this.currentValidatorAbort?.abort();
 		for (const child of Object.values(this.fields)) child.dispose?.();
 	}
@@ -1941,10 +2135,15 @@ var FormImpl = class {
 		const myId = ++this.currentValidatorRun;
 		const syncErrors = [];
 		const asyncPromises = [];
-		for (const v of this.validators) {
+		for (const v of this.validators) try {
 			const r = v(value, abort.signal);
 			if (r instanceof Promise) asyncPromises.push(r);
 			else if (r != null) syncErrors.push(r);
+		} catch (err) {
+			try {
+				this.onValidatorError?.(err);
+			} catch {}
+			syncErrors.push(err instanceof Error ? err.message : String(err));
 		}
 		if (syncErrors.length > 0) {
 			batch(() => {
@@ -2038,9 +2237,15 @@ var FieldArrayImpl = class {
 	currentValidatorAbort = null;
 	validatorDispose = null;
 	disposed = false;
-	constructor(itemFactory, options) {
+	onValidatorError = null;
+	/** Internal — see `FormImpl.bindValidatorErrorReporter`. */
+	bindValidatorErrorReporter(reporter) {
+		this.onValidatorError = reporter;
+	}
+	constructor(itemFactory, options, internalOptions) {
 		this.itemFactory = itemFactory;
 		this.validators = options?.validators ?? [];
+		this.onValidatorError = internalOptions?.onValidatorError ?? null;
 		this.items$ = signal([]);
 		if (options?.initial) {
 			this.initialItems = options.initial;
@@ -2113,6 +2318,15 @@ var FieldArrayImpl = class {
 		for (const item of this.items$.peek()) item.dispose?.();
 		this.items$.set([]);
 	}
+	/**
+	* Internal — used by `Form.resetWithInitial` to re-anchor the array's
+	* initial items after a parent-driven `applyPartial(..., asInitial: true)`.
+	* Without this, a subsequent `reset()` would revert to the construction-
+	* time initials rather than the most-recently-applied ones.
+	*/
+	replaceInitialItems(items) {
+		this.initialItems = [...items];
+	}
 	reset() {
 		if (this.disposed) return;
 		batch(() => {
@@ -2131,6 +2345,7 @@ var FieldArrayImpl = class {
 		for (const item of this.items$.peek()) if (isForm(item)) tasks.push(item.validate());
 		else tasks.push(item.revalidate());
 		await Promise.all(tasks);
+		if (this.validators.length > 0) this.runTopLevelValidators();
 		if (this.topLevelValidating$.peek()) await new Promise((resolve) => {
 			const unsub = this.topLevelValidating$.subscribe((v) => {
 				if (!v) {
@@ -2157,10 +2372,15 @@ var FieldArrayImpl = class {
 		const myId = ++this.currentValidatorRun;
 		const syncErrors = [];
 		const asyncPromises = [];
-		for (const v of this.validators) {
+		for (const v of this.validators) try {
 			const r = v(value, abort.signal);
 			if (r instanceof Promise) asyncPromises.push(r);
 			else if (r != null) syncErrors.push(r);
+		} catch (err) {
+			try {
+				this.onValidatorError?.(err);
+			} catch {}
+			syncErrors.push(err instanceof Error ? err.message : String(err));
 		}
 		if (syncErrors.length > 0) {
 			batch(() => {
@@ -2191,11 +2411,11 @@ var FieldArrayImpl = class {
 		});
 	}
 };
-function createForm(schema, options) {
-	return new FormImpl(schema, options);
+function createForm(schema, options, internalOptions) {
+	return new FormImpl(schema, options, internalOptions);
 }
-function createFieldArray(itemFactory, options) {
-	return new FieldArrayImpl(itemFactory, options);
+function createFieldArray(itemFactory, options, internalOptions) {
+	return new FieldArrayImpl(itemFactory, options, internalOptions);
 }
 /**
 * Recursively wire every leaf `Field` in a form / field-array tree to a
@@ -2222,12 +2442,24 @@ function bindTreeToDevtoolsInto(node, prefix, controllerPath, emitter, disposers
 	}
 	if (isFieldArray(node)) {
 		const arr = node;
+		let perPass = [];
 		const stop = effect(() => {
-			arr.items.value.forEach((item, idx) => {
-				bindTreeToDevtoolsInto(item, `${prefix}[${idx}]`, controllerPath, emitter, disposers);
+			const items = arr.items.value;
+			for (const d of perPass) try {
+				d();
+			} catch {}
+			perPass = [];
+			items.forEach((item, idx) => {
+				bindTreeToDevtoolsInto(item, `${prefix}[${idx}]`, controllerPath, emitter, perPass);
 			});
 		});
 		disposers.push(stop);
+		disposers.push(() => {
+			for (const d of perPass) try {
+				d();
+			} catch {}
+			perPass = [];
+		});
 		return;
 	}
 	bindFieldDevtoolsOwner(node, {
@@ -2236,6 +2468,26 @@ function bindTreeToDevtoolsInto(node, prefix, controllerPath, emitter, disposers
 		emitter
 	});
 }
+/**
+* Walk a Form/FieldArray subtree and install `reporter` on every level —
+* leaf fields, nested forms' top-level validators, and field-arrays' top-level
+* validators. Called by `ctx.form` / `ctx.fieldArray` so synchronous validator
+* throws anywhere in the tree route through `root.onError`. See
+* `ValidatorErrorReporter` in `./field.ts`.
+*/
+function bindTreeValidatorErrorReporter(node, reporter) {
+	if (isForm(node)) {
+		node.bindValidatorErrorReporter?.(reporter);
+		for (const child of Object.values(node.fields)) bindTreeValidatorErrorReporter(child, reporter);
+		return;
+	}
+	if (isFieldArray(node)) {
+		node.bindValidatorErrorReporter?.(reporter);
+		for (const item of node.items.value) bindTreeValidatorErrorReporter(item, reporter);
+		return;
+	}
+	bindFieldValidatorErrorReporter(node, reporter);
+}
 //#endregion
 //#region src/query/local.ts
 var LocalCacheImpl = class {
@@ -2469,7 +2721,13 @@ var MutationImpl = class {
 	reset() {
 		if (this.disposed) return;
 		for (const handle of this.inflight) handle.abort.abort();
-		this.serialQueue.length = 0;
+		if (this.serialQueue.length > 0) {
+			const aborted = new DOMException("Aborted", "AbortError");
+			const queue = this.serialQueue;
+			this.serialQueue = [];
+			for (const queued of queue) queued.reject(aborted);
+		}
+		this.serialActive = false;
 		batch(() => {
 			this.data.set(void 0);
 			this.error.set(void 0);
@@ -2517,24 +2775,6 @@ function raceAbort(promise, signal) {
 		});
 	});
 }
-function abortableSleep(ms, signal) {
-	return new Promise((resolve, reject) => {
-		if (signal.aborted) {
-			reject(new DOMException("Aborted", "AbortError"));
-			return;
-		}
-		const timer = setTimeout(() => {
-			signal.removeEventListener("abort", onAbort);
-			resolve();
-		}, ms);
-		const onAbort = () => {
-			clearTimeout(timer);
-			signal.removeEventListener("abort", onAbort);
-			reject(new DOMException("Aborted", "AbortError"));
-		};
-		signal.addEventListener("abort", onAbort, { once: true });
-	});
-}
 //#endregion
 //#region src/query/use.ts
 var SubscriptionImpl = class {
@@ -2605,7 +2845,9 @@ function createUse(client, query, keyOrOptions) {
 	const enabledFn = typeof keyOrOptions === "object" && keyOrOptions !== null ? keyOrOptions.enabled : void 0;
 	const sub = new SubscriptionImpl(keepPreviousData);
 	let currentEntry = null;
+	let suspended = false;
 	const effectDispose = effect(() => {
+		if (suspended) return;
 		if (!(enabledFn ? enabledFn() : true)) {
 			untracked(() => {
 				if (currentEntry) {
@@ -2636,9 +2878,31 @@ function createUse(client, query, keyOrOptions) {
 		}
 		sub.detach();
 	};
+	const suspend = () => {
+		if (suspended) return;
+		suspended = true;
+		if (currentEntry) {
+			currentEntry.release();
+			currentEntry = null;
+		}
+	};
+	const resume = () => {
+		if (!suspended) return;
+		suspended = false;
+		if (!(enabledFn ? enabledFn() : true)) return;
+		const args = keyFn ? keyFn() : [];
+		const entry = client.bindEntry(query, args);
+		entry.acquire();
+		currentEntry = entry;
+		sub.attach(entry);
+		const status = entry.entry.status.peek();
+		if (status === "idle" || entry.entry.isStaleNow() || status === "error") entry.entry.startFetch().catch(() => {});
+	};
 	return {
 		subscription: sub,
-		dispose
+		dispose,
+		suspend,
+		resume
 	};
 }
 var InfiniteSubscriptionImpl = class {
@@ -2738,7 +3002,9 @@ function createInfiniteUse(client, query, keyOrOptions) {
 	const enabledFn = typeof keyOrOptions === "object" && keyOrOptions !== null ? keyOrOptions.enabled : void 0;
 	const sub = new InfiniteSubscriptionImpl(keepPreviousData);
 	let currentEntry = null;
+	let suspended = false;
 	const effectDispose = effect(() => {
+		if (suspended) return;
 		if (!(enabledFn ? enabledFn() : true)) {
 			untracked(() => {
 				if (currentEntry) {
@@ -2769,9 +3035,31 @@ function createInfiniteUse(client, query, keyOrOptions) {
 		}
 		sub.detach();
 	};
+	const suspend = () => {
+		if (suspended) return;
+		suspended = true;
+		if (currentEntry) {
+			currentEntry.release();
+			currentEntry = null;
+		}
+	};
+	const resume = () => {
+		if (!suspended) return;
+		suspended = false;
+		if (!(enabledFn ? enabledFn() : true)) return;
+		const args = keyFn ? keyFn() : [];
+		const entry = client.bindInfiniteEntry(query, args);
+		entry.acquire();
+		currentEntry = entry;
+		sub.attach(entry);
+		const status = entry.entry.status.peek();
+		if (status === "idle" || entry.entry.isStaleNow() || status === "error") entry.entry.startFetch().catch(() => {});
+	};
 	return {
 		subscription: sub,
-		dispose
+		dispose,
+		suspend,
+		resume
 	};
 }
 //#endregion
@@ -2821,7 +3109,6 @@ var ControllerInstance = class ControllerInstance {
 	}
 	dispose() {
 		if (this.state === "disposed") return;
-		this.state;
 		this.state = "disposed";
 		for (let i = this.entries.length - 1; i >= 0; i--) {
 			const entry = this.entries[i];
@@ -2847,6 +3134,9 @@ var ControllerInstance = class ControllerInstance {
 			case "cleanup":
 				entry.dispose();
 				break;
+			case "subscription-cache":
+				entry.dispose();
+				break;
 			case "child":
 				entry.instance.dispose();
 				break;
@@ -2872,6 +3162,9 @@ var ControllerInstance = class ControllerInstance {
 						entry.dispose?.();
 						entry.dispose = null;
 						break;
+					case "subscription-cache":
+						entry.suspend();
+						break;
 					case "child":
 						entry.instance.suspend();
 						break;
@@ -2896,6 +3189,9 @@ var ControllerInstance = class ControllerInstance {
 				case "effect":
 					entry.dispose = effect(entry.factory);
 					break;
+				case "subscription-cache":
+					entry.resume();
+					break;
 				case "child":
 					entry.instance.resume();
 					break;
@@ -2936,7 +3232,7 @@ var ControllerInstance = class ControllerInstance {
 					}
 				};
 				entry.factory = wrapped;
-				entry.dispose = effect(wrapped);
+				if (self.state !== "suspended") entry.dispose = effect(wrapped);
 				self.entries.push(entry);
 			},
 			cache(fetcher, options) {
@@ -2949,19 +3245,23 @@ var ControllerInstance = class ControllerInstance {
 			},
 			use(query, keyOrOptions) {
 				if (query.__olas === "infiniteQuery") {
-					const { subscription, dispose: d } = createInfiniteUse(self.rootShared.queryClient, query, keyOrOptions);
+					const handle = createInfiniteUse(self.rootShared.queryClient, query, keyOrOptions);
 					self.entries.push({
-						kind: "cleanup",
-						dispose: d
+						kind: "subscription-cache",
+						dispose: handle.dispose,
+						suspend: handle.suspend,
+						resume: handle.resume
 					});
-					return subscription;
+					return handle.subscription;
 				}
-				const { subscription, dispose: d } = createUse(self.rootShared.queryClient, query, keyOrOptions);
+				const handle = createUse(self.rootShared.queryClient, query, keyOrOptions);
 				self.entries.push({
-					kind: "cleanup",
-					dispose: d
+					kind: "subscription-cache",
+					dispose: handle.dispose,
+					suspend: handle.suspend,
+					resume: handle.resume
 				});
-				return subscription;
+				return handle.subscription;
 			},
 			mutation(spec) {
 				const m = createMutation(spec, self.rootShared.onError, self.path, self.rootShared.queryClient.mutationsInflight$, self.rootShared.devtools);
@@ -2972,7 +3272,12 @@ var ControllerInstance = class ControllerInstance {
 				return m;
 			},
 			emitter() {
-				const e = createEmitter();
+				const e = createEmitter({ onError: (err) => {
+					dispatchError(self.rootShared.onError, err, {
+						kind: "emitter",
+						controllerPath: self.path
+					});
+				} });
 				self.entries.push({
 					kind: "cleanup",
 					dispose: () => e.dispose()
@@ -2980,7 +3285,12 @@ var ControllerInstance = class ControllerInstance {
 				return e;
 			},
 			field(initial, validators) {
-				const f = createField(initial, validators);
+				const f = createField(initial, validators, { onValidatorError: (err) => {
+					dispatchError(self.rootShared.onError, err, {
+						kind: "effect",
+						controllerPath: self.path
+					});
+				} });
 				self.entries.push({
 					kind: "cleanup",
 					dispose: () => f.dispose()
@@ -2993,7 +3303,13 @@ var ControllerInstance = class ControllerInstance {
 				return f;
 			},
 			form(schema, options) {
-				const f = createForm(schema, options);
+				const reporter = (err) => {
+					dispatchError(self.rootShared.onError, err, {
+						kind: "effect",
+						controllerPath: self.path
+					});
+				};
+				const f = createForm(schema, options, { onValidatorError: reporter });
 				self.entries.push({
 					kind: "cleanup",
 					dispose: () => f.dispose()
@@ -3003,10 +3319,17 @@ var ControllerInstance = class ControllerInstance {
 					kind: "cleanup",
 					dispose: stop
 				});
+				bindTreeValidatorErrorReporter(f, reporter);
 				return f;
 			},
 			fieldArray(itemFactory, options) {
-				const fa = createFieldArray(itemFactory, options);
+				const reporter = (err) => {
+					dispatchError(self.rootShared.onError, err, {
+						kind: "effect",
+						controllerPath: self.path
+					});
+				};
+				const fa = createFieldArray(itemFactory, options, { onValidatorError: reporter });
 				self.entries.push({
 					kind: "cleanup",
 					dispose: () => fa.dispose()
@@ -3016,6 +3339,7 @@ var ControllerInstance = class ControllerInstance {
 					kind: "cleanup",
 					dispose: stop
 				});
+				bindTreeValidatorErrorReporter(fa, reporter);
 				return fa;
 			},
 			provide(scope, value) {
@@ -3095,9 +3419,280 @@ var ControllerInstance = class ControllerInstance {
 								controllerPath: self.path
 							});
 						}
+					},
+					suspend: () => {
+						if (disposed) return;
+						try {
+							childInstance.suspend();
+						} catch (err) {
+							dispatchError(self.rootShared.onError, err, {
+								kind: "effect",
+								controllerPath: self.path
+							});
+						}
+					},
+					resume: () => {
+						if (disposed) return;
+						try {
+							childInstance.resume();
+						} catch (err) {
+							dispatchError(self.rootShared.onError, err, {
+								kind: "effect",
+								controllerPath: self.path
+							});
+						}
 					}
 				};
 			},
+			session(def, props, options) {
+				const segment = self.makeChildSegment(getFactory(def), getName(def));
+				const override = options?.deps;
+				const childDeps = override !== void 0 ? {
+					...self.deps,
+					...override
+				} : self.deps;
+				const childInstance = new ControllerInstance(self, self.rootShared, segment, childDeps);
+				const api = childInstance.construct(getFactory(def), props);
+				const entry = {
+					kind: "child",
+					instance: childInstance
+				};
+				self.entries.push(entry);
+				let disposed = false;
+				const dispose = () => {
+					if (disposed) return;
+					disposed = true;
+					const idx = self.entries.indexOf(entry);
+					if (idx >= 0) self.entries.splice(idx, 1);
+					try {
+						childInstance.dispose();
+					} catch (err) {
+						dispatchError(self.rootShared.onError, err, {
+							kind: "effect",
+							controllerPath: self.path
+						});
+					}
+				};
+				return [api, dispose];
+			},
+			collection(options) {
+				const childMap = /* @__PURE__ */ new Map();
+				const items$ = signal([]);
+				const size$ = computed(() => items$.value.length);
+				const isFactoryForm = options.factory !== void 0;
+				const buildChild = (item) => {
+					let def;
+					let childProps;
+					if (isFactoryForm) {
+						const result = options.factory(item);
+						def = result.controller;
+						childProps = result.props;
+					} else {
+						const homoOpts = options;
+						def = homoOpts.controller;
+						childProps = homoOpts.propsOf(item);
+					}
+					const segment = self.makeChildSegment(getFactory(def), getName(def));
+					const childDeps = options.deps !== void 0 ? {
+						...self.deps,
+						...options.deps
+					} : self.deps;
+					const instance = new ControllerInstance(self, self.rootShared, segment, childDeps);
+					try {
+						return {
+							instance,
+							api: instance.construct(getFactory(def), childProps),
+							def
+						};
+					} catch (err) {
+						dispatchError(self.rootShared.onError, err, {
+							kind: "construction",
+							controllerPath: self.path
+						});
+						return null;
+					}
+				};
+				const removeKey = (key) => {
+					const info = childMap.get(key);
+					if (info === void 0) return;
+					childMap.delete(key);
+					const idx = self.entries.indexOf(info.entry);
+					if (idx >= 0) self.entries.splice(idx, 1);
+					try {
+						info.instance.dispose();
+					} catch (err) {
+						dispatchError(self.rootShared.onError, err, {
+							kind: "effect",
+							controllerPath: self.path
+						});
+					}
+				};
+				const reconcile = () => {
+					const source = options.source.value;
+					const itemByKey = /* @__PURE__ */ new Map();
+					for (const item of source) {
+						const key = options.keyOf(item);
+						if (!itemByKey.has(key)) itemByKey.set(key, item);
+					}
+					for (const key of [...childMap.keys()]) if (!itemByKey.has(key)) removeKey(key);
+					for (const [key, item] of itemByKey) {
+						const existing = childMap.get(key);
+						if (existing !== void 0) {
+							if (isFactoryForm) {
+								if (options.factory(item).controller !== existing.def) {
+									removeKey(key);
+									const built = buildChild(item);
+									if (built !== null) {
+										const entry = {
+											kind: "child",
+											instance: built.instance
+										};
+										self.entries.push(entry);
+										childMap.set(key, {
+											...built,
+											entry
+										});
+									}
+								}
+							}
+							continue;
+						}
+						const built = buildChild(item);
+						if (built !== null) {
+							const entry = {
+								kind: "child",
+								instance: built.instance
+							};
+							self.entries.push(entry);
+							childMap.set(key, {
+								...built,
+								entry
+							});
+						}
+					}
+					const next = [];
+					const seen = /* @__PURE__ */ new Set();
+					for (const item of source) {
+						const key = options.keyOf(item);
+						if (seen.has(key)) continue;
+						seen.add(key);
+						const info = childMap.get(key);
+						if (info !== void 0) next.push({
+							key,
+							api: info.api
+						});
+					}
+					items$.set(next);
+				};
+				const wrapped = () => {
+					try {
+						reconcile();
+					} catch (err) {
+						dispatchError(self.rootShared.onError, err, {
+							kind: "effect",
+							controllerPath: self.path
+						});
+					}
+				};
+				const effectEntry = {
+					kind: "effect",
+					factory: wrapped,
+					dispose: null
+				};
+				if (self.state !== "suspended") effectEntry.dispose = effect(wrapped);
+				self.entries.push(effectEntry);
+				return {
+					items: items$,
+					size: size$,
+					get: (key) => childMap.get(key)?.api,
+					has: (key) => childMap.has(key)
+				};
+			},
+			lazyChild(loader, props, options) {
+				const status$ = signal("idle");
+				const api$ = signal(void 0);
+				const error$ = signal(void 0);
+				let childInstance = null;
+				let childEntry = null;
+				let pendingLoad = null;
+				let disposed = false;
+				const flagEntry = {
+					kind: "onDispose",
+					fn: () => {
+						disposed = true;
+					}
+				};
+				self.entries.push(flagEntry);
+				const handleFailure = (err) => {
+					status$.set("error");
+					error$.set(err);
+					dispatchError(self.rootShared.onError, err, {
+						kind: "construction",
+						controllerPath: self.path
+					});
+				};
+				const load = () => {
+					if (disposed) return Promise.reject(/* @__PURE__ */ new Error("[olas] ctx.lazyChild: cannot load after dispose"));
+					if (pendingLoad !== null) return pendingLoad;
+					status$.set("loading");
+					pendingLoad = loader().then((def) => {
+						if (disposed) throw new Error("[olas] ctx.lazyChild: disposed during load");
+						const segment = self.makeChildSegment(getFactory(def), getName(def));
+						const childDeps = options?.deps !== void 0 ? {
+							...self.deps,
+							...options.deps
+						} : self.deps;
+						const instance = new ControllerInstance(self, self.rootShared, segment, childDeps);
+						try {
+							const api = instance.construct(getFactory(def), props);
+							childInstance = instance;
+							childEntry = {
+								kind: "child",
+								instance
+							};
+							self.entries.push(childEntry);
+							api$.set(api);
+							status$.set("ready");
+							return api;
+						} catch (err) {
+							handleFailure(err);
+							throw err;
+						}
+					}, (err) => {
+						if (disposed) throw err;
+						handleFailure(err);
+						throw err;
+					});
+					return pendingLoad;
+				};
+				const dispose = () => {
+					if (disposed) return;
+					disposed = true;
+					if (childEntry !== null && childInstance !== null) {
+						const idx = self.entries.indexOf(childEntry);
+						if (idx >= 0) self.entries.splice(idx, 1);
+						try {
+							childInstance.dispose();
+						} catch (err) {
+							dispatchError(self.rootShared.onError, err, {
+								kind: "effect",
+								controllerPath: self.path
+							});
+						}
+						childInstance = null;
+						childEntry = null;
+					}
+					const flagIdx = self.entries.indexOf(flagEntry);
+					if (flagIdx >= 0) self.entries.splice(flagIdx, 1);
+				};
+				return {
+					status: status$,
+					api: api$,
+					error: error$,
+					load,
+					dispose
+				};
+			},
 			onDispose(fn) {
 				self.entries.push({
 					kind: "onDispose",
@@ -3186,7 +3781,13 @@ function createRootWithProps(def, props, options) {
 		onError: options.onError,
 		queryClient
 	}, "root", options.deps);
-	const api = instance.construct(getFactory(def), props);
+	let api;
+	try {
+		api = instance.construct(getFactory(def), props);
+	} catch (err) {
+		queryClient.dispose();
+		throw err;
+	}
 	if (typeof api !== "object" || api === null) return attachRootControls({ value: api }, instance, devtools, queryClient);
 	return attachRootControls(api, instance, devtools, queryClient);
 }
@@ -3337,6 +3938,12 @@ Object.defineProperty(exports, "signal", {
 		return signal;
 	}
 });
+Object.defineProperty(exports, "stableHash", {
+	enumerable: true,
+	get: function() {
+		return stableHash;
+	}
+});
 Object.defineProperty(exports, "untracked", {
 	enumerable: true,
 	get: function() {
@@ -3344,4 +3951,4 @@ Object.defineProperty(exports, "untracked", {
 	}
 });
 
-//# sourceMappingURL=root-Bazp5_Ik.cjs.map
+//# sourceMappingURL=root-XKEsSmcd.cjs.map