@kontsedal/olas-core 0.0.1 → 0.0.3

package/dist/{root-BCZDC5Fv.mjs → root-Cnkb3I--.mjs}

@@ -212,14 +212,16 @@ function untracked$1(fn) {
 //#endregion
 //#region src/utils.ts
 /**
-* True iff `err` is an AbortError. Used to filter superseded latest-wins
-* mutations and aborted fetches from genuine failures.
+* True iff `err` looks like an AbortError. Matches the standard `DOMException`
+* shape thrown by `AbortController` AND any object whose `name === 'AbortError'`
+* — that covers axios / msw / user-thrown plain Errors that signal abort.
 *
-* Spec: §20.12 — checks `err instanceof DOMException && err.name === 'AbortError'`.
-* Node 17+ exposes a global DOMException, so this works server-side too.
+* Spec: §20.12. Node 17+ exposes a global DOMException, so the instanceof
+* branch works server-side; the name-based branch is the portable fallback.
 */
 function isAbortError(err) {
 	if (typeof DOMException !== "undefined" && err instanceof DOMException) return err.name === "AbortError";
+	if (err != null && typeof err === "object" && "name" in err) return err.name === "AbortError";
 	return false;
 }
 /**
@@ -246,6 +248,83 @@ function abortableSleep(ms, signal) {
 	});
 }
 //#endregion
+//#region src/query/structural-share.ts
+/**
+* Walk `prev` and `next` in parallel. Wherever a sub-tree in `next` is
+* structurally equal to the corresponding sub-tree in `prev`, return `prev`'s
+* reference for that sub-tree. Otherwise return `next`'s.
+*
+* Result: a value that is `===` to `prev` on every refetch where the payload
+* didn't actually change, and shares maximum ref-identity on partial changes.
+* Downstream `computed`s and React `useSyncExternalStore` snapshots stop
+* thrashing because reference equality holds where content equality holds.
+*
+* Bails (returns the `next` ref unchanged, no recursion) on:
+*   - Mismatched constructors / different `typeof` between `prev` and `next`
+*   - `Map`, `Set`, `Date`, `RegExp`, class instances (anything where the
+*     plain-object / array fast path isn't safe)
+*   - Functions, symbols, promises
+*
+* Handles cycles via a `WeakSet` of in-progress objects — a self-referential
+* payload that compares structurally identical against itself won't loop.
+*/
+function structuralShare(prev, next) {
+	if (Object.is(prev, next)) return prev;
+	return walk(prev, next, /* @__PURE__ */ new WeakSet());
+}
+function walk(prev, next, seen) {
+	if (Object.is(prev, next)) return prev;
+	if (prev === null || next === null) return next;
+	if (typeof prev !== "object" || typeof next !== "object") return next;
+	if (seen.has(prev) || seen.has(next)) return next;
+	if (Array.isArray(prev) && Array.isArray(next)) return walkArray(prev, next, seen);
+	if (Array.isArray(prev) !== Array.isArray(next)) return next;
+	const prevProto = Object.getPrototypeOf(prev);
+	if (prevProto !== Object.getPrototypeOf(next)) return next;
+	if (prevProto !== Object.prototype && prevProto !== null) return next;
+	return walkPlainObject(prev, next, seen);
+}
+function walkArray(prev, next, seen) {
+	if (prev.length !== next.length) {}
+	seen.add(prev);
+	seen.add(next);
+	try {
+		const out = new Array(next.length);
+		let changed = next.length !== prev.length;
+		for (let i = 0; i < next.length; i++) {
+			const shared = walk(i < prev.length ? prev[i] : void 0, next[i], seen);
+			out[i] = shared;
+			if (shared !== prev[i]) changed = true;
+		}
+		if (!changed) return prev;
+		return out;
+	} finally {
+		seen.delete(prev);
+		seen.delete(next);
+	}
+}
+function walkPlainObject(prev, next, seen) {
+	const prevKeys = Object.keys(prev);
+	const nextKeys = Object.keys(next);
+	let changed = prevKeys.length !== nextKeys.length;
+	seen.add(prev);
+	seen.add(next);
+	try {
+		const out = {};
+		for (const key of nextKeys) {
+			const shared = walk(prev[key], next[key], seen);
+			out[key] = shared;
+			if (shared !== prev[key]) changed = true;
+			else if (!(key in prev)) changed = true;
+		}
+		if (!changed) return prev;
+		return out;
+	} finally {
+		seen.delete(prev);
+		seen.delete(next);
+	}
+}
+//#endregion
 //#region src/query/entry.ts
 /**
 * One cache entry's state machine. Owns the AsyncState signals, race
@@ -352,8 +431,10 @@ var Entry = class {
 		return typeof d === "function" ? d(attempt) : d;
 	}
 	applySuccess(result) {
+		const prev = this.data.peek();
+		const shared = prev === void 0 ? result : structuralShare(prev, result);
 		batch$1(() => {
-			this.data.set(result);
+			this.data.set(shared);
 			this.error.set(void 0);
 			this.status.set("success");
 			this.isLoading.set(false);
@@ -365,8 +446,8 @@ var Entry = class {
 		try {
 			this.events.onFetchSuccess?.(Date.now() - this.fetchStartTime);
 		} catch {}
-		this.onSuccessData?.(result);
-		return result;
+		this.onSuccessData?.(shared);
+		return shared;
 	}
 	applyFailure(err) {
 		batch$1(() => {
@@ -634,8 +715,10 @@ var InfiniteEntry = class {
 		});
 		return this.runFetch(myId, abort.signal, this.initialPageParam, (page, param) => {
 			if (myId !== this.currentFetchId || this.disposed) return;
+			const prevPages = this.pages.peek();
+			const sharedPage = prevPages.length > 0 ? structuralShare(prevPages[0], page) : page;
 			batch$1(() => {
-				this.pages.set([page]);
+				this.pages.set([sharedPage]);
 				this.pageParams.set([param]);
 				this.error.set(void 0);
 				this.status.set("success");
@@ -1630,12 +1713,25 @@ function waitUntilFalse(sig) {
 //#endregion
 //#region src/emitter.ts
 var EmitterImpl = class {
+	onError;
 	handlers = /* @__PURE__ */ new Set();
 	disposed = false;
+	constructor(onError) {
+		this.onError = onError;
+	}
 	emit(value) {
 		if (this.disposed) return;
 		const snapshot = Array.from(this.handlers);
-		for (const handler of snapshot) handler(value);
+		for (const handler of snapshot) try {
+			handler(value);
+		} catch (err) {
+			if (this.onError) try {
+				this.onError(err);
+			} catch {
+				console.error("[olas] emitter handler threw and reporter threw:", err);
+			}
+			else console.error("[olas] emitter handler threw:", err);
+		}
 	}
 	on(handler) {
 		if (this.disposed) return () => {};
@@ -1667,9 +1763,14 @@ var EmitterImpl = class {
 * (or the emitter is disposed). Use this for emitters that live outside any
 * single controller — typically in deps. Use `ctx.emitter()` for emitters that
 * should auto-clean with a controller.
+*
+* Pass `onError` to receive emit-time handler throws (spec §20.6 — one
+* throwing handler must not block the rest of the fan-out). `ctx.emitter()`
+* wires this to the root's `onError` so deps-level emitters get isolation
+* by default when constructed via `ctx`.
 */
-function createEmitter() {
-	const impl = new EmitterImpl();
+function createEmitter(options) {
+	const impl = new EmitterImpl(options?.onError);
 	return {
 		emit: ((value) => impl.emit(value)),
 		on: (handler) => impl.on(handler),
@@ -1681,6 +1782,17 @@ function createEmitter() {
 //#region src/forms/field.ts
 var FieldImpl = class {
 	value$;
+	/**
+	* Validator-produced errors. The public `errors` getter merges this with
+	* `serverErrors$` so consumers see a single flat array. Kept separate so a
+	* re-run of validators (after a new value) doesn't clobber server errors.
+	*/
+	validatorErrors$;
+	/**
+	* Externally-injected errors — see `setErrors`. Cleared on the next user
+	* `set()`, on `reset()`, or via an explicit `setErrors([])`.
+	*/
+	serverErrors$;
 	errors$;
 	touched$;
 	dirty$;
@@ -1702,11 +1814,19 @@ var FieldImpl = class {
 		this.validators = validators;
 		this.onValidatorError = options?.onValidatorError ?? null;
 		this.value$ = signal$1(initial);
-		this.errors$ = signal$1([]);
+		this.validatorErrors$ = signal$1([]);
+		this.serverErrors$ = signal$1([]);
 		this.touched$ = signal$1(false);
 		this.dirty$ = signal$1(false);
 		this.validating$ = signal$1(false);
 		this.revalidateTrigger$ = signal$1(0);
+		this.errors$ = computed$1(() => {
+			const v = this.validatorErrors$.value;
+			const s = this.serverErrors$.value;
+			if (s.length === 0) return v;
+			if (v.length === 0) return s;
+			return [...v, ...s];
+		});
 		this.isValid$ = computed$1(() => this.errors$.value.length === 0 && !this.validating$.value);
 		if (validators.length > 0) this.validatorDispose = effect$1(() => {
 			this.runValidators();
@@ -1745,8 +1865,16 @@ var FieldImpl = class {
 	}
 	set(value) {
 		if (this.disposed) return;
-		this.value$.set(value);
-		this.dirty$.set(true);
+		batch$1(() => {
+			this.value$.set(value);
+			this.dirty$.set(true);
+			if (this.serverErrors$.peek().length > 0) this.serverErrors$.set([]);
+		});
+	}
+	setErrors(errors) {
+		if (this.disposed) return;
+		const next = errors.length === 0 ? [] : [...errors];
+		this.serverErrors$.set(next);
 	}
 	/**
 	* Reseat the field as if this value had been its constructor `initial`.
@@ -1771,7 +1899,8 @@ var FieldImpl = class {
 			this.value$.set(this.initial);
 			this.dirty$.set(false);
 			this.touched$.set(false);
-			this.errors$.set([]);
+			this.validatorErrors$.set([]);
+			this.serverErrors$.set([]);
 			this.validating$.set(false);
 		});
 	}
@@ -1837,7 +1966,7 @@ var FieldImpl = class {
 		}
 		if (syncErrors.length > 0) {
 			batch$1(() => {
-				this.errors$.set(syncErrors);
+				this.validatorErrors$.set(syncErrors);
 				this.validating$.set(false);
 			});
 			this.emitValidated(false, syncErrors);
@@ -1845,14 +1974,14 @@ var FieldImpl = class {
 		}
 		if (asyncPromises.length === 0) {
 			batch$1(() => {
-				this.errors$.set([]);
+				this.validatorErrors$.set([]);
 				this.validating$.set(false);
 			});
 			this.emitValidated(true, []);
 			return;
 		}
 		batch$1(() => {
-			this.errors$.set([]);
+			this.validatorErrors$.set([]);
 			this.validating$.set(true);
 		});
 		Promise.allSettled(asyncPromises).then((results) => {
@@ -1865,7 +1994,7 @@ var FieldImpl = class {
 				asyncErrors.push(msg);
 			}
 			batch$1(() => {
-				this.errors$.set(asyncErrors);
+				this.validatorErrors$.set(asyncErrors);
 				this.validating$.set(false);
 			});
 			this.emitValidated(asyncErrors.length === 0, asyncErrors);
@@ -1936,6 +2065,12 @@ var FormImpl = class {
 	topLevelErrors$ = signal$1([]);
 	topLevelErrors = this.topLevelErrors$;
 	topLevelValidating$ = signal$1(false);
+	isSubmitting$ = signal$1(false);
+	submitCount$ = signal$1(0);
+	submitError$ = signal$1(void 0);
+	isSubmitting = this.isSubmitting$;
+	submitCount = this.submitCount$;
+	submitError = this.submitError$;
 	validators;
 	options;
 	validatorDispose = null;
@@ -2034,8 +2169,23 @@ var FormImpl = class {
 			else child.set(val);
 			else if (isFieldArray(child)) {
 				const arr = child;
-				arr.clear();
-				for (const itemVal of val) arr.add(itemVal);
+				const newValues = val;
+				if (asInitial) {
+					arr.clear();
+					for (const itemVal of newValues) arr.add(itemVal);
+					arr.replaceInitialItems(newValues);
+				} else {
+					const current = arr.items.peek();
+					const overlap = Math.min(current.length, newValues.length);
+					for (let i = 0; i < overlap; i++) {
+						const item = current[i];
+						const v = newValues[i];
+						if (isForm(item)) item.set(v);
+						else item.set(v);
+					}
+					for (let i = current.length; i < newValues.length; i++) arr.add(newValues[i]);
+					for (let i = current.length - 1; i >= newValues.length; i--) arr.remove(i);
+				}
 			} else {
 				const f = child;
 				if (asInitial) f.setAsInitial(val);
@@ -2083,6 +2233,107 @@ var FormImpl = class {
 		});
 		return this.isValid.peek();
 	}
+	/**
+	* Run a submission against this form. Wraps `handler(value)` with:
+	* - `isSubmitting` set true while the handler is in flight.
+	* - `submitCount` incremented before the handler runs.
+	* - `submitError` set to the throw, if any.
+	* - Optional pre-submit `validate()` (default true). When invalid every
+	*   field is marked touched and the handler is skipped — the returned
+	*   promise resolves with `{ ok: false }` and `submitError` is left
+	*   untouched (validation failure is not a thrown error).
+	*
+	* The handler may return a value (synchronously or via Promise); it's
+	* captured in the resolved object's `data` field. Throws are captured
+	* unless `onError: 'rethrow'`. A `resetOnSuccess: true` option calls
+	* `reset()` after the handler resolves successfully.
+	*/
+	async submit(handler, options) {
+		if (this.disposed) return {
+			ok: false,
+			error: /* @__PURE__ */ new Error("form is disposed")
+		};
+		if (this.isSubmitting$.peek()) return {
+			ok: false,
+			error: /* @__PURE__ */ new Error("submit already in progress")
+		};
+		const validateFirst = options?.validateBeforeSubmit ?? true;
+		const onErrorMode = options?.onError ?? "capture";
+		batch$1(() => {
+			this.submitCount$.update((n) => n + 1);
+			this.submitError$.set(void 0);
+			this.isSubmitting$.set(true);
+		});
+		try {
+			if (validateFirst) {
+				if (!await this.validate()) {
+					this.markAllTouched();
+					this.isSubmitting$.set(false);
+					return { ok: false };
+				}
+			}
+			const result = await handler(this.value.peek());
+			if (options?.resetOnSuccess) this.reset();
+			this.isSubmitting$.set(false);
+			return {
+				ok: true,
+				data: result
+			};
+		} catch (err) {
+			batch$1(() => {
+				this.submitError$.set(err);
+				this.isSubmitting$.set(false);
+			});
+			if (onErrorMode === "rethrow") throw err;
+			return {
+				ok: false,
+				error: err
+			};
+		}
+	}
+	/**
+	* Pin externally-sourced errors on specific fields — typically server-side
+	* validation results from a failed submit. Paths are dot-separated and
+	* traverse nested `Form` / `FieldArray` children (numeric segments are
+	* array indices). Errors land in the field's `serverErrors` channel and
+	* clear automatically on the next user write to that field. Passing an
+	* empty array for a path clears that field's server errors immediately.
+	*/
+	setErrors(errors) {
+		if (this.disposed) return;
+		batch$1(() => {
+			for (const [path, msgs] of Object.entries(errors)) {
+				const target = this.resolvePath(path);
+				if (target === void 0) continue;
+				if (target.setErrors === void 0) continue;
+				target.setErrors(msgs);
+			}
+		});
+	}
+	resolvePath(path) {
+		if (path === "") return void 0;
+		const segments = path.split(".");
+		let cursor = this;
+		for (const seg of segments) {
+			if (cursor === void 0 || cursor === null) return void 0;
+			if (isForm(cursor)) {
+				cursor = cursor.fields[seg];
+				continue;
+			}
+			if (isFieldArray(cursor)) {
+				const idx = Number(seg);
+				if (!Number.isInteger(idx) || idx < 0) return void 0;
+				cursor = cursor.at(idx);
+				continue;
+			}
+			if (cursor === this) {
+				cursor = this.fields[seg];
+				continue;
+			}
+			return;
+		}
+		return cursor;
+	}
 	dispose() {
 		if (this.disposed) return;
 		this.disposed = true;
@@ -2283,6 +2534,15 @@ var FieldArrayImpl = class {
 		for (const item of this.items$.peek()) item.dispose?.();
 		this.items$.set([]);
 	}
+	/**
+	* Internal — used by `Form.resetWithInitial` to re-anchor the array's
+	* initial items after a parent-driven `applyPartial(..., asInitial: true)`.
+	* Without this, a subsequent `reset()` would revert to the construction-
+	* time initials rather than the most-recently-applied ones.
+	*/
+	replaceInitialItems(items) {
+		this.initialItems = [...items];
+	}
 	reset() {
 		if (this.disposed) return;
 		batch$1(() => {
@@ -2735,6 +2995,7 @@ function raceAbort(promise, signal) {
 //#region src/query/use.ts
 var SubscriptionImpl = class {
 	keepPreviousData;
+	select;
 	current$ = signal$1(null);
 	previousData$ = signal$1(void 0);
 	data;
@@ -2745,13 +3006,18 @@ var SubscriptionImpl = class {
 	isStale;
 	lastUpdatedAt;
 	hasPendingMutations;
-	constructor(keepPreviousData) {
+	constructor(keepPreviousData, select) {
 		this.keepPreviousData = keepPreviousData;
-		this.data = computed$1(() => {
+		this.select = select;
+		const rawData = computed$1(() => {
 			const curData = this.current$.value?.entry.data.value;
 			if (curData !== void 0) return curData;
 			if (keepPreviousData) return this.previousData$.value;
 		});
+		this.data = select === void 0 ? rawData : computed$1(() => {
+			const raw = rawData.value;
+			return raw === void 0 ? void 0 : select(raw);
+		});
 		this.error = computed$1(() => this.current$.value?.entry.error.value);
 		this.status = computed$1(() => this.current$.value?.entry.status.value ?? "idle");
 		this.isLoading = computed$1(() => {
@@ -2780,7 +3046,7 @@ var SubscriptionImpl = class {
 	refetch = () => {
 		const cur = this.current$.peek();
 		if (!cur) return Promise.reject(/* @__PURE__ */ new Error("[olas] no active subscription"));
-		return cur.entry.refetch();
+		return cur.entry.refetch().then((v) => this.project(v));
 	};
 	reset = () => {
 		this.current$.peek()?.entry.reset();
@@ -2788,18 +3054,26 @@ var SubscriptionImpl = class {
 	firstValue = () => {
 		const cur = this.current$.peek();
 		if (!cur) return Promise.reject(/* @__PURE__ */ new Error("[olas] no active subscription"));
-		return cur.entry.firstValue();
+		return cur.entry.firstValue().then((v) => this.project(v));
 	};
+	project(v) {
+		return this.select === void 0 ? v : this.select(v);
+	}
 };
 /**
 * Build a subscription + the effect that keeps it bound to the right entry.
 * The controller container wires the disposer into the lifecycle.
+*
+* `keyOrOptions` may carry an optional `select` projection that maps the
+* underlying `T` to a view `U`; the returned subscription's data shape
+* widens accordingly. Without `select`, `U = T` and the projection
+* computed is skipped.
 */
 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);
+	const sub = new SubscriptionImpl(keepPreviousData, typeof keyOrOptions === "object" && keyOrOptions !== null ? keyOrOptions.select : void 0);
 	let currentEntry = null;
 	let suspended = false;
 	const effectDispose = effect$1(() => {
@@ -3228,7 +3502,12 @@ var ControllerInstance = class ControllerInstance {
 				return m;
 			},
 			emitter() {
-				const e = createEmitter();
+				const e = createEmitter({ onError: (err) => {
+					dispatchError(self.rootShared.onError, err, {
+						kind: "emitter",
+						controllerPath: self.path
+					});
+				} });
 				self.entries.push({
 					kind: "cleanup",
 					dispose: () => e.dispose()
@@ -3395,6 +3674,255 @@ var ControllerInstance = class ControllerInstance {
 					}
 				};
 			},
+			session(def, props, options) {
+				const segment = self.makeChildSegment(getFactory(def), getName(def));
+				const override = options?.deps;
+				const childDeps = override !== void 0 ? {
+					...self.deps,
+					...override
+				} : self.deps;
+				const childInstance = new ControllerInstance(self, self.rootShared, segment, childDeps);
+				const api = childInstance.construct(getFactory(def), props);
+				const entry = {
+					kind: "child",
+					instance: childInstance
+				};
+				self.entries.push(entry);
+				let disposed = false;
+				const dispose = () => {
+					if (disposed) return;
+					disposed = true;
+					const idx = self.entries.indexOf(entry);
+					if (idx >= 0) self.entries.splice(idx, 1);
+					try {
+						childInstance.dispose();
+					} catch (err) {
+						dispatchError(self.rootShared.onError, err, {
+							kind: "effect",
+							controllerPath: self.path
+						});
+					}
+				};
+				return [api, dispose];
+			},
+			collection(options) {
+				const childMap = /* @__PURE__ */ new Map();
+				const items$ = signal$1([]);
+				const size$ = computed$1(() => items$.value.length);
+				const isFactoryForm = options.factory !== void 0;
+				const buildChild = (item) => {
+					let def;
+					let childProps;
+					if (isFactoryForm) {
+						const result = options.factory(item);
+						def = result.controller;
+						childProps = result.props;
+					} else {
+						const homoOpts = options;
+						def = homoOpts.controller;
+						childProps = homoOpts.propsOf(item);
+					}
+					const segment = self.makeChildSegment(getFactory(def), getName(def));
+					const childDeps = options.deps !== void 0 ? {
+						...self.deps,
+						...options.deps
+					} : self.deps;
+					const instance = new ControllerInstance(self, self.rootShared, segment, childDeps);
+					try {
+						return {
+							instance,
+							api: instance.construct(getFactory(def), childProps),
+							def
+						};
+					} catch (err) {
+						dispatchError(self.rootShared.onError, err, {
+							kind: "construction",
+							controllerPath: self.path
+						});
+						return null;
+					}
+				};
+				const removeKey = (key) => {
+					const info = childMap.get(key);
+					if (info === void 0) return;
+					childMap.delete(key);
+					const idx = self.entries.indexOf(info.entry);
+					if (idx >= 0) self.entries.splice(idx, 1);
+					try {
+						info.instance.dispose();
+					} catch (err) {
+						dispatchError(self.rootShared.onError, err, {
+							kind: "effect",
+							controllerPath: self.path
+						});
+					}
+				};
+				const reconcile = () => {
+					const source = options.source.value;
+					const itemByKey = /* @__PURE__ */ new Map();
+					for (const item of source) {
+						const key = options.keyOf(item);
+						if (!itemByKey.has(key)) itemByKey.set(key, item);
+					}
+					for (const key of [...childMap.keys()]) if (!itemByKey.has(key)) removeKey(key);
+					for (const [key, item] of itemByKey) {
+						const existing = childMap.get(key);
+						if (existing !== void 0) {
+							if (isFactoryForm) {
+								if (options.factory(item).controller !== existing.def) {
+									removeKey(key);
+									const built = buildChild(item);
+									if (built !== null) {
+										const entry = {
+											kind: "child",
+											instance: built.instance
+										};
+										self.entries.push(entry);
+										childMap.set(key, {
+											...built,
+											entry
+										});
+									}
+								}
+							}
+							continue;
+						}
+						const built = buildChild(item);
+						if (built !== null) {
+							const entry = {
+								kind: "child",
+								instance: built.instance
+							};
+							self.entries.push(entry);
+							childMap.set(key, {
+								...built,
+								entry
+							});
+						}
+					}
+					const next = [];
+					const seen = /* @__PURE__ */ new Set();
+					for (const item of source) {
+						const key = options.keyOf(item);
+						if (seen.has(key)) continue;
+						seen.add(key);
+						const info = childMap.get(key);
+						if (info !== void 0) next.push({
+							key,
+							api: info.api
+						});
+					}
+					items$.set(next);
+				};
+				const wrapped = () => {
+					try {
+						reconcile();
+					} catch (err) {
+						dispatchError(self.rootShared.onError, err, {
+							kind: "effect",
+							controllerPath: self.path
+						});
+					}
+				};
+				const effectEntry = {
+					kind: "effect",
+					factory: wrapped,
+					dispose: null
+				};
+				if (self.state !== "suspended") effectEntry.dispose = effect$1(wrapped);
+				self.entries.push(effectEntry);
+				return {
+					items: items$,
+					size: size$,
+					get: (key) => childMap.get(key)?.api,
+					has: (key) => childMap.has(key)
+				};
+			},
+			lazyChild(loader, props, options) {
+				const status$ = signal$1("idle");
+				const api$ = signal$1(void 0);
+				const error$ = signal$1(void 0);
+				let childInstance = null;
+				let childEntry = null;
+				let pendingLoad = null;
+				let disposed = false;
+				const flagEntry = {
+					kind: "onDispose",
+					fn: () => {
+						disposed = true;
+					}
+				};
+				self.entries.push(flagEntry);
+				const handleFailure = (err) => {
+					status$.set("error");
+					error$.set(err);
+					dispatchError(self.rootShared.onError, err, {
+						kind: "construction",
+						controllerPath: self.path
+					});
+				};
+				const load = () => {
+					if (disposed) return Promise.reject(/* @__PURE__ */ new Error("[olas] ctx.lazyChild: cannot load after dispose"));
+					if (pendingLoad !== null) return pendingLoad;
+					status$.set("loading");
+					pendingLoad = loader().then((def) => {
+						if (disposed) throw new Error("[olas] ctx.lazyChild: disposed during load");
+						const segment = self.makeChildSegment(getFactory(def), getName(def));
+						const childDeps = options?.deps !== void 0 ? {
+							...self.deps,
+							...options.deps
+						} : self.deps;
+						const instance = new ControllerInstance(self, self.rootShared, segment, childDeps);
+						try {
+							const api = instance.construct(getFactory(def), props);
+							childInstance = instance;
+							childEntry = {
+								kind: "child",
+								instance
+							};
+							self.entries.push(childEntry);
+							api$.set(api);
+							status$.set("ready");
+							return api;
+						} catch (err) {
+							handleFailure(err);
+							throw err;
+						}
+					}, (err) => {
+						if (disposed) throw err;
+						handleFailure(err);
+						throw err;
+					});
+					return pendingLoad;
+				};
+				const dispose = () => {
+					if (disposed) return;
+					disposed = true;
+					if (childEntry !== null && childInstance !== null) {
+						const idx = self.entries.indexOf(childEntry);
+						if (idx >= 0) self.entries.splice(idx, 1);
+						try {
+							childInstance.dispose();
+						} catch (err) {
+							dispatchError(self.rootShared.onError, err, {
+								kind: "effect",
+								controllerPath: self.path
+							});
+						}
+						childInstance = null;
+						childEntry = null;
+					}
+					const flagIdx = self.entries.indexOf(flagEntry);
+					if (flagIdx >= 0) self.entries.splice(flagIdx, 1);
+				};
+				return {
+					status: status$,
+					api: api$,
+					error: error$,
+					load,
+					dispose
+				};
+			},
 			onDispose(fn) {
 				self.entries.push({
 					kind: "onDispose",
@@ -3570,4 +4098,4 @@ function createRoot(def, options) {
 //#endregion
 export { lookupRegisteredQuery as a, isAbortError as c, effect$1 as d, signal$1 as f, createEmitter as i, batch$1 as l, defineController as m, createRootWithProps as n, registerQueryById as o, untracked$1 as p, debouncedValidator as r, stableHash as s, createRoot as t, computed$1 as u };
 
-//# sourceMappingURL=root-BCZDC5Fv.mjs.map
+//# sourceMappingURL=root-Cnkb3I--.mjs.map