@kontsedal/olas-core 0.0.1-rc.0

package/dist/root-Bazp5_Ik.cjs

@@ -0,0 +1,3347 @@
+let _preact_signals_core = require("@preact/signals-core");
+//#region src/controller/define.ts
+/**
+* Create a controller definition. The factory is stored on the returned object
+* and invoked during `createRoot` / `ctx.child` to build instances.
+*
+* `Props` defaults to `void` so a factory written as `(ctx) => ...` is typed
+* as `ControllerDef<void, Api>` — the form `createRoot` requires.
+*/
+function defineController(factory, options) {
+	return {
+		__olas: "controller",
+		__factory: factory,
+		...options?.name !== void 0 ? { __name: options.name } : {}
+	};
+}
+/** Internal — extracts the factory from a ControllerDef. */
+function getFactory(def) {
+	return def.__factory;
+}
+/** Internal — extracts the explicit `name` option from a ControllerDef, if any. */
+function getName(def) {
+	return def.__name;
+}
+//#endregion
+//#region src/devtools.ts
+function pathKey(path) {
+	return path.join("\0");
+}
+/**
+* Per-root devtools event multiplexer. Emit is a no-op when no one is
+* subscribed (one Set size check), so leaving the bus in production has
+* effectively zero cost until a consumer attaches.
+*
+* Internal — exposed to consumers via `root.__debug`.
+*
+* Tracks a snapshot of every live controller (constructed but not yet
+* disposed) and replays construction events to new subscribers, so the
+* devtools tree populates on mount instead of staying blank until the
+* next event.
+*/
+var DevtoolsEmitter = class {
+	handlers = /* @__PURE__ */ new Set();
+	/** Path → entry for every live (constructed, not disposed) controller. */
+	liveControllers = /* @__PURE__ */ new Map();
+	subscribe(handler) {
+		for (const entry of this.liveControllers.values()) try {
+			handler({
+				type: "controller:constructed",
+				path: entry.path,
+				props: entry.props
+			});
+			if (entry.state === "suspended") handler({
+				type: "controller:suspended",
+				path: entry.path
+			});
+		} catch {}
+		this.handlers.add(handler);
+		return () => {
+			this.handlers.delete(handler);
+		};
+	}
+	emit(event) {
+		this.recordLifecycle(event);
+		if (this.handlers.size === 0) return;
+		const snapshot = Array.from(this.handlers);
+		for (const handler of snapshot) try {
+			handler(event);
+		} catch {}
+	}
+	get hasSubscribers() {
+		return this.handlers.size > 0;
+	}
+	recordLifecycle(event) {
+		if (event.type === "controller:constructed") {
+			this.liveControllers.set(pathKey(event.path), {
+				path: event.path,
+				props: event.props,
+				state: "active"
+			});
+			return;
+		}
+		if (event.type === "controller:suspended") {
+			const key = pathKey(event.path);
+			const cur = this.liveControllers.get(key);
+			if (cur !== void 0) cur.state = "suspended";
+			return;
+		}
+		if (event.type === "controller:resumed") {
+			const key = pathKey(event.path);
+			const cur = this.liveControllers.get(key);
+			if (cur !== void 0) cur.state = "active";
+			return;
+		}
+		if (event.type === "controller:disposed") {
+			this.liveControllers.delete(pathKey(event.path));
+			return;
+		}
+	}
+};
+//#endregion
+//#region src/errors.ts
+const defaultHandler = (err, context) => {
+	console.error("[olas]", context, err);
+};
+/**
+* Dispatch an error to a user-provided handler, falling back to console.error.
+* The handler itself is wrapped — if it throws, the throw is swallowed and
+* logged so an `onError` bug never tears down the tree.
+*
+* Internal — used by the controller container and query client.
+*/
+function dispatchError(handler, err, context) {
+	const fn = handler ?? defaultHandler;
+	try {
+		fn(err, context);
+	} catch (handlerErr) {
+		try {
+			console.error("[olas] onError handler threw:", handlerErr);
+			console.error("[olas] original error:", err, context);
+		} catch {}
+	}
+}
+//#endregion
+//#region src/signals/runtime.ts
+var SignalImpl = class {
+	inner;
+	constructor(initial) {
+		this.inner = (0, _preact_signals_core.signal)(initial);
+	}
+	get value() {
+		return this.inner.value;
+	}
+	set value(next) {
+		this.inner.value = next;
+	}
+	peek() {
+		return this.inner.peek();
+	}
+	subscribe(handler) {
+		return this.inner.subscribe(handler);
+	}
+	set(value) {
+		this.inner.value = value;
+	}
+	update(fn) {
+		this.inner.value = fn(this.inner.peek());
+	}
+};
+var ComputedImpl = class {
+	inner;
+	constructor(fn) {
+		this.inner = (0, _preact_signals_core.computed)(fn);
+	}
+	get value() {
+		return this.inner.value;
+	}
+	peek() {
+		return this.inner.peek();
+	}
+	subscribe(handler) {
+		return this.inner.subscribe(handler);
+	}
+};
+/**
+* Create a writable `Signal<T>`. Reads track the current auto-tracking scope
+* (effect / computed); writes notify all subscribers (deduped via `Object.is`).
+*
+* Spec §20.1. For a single-pass non-tracked read use `signal.peek()`.
+*/
+function signal(initial) {
+	return new SignalImpl(initial);
+}
+/**
+* Create a `Computed<T>` — a read-only derived signal. The provided `fn` is
+* re-evaluated whenever a signal it read during its last run changes; the
+* resulting value is cached until then.
+*
+* Spec §20.1. The graph is glitch-free: a `computed` re-runs at most once per
+* batched-write cycle.
+*/
+function computed(fn) {
+	return new ComputedImpl(fn);
+}
+/**
+* Run `fn` immediately and again whenever any signal it reads changes. If
+* `fn` returns a function, that function is called as a cleanup before the
+* next re-run and on dispose.
+*
+* Returns a `dispose` function. Inside a controller use `ctx.effect(...)`
+* instead — that variant is auto-disposed with the controller.
+*/
+function effect(fn) {
+	return (0, _preact_signals_core.effect)(fn);
+}
+/**
+* Batch synchronous signal writes so subscribers see one notification at the
+* end of the batch rather than one per write. Returns whatever `fn` returns.
+*/
+function batch(fn) {
+	return (0, _preact_signals_core.batch)(fn);
+}
+/**
+* Run `fn` with auto-tracking suppressed — signals read inside don't become
+* dependencies of the surrounding `computed` / `effect`. Useful for "read
+* these signals once to log them" or for snapshotting state inside an effect
+* without subscribing to it. For a single-signal peek, prefer `signal.peek()`.
+*/
+function untracked(fn) {
+	return (0, _preact_signals_core.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.
+*
+* Spec: §20.12 — checks `err instanceof DOMException && err.name === 'AbortError'`.
+* Node 17+ exposes a global DOMException, so this works server-side too.
+*/
+function isAbortError(err) {
+	if (typeof DOMException !== "undefined" && err instanceof DOMException) return err.name === "AbortError";
+	return false;
+}
+//#endregion
+//#region src/query/entry.ts
+/**
+* One cache entry's state machine. Owns the AsyncState signals, race
+* protection, retry loop, optimistic-update snapshot stack.
+*
+* Internal — not exported from the public surface.
+*/
+var Entry = class {
+	data;
+	error = signal(void 0);
+	status;
+	isLoading = signal(false);
+	isFetching = signal(false);
+	lastUpdatedAt;
+	hasPendingMutations = signal(false);
+	isStale = signal(true);
+	fetcherProvider;
+	staleTime;
+	retry;
+	retryDelay;
+	currentFetchId = 0;
+	currentAbort = null;
+	staleTimer = null;
+	snapshots = [];
+	nextSnapshotId = 0;
+	disposed = false;
+	events;
+	fetchStartTime = 0;
+	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.data = signal(options.initialData);
+		if (options.initialData !== void 0) {
+			this.status = signal("success");
+			this.scheduleStaleness();
+			this.isStale.set(this.staleTime === 0);
+		} else this.status = signal("idle");
+		this.lastUpdatedAt = signal(options.initialUpdatedAt);
+	}
+	startFetch() {
+		if (this.disposed) return Promise.reject(/* @__PURE__ */ new Error("Entry disposed"));
+		const myId = ++this.currentFetchId;
+		this.currentAbort?.abort();
+		const abort = new AbortController();
+		this.currentAbort = abort;
+		const previouslyHadData = this.data.peek() !== void 0;
+		batch(() => {
+			this.status.set("pending");
+			this.isFetching.set(true);
+			this.isLoading.set(!previouslyHadData);
+		});
+		this.fetchStartTime = Date.now();
+		try {
+			this.events.onFetchStart?.();
+		} catch {}
+		return this.runWithRetry(myId, abort);
+	}
+	async runWithRetry(myId, abort) {
+		let attempt = 0;
+		while (true) {
+			if (myId !== this.currentFetchId || this.disposed) throw new DOMException("Superseded", "AbortError");
+			try {
+				const result = await this.fetcherProvider()(abort.signal);
+				if (myId !== this.currentFetchId || this.disposed) throw new DOMException("Superseded", "AbortError");
+				return this.applySuccess(result);
+			} 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);
+				attempt += 1;
+			}
+		}
+	}
+	shouldRetry(attempt, err) {
+		const retry = this.retry;
+		if (retry === 0) return false;
+		if (typeof retry === "number") return attempt < retry;
+		return retry(attempt, err);
+	}
+	computeDelay(attempt) {
+		const d = this.retryDelay;
+		return typeof d === "function" ? d(attempt) : d;
+	}
+	applySuccess(result) {
+		batch(() => {
+			this.data.set(result);
+			this.error.set(void 0);
+			this.status.set("success");
+			this.isLoading.set(false);
+			this.isFetching.set(false);
+			this.lastUpdatedAt.set(Date.now());
+			this.isStale.set(this.staleTime === 0);
+		});
+		if (this.staleTime > 0) this.scheduleStaleness();
+		try {
+			this.events.onFetchSuccess?.(Date.now() - this.fetchStartTime);
+		} catch {}
+		return result;
+	}
+	applyFailure(err) {
+		batch(() => {
+			this.error.set(err);
+			this.status.set("error");
+			this.isLoading.set(false);
+			this.isFetching.set(false);
+		});
+		try {
+			this.events.onFetchError?.(Date.now() - this.fetchStartTime, err);
+		} catch {}
+		throw err;
+	}
+	scheduleStaleness() {
+		if (this.staleTimer != null) clearTimeout(this.staleTimer);
+		if (this.staleTime > 0) this.staleTimer = setTimeout(() => {
+			this.staleTimer = null;
+			if (!this.disposed) this.isStale.set(true);
+		}, this.staleTime);
+	}
+	refetch() {
+		return this.startFetch();
+	}
+	invalidate() {
+		if (this.staleTimer != null) {
+			clearTimeout(this.staleTimer);
+			this.staleTimer = null;
+		}
+		this.isStale.set(true);
+		return this.startFetch();
+	}
+	reset() {
+		if (this.disposed) return;
+		batch(() => {
+			this.error.set(void 0);
+			this.status.set(this.data.peek() !== void 0 ? "success" : "idle");
+		});
+	}
+	setData(updater) {
+		if (this.disposed) return {
+			rollback: () => {},
+			finalize: () => {}
+		};
+		const prev = this.data.peek();
+		const next = updater(prev);
+		const id = this.nextSnapshotId++;
+		const record = {
+			id,
+			prev,
+			live: true
+		};
+		this.snapshots.push(record);
+		batch(() => {
+			this.data.set(next);
+			if (this.status.peek() === "idle" || this.status.peek() === "pending") this.status.set("success");
+			this.lastUpdatedAt.set(Date.now());
+			this.hasPendingMutations.set(true);
+		});
+		return {
+			rollback: () => {
+				if (!record.live || this.disposed) return;
+				record.live = false;
+				batch(() => {
+					this.data.set(record.prev);
+					this.snapshots = this.snapshots.filter((s) => s.id !== id);
+					const anyLive = this.snapshots.some((s) => s.live);
+					this.hasPendingMutations.set(anyLive);
+				});
+			},
+			finalize: () => {
+				if (!record.live || this.disposed) return;
+				record.live = false;
+				this.snapshots = this.snapshots.filter((s) => s.id !== id);
+				if (!this.snapshots.some((s) => s.live)) this.hasPendingMutations.set(false);
+			}
+		};
+	}
+	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.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 unsub = this.status.subscribe((s) => {
+				if (s === "success") {
+					unsub();
+					resolve(this.data.peek());
+				} else if (s === "error") {
+					unsub();
+					reject(this.error.peek());
+				}
+			});
+		});
+	}
+	/**
+	* True iff data is older than `staleTime` (or no data has been fetched yet).
+	* Used by the query client to decide whether to refetch on subscribe.
+	*/
+	isStaleNow() {
+		const last = this.lastUpdatedAt.peek();
+		if (last === void 0) return true;
+		return Date.now() - last >= this.staleTime;
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		if (this.staleTimer != null) {
+			clearTimeout(this.staleTimer);
+			this.staleTimer = null;
+		}
+		this.currentAbort?.abort();
+		this.currentAbort = null;
+	}
+};
+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();
+const onlineSubs = /* @__PURE__ */ new Set();
+let focusInstalled = false;
+let onlineInstalled = false;
+function fireFocus() {
+	for (const fn of focusSubs) try {
+		fn();
+	} catch {}
+}
+function fireOnline() {
+	for (const fn of onlineSubs) try {
+		fn();
+	} catch {}
+}
+function ensureFocusInstalled() {
+	if (focusInstalled) return;
+	if (typeof window === "undefined") return;
+	window.addEventListener("focus", fireFocus);
+	if (typeof document !== "undefined") document.addEventListener("visibilitychange", () => {
+		if (document.visibilityState === "visible") fireFocus();
+	});
+	focusInstalled = true;
+}
+function ensureOnlineInstalled() {
+	if (onlineInstalled) return;
+	if (typeof window === "undefined") return;
+	window.addEventListener("online", fireOnline);
+	onlineInstalled = true;
+}
+function subscribeWindowFocus(fn) {
+	ensureFocusInstalled();
+	focusSubs.add(fn);
+	return () => {
+		focusSubs.delete(fn);
+	};
+}
+function subscribeReconnect(fn) {
+	ensureOnlineInstalled();
+	onlineSubs.add(fn);
+	return () => {
+		onlineSubs.delete(fn);
+	};
+}
+//#endregion
+//#region src/query/infinite.ts
+/**
+* Holds an array of pages plus their pageParams. Supports fetchNextPage /
+* fetchPreviousPage / invalidate (drops all pages). Race-protected.
+*
+* Internal.
+*/
+var InfiniteEntry = class {
+	pages = signal([]);
+	pageParams;
+	data;
+	error = signal(void 0);
+	status = signal("idle");
+	isLoading = signal(false);
+	isFetching = signal(false);
+	isStale = signal(true);
+	lastUpdatedAt = signal(void 0);
+	hasPendingMutations = signal(false);
+	isFetchingNextPage = signal(false);
+	isFetchingPreviousPage = signal(false);
+	hasNextPage;
+	hasPreviousPage;
+	flat;
+	currentFetchId = 0;
+	currentAbort = null;
+	staleTimer = null;
+	snapshots = [];
+	nextSnapshotId = 0;
+	disposed = false;
+	fetcher;
+	initialPageParam;
+	getNextPageParam;
+	getPreviousPageParam;
+	staleTime;
+	retry;
+	retryDelay;
+	itemsOf;
+	constructor(opts) {
+		this.fetcher = opts.fetcher;
+		this.initialPageParam = opts.initialPageParam;
+		this.getNextPageParam = opts.getNextPageParam;
+		this.getPreviousPageParam = opts.getPreviousPageParam;
+		this.itemsOf = opts.itemsOf;
+		this.staleTime = opts.staleTime ?? 0;
+		this.retry = opts.retry ?? 0;
+		this.retryDelay = opts.retryDelay ?? 1e3;
+		this.pageParams = signal([]);
+		this.data = computed(() => {
+			const ps = this.pages.value;
+			return ps.length === 0 ? void 0 : ps;
+		});
+		this.flat = computed(() => {
+			const ps = this.pages.value;
+			if (!this.itemsOf) return ps;
+			const out = [];
+			for (const p of ps) for (const item of this.itemsOf(p)) out.push(item);
+			return out;
+		});
+		this.hasNextPage = computed(() => {
+			const ps = this.pages.value;
+			if (ps.length === 0) return false;
+			return this.getNextPageParam(ps[ps.length - 1], ps) !== null;
+		});
+		this.hasPreviousPage = computed(() => {
+			const ps = this.pages.value;
+			if (ps.length === 0) return false;
+			const fn = this.getPreviousPageParam;
+			if (!fn) return false;
+			return fn(ps[0], ps) !== null;
+		});
+	}
+	/** Initial / refetch — drops all pages and fetches starting from initialPageParam. */
+	startFetch() {
+		if (this.disposed) return Promise.reject(/* @__PURE__ */ new Error("Entry disposed"));
+		const myId = ++this.currentFetchId;
+		this.currentAbort?.abort();
+		const abort = new AbortController();
+		this.currentAbort = abort;
+		const previouslyHadPages = this.pages.peek().length > 0;
+		batch(() => {
+			this.status.set("pending");
+			this.isFetching.set(true);
+			this.isLoading.set(!previouslyHadPages);
+		});
+		return this.runFetch(myId, abort.signal, this.initialPageParam, (page, param) => {
+			if (myId !== this.currentFetchId || this.disposed) return;
+			batch(() => {
+				this.pages.set([page]);
+				this.pageParams.set([param]);
+				this.error.set(void 0);
+				this.status.set("success");
+				this.isLoading.set(false);
+				this.isFetching.set(false);
+				this.lastUpdatedAt.set(Date.now());
+				this.isStale.set(this.staleTime === 0);
+			});
+			if (this.staleTime > 0) this.scheduleStaleness();
+		}, "initial");
+	}
+	fetchNextPage() {
+		if (this.disposed) return Promise.reject(/* @__PURE__ */ new Error("Entry disposed"));
+		if (this.isFetchingNextPage.peek()) return Promise.resolve();
+		const ps = this.pages.peek();
+		if (ps.length === 0) return this.startFetch().then(() => {});
+		const nextParam = this.getNextPageParam(ps[ps.length - 1], ps);
+		if (nextParam === null) return Promise.resolve();
+		const myId = ++this.currentFetchId;
+		const abort = new AbortController();
+		this.currentAbort?.abort();
+		this.currentAbort = abort;
+		batch(() => {
+			this.isFetchingNextPage.set(true);
+			this.isFetching.set(true);
+		});
+		return this.runFetch(myId, abort.signal, nextParam, (page, param) => {
+			if (myId !== this.currentFetchId || this.disposed) return;
+			batch(() => {
+				this.pages.set([...this.pages.peek(), page]);
+				this.pageParams.set([...this.pageParams.peek(), param]);
+				this.isFetchingNextPage.set(false);
+				this.isFetching.set(false);
+				this.lastUpdatedAt.set(Date.now());
+			});
+		}, "next").then(() => {});
+	}
+	fetchPreviousPage() {
+		if (this.disposed) return Promise.reject(/* @__PURE__ */ new Error("Entry disposed"));
+		if (this.isFetchingPreviousPage.peek()) return Promise.resolve();
+		if (!this.getPreviousPageParam) return Promise.resolve();
+		const ps = this.pages.peek();
+		if (ps.length === 0) return this.startFetch().then(() => {});
+		const prevParam = this.getPreviousPageParam(ps[0], ps);
+		if (prevParam === null) return Promise.resolve();
+		const myId = ++this.currentFetchId;
+		const abort = new AbortController();
+		this.currentAbort?.abort();
+		this.currentAbort = abort;
+		batch(() => {
+			this.isFetchingPreviousPage.set(true);
+			this.isFetching.set(true);
+		});
+		return this.runFetch(myId, abort.signal, prevParam, (page, param) => {
+			if (myId !== this.currentFetchId || this.disposed) return;
+			batch(() => {
+				this.pages.set([page, ...this.pages.peek()]);
+				this.pageParams.set([param, ...this.pageParams.peek()]);
+				this.isFetchingPreviousPage.set(false);
+				this.isFetching.set(false);
+				this.lastUpdatedAt.set(Date.now());
+			});
+		}, "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
+				});
+				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);
+					});
+					throw err;
+				}
+				await abortableSleep$1(typeof this.retryDelay === "function" ? this.retryDelay(attempt) : this.retryDelay, signal);
+				attempt += 1;
+			}
+		}
+	}
+	refetch() {
+		return this.startFetch();
+	}
+	invalidate() {
+		if (this.staleTimer != null) {
+			clearTimeout(this.staleTimer);
+			this.staleTimer = null;
+		}
+		this.isStale.set(true);
+		return this.startFetch();
+	}
+	reset() {
+		if (this.disposed) return;
+		batch(() => {
+			this.error.set(void 0);
+			this.status.set(this.pages.peek().length > 0 ? "success" : "idle");
+		});
+	}
+	setData(updater) {
+		if (this.disposed) return {
+			rollback: () => {},
+			finalize: () => {}
+		};
+		const prev = this.pages.peek();
+		const next = updater(prev.length === 0 ? void 0 : prev);
+		const id = this.nextSnapshotId++;
+		const record = {
+			id,
+			prev,
+			live: true
+		};
+		this.snapshots.push(record);
+		batch(() => {
+			this.pages.set(next);
+			if (this.status.peek() === "idle" || this.status.peek() === "pending") this.status.set("success");
+			this.lastUpdatedAt.set(Date.now());
+			this.hasPendingMutations.set(true);
+		});
+		return {
+			rollback: () => {
+				if (!record.live || this.disposed) return;
+				record.live = false;
+				batch(() => {
+					this.pages.set(record.prev);
+					this.snapshots = this.snapshots.filter((s) => s.id !== id);
+					this.hasPendingMutations.set(this.snapshots.some((s) => s.live));
+				});
+			},
+			finalize: () => {
+				if (!record.live || this.disposed) return;
+				record.live = false;
+				this.snapshots = this.snapshots.filter((s) => s.id !== id);
+				if (!this.snapshots.some((s) => s.live)) this.hasPendingMutations.set(false);
+			}
+		};
+	}
+	firstValue() {
+		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 unsub = this.status.subscribe((s) => {
+				if (s === "success") {
+					unsub();
+					resolve(this.pages.peek());
+				} else if (s === "error") {
+					unsub();
+					reject(this.error.peek());
+				}
+			});
+		});
+	}
+	isStaleNow() {
+		const last = this.lastUpdatedAt.peek();
+		if (last === void 0) return true;
+		return Date.now() - last >= this.staleTime;
+	}
+	scheduleStaleness() {
+		if (this.staleTimer != null) clearTimeout(this.staleTimer);
+		if (this.staleTime > 0) this.staleTimer = setTimeout(() => {
+			this.staleTimer = null;
+			if (!this.disposed) this.isStale.set(true);
+		}, this.staleTime);
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		if (this.staleTimer != null) {
+			clearTimeout(this.staleTimer);
+			this.staleTimer = null;
+		}
+		this.currentAbort?.abort();
+		this.currentAbort = null;
+	}
+};
+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
+/**
+* Stable string hash of a key tuple. Two equal-by-content args produce the
+* same string regardless of property iteration order. Handles primitives,
+* arrays, plain objects, Date.
+*
+* Functions and symbols throw — keys must be serializable so distinct
+* subscribers can share entries.
+*/
+function stableHash(args) {
+	return JSON.stringify(args, replacer);
+}
+const replacer = (_key, value) => {
+	if (typeof value === "function") throw new Error("[olas] query keys cannot contain functions");
+	if (typeof value === "symbol") throw new Error("[olas] query keys cannot contain symbols");
+	if (value === void 0) return "__undefined__";
+	if (value instanceof Date) return { __date: value.toISOString() };
+	if (value instanceof Map || value instanceof Set) throw new Error("[olas] query keys cannot contain Map/Set — use arrays/objects");
+	if (value && typeof value === "object" && !Array.isArray(value)) {
+		const sorted = {};
+		for (const k of Object.keys(value).sort()) sorted[k] = value[k];
+		return sorted;
+	}
+	return value;
+};
+//#endregion
+//#region src/query/plugin.ts
+const queryRegistry = /* @__PURE__ */ new Map();
+/**
+* Register a query by its `queryId`. Internal — called from `defineQuery` /
+* `defineInfiniteQuery`. Replaces any previous registration with the same
+* id (matches Olas's "full root rebuild" HMR story; a mid-flight remote
+* message routed against the old `Query` simply misses).
+*/
+function registerQueryById(queryId, query) {
+	queryRegistry.set(queryId, query);
+}
+/**
+* Look up a query by its declared `queryId`. Returns `undefined` when no
+* query with that id has been defined yet (e.g. the module isn't imported
+* in the receiving tab).
+*/
+function lookupRegisteredQuery(queryId) {
+	return queryRegistry.get(queryId);
+}
+//#endregion
+//#region src/query/client.ts
+const DEFAULT_GC_TIME = 5 * 6e4;
+var ClientEntry = class {
+	entry;
+	/** The result of `spec.key(...args)` — used for hashing/identity. */
+	keyArgs;
+	/** The original args the consumer passed — what the fetcher receives. */
+	callArgs;
+	client;
+	query;
+	subscriberCount = 0;
+	gcTimer = null;
+	intervalTimer = null;
+	unsubFocus = null;
+	unsubOnline = null;
+	gcTime;
+	refetchInterval;
+	refetchOnWindowFocus;
+	refetchOnReconnect;
+	constructor(client, query, callArgs, keyArgs, spec, hydrated) {
+		this.client = client;
+		this.query = query;
+		this.callArgs = callArgs;
+		this.keyArgs = keyArgs;
+		this.gcTime = spec.gcTime ?? DEFAULT_GC_TIME;
+		this.refetchInterval = spec.refetchInterval;
+		this.refetchOnWindowFocus = spec.refetchOnWindowFocus ?? client.refetchOnWindowFocus;
+		this.refetchOnReconnect = spec.refetchOnReconnect ?? client.refetchOnReconnect;
+		const fetcherFn = spec.fetcher;
+		const deps = client.deps;
+		client.devtools;
+		this.keyArgs;
+		this.entry = new Entry({
+			fetcher: () => (signal) => fetcherFn({
+				signal,
+				deps
+			}, ...callArgs),
+			staleTime: spec.staleTime,
+			retry: spec.retry,
+			retryDelay: spec.retryDelay,
+			initialData: hydrated?.data,
+			initialUpdatedAt: hydrated?.lastUpdatedAt,
+			events: void 0
+		});
+	}
+	acquire() {
+		this.subscriberCount += 1;
+		if (this.gcTimer != null) {
+			clearTimeout(this.gcTimer);
+			this.gcTimer = null;
+		}
+		if (this.subscriberCount === 1) {
+			if (this.refetchInterval != null) this.startIntervalTimer();
+			if (this.refetchOnWindowFocus) this.unsubFocus = subscribeWindowFocus(() => this.triggerEventRefetch());
+			if (this.refetchOnReconnect) this.unsubOnline = subscribeReconnect(() => this.triggerEventRefetch());
+		}
+	}
+	release() {
+		this.subscriberCount -= 1;
+		if (this.subscriberCount <= 0) {
+			this.stopIntervalTimer();
+			this.stopEventSubscriptions();
+			if (this.gcTime === 0) this.client.dropEntry(this);
+			else this.gcTimer = setTimeout(() => {
+				this.gcTimer = null;
+				this.client.dropEntry(this);
+			}, this.gcTime);
+		}
+	}
+	hasSubscribers() {
+		return this.subscriberCount > 0;
+	}
+	startIntervalTimer() {
+		if (this.refetchInterval == null) return;
+		if (this.intervalTimer != null) return;
+		this.intervalTimer = setInterval(() => {
+			this.entry.startFetch().catch(() => {});
+		}, this.refetchInterval);
+	}
+	stopIntervalTimer() {
+		if (this.intervalTimer != null) {
+			clearInterval(this.intervalTimer);
+			this.intervalTimer = null;
+		}
+	}
+	stopEventSubscriptions() {
+		if (this.unsubFocus != null) {
+			this.unsubFocus();
+			this.unsubFocus = null;
+		}
+		if (this.unsubOnline != null) {
+			this.unsubOnline();
+			this.unsubOnline = null;
+		}
+	}
+	/**
+	* Schedule a gc timer for an entry that was just created via a non-subscribing
+	* path (`prefetch`, `setData`, `invalidate`). Without this, those entries
+	* never trigger `release()` and would live until root dispose. Called by
+	* `QueryClient.bindEntry` right after creating a fresh entry; `acquire()`
+	* (e.g., from a subscriber that arrives shortly after a prefetch) clears it.
+	* No-op if the entry already has subscribers or a gc timer pending.
+	*/
+	scheduleGcIfOrphan() {
+		if (this.subscriberCount > 0 || this.gcTimer != null) return;
+		if (this.gcTime === 0) {
+			queueMicrotask(() => {
+				if (this.subscriberCount === 0 && this.gcTimer == null) this.client.dropEntry(this);
+			});
+			return;
+		}
+		this.gcTimer = setTimeout(() => {
+			this.gcTimer = null;
+			this.client.dropEntry(this);
+		}, this.gcTime);
+	}
+	/** Refetch on focus / reconnect, but only if the data is actually stale. */
+	triggerEventRefetch() {
+		if (!this.entry.isStaleNow()) return;
+		this.entry.startFetch().catch(() => {});
+	}
+	dispose() {
+		if (this.gcTimer != null) {
+			clearTimeout(this.gcTimer);
+			this.gcTimer = null;
+		}
+		this.stopIntervalTimer();
+		this.stopEventSubscriptions();
+		this.entry.dispose();
+	}
+};
+var InfiniteClientEntry = class {
+	entry;
+	keyArgs;
+	callArgs;
+	client;
+	query;
+	subscriberCount = 0;
+	gcTimer = null;
+	intervalTimer = null;
+	gcTime;
+	refetchInterval;
+	constructor(client, query, callArgs, keyArgs, spec) {
+		this.client = client;
+		this.query = query;
+		this.callArgs = callArgs;
+		this.keyArgs = keyArgs;
+		this.gcTime = spec.gcTime ?? DEFAULT_GC_TIME;
+		this.refetchInterval = spec.refetchInterval;
+		const fetcherFn = spec.fetcher;
+		const deps = client.deps;
+		this.entry = new InfiniteEntry({
+			fetcher: ({ pageParam, signal }) => fetcherFn({
+				pageParam,
+				signal,
+				deps
+			}, ...callArgs),
+			initialPageParam: spec.initialPageParam,
+			getNextPageParam: spec.getNextPageParam,
+			getPreviousPageParam: spec.getPreviousPageParam,
+			itemsOf: spec.itemsOf,
+			staleTime: spec.staleTime,
+			retry: spec.retry,
+			retryDelay: spec.retryDelay
+		});
+	}
+	acquire() {
+		this.subscriberCount += 1;
+		if (this.gcTimer != null) {
+			clearTimeout(this.gcTimer);
+			this.gcTimer = null;
+		}
+		if (this.subscriberCount === 1 && this.refetchInterval != null) this.startIntervalTimer();
+	}
+	release() {
+		this.subscriberCount -= 1;
+		if (this.subscriberCount <= 0) {
+			this.stopIntervalTimer();
+			if (this.gcTime === 0) this.client.dropInfiniteEntry(this);
+			else this.gcTimer = setTimeout(() => {
+				this.gcTimer = null;
+				this.client.dropInfiniteEntry(this);
+			}, this.gcTime);
+		}
+	}
+	startIntervalTimer() {
+		if (this.refetchInterval == null || this.intervalTimer != null) return;
+		this.intervalTimer = setInterval(() => {
+			this.entry.startFetch().catch(() => {});
+		}, this.refetchInterval);
+	}
+	stopIntervalTimer() {
+		if (this.intervalTimer != null) {
+			clearInterval(this.intervalTimer);
+			this.intervalTimer = null;
+		}
+	}
+	/** See `ClientEntry.scheduleGcIfOrphan`. */
+	scheduleGcIfOrphan() {
+		if (this.subscriberCount > 0 || this.gcTimer != null) return;
+		if (this.gcTime === 0) {
+			queueMicrotask(() => {
+				if (this.subscriberCount === 0 && this.gcTimer == null) this.client.dropInfiniteEntry(this);
+			});
+			return;
+		}
+		this.gcTimer = setTimeout(() => {
+			this.gcTimer = null;
+			this.client.dropInfiniteEntry(this);
+		}, this.gcTime);
+	}
+	dispose() {
+		if (this.gcTimer != null) {
+			clearTimeout(this.gcTimer);
+			this.gcTimer = null;
+		}
+		this.stopIntervalTimer();
+		this.entry.dispose();
+	}
+};
+/**
+* Per-root entry registry. Owns the keyed `Map<hash, ClientEntry>` per query,
+* GC timers, refetch-interval timers. Subscribers are routed in/out via
+* `acquire` / `release`.
+*/
+var QueryClient = class {
+	maps = /* @__PURE__ */ new Map();
+	infiniteMaps = /* @__PURE__ */ new Map();
+	touchedQueries = /* @__PURE__ */ new Set();
+	touchedInfiniteQueries = /* @__PURE__ */ new Set();
+	hydratedData = /* @__PURE__ */ new Map();
+	/** Mutations inflight across the whole root — used by `waitForIdle`. */
+	mutationsInflight$ = signal(0);
+	onError;
+	disposed = false;
+	/** Devtools bus, if any — passed by `createRoot`. Used to emit cache events. */
+	devtools;
+	/** Root-level deps; passed to every `QuerySpec.fetcher` via `FetchCtx`. */
+	deps;
+	/** Root-wide defaults for refetch triggers; per-query spec overrides win. Spec §5.9. */
+	refetchOnWindowFocus;
+	refetchOnReconnect;
+	/**
+	* Installed plugins. Fired on every `setData` / `invalidate` / `gc` so
+	* cross-tab / persistence-like layers can observe and react. SPEC §13.2.
+	*/
+	plugins;
+	/**
+	* Flipped to `true` while a remote-originated write (via
+	* `applyRemoteSetData` / `applyRemoteInvalidate`) is being applied. The
+	* resulting plugin events carry `isRemote: true` so plugins know to skip
+	* rebroadcast.
+	*/
+	applyingRemote = false;
+	constructor(opts) {
+		this.onError = opts?.onError;
+		this.devtools = opts?.devtools;
+		this.deps = opts?.deps ?? {};
+		this.refetchOnWindowFocus = opts?.refetchOnWindowFocus ?? false;
+		this.refetchOnReconnect = opts?.refetchOnReconnect ?? false;
+		this.plugins = opts?.plugins ?? [];
+		if (opts?.hydrate) this.hydrate(opts.hydrate);
+		const api = this.makePluginApi();
+		for (const plugin of this.plugins) this.callPlugin(() => plugin.init?.(api));
+	}
+	/**
+	* Build the `QueryClientPluginApi` view that plugins receive at `init`
+	* time. Closes over `this`; safe to hand out — plugins call back through
+	* these methods to push remote-originated writes into the local cache.
+	*/
+	makePluginApi() {
+		const self = this;
+		return {
+			applyRemoteSetData(queryId, keyArgs, data) {
+				self.applyRemoteSetData(queryId, keyArgs, data);
+			},
+			applyRemoteInvalidate(queryId, keyArgs) {
+				self.applyRemoteInvalidate(queryId, keyArgs);
+			},
+			subscribedKeys(queryId) {
+				return self.subscribedKeysFor(queryId);
+			}
+		};
+	}
+	/** Invoke a plugin callback; route exceptions through `onError`. */
+	callPlugin(fn) {
+		try {
+			fn();
+		} catch (err) {
+			dispatchError(this.onError, err, {
+				kind: "plugin",
+				controllerPath: []
+			});
+		}
+	}
+	emitSetData(query, keyArgs, data, kind) {
+		if (this.plugins.length === 0) return;
+		const queryId = query.__spec.queryId;
+		if (queryId == null) return;
+		const event = {
+			queryId,
+			keyArgs,
+			data,
+			kind,
+			isRemote: this.applyingRemote
+		};
+		for (const plugin of this.plugins) if (plugin.onSetData) {
+			const cb = plugin.onSetData;
+			this.callPlugin(() => cb.call(plugin, event));
+		}
+	}
+	emitInvalidate(query, keyArgs, kind) {
+		if (this.plugins.length === 0) return;
+		const queryId = query.__spec.queryId;
+		if (queryId == null) return;
+		const event = {
+			queryId,
+			keyArgs,
+			kind,
+			isRemote: this.applyingRemote
+		};
+		for (const plugin of this.plugins) if (plugin.onInvalidate) {
+			const cb = plugin.onInvalidate;
+			this.callPlugin(() => cb.call(plugin, event));
+		}
+	}
+	emitGc(query, keyArgs, kind) {
+		if (this.plugins.length === 0) return;
+		const queryId = query.__spec.queryId;
+		if (queryId == null) return;
+		const event = {
+			queryId,
+			keyArgs,
+			kind
+		};
+		for (const plugin of this.plugins) if (plugin.onGc) {
+			const cb = plugin.onGc;
+			this.callPlugin(() => cb.call(plugin, event));
+		}
+	}
+	/** Resolve `queryId → live entry-map keys`. Empty array when unknown. */
+	subscribedKeysFor(queryId) {
+		const query = lookupRegisteredQuery(queryId);
+		if (!query) return [];
+		const out = [];
+		if (query.__olas === "query") {
+			const map = this.maps.get(query);
+			if (map) for (const ce of map.values()) out.push(ce.keyArgs);
+		} else {
+			const map = this.infiniteMaps.get(query);
+			if (map) for (const ce of map.values()) out.push(ce.keyArgs);
+		}
+		return out;
+	}
+	/**
+	* Apply a remote-originated `setData` for the query identified by
+	* `queryId`, scoped to the entry already keyed by `keyArgs` in this
+	* client. Goes through the underlying `Entry.setData` so subscribers see
+	* the write; plugin `onSetData` fires with `isRemote: true`.
+	*
+	* Drops silently when:
+	* - No query with that id is registered (the receiving tab hasn't
+	*   imported the module that defined it).
+	* - The registered query is an infinite query (cross-tab infinite sync
+	*   is deferred — see `plugin.ts` `SetDataEvent.kind`).
+	* - No local entry exists for that key (the receiving tab isn't
+	*   subscribed; nothing useful to write to without callArgs for a
+	*   future refetch).
+	*/
+	applyRemoteSetData(queryId, keyArgs, data) {
+		const query = lookupRegisteredQuery(queryId);
+		if (!query) return;
+		if (query.__olas !== "query") return;
+		const internal = query;
+		const map = this.maps.get(internal);
+		if (!map) return;
+		const hash = stableHash(keyArgs);
+		const entry = map.get(hash);
+		if (!entry) return;
+		this.applyingRemote = true;
+		try {
+			entry.entry.setData(() => data);
+			this.emitSetData(internal, entry.keyArgs, data, "data");
+		} finally {
+			this.applyingRemote = false;
+		}
+	}
+	applyRemoteInvalidate(queryId, keyArgs) {
+		const query = lookupRegisteredQuery(queryId);
+		if (!query) return;
+		if (query.__olas !== "query") return;
+		const internal = query;
+		const map = this.maps.get(internal);
+		if (!map) return;
+		const hash = stableHash(keyArgs);
+		const entry = map.get(hash);
+		if (!entry) return;
+		this.applyingRemote = true;
+		try {
+			entry.entry.invalidate().catch((err) => {
+				dispatchError(this.onError, err, {
+					kind: "cache",
+					controllerPath: [],
+					queryKey: entry.keyArgs
+				});
+			});
+			this.emitInvalidate(internal, entry.keyArgs, "data");
+		} finally {
+			this.applyingRemote = false;
+		}
+	}
+	hydrate(state) {
+		if (state.version !== 1) return;
+		for (const entry of state.entries) {
+			const hash = stableHash(entry.key);
+			this.hydratedData.set(hash, {
+				data: entry.data,
+				lastUpdatedAt: entry.lastUpdatedAt
+			});
+		}
+	}
+	/**
+	* Snapshot every live cache entry (regular + infinite) as a flat list of
+	* `DebugCacheEntry`. Exposed via `root.__debug.queryEntries()` for the
+	* devtools cache inspector — shows current data and state, not past
+	* fetch events. Spec §20.9.
+	*/
+	queryEntriesSnapshot() {
+		const out = [];
+		for (const map of this.maps.values()) for (const ce of map.values()) out.push({
+			key: ce.keyArgs,
+			status: ce.entry.status.peek(),
+			data: ce.entry.data.peek(),
+			error: ce.entry.error.peek(),
+			lastUpdatedAt: ce.entry.lastUpdatedAt.peek(),
+			isStale: ce.entry.isStale.peek(),
+			isFetching: ce.entry.isFetching.peek(),
+			hasPendingMutations: ce.entry.hasPendingMutations.peek()
+		});
+		for (const map of this.infiniteMaps.values()) for (const ce of map.values()) out.push({
+			key: ce.keyArgs,
+			status: ce.entry.status.peek(),
+			data: ce.entry.pages.peek(),
+			error: ce.entry.error.peek(),
+			lastUpdatedAt: ce.entry.lastUpdatedAt.peek(),
+			isStale: ce.entry.isStale.peek(),
+			isFetching: ce.entry.isFetching.peek(),
+			hasPendingMutations: ce.entry.hasPendingMutations.peek()
+		});
+		return out;
+	}
+	dehydrate() {
+		const entries = [];
+		for (const map of this.maps.values()) for (const ce of map.values()) if (ce.entry.status.peek() === "success") entries.push({
+			key: ce.keyArgs,
+			data: ce.entry.data.peek(),
+			lastUpdatedAt: ce.entry.lastUpdatedAt.peek() ?? Date.now()
+		});
+		return {
+			version: 1,
+			entries
+		};
+	}
+	async waitForIdle() {
+		for (let safety = 0; safety < 100; safety++) {
+			const tasks = [];
+			for (const map of this.maps.values()) for (const ce of map.values()) if (ce.entry.isFetching.peek()) tasks.push(waitUntilFalse(ce.entry.isFetching));
+			for (const map of this.infiniteMaps.values()) for (const ce of map.values()) if (ce.entry.isFetching.peek()) tasks.push(waitUntilFalse(ce.entry.isFetching));
+			if (this.mutationsInflight$.peek() > 0) tasks.push(new Promise((resolve) => {
+				const unsub = this.mutationsInflight$.subscribe((v) => {
+					if (v === 0) {
+						unsub();
+						resolve();
+					}
+				});
+			}));
+			if (tasks.length === 0) return;
+			await Promise.all(tasks);
+		}
+	}
+	bindEntry(query, args) {
+		const internal = query;
+		let map = this.maps.get(internal);
+		if (!map) {
+			map = /* @__PURE__ */ new Map();
+			this.maps.set(internal, map);
+			this.touchedQueries.add(internal);
+			internal.__clients.add(this);
+		}
+		const keyArgs = internal.__spec.key(...args);
+		const hash = stableHash(keyArgs);
+		let entry = map.get(hash);
+		if (!entry) {
+			const hydrated = this.hydratedData.get(hash);
+			if (hydrated) this.hydratedData.delete(hash);
+			entry = new ClientEntry(this, internal, args, keyArgs, internal.__spec, hydrated);
+			map.set(hash, entry);
+			entry.scheduleGcIfOrphan();
+		}
+		return entry;
+	}
+	dropEntry(entry) {
+		const map = this.maps.get(entry.query);
+		if (!map) return;
+		const hash = stableHash(entry.keyArgs);
+		if (map.get(hash) !== entry) return;
+		map.delete(hash);
+		entry.dispose();
+		if (map.size === 0) this.maps.delete(entry.query);
+		this.emitGc(entry.query, entry.keyArgs, "data");
+	}
+	invalidate(query, args) {
+		const internal = query;
+		const map = this.maps.get(internal);
+		if (!map) return;
+		const keyArgs = internal.__spec.key(...args);
+		const hash = stableHash(keyArgs);
+		const entry = map.get(hash);
+		if (!entry) return;
+		entry.entry.invalidate().catch((err) => {
+			dispatchError(this.onError, err, {
+				kind: "cache",
+				controllerPath: [],
+				queryKey: keyArgs
+			});
+		});
+		this.emitInvalidate(internal, keyArgs, "data");
+	}
+	invalidateAll(query) {
+		const internal = query;
+		const map = this.maps.get(internal);
+		if (!map) return;
+		for (const [hash, entry] of map) {
+			entry.entry.invalidate().catch((err) => {
+				dispatchError(this.onError, err, {
+					kind: "cache",
+					controllerPath: [],
+					queryKey: entry.keyArgs
+				});
+			});
+			this.emitInvalidate(internal, entry.keyArgs, "data");
+		}
+	}
+	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");
+		return snapshot;
+	}
+	bindInfiniteEntry(query, args) {
+		const internal = query;
+		let map = this.infiniteMaps.get(internal);
+		if (!map) {
+			map = /* @__PURE__ */ new Map();
+			this.infiniteMaps.set(internal, map);
+			this.touchedInfiniteQueries.add(internal);
+			internal.__clients.add(this);
+		}
+		const keyArgs = internal.__spec.key(...args);
+		const hash = stableHash(keyArgs);
+		let entry = map.get(hash);
+		if (!entry) {
+			entry = new InfiniteClientEntry(this, internal, args, keyArgs, internal.__spec);
+			map.set(hash, entry);
+			entry.scheduleGcIfOrphan();
+		}
+		return entry;
+	}
+	dropInfiniteEntry(entry) {
+		const map = this.infiniteMaps.get(entry.query);
+		if (!map) return;
+		const hash = stableHash(entry.keyArgs);
+		if (map.get(hash) !== entry) return;
+		map.delete(hash);
+		entry.dispose();
+		if (map.size === 0) this.infiniteMaps.delete(entry.query);
+		this.emitGc(entry.query, entry.keyArgs, "infinite");
+	}
+	invalidateInfinite(query, args) {
+		const internal = query;
+		const map = this.infiniteMaps.get(internal);
+		if (!map) return;
+		const keyArgs = internal.__spec.key(...args);
+		const hash = stableHash(keyArgs);
+		const entry = map.get(hash);
+		if (!entry) return;
+		entry.entry.invalidate().catch((err) => {
+			dispatchError(this.onError, err, {
+				kind: "cache",
+				controllerPath: [],
+				queryKey: entry.keyArgs
+			});
+		});
+		this.emitInvalidate(internal, keyArgs, "infinite");
+	}
+	invalidateAllInfinite(query) {
+		const internal = query;
+		const map = this.infiniteMaps.get(internal);
+		if (!map) return;
+		for (const entry of map.values()) {
+			entry.entry.invalidate().catch((err) => {
+				dispatchError(this.onError, err, {
+					kind: "cache",
+					controllerPath: [],
+					queryKey: entry.keyArgs
+				});
+			});
+			this.emitInvalidate(internal, entry.keyArgs, "infinite");
+		}
+	}
+	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");
+		return snapshot;
+	}
+	prefetchInfinite(query, args) {
+		const entry = this.bindInfiniteEntry(query, args);
+		entry.acquire();
+		return (async () => {
+			if (entry.entry.status.peek() === "success" && !entry.entry.isStaleNow()) return entry.entry.pages.peek()[0];
+			return entry.entry.startFetch();
+		})().finally(() => entry.release());
+	}
+	prefetch(query, args) {
+		const entry = this.bindEntry(query, args);
+		entry.acquire();
+		return (async () => {
+			if (entry.entry.status.peek() === "success" && !entry.entry.isStaleNow()) return entry.entry.data.peek();
+			if (entry.entry.isFetching.peek()) return entry.entry.firstValue();
+			return entry.entry.startFetch();
+		})().finally(() => entry.release());
+	}
+	inflightCount() {
+		let count = 0;
+		for (const [, map] of this.maps) for (const [, entry] of map) if (entry.entry.isFetching.peek()) count++;
+		return count;
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		for (const map of this.maps.values()) for (const entry of map.values()) entry.dispose();
+		this.maps.clear();
+		for (const map of this.infiniteMaps.values()) for (const entry of map.values()) entry.dispose();
+		this.infiniteMaps.clear();
+		for (const q of this.touchedQueries) q.__clients.delete(this);
+		this.touchedQueries.clear();
+		for (const q of this.touchedInfiniteQueries) q.__clients.delete(this);
+		this.touchedInfiniteQueries.clear();
+		this.hydratedData.clear();
+		for (const plugin of this.plugins) if (plugin.dispose) {
+			const cb = plugin.dispose;
+			this.callPlugin(() => cb.call(plugin));
+		}
+	}
+};
+function waitUntilFalse(sig) {
+	if (!sig.peek()) return Promise.resolve();
+	return new Promise((resolve) => {
+		const unsub = sig.subscribe((v) => {
+			if (!v) {
+				unsub();
+				resolve();
+			}
+		});
+	});
+}
+//#endregion
+//#region src/emitter.ts
+var EmitterImpl = class {
+	handlers = /* @__PURE__ */ new Set();
+	disposed = false;
+	emit(value) {
+		if (this.disposed) return;
+		const snapshot = Array.from(this.handlers);
+		for (const handler of snapshot) handler(value);
+	}
+	on(handler) {
+		if (this.disposed) return () => {};
+		const wrapped = handler;
+		this.handlers.add(wrapped);
+		return () => {
+			this.handlers.delete(wrapped);
+		};
+	}
+	once(handler) {
+		if (this.disposed) return () => {};
+		const wrapped = (value) => {
+			this.handlers.delete(wrapped);
+			handler(value);
+		};
+		this.handlers.add(wrapped);
+		return () => {
+			this.handlers.delete(wrapped);
+		};
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.handlers.clear();
+	}
+};
+/**
+* Create a standalone emitter. Handlers persist until explicitly unsubscribed
+* (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.
+*/
+function createEmitter() {
+	const impl = new EmitterImpl();
+	return {
+		emit: ((value) => impl.emit(value)),
+		on: (handler) => impl.on(handler),
+		once: (handler) => impl.once(handler),
+		dispose: () => impl.dispose()
+	};
+}
+//#endregion
+//#region src/forms/field.ts
+var FieldImpl = class {
+	value$;
+	errors$;
+	touched$;
+	dirty$;
+	validating$;
+	isValid$;
+	revalidateTrigger$;
+	validators;
+	/** The value `reset()` returns to. Mutated by `setAsInitial()` so a form
+	* initialized from server data resets to *that* data, not the empty seed. */
+	initial;
+	validatorDispose = null;
+	currentAbort = null;
+	runId = 0;
+	disposed = false;
+	devtoolsOwner = null;
+	constructor(initial, validators = []) {
+		this.initial = initial;
+		this.validators = validators;
+		this.value$ = signal(initial);
+		this.errors$ = signal([]);
+		this.touched$ = signal(false);
+		this.dirty$ = signal(false);
+		this.validating$ = signal(false);
+		this.revalidateTrigger$ = signal(0);
+		this.isValid$ = computed(() => this.errors$.value.length === 0 && !this.validating$.value);
+		if (validators.length > 0) this.validatorDispose = effect(() => {
+			this.runValidators();
+		});
+	}
+	get value() {
+		return this.value$.value;
+	}
+	peek() {
+		return this.value$.peek();
+	}
+	subscribe(handler) {
+		return this.value$.subscribe(handler);
+	}
+	get errors() {
+		return this.errors$;
+	}
+	get isValid() {
+		return this.isValid$;
+	}
+	get isDirty() {
+		return this.dirty$;
+	}
+	get touched() {
+		return this.touched$;
+	}
+	get isValidating() {
+		return this.validating$;
+	}
+	set(value) {
+		if (this.disposed) return;
+		this.value$.set(value);
+		this.dirty$.set(true);
+	}
+	/**
+	* Reseat the field as if this value had been its constructor `initial`.
+	* Sets the value, re-anchors `reset()`'s target, and does NOT mark dirty.
+	* Used by `Form` when applying its own `initial` (in the constructor and
+	* on `reset()`), so server-loaded forms don't start dirty. Internal-ish —
+	* exposed for `Form`'s use, not for user code that just wants to write.
+	*/
+	setAsInitial(value) {
+		if (this.disposed) return;
+		this.initial = value;
+		batch(() => {
+			this.value$.set(value);
+			this.dirty$.set(false);
+		});
+	}
+	reset() {
+		if (this.disposed) return;
+		this.currentAbort?.abort();
+		this.currentAbort = null;
+		batch(() => {
+			this.value$.set(this.initial);
+			this.dirty$.set(false);
+			this.touched$.set(false);
+			this.errors$.set([]);
+			this.validating$.set(false);
+		});
+	}
+	markTouched() {
+		if (this.disposed) return;
+		this.touched$.set(true);
+	}
+	async revalidate() {
+		if (this.disposed) return this.isValid$.peek();
+		this.revalidateTrigger$.update((n) => n + 1);
+		await this.waitUntilSettled();
+		return this.isValid$.peek();
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.validatorDispose?.();
+		this.validatorDispose = null;
+		this.currentAbort?.abort();
+		this.currentAbort = null;
+		this.devtoolsOwner = null;
+	}
+	/**
+	* Bind this field to a devtools owner. Each subsequent validation pass
+	* publishes a `field:validated` event with the supplied path + name.
+	* Idempotent — calling again replaces the owner. Internal: called by
+	* `createForm` / `createFieldArray` so the form's keys reach the panel.
+	*/
+	bindDevtoolsOwner(owner) {
+		this.devtoolsOwner = owner;
+	}
+	emitValidated(valid, errors) {}
+	async waitUntilSettled() {
+		if (!this.validating$.peek()) return;
+		await new Promise((resolve) => {
+			const unsub = this.validating$.subscribe((v) => {
+				if (!v) {
+					unsub();
+					resolve();
+				}
+			});
+		});
+	}
+	runValidators() {
+		if (this.disposed) return;
+		const value = this.value$.value;
+		this.revalidateTrigger$.value;
+		this.currentAbort?.abort();
+		const abort = new AbortController();
+		this.currentAbort = abort;
+		const myId = ++this.runId;
+		const syncErrors = [];
+		const asyncPromises = [];
+		for (const validator of this.validators) {
+			const result = validator(value, abort.signal);
+			if (result instanceof Promise) asyncPromises.push(result);
+			else if (result != null) syncErrors.push(result);
+		}
+		if (syncErrors.length > 0) {
+			batch(() => {
+				this.errors$.set(syncErrors);
+				this.validating$.set(false);
+			});
+			this.emitValidated(false, syncErrors);
+			return;
+		}
+		if (asyncPromises.length === 0) {
+			batch(() => {
+				this.errors$.set([]);
+				this.validating$.set(false);
+			});
+			this.emitValidated(true, []);
+			return;
+		}
+		batch(() => {
+			this.errors$.set([]);
+			this.validating$.set(true);
+		});
+		Promise.allSettled(asyncPromises).then((results) => {
+			if (myId !== this.runId || this.disposed) return;
+			const asyncErrors = [];
+			for (const r of results) if (r.status === "fulfilled") {
+				if (r.value != null) asyncErrors.push(r.value);
+			} else if (!isAbortError(r.reason)) {
+				const msg = r.reason instanceof Error ? r.reason.message : String(r.reason);
+				asyncErrors.push(msg);
+			}
+			batch(() => {
+				this.errors$.set(asyncErrors);
+				this.validating$.set(false);
+			});
+			this.emitValidated(asyncErrors.length === 0, asyncErrors);
+		});
+	}
+};
+/**
+* Internal — type guard / accessor for the binding hook. Avoids exposing
+* `bindDevtoolsOwner` on the public `Field<T>` type while letting `createForm`
+* call it via a structural check.
+*/
+function bindFieldDevtoolsOwner(field, owner) {
+	const impl = field;
+	if (typeof impl.bindDevtoolsOwner === "function") impl.bindDevtoolsOwner(owner);
+}
+function createField(initial, validators) {
+	return new FieldImpl(initial, validators);
+}
+/**
+* Wrap an async validator with a debounce. The debounce timer resets on every
+* value change. While debouncing or the request is in flight, the field's
+* `isValidating` is true and `isValid` is false (treat-as-invalid-until-proven-valid).
+*/
+function debouncedValidator(fn, ms) {
+	return (value, signal) => new Promise((resolve, reject) => {
+		if (signal.aborted) {
+			reject(new DOMException("Aborted", "AbortError"));
+			return;
+		}
+		const timer = setTimeout(() => {
+			signal.removeEventListener("abort", onAbort);
+			fn(value, signal).then(resolve, reject);
+		}, ms);
+		const onAbort = () => {
+			clearTimeout(timer);
+			signal.removeEventListener("abort", onAbort);
+			reject(new DOMException("Aborted", "AbortError"));
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
+//#endregion
+//#region src/forms/form.ts
+const FORM_BRAND = Symbol.for("olas.form");
+const FIELD_ARRAY_BRAND = Symbol.for("olas.fieldArray");
+const isForm = (x) => typeof x === "object" && x !== null && x[FORM_BRAND] === true;
+const isFieldArray = (x) => typeof x === "object" && x !== null && x[FIELD_ARRAY_BRAND] === true;
+var FormImpl = class {
+	[FORM_BRAND] = true;
+	fields;
+	value;
+	errors;
+	isValid;
+	isDirty;
+	touched;
+	isValidating;
+	flatErrors;
+	topLevelErrors$ = signal([]);
+	topLevelErrors = this.topLevelErrors$;
+	topLevelValidating$ = signal(false);
+	validators;
+	options;
+	validatorDispose = null;
+	currentValidatorRun = 0;
+	currentValidatorAbort = null;
+	disposed = false;
+	constructor(schema, options) {
+		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.value = computed(() => this.computeValue());
+		this.errors = computed(() => this.computeErrors());
+		this.isDirty = computed(() => this.computeBool("isDirty"));
+		this.touched = computed(() => this.computeBool("touched"));
+		this.isValidating = computed(() => {
+			if (this.topLevelValidating$.value) return true;
+			for (const child of Object.values(this.fields)) if (child.isValidating.value) return true;
+			return false;
+		});
+		this.isValid = computed(() => {
+			if (this.topLevelErrors$.value.length > 0) return false;
+			if (this.isValidating.value) return false;
+			for (const child of Object.values(this.fields)) if (!child.isValid.value) return false;
+			return true;
+		});
+		this.flatErrors = computed(() => this.computeFlatErrors());
+		if (this.validators.length > 0) this.validatorDispose = effect(() => this.runTopLevelValidators());
+	}
+	computeValue() {
+		const out = {};
+		for (const [k, child] of Object.entries(this.fields)) if (isForm(child) || isFieldArray(child)) out[k] = child.value.value;
+		else out[k] = child.value;
+		return out;
+	}
+	computeErrors() {
+		const out = {};
+		for (const [k, child] of Object.entries(this.fields)) if (isForm(child)) out[k] = child.errors.value;
+		else if (isFieldArray(child)) out[k] = child.errors.value;
+		else {
+			const errs = child.errors.value;
+			out[k] = errs.length > 0 ? errs : void 0;
+		}
+		return out;
+	}
+	computeBool(key) {
+		for (const child of Object.values(this.fields)) if (child[key]?.value) return true;
+		return false;
+	}
+	computeFlatErrors() {
+		const out = [];
+		const tle = this.topLevelErrors$.value;
+		if (tle.length > 0) out.push({
+			path: "",
+			errors: tle
+		});
+		walkErrors(this.fields, "", out);
+		return out;
+	}
+	set(partial) {
+		if (this.disposed) return;
+		batch(() => this.applyPartial(partial, false));
+	}
+	applyPartial(partial, asInitial) {
+		for (const [k, val] of Object.entries(partial)) {
+			const child = this.fields[k];
+			if (!child) 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);
+			} else {
+				const f = child;
+				if (asInitial) f.setAsInitial(val);
+				else f.set(val);
+			}
+		}
+	}
+	/** Internal: re-seat this form's leaves from `partial` as their new initial. */
+	resetWithInitial(partial) {
+		if (this.disposed) return;
+		batch(() => this.applyPartial(partial, true));
+	}
+	reset() {
+		if (this.disposed) return;
+		batch(() => {
+			for (const child of Object.values(this.fields)) if (isForm(child) || isFieldArray(child)) child.reset();
+			else child.reset();
+			this.topLevelErrors$.set([]);
+		});
+		if (this.options?.initial !== void 0) {
+			const ini = typeof this.options.initial === "function" ? this.options.initial() : this.options.initial;
+			if (ini !== void 0) this.applyPartial(ini, true);
+		}
+	}
+	markAllTouched() {
+		if (this.disposed) return;
+		for (const child of Object.values(this.fields)) if (isForm(child)) child.markAllTouched();
+		else if (isFieldArray(child)) child.markAllTouched();
+		else child.markTouched();
+	}
+	async validate() {
+		if (this.disposed) return this.isValid.peek();
+		const tasks = [];
+		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.topLevelValidating$.peek()) await new Promise((resolve) => {
+			const unsub = this.topLevelValidating$.subscribe((v) => {
+				if (!v) {
+					unsub();
+					resolve();
+				}
+			});
+		});
+		return this.isValid.peek();
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.validatorDispose?.();
+		this.currentValidatorAbort?.abort();
+		for (const child of Object.values(this.fields)) child.dispose?.();
+	}
+	runTopLevelValidators() {
+		if (this.disposed) return;
+		const value = this.value.value;
+		this.currentValidatorAbort?.abort();
+		const abort = new AbortController();
+		this.currentValidatorAbort = abort;
+		const myId = ++this.currentValidatorRun;
+		const syncErrors = [];
+		const asyncPromises = [];
+		for (const v of this.validators) {
+			const r = v(value, abort.signal);
+			if (r instanceof Promise) asyncPromises.push(r);
+			else if (r != null) syncErrors.push(r);
+		}
+		if (syncErrors.length > 0) {
+			batch(() => {
+				this.topLevelErrors$.set(syncErrors);
+				this.topLevelValidating$.set(false);
+			});
+			return;
+		}
+		if (asyncPromises.length === 0) {
+			batch(() => {
+				this.topLevelErrors$.set([]);
+				this.topLevelValidating$.set(false);
+			});
+			return;
+		}
+		batch(() => {
+			this.topLevelErrors$.set([]);
+			this.topLevelValidating$.set(true);
+		});
+		Promise.allSettled(asyncPromises).then((results) => {
+			if (myId !== this.currentValidatorRun || this.disposed) return;
+			const errs = [];
+			for (const r of results) if (r.status === "fulfilled" && r.value != null) errs.push(r.value);
+			batch(() => {
+				this.topLevelErrors$.set(errs);
+				this.topLevelValidating$.set(false);
+			});
+		});
+	}
+};
+function walkErrors(fields, prefix, out) {
+	for (const [k, child] of Object.entries(fields)) {
+		const path = prefix ? `${prefix}.${k}` : k;
+		if (isForm(child)) {
+			const tle = child.topLevelErrors.value;
+			if (tle.length > 0) out.push({
+				path,
+				errors: tle
+			});
+			walkErrors(child.fields, path, out);
+		} else if (isFieldArray(child)) {
+			const tle = child.topLevelErrors.value;
+			if (tle.length > 0) out.push({
+				path,
+				errors: tle
+			});
+			child.items.value.forEach((item, idx) => {
+				const itemPath = `${path}[${idx}]`;
+				if (isForm(item)) {
+					const itle = item.topLevelErrors.value;
+					if (itle.length > 0) out.push({
+						path: itemPath,
+						errors: itle
+					});
+					walkErrors(item.fields, itemPath, out);
+				} else {
+					const errs = item.errors.value;
+					if (errs.length > 0) out.push({
+						path: itemPath,
+						errors: errs
+					});
+				}
+			});
+		} else {
+			const errs = child.errors.value;
+			if (errs.length > 0) out.push({
+				path,
+				errors: errs
+			});
+		}
+	}
+}
+var FieldArrayImpl = class {
+	[FIELD_ARRAY_BRAND] = true;
+	items;
+	value;
+	errors;
+	size;
+	isValid;
+	isDirty;
+	touched;
+	isValidating;
+	items$;
+	topLevelErrors$ = signal([]);
+	topLevelErrors = this.topLevelErrors$;
+	topLevelValidating$ = signal(false);
+	itemFactory;
+	initialItems = [];
+	validators;
+	currentValidatorRun = 0;
+	currentValidatorAbort = null;
+	validatorDispose = null;
+	disposed = false;
+	constructor(itemFactory, options) {
+		this.itemFactory = itemFactory;
+		this.validators = options?.validators ?? [];
+		this.items$ = signal([]);
+		if (options?.initial) {
+			this.initialItems = options.initial;
+			for (const ini of options.initial) this.items$.peek().push(itemFactory(ini));
+			this.items$.set([...this.items$.peek()]);
+		}
+		this.items = this.items$;
+		this.size = computed(() => this.items$.value.length);
+		this.value = computed(() => this.items$.value.map((item) => {
+			if (isForm(item)) return item.value.value;
+			return item.value;
+		}));
+		this.errors = computed(() => this.items$.value.map((item) => {
+			if (isForm(item)) return item.errors.value;
+			const errs = item.errors.value;
+			return errs.length > 0 ? errs : void 0;
+		}));
+		this.isDirty = computed(() => {
+			for (const item of this.items$.value) if (item.isDirty.value) return true;
+			return false;
+		});
+		this.touched = computed(() => {
+			for (const item of this.items$.value) if (item.touched.value) return true;
+			return false;
+		});
+		this.isValidating = computed(() => {
+			if (this.topLevelValidating$.value) return true;
+			for (const item of this.items$.value) if (item.isValidating.value) return true;
+			return false;
+		});
+		this.isValid = computed(() => {
+			if (this.topLevelErrors$.value.length > 0) return false;
+			if (this.isValidating.value) return false;
+			for (const item of this.items$.value) if (!item.isValid.value) return false;
+			return true;
+		});
+		if (this.validators.length > 0) this.validatorDispose = effect(() => this.runTopLevelValidators());
+	}
+	at(index) {
+		return this.items$.peek()[index];
+	}
+	add(initial) {
+		if (this.disposed) return;
+		const item = this.itemFactory(initial);
+		this.items$.set([...this.items$.peek(), item]);
+	}
+	insert(index, initial) {
+		if (this.disposed) return;
+		const item = this.itemFactory(initial);
+		const next = [...this.items$.peek()];
+		next.splice(index, 0, item);
+		this.items$.set(next);
+	}
+	remove(index) {
+		if (this.disposed) return;
+		const next = [...this.items$.peek()];
+		const [removed] = next.splice(index, 1);
+		if (removed) removed.dispose?.();
+		this.items$.set(next);
+	}
+	move(from, to) {
+		if (this.disposed) return;
+		const next = [...this.items$.peek()];
+		const [item] = next.splice(from, 1);
+		if (item) next.splice(to, 0, item);
+		this.items$.set(next);
+	}
+	clear() {
+		if (this.disposed) return;
+		for (const item of this.items$.peek()) item.dispose?.();
+		this.items$.set([]);
+	}
+	reset() {
+		if (this.disposed) return;
+		batch(() => {
+			this.clear();
+			for (const ini of this.initialItems) this.add(ini);
+			this.topLevelErrors$.set([]);
+		});
+	}
+	markAllTouched() {
+		for (const item of this.items$.peek()) if (isForm(item)) item.markAllTouched();
+		else item.markTouched();
+	}
+	async validate() {
+		if (this.disposed) return this.isValid.peek();
+		const tasks = [];
+		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.topLevelValidating$.peek()) await new Promise((resolve) => {
+			const unsub = this.topLevelValidating$.subscribe((v) => {
+				if (!v) {
+					unsub();
+					resolve();
+				}
+			});
+		});
+		return this.isValid.peek();
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.validatorDispose?.();
+		this.currentValidatorAbort?.abort();
+		for (const item of this.items$.peek()) item.dispose?.();
+	}
+	runTopLevelValidators() {
+		if (this.disposed) return;
+		const value = this.value.value;
+		this.currentValidatorAbort?.abort();
+		const abort = new AbortController();
+		this.currentValidatorAbort = abort;
+		const myId = ++this.currentValidatorRun;
+		const syncErrors = [];
+		const asyncPromises = [];
+		for (const v of this.validators) {
+			const r = v(value, abort.signal);
+			if (r instanceof Promise) asyncPromises.push(r);
+			else if (r != null) syncErrors.push(r);
+		}
+		if (syncErrors.length > 0) {
+			batch(() => {
+				this.topLevelErrors$.set(syncErrors);
+				this.topLevelValidating$.set(false);
+			});
+			return;
+		}
+		if (asyncPromises.length === 0) {
+			batch(() => {
+				this.topLevelErrors$.set([]);
+				this.topLevelValidating$.set(false);
+			});
+			return;
+		}
+		batch(() => {
+			this.topLevelErrors$.set([]);
+			this.topLevelValidating$.set(true);
+		});
+		Promise.allSettled(asyncPromises).then((results) => {
+			if (myId !== this.currentValidatorRun || this.disposed) return;
+			const errs = [];
+			for (const r of results) if (r.status === "fulfilled" && r.value != null) errs.push(r.value);
+			batch(() => {
+				this.topLevelErrors$.set(errs);
+				this.topLevelValidating$.set(false);
+			});
+		});
+	}
+};
+function createForm(schema, options) {
+	return new FormImpl(schema, options);
+}
+function createFieldArray(itemFactory, options) {
+	return new FieldArrayImpl(itemFactory, options);
+}
+/**
+* Recursively wire every leaf `Field` in a form / field-array tree to a
+* devtools emitter. Returns a single disposer that tears down every standalone
+* `effect()` registered along the way (used for FieldArray watching), so the
+* caller — `ctx.form` / `ctx.fieldArray` in the controller — can register one
+* cleanup entry and have the whole subtree's reactive work die with the
+* controller. Spec §20.9.
+*/
+function bindTreeToDevtools(node, prefix, controllerPath, emitter) {
+	const disposers = [];
+	bindTreeToDevtoolsInto(node, prefix, controllerPath, emitter, disposers);
+	return () => {
+		for (const d of disposers) try {
+			d();
+		} catch {}
+		disposers.length = 0;
+	};
+}
+function bindTreeToDevtoolsInto(node, prefix, controllerPath, emitter, disposers) {
+	if (isForm(node)) {
+		for (const [key, child] of Object.entries(node.fields)) bindTreeToDevtoolsInto(child, prefix === "" ? key : `${prefix}.${key}`, controllerPath, emitter, disposers);
+		return;
+	}
+	if (isFieldArray(node)) {
+		const arr = node;
+		const stop = effect(() => {
+			arr.items.value.forEach((item, idx) => {
+				bindTreeToDevtoolsInto(item, `${prefix}[${idx}]`, controllerPath, emitter, disposers);
+			});
+		});
+		disposers.push(stop);
+		return;
+	}
+	bindFieldDevtoolsOwner(node, {
+		controllerPath,
+		fieldName: prefix,
+		emitter
+	});
+}
+//#endregion
+//#region src/query/local.ts
+var LocalCacheImpl = class {
+	entry;
+	keyEffectDispose = null;
+	disposed = false;
+	keepPreviousData;
+	lastSucceededFor = null;
+	constructor(fetcher, options) {
+		this.keepPreviousData = options.keepPreviousData ?? false;
+		this.entry = new Entry({
+			fetcher: () => fetcher,
+			staleTime: options.staleTime ?? 0,
+			initialData: options.initialData
+		});
+		if (options.key) {
+			const keyFn = options.key;
+			this.keyEffectDispose = effect(() => {
+				const keyArgs = keyFn();
+				untracked(() => {
+					if (!this.keepPreviousData) {
+						if (this.lastSucceededFor != null && !arraysEqual(this.lastSucceededFor, keyArgs)) this.entry.data.set(void 0);
+					}
+					this.entry.startFetch().then(() => {
+						this.lastSucceededFor = [...keyArgs];
+					}, () => {});
+				});
+			});
+		} else this.entry.startFetch().catch(() => {});
+	}
+	get data() {
+		return this.entry.data;
+	}
+	get error() {
+		return this.entry.error;
+	}
+	get status() {
+		return this.entry.status;
+	}
+	get isLoading() {
+		return this.entry.isLoading;
+	}
+	get isFetching() {
+		return this.entry.isFetching;
+	}
+	get isStale() {
+		return this.entry.isStale;
+	}
+	get lastUpdatedAt() {
+		return this.entry.lastUpdatedAt;
+	}
+	get hasPendingMutations() {
+		return this.entry.hasPendingMutations;
+	}
+	refetch = () => this.entry.refetch();
+	reset = () => this.entry.reset();
+	firstValue = () => this.entry.firstValue();
+	invalidate = () => {
+		this.entry.invalidate().catch(() => {});
+	};
+	setData = (updater) => this.entry.setData(updater);
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.keyEffectDispose?.();
+		this.keyEffectDispose = null;
+		this.entry.dispose();
+	}
+};
+function createLocalCache(fetcher, options) {
+	return new LocalCacheImpl(fetcher, options ?? {});
+}
+function arraysEqual(a, b) {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (!Object.is(a[i], b[i])) return false;
+	return true;
+}
+//#endregion
+//#region src/query/mutation.ts
+var MutationImpl = class {
+	spec;
+	onError;
+	controllerPath;
+	inflightCounter;
+	devtools;
+	data = signal(void 0);
+	error = signal(void 0);
+	isPending = signal(false);
+	lastVariables = signal(void 0);
+	inflight = /* @__PURE__ */ new Set();
+	serialQueue = [];
+	serialActive = false;
+	disposed = false;
+	constructor(spec, onError, controllerPath, inflightCounter, devtools) {
+		this.spec = spec;
+		this.onError = onError;
+		this.controllerPath = controllerPath;
+		this.inflightCounter = inflightCounter;
+		this.devtools = devtools;
+	}
+	emit(event) {}
+	run = ((vars = void 0) => {
+		if (this.disposed) return Promise.reject(/* @__PURE__ */ new Error("Mutation disposed"));
+		switch (this.spec.concurrency ?? "parallel") {
+			case "parallel": return this.executeRun(vars);
+			case "latest-wins":
+				for (const handle of this.inflight) {
+					handle.abort.abort();
+					handle.snapshot?.rollback();
+					handle.snapshot = void 0;
+				}
+				return this.executeRun(vars);
+			case "serial": return this.enqueueSerial(vars);
+		}
+	});
+	enqueueSerial(vars) {
+		if (this.serialActive) return new Promise((resolve, reject) => {
+			this.serialQueue.push({
+				vars,
+				resolve,
+				reject
+			});
+		});
+		this.serialActive = true;
+		return this.executeRun(vars).finally(() => this.advanceSerialQueue());
+	}
+	advanceSerialQueue() {
+		const next = this.serialQueue.shift();
+		if (!next) {
+			this.serialActive = false;
+			return;
+		}
+		this.executeRun(next.vars).then((result) => {
+			next.resolve(result);
+			this.advanceSerialQueue();
+		}, (err) => {
+			next.reject(err);
+			this.advanceSerialQueue();
+		});
+	}
+	async executeRun(vars) {
+		const abort = new AbortController();
+		let snapshot;
+		try {
+			const raw = this.spec.onMutate?.(vars) ?? void 0;
+			snapshot = raw === void 0 ? void 0 : this.wrapSnapshot(raw);
+		} catch (err) {
+			dispatchError(this.onError, err, {
+				kind: "mutation",
+				controllerPath: this.controllerPath
+			});
+		}
+		const handle = {
+			abort,
+			snapshot
+		};
+		this.inflight.add(handle);
+		this.inflightCounter?.update((n) => n + 1);
+		batch(() => {
+			this.isPending.set(true);
+			this.lastVariables.set(vars);
+		});
+		try {
+			const result = await raceAbort(this.runWithRetry(vars, abort.signal), abort.signal);
+			if (abort.signal.aborted || this.disposed) {
+				snapshot?.rollback();
+				throw new DOMException("Superseded", "AbortError");
+			}
+			batch(() => {
+				this.data.set(result);
+				this.error.set(void 0);
+			});
+			this.safeCall(() => this.spec.onSuccess?.(result, vars), "mutation");
+			snapshot?.finalize();
+			this.safeCall(() => this.spec.onSettled?.(result, void 0, vars), "mutation");
+			return result;
+		} catch (err) {
+			if (isAbortError(err) || abort.signal.aborted) {
+				snapshot?.rollback();
+				throw err;
+			}
+			this.error.set(err);
+			this.safeCall(() => this.spec.onError?.(err, vars, snapshot), "mutation");
+			snapshot?.rollback();
+			this.safeCall(() => this.spec.onSettled?.(void 0, err, vars), "mutation");
+			throw err;
+		} finally {
+			this.inflight.delete(handle);
+			this.inflightCounter?.update((n) => Math.max(0, n - 1));
+			if (this.inflight.size === 0) this.isPending.set(false);
+		}
+	}
+	wrapSnapshot(raw) {
+		let consumed = false;
+		return {
+			rollback: () => {
+				if (consumed) return;
+				consumed = true;
+				raw.rollback();
+			},
+			finalize: () => {
+				if (consumed) return;
+				consumed = true;
+				raw.finalize();
+			}
+		};
+	}
+	async runWithRetry(vars, signal) {
+		const retry = this.spec.retry ?? 0;
+		const retryDelay = this.spec.retryDelay ?? 1e3;
+		let attempt = 0;
+		while (true) try {
+			return await this.spec.mutate(vars, signal);
+		} catch (err) {
+			if (signal.aborted || isAbortError(err)) throw err;
+			if (!(typeof retry === "number" ? attempt < retry : retry(attempt, err))) throw err;
+			await abortableSleep(typeof retryDelay === "function" ? retryDelay(attempt) : retryDelay, signal);
+			attempt += 1;
+		}
+	}
+	safeCall(fn, kind) {
+		try {
+			fn();
+		} catch (err) {
+			dispatchError(this.onError, err, {
+				kind,
+				controllerPath: this.controllerPath
+			});
+		}
+	}
+	reset() {
+		if (this.disposed) return;
+		for (const handle of this.inflight) handle.abort.abort();
+		this.serialQueue.length = 0;
+		batch(() => {
+			this.data.set(void 0);
+			this.error.set(void 0);
+			this.lastVariables.set(void 0);
+			this.isPending.set(false);
+		});
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		for (const handle of this.inflight) handle.abort.abort();
+		for (const queued of this.serialQueue) queued.reject(new DOMException("Disposed", "AbortError"));
+		this.serialQueue.length = 0;
+	}
+};
+function createMutation(spec, onError, controllerPath, inflightCounter, devtools) {
+	return new MutationImpl(spec, onError, controllerPath, inflightCounter, devtools);
+}
+/**
+* Race a promise against an AbortSignal. If the signal fires before the
+* promise settles, the returned promise rejects with AbortError — regardless
+* of whether the underlying promise ever resolves. Protects against
+* misbehaving mutate fns that ignore their signal.
+*/
+function raceAbort(promise, signal) {
+	if (signal.aborted) return Promise.reject(new DOMException("Aborted", "AbortError"));
+	return new Promise((resolve, reject) => {
+		let settled = false;
+		const onAbort = () => {
+			if (settled) return;
+			settled = true;
+			reject(new DOMException("Aborted", "AbortError"));
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+		promise.then((v) => {
+			if (settled) return;
+			settled = true;
+			signal.removeEventListener("abort", onAbort);
+			resolve(v);
+		}, (e) => {
+			if (settled) return;
+			settled = true;
+			signal.removeEventListener("abort", onAbort);
+			reject(e);
+		});
+	});
+}
+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 {
+	keepPreviousData;
+	current$ = signal(null);
+	previousData$ = signal(void 0);
+	data;
+	error;
+	status;
+	isLoading;
+	isFetching;
+	isStale;
+	lastUpdatedAt;
+	hasPendingMutations;
+	constructor(keepPreviousData) {
+		this.keepPreviousData = keepPreviousData;
+		this.data = computed(() => {
+			const curData = this.current$.value?.entry.data.value;
+			if (curData !== void 0) return curData;
+			if (keepPreviousData) return this.previousData$.value;
+		});
+		this.error = computed(() => this.current$.value?.entry.error.value);
+		this.status = computed(() => this.current$.value?.entry.status.value ?? "idle");
+		this.isLoading = computed(() => {
+			const cur = this.current$.value;
+			if (!cur) return false;
+			if (keepPreviousData && this.previousData$.value !== void 0) return false;
+			return cur.entry.isLoading.value;
+		});
+		this.isFetching = computed(() => this.current$.value?.entry.isFetching.value ?? false);
+		this.isStale = computed(() => this.current$.value?.entry.isStale.value ?? true);
+		this.lastUpdatedAt = computed(() => this.current$.value?.entry.lastUpdatedAt.value);
+		this.hasPendingMutations = computed(() => this.current$.value?.entry.hasPendingMutations.value ?? false);
+	}
+	attach(entry) {
+		const prev = this.current$.peek();
+		if (prev === entry) return;
+		if (prev && this.keepPreviousData) {
+			const prevData = prev.entry.data.peek();
+			if (prevData !== void 0) this.previousData$.set(prevData);
+		}
+		this.current$.set(entry);
+	}
+	detach() {
+		this.current$.set(null);
+	}
+	refetch = () => {
+		const cur = this.current$.peek();
+		if (!cur) return Promise.reject(/* @__PURE__ */ new Error("[olas] no active subscription"));
+		return cur.entry.refetch();
+	};
+	reset = () => {
+		this.current$.peek()?.entry.reset();
+	};
+	firstValue = () => {
+		const cur = this.current$.peek();
+		if (!cur) return Promise.reject(/* @__PURE__ */ new Error("[olas] no active subscription"));
+		return cur.entry.firstValue();
+	};
+};
+/**
+* Build a subscription + the effect that keeps it bound to the right entry.
+* The controller container wires the disposer into the lifecycle.
+*/
+function createUse(client, query, keyOrOptions) {
+	const keepPreviousData = query.__spec.keepPreviousData ?? false;
+	const keyFn = typeof keyOrOptions === "function" ? keyOrOptions : keyOrOptions?.key;
+	const enabledFn = typeof keyOrOptions === "object" && keyOrOptions !== null ? keyOrOptions.enabled : void 0;
+	const sub = new SubscriptionImpl(keepPreviousData);
+	let currentEntry = null;
+	const effectDispose = effect(() => {
+		if (!(enabledFn ? enabledFn() : true)) {
+			untracked(() => {
+				if (currentEntry) {
+					currentEntry.release();
+					currentEntry = null;
+				}
+				sub.detach();
+			});
+			return;
+		}
+		const args = keyFn ? keyFn() : [];
+		untracked(() => {
+			const entry = client.bindEntry(query, args);
+			if (currentEntry === entry) return;
+			if (currentEntry) currentEntry.release();
+			entry.acquire();
+			currentEntry = entry;
+			sub.attach(entry);
+			const status = entry.entry.status.peek();
+			if (!entry.entry.isFetching.peek() && (status === "idle" || entry.entry.isStaleNow() || status === "error")) entry.entry.startFetch().catch(() => {});
+		});
+	});
+	const dispose = () => {
+		effectDispose();
+		if (currentEntry) {
+			currentEntry.release();
+			currentEntry = null;
+		}
+		sub.detach();
+	};
+	return {
+		subscription: sub,
+		dispose
+	};
+}
+var InfiniteSubscriptionImpl = class {
+	keepPreviousData;
+	current$ = signal(null);
+	previousPages$ = signal(void 0);
+	data;
+	pages;
+	flat;
+	error;
+	status;
+	isLoading;
+	isFetching;
+	isStale;
+	lastUpdatedAt;
+	hasPendingMutations;
+	hasNextPage;
+	hasPreviousPage;
+	isFetchingNextPage;
+	isFetchingPreviousPage;
+	constructor(keepPreviousData) {
+		this.keepPreviousData = keepPreviousData;
+		this.pages = computed(() => {
+			const ps = this.current$.value?.entry.pages.value;
+			if (ps && ps.length > 0) return ps;
+			if (keepPreviousData) return this.previousPages$.value ?? [];
+			return ps ?? [];
+		});
+		this.data = computed(() => {
+			const ps = this.current$.value?.entry.pages.value;
+			if (ps && ps.length > 0) return ps;
+			if (keepPreviousData) {
+				const prev = this.previousPages$.value;
+				if (prev && prev.length > 0) return prev;
+			}
+		});
+		this.flat = computed(() => this.current$.value?.entry.flat.value ?? []);
+		this.error = computed(() => this.current$.value?.entry.error.value);
+		this.status = computed(() => this.current$.value?.entry.status.value ?? "idle");
+		this.isLoading = computed(() => {
+			const cur = this.current$.value;
+			if (!cur) return false;
+			if (keepPreviousData) {
+				const prev = this.previousPages$.value;
+				if (prev && prev.length > 0) return false;
+			}
+			return cur.entry.isLoading.value;
+		});
+		this.isFetching = computed(() => this.current$.value?.entry.isFetching.value ?? false);
+		this.isStale = computed(() => this.current$.value?.entry.isStale.value ?? true);
+		this.lastUpdatedAt = computed(() => this.current$.value?.entry.lastUpdatedAt.value);
+		this.hasPendingMutations = computed(() => this.current$.value?.entry.hasPendingMutations.value ?? false);
+		this.hasNextPage = computed(() => this.current$.value?.entry.hasNextPage.value ?? false);
+		this.hasPreviousPage = computed(() => this.current$.value?.entry.hasPreviousPage.value ?? false);
+		this.isFetchingNextPage = computed(() => this.current$.value?.entry.isFetchingNextPage.value ?? false);
+		this.isFetchingPreviousPage = computed(() => this.current$.value?.entry.isFetchingPreviousPage.value ?? false);
+	}
+	attach(entry) {
+		const prev = this.current$.peek();
+		if (prev === entry) return;
+		if (prev && this.keepPreviousData) {
+			const prevPages = prev.entry.pages.peek();
+			if (prevPages.length > 0) this.previousPages$.set(prevPages);
+		}
+		this.current$.set(entry);
+	}
+	detach() {
+		this.current$.set(null);
+	}
+	refetch = () => {
+		const cur = this.current$.peek();
+		if (!cur) return Promise.reject(/* @__PURE__ */ new Error("[olas] no active subscription"));
+		return cur.entry.refetch().then(() => cur.entry.pages.peek());
+	};
+	reset = () => {
+		this.current$.peek()?.entry.reset();
+	};
+	firstValue = () => {
+		const cur = this.current$.peek();
+		if (!cur) return Promise.reject(/* @__PURE__ */ new Error("[olas] no active subscription"));
+		return cur.entry.firstValue();
+	};
+	fetchNextPage = () => {
+		const cur = this.current$.peek();
+		if (!cur) return Promise.resolve();
+		return cur.entry.fetchNextPage();
+	};
+	fetchPreviousPage = () => {
+		const cur = this.current$.peek();
+		if (!cur) return Promise.resolve();
+		return cur.entry.fetchPreviousPage();
+	};
+};
+function createInfiniteUse(client, query, keyOrOptions) {
+	const keepPreviousData = query.__spec.keepPreviousData ?? false;
+	const keyFn = typeof keyOrOptions === "function" ? keyOrOptions : keyOrOptions?.key;
+	const enabledFn = typeof keyOrOptions === "object" && keyOrOptions !== null ? keyOrOptions.enabled : void 0;
+	const sub = new InfiniteSubscriptionImpl(keepPreviousData);
+	let currentEntry = null;
+	const effectDispose = effect(() => {
+		if (!(enabledFn ? enabledFn() : true)) {
+			untracked(() => {
+				if (currentEntry) {
+					currentEntry.release();
+					currentEntry = null;
+				}
+				sub.detach();
+			});
+			return;
+		}
+		const args = keyFn ? keyFn() : [];
+		untracked(() => {
+			const entry = client.bindInfiniteEntry(query, args);
+			if (currentEntry === entry) return;
+			if (currentEntry) currentEntry.release();
+			entry.acquire();
+			currentEntry = entry;
+			sub.attach(entry);
+			const status = entry.entry.status.peek();
+			if (!entry.entry.isFetching.peek() && (status === "idle" || entry.entry.isStaleNow() || status === "error")) entry.entry.startFetch().catch(() => {});
+		});
+	});
+	const dispose = () => {
+		effectDispose();
+		if (currentEntry) {
+			currentEntry.release();
+			currentEntry = null;
+		}
+		sub.detach();
+	};
+	return {
+		subscription: sub,
+		dispose
+	};
+}
+//#endregion
+//#region src/controller/instance.ts
+var ControllerInstance = class ControllerInstance {
+	path;
+	deps;
+	state = "constructing";
+	entries = [];
+	rootShared;
+	parent;
+	childCounter = 0;
+	/** Scope values provided on this instance, keyed by `Scope.__id`. */
+	scopes = null;
+	constructor(parent, rootShared, pathSegment, deps) {
+		this.parent = parent;
+		this.rootShared = rootShared;
+		this.path = parent ? [...parent.path, pathSegment] : [pathSegment];
+		this.deps = deps;
+	}
+	/**
+	* Run the factory and produce an api. On throw, the partially-constructed
+	* state is rolled back (entries disposed in reverse) and the error is rethrown.
+	*/
+	construct(factory, props) {
+		const ctx = this.buildCtx();
+		let api;
+		try {
+			api = factory(ctx, props);
+		} catch (err) {
+			this.rollbackPartialConstruction();
+			throw err;
+		}
+		this.state = "active";
+		return api;
+	}
+	rollbackPartialConstruction() {
+		for (let i = this.entries.length - 1; i >= 0; i--) {
+			const entry = this.entries[i];
+			if (!entry) continue;
+			try {
+				this.disposeEntry(entry);
+			} catch {}
+		}
+		this.entries.length = 0;
+		this.state = "disposed";
+	}
+	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];
+			if (!entry) continue;
+			try {
+				this.disposeEntry(entry);
+			} catch (err) {
+				dispatchError(this.rootShared.onError, err, {
+					kind: "effect",
+					controllerPath: this.path
+				});
+			}
+		}
+		this.entries.length = 0;
+		this.scopes = null;
+	}
+	disposeEntry(entry) {
+		switch (entry.kind) {
+			case "effect":
+				entry.dispose?.();
+				entry.dispose = null;
+				break;
+			case "cleanup":
+				entry.dispose();
+				break;
+			case "child":
+				entry.instance.dispose();
+				break;
+			case "subscription":
+				entry.unsubscribe();
+				break;
+			case "onDispose":
+				entry.fn();
+				break;
+			case "onSuspend":
+			case "onResume": break;
+		}
+	}
+	suspend() {
+		if (this.state !== "active") return;
+		this.state = "suspended";
+		for (let i = this.entries.length - 1; i >= 0; i--) {
+			const entry = this.entries[i];
+			if (!entry) continue;
+			try {
+				switch (entry.kind) {
+					case "effect":
+						entry.dispose?.();
+						entry.dispose = null;
+						break;
+					case "child":
+						entry.instance.suspend();
+						break;
+					case "onSuspend":
+						entry.fn();
+						break;
+					default: break;
+				}
+			} catch (err) {
+				dispatchError(this.rootShared.onError, err, {
+					kind: "effect",
+					controllerPath: this.path
+				});
+			}
+		}
+	}
+	resume() {
+		if (this.state !== "suspended") return;
+		this.state = "active";
+		for (const entry of this.entries) try {
+			switch (entry.kind) {
+				case "effect":
+					entry.dispose = effect(entry.factory);
+					break;
+				case "child":
+					entry.instance.resume();
+					break;
+				case "onResume":
+					entry.fn();
+					break;
+				default: break;
+			}
+		} catch (err) {
+			dispatchError(this.rootShared.onError, err, {
+				kind: "effect",
+				controllerPath: this.path
+			});
+		}
+	}
+	buildCtx() {
+		const self = this;
+		return {
+			get deps() {
+				return self.deps;
+			},
+			effect(fn) {
+				if (self.isTerminal()) return;
+				const entry = {
+					kind: "effect",
+					factory: () => fn(),
+					dispose: null
+				};
+				const wrapped = () => {
+					try {
+						return fn();
+					} catch (err) {
+						dispatchError(self.rootShared.onError, err, {
+							kind: "effect",
+							controllerPath: self.path
+						});
+						return;
+					}
+				};
+				entry.factory = wrapped;
+				entry.dispose = effect(wrapped);
+				self.entries.push(entry);
+			},
+			cache(fetcher, options) {
+				const cache = createLocalCache(fetcher, options);
+				self.entries.push({
+					kind: "cleanup",
+					dispose: () => cache.dispose()
+				});
+				return cache;
+			},
+			use(query, keyOrOptions) {
+				if (query.__olas === "infiniteQuery") {
+					const { subscription, dispose: d } = createInfiniteUse(self.rootShared.queryClient, query, keyOrOptions);
+					self.entries.push({
+						kind: "cleanup",
+						dispose: d
+					});
+					return subscription;
+				}
+				const { subscription, dispose: d } = createUse(self.rootShared.queryClient, query, keyOrOptions);
+				self.entries.push({
+					kind: "cleanup",
+					dispose: d
+				});
+				return subscription;
+			},
+			mutation(spec) {
+				const m = createMutation(spec, self.rootShared.onError, self.path, self.rootShared.queryClient.mutationsInflight$, self.rootShared.devtools);
+				self.entries.push({
+					kind: "cleanup",
+					dispose: () => m.dispose()
+				});
+				return m;
+			},
+			emitter() {
+				const e = createEmitter();
+				self.entries.push({
+					kind: "cleanup",
+					dispose: () => e.dispose()
+				});
+				return e;
+			},
+			field(initial, validators) {
+				const f = createField(initial, validators);
+				self.entries.push({
+					kind: "cleanup",
+					dispose: () => f.dispose()
+				});
+				bindFieldDevtoolsOwner(f, {
+					controllerPath: self.path,
+					fieldName: "(field)",
+					emitter: self.rootShared.devtools
+				});
+				return f;
+			},
+			form(schema, options) {
+				const f = createForm(schema, options);
+				self.entries.push({
+					kind: "cleanup",
+					dispose: () => f.dispose()
+				});
+				const stop = bindTreeToDevtools(f, "", self.path, self.rootShared.devtools);
+				self.entries.push({
+					kind: "cleanup",
+					dispose: stop
+				});
+				return f;
+			},
+			fieldArray(itemFactory, options) {
+				const fa = createFieldArray(itemFactory, options);
+				self.entries.push({
+					kind: "cleanup",
+					dispose: () => fa.dispose()
+				});
+				const stop = bindTreeToDevtools(fa, "", self.path, self.rootShared.devtools);
+				self.entries.push({
+					kind: "cleanup",
+					dispose: stop
+				});
+				return fa;
+			},
+			provide(scope, value) {
+				if (self.scopes === null) self.scopes = /* @__PURE__ */ new Map();
+				self.scopes.set(scope.__id, value);
+			},
+			inject(scope) {
+				let node = self;
+				while (node !== null) {
+					const map = node.scopes;
+					if (map?.has(scope.__id)) return map.get(scope.__id);
+					node = node.parent;
+				}
+				if (scope.hasDefault) return scope.default;
+				const label = scope.name ?? scope.__id.description ?? "unnamed";
+				throw new Error(`[olas] ctx.inject(): no provider for scope '${label}' and no default. Provide it on an ancestor via ctx.provide(${label}, ...) or pass a default to defineScope.`);
+			},
+			on(emitter, handler) {
+				const wrapped = (value) => {
+					try {
+						handler(value);
+					} catch (err) {
+						dispatchError(self.rootShared.onError, err, {
+							kind: "emitter",
+							controllerPath: self.path
+						});
+					}
+				};
+				const unsubscribe = emitter.on(wrapped);
+				self.entries.push({
+					kind: "subscription",
+					unsubscribe
+				});
+			},
+			child(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);
+				self.entries.push({
+					kind: "child",
+					instance: childInstance
+				});
+				return api;
+			},
+			attach(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;
+				return {
+					api,
+					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
+							});
+						}
+					}
+				};
+			},
+			onDispose(fn) {
+				self.entries.push({
+					kind: "onDispose",
+					fn: () => {
+						try {
+							fn();
+						} catch (err) {
+							dispatchError(self.rootShared.onError, err, {
+								kind: "effect",
+								controllerPath: self.path
+							});
+						}
+					}
+				});
+			},
+			onSuspend(fn) {
+				self.entries.push({
+					kind: "onSuspend",
+					fn: () => {
+						try {
+							fn();
+						} catch (err) {
+							dispatchError(self.rootShared.onError, err, {
+								kind: "effect",
+								controllerPath: self.path
+							});
+						}
+					}
+				});
+			},
+			onResume(fn) {
+				self.entries.push({
+					kind: "onResume",
+					fn: () => {
+						try {
+							fn();
+						} catch (err) {
+							dispatchError(self.rootShared.onError, err, {
+								kind: "effect",
+								controllerPath: self.path
+							});
+						}
+					}
+				});
+			}
+		};
+	}
+	isTerminal() {
+		return this.state === "disposed";
+	}
+	makeChildSegment(factory, explicitName) {
+		const idx = this.childCounter++;
+		const base = explicitName ?? factory.name ?? "";
+		return `${base !== "" ? base : "anonymous"}[${idx}]`;
+	}
+};
+//#endregion
+//#region src/controller/root.ts
+const ROOT_METHODS = [
+	"dispose",
+	"suspend",
+	"resume",
+	"dehydrate",
+	"waitForIdle",
+	"__debug"
+];
+/**
+* Construct a root controller.
+*
+* Internal: this is the shared engine. The public `createRoot` (props-less)
+* and `createTestController` (props-allowing) both call through here.
+*/
+function createRootWithProps(def, props, options) {
+	const devtools = new DevtoolsEmitter();
+	const queryClient = new QueryClient({
+		onError: options.onError,
+		hydrate: options.hydrate,
+		devtools,
+		deps: options.deps,
+		refetchOnWindowFocus: options.refetchOnWindowFocus,
+		refetchOnReconnect: options.refetchOnReconnect,
+		plugins: options.plugins
+	});
+	const instance = new ControllerInstance(null, {
+		devtools,
+		onError: options.onError,
+		queryClient
+	}, "root", options.deps);
+	const api = instance.construct(getFactory(def), props);
+	if (typeof api !== "object" || api === null) return attachRootControls({ value: api }, instance, devtools, queryClient);
+	return attachRootControls(api, instance, devtools, queryClient);
+}
+function attachRootControls(api, instance, devtools, queryClient) {
+	let suspendTimer = null;
+	const dispose = () => {
+		if (suspendTimer != null) {
+			clearTimeout(suspendTimer);
+			suspendTimer = null;
+		}
+		instance.dispose();
+		queryClient.dispose();
+	};
+	const suspend = (opts) => {
+		instance.suspend();
+		if (suspendTimer != null) {
+			clearTimeout(suspendTimer);
+			suspendTimer = null;
+		}
+		const maxIdle = opts?.maxIdle;
+		if (maxIdle != null && maxIdle !== Number.POSITIVE_INFINITY) suspendTimer = setTimeout(() => {
+			suspendTimer = null;
+			dispose();
+		}, maxIdle);
+	};
+	const resume = () => {
+		if (suspendTimer != null) {
+			clearTimeout(suspendTimer);
+			suspendTimer = null;
+		}
+		instance.resume();
+	};
+	const debug = {
+		subscribe: (handler) => devtools.subscribe(handler),
+		queryEntries: () => queryClient.queryEntriesSnapshot()
+	};
+	const target = api;
+	for (const method of ROOT_METHODS) if (Object.hasOwn(target, method)) throw new Error(`[olas] Root controller api defines '${method}' which conflicts with the root controls.`);
+	Object.defineProperty(target, "dispose", {
+		value: dispose,
+		enumerable: false,
+		configurable: true
+	});
+	Object.defineProperty(target, "suspend", {
+		value: suspend,
+		enumerable: false,
+		configurable: true
+	});
+	Object.defineProperty(target, "resume", {
+		value: resume,
+		enumerable: false,
+		configurable: true
+	});
+	Object.defineProperty(target, "__debug", {
+		value: debug,
+		enumerable: false,
+		configurable: true
+	});
+	Object.defineProperty(target, "dehydrate", {
+		value: () => queryClient.dehydrate(),
+		enumerable: false,
+		configurable: true
+	});
+	Object.defineProperty(target, "waitForIdle", {
+		value: () => queryClient.waitForIdle(),
+		enumerable: false,
+		configurable: true
+	});
+	return api;
+}
+/**
+* Construct a root controller. Root factories take no props — startup config
+* goes in `deps`.
+*/
+function createRoot(def, options) {
+	return createRootWithProps(def, void 0, options);
+}
+//#endregion
+Object.defineProperty(exports, "batch", {
+	enumerable: true,
+	get: function() {
+		return batch;
+	}
+});
+Object.defineProperty(exports, "computed", {
+	enumerable: true,
+	get: function() {
+		return computed;
+	}
+});
+Object.defineProperty(exports, "createEmitter", {
+	enumerable: true,
+	get: function() {
+		return createEmitter;
+	}
+});
+Object.defineProperty(exports, "createRoot", {
+	enumerable: true,
+	get: function() {
+		return createRoot;
+	}
+});
+Object.defineProperty(exports, "createRootWithProps", {
+	enumerable: true,
+	get: function() {
+		return createRootWithProps;
+	}
+});
+Object.defineProperty(exports, "debouncedValidator", {
+	enumerable: true,
+	get: function() {
+		return debouncedValidator;
+	}
+});
+Object.defineProperty(exports, "defineController", {
+	enumerable: true,
+	get: function() {
+		return defineController;
+	}
+});
+Object.defineProperty(exports, "effect", {
+	enumerable: true,
+	get: function() {
+		return effect;
+	}
+});
+Object.defineProperty(exports, "isAbortError", {
+	enumerable: true,
+	get: function() {
+		return isAbortError;
+	}
+});
+Object.defineProperty(exports, "lookupRegisteredQuery", {
+	enumerable: true,
+	get: function() {
+		return lookupRegisteredQuery;
+	}
+});
+Object.defineProperty(exports, "registerQueryById", {
+	enumerable: true,
+	get: function() {
+		return registerQueryById;
+	}
+});
+Object.defineProperty(exports, "signal", {
+	enumerable: true,
+	get: function() {
+		return signal;
+	}
+});
+Object.defineProperty(exports, "untracked", {
+	enumerable: true,
+	get: function() {
+		return untracked;
+	}
+});
+
+//# sourceMappingURL=root-Bazp5_Ik.cjs.map