@kontsedal/olas-core 0.0.1 → 0.0.3

package/dist/{types-DSlDowpE.d.mts → types-r_TVaRkD.d.cts}

@@ -15,13 +15,27 @@ type Emitter<T> = {
   once(handler: (value: T) => void): () => void; /** Tear down the emitter. Subsequent `emit` / `on` / `once` are no-ops. */
   dispose(): void;
 };
+/**
+ * Optional escape hatch for emit-time handler throws. If supplied, a thrown
+ * handler is reported here and emission continues with the remaining handlers
+ * (spec §20.6 — one throwing handler must not block the rest). If absent,
+ * the throw is logged via `console.error`.
+ */
+type EmitterErrorReporter = (err: unknown) => void;
 /**
  * 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.
+ *
+ * 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`.
  */
-declare function createEmitter<T = void>(): Emitter<T>;
+declare function createEmitter<T = void>(options?: {
+  onError?: EmitterErrorReporter;
+}): Emitter<T>;
 //#endregion
 //#region src/errors.d.ts
 /**
@@ -129,7 +143,21 @@ type Form<S extends FormSchema> = {
   readonly isValid: ReadSignal<boolean>;
   readonly isDirty: ReadSignal<boolean>;
   readonly touched: ReadSignal<boolean>;
-  readonly isValidating: ReadSignal<boolean>; /** Deep-merge a partial value into the form, batched. */
+  readonly isValidating: ReadSignal<boolean>;
+  /**
+   * `true` while a `submit(...)` is in flight. Clears when the handler
+   * resolves, throws, or pre-submit validation fails.
+   */
+  readonly isSubmitting: ReadSignal<boolean>; /** Number of times `submit(...)` has been called. Bumps before the handler runs. */
+  readonly submitCount: ReadSignal<number>;
+  /**
+   * The thrown value from the most recent failed submission, if any.
+   * Cleared at the start of each new `submit(...)` call and on `reset()`.
+   * Note that a validation failure ("submit blocked because the form is
+   * invalid") is NOT a thrown error — `submitError` stays whatever it
+   * was, and the returned promise resolves with `{ ok: false }`.
+   */
+  readonly submitError: ReadSignal<unknown>; /** Deep-merge a partial value into the form, batched. */
   set(partial: DeepPartial<FormValue<S>>): void;
   /**
    * Re-seat the form's leaves from `partial` as their new initials —
@@ -140,7 +168,29 @@ type Form<S extends FormSchema> = {
   resetWithInitial(partial: DeepPartial<FormValue<S>>): void; /** Reset every leaf to its initial value. */
   reset(): void; /** Mark every leaf as touched (so error messages appear). */
   markAllTouched(): void; /** Re-run every leaf's validators. Resolves with true if all leaves are valid. */
-  validate(): Promise<boolean>; /** Idempotent. Called by the owning controller's dispose. */
+  validate(): Promise<boolean>;
+  /**
+   * Run a submission. Pre-validates the form (unless `validateBeforeSubmit: false`),
+   * then calls `handler(value)`. Maintains `isSubmitting` / `submitCount` /
+   * `submitError`. Returns `{ ok, data?, error? }` — see `FormImpl.submit`
+   * for the full contract.
+   */
+  submit(handler: (value: FormValue<S>) => unknown | Promise<unknown>, options?: {
+    validateBeforeSubmit?: boolean;
+    resetOnSuccess?: boolean;
+    onError?: 'rethrow' | 'capture';
+  }): Promise<{
+    ok: boolean;
+    data?: unknown;
+    error?: unknown;
+  }>;
+  /**
+   * Pin externally-sourced errors on specific fields. Keys are dot-separated
+   * paths through nested forms / field arrays (numeric segments are array
+   * indices). Errors land in each field's `serverErrors` channel — kept
+   * separate from validator output and auto-cleared on the next user write.
+   */
+  setErrors(errors: Record<string, ReadonlyArray<string>>): void; /** Idempotent. Called by the owning controller's dispose. */
   dispose(): void;
 };
 /**
@@ -310,8 +360,12 @@ type Query<Args extends unknown[], T> = {
 type QuerySubscription<T> = AsyncState<T>;
 /**
  * Options passed to `ctx.use(query, opts)` to control the subscription
- * (reactive key, enabled-gating). The `key` thunk reads signals — re-evaluating
- * when they change re-keys the subscription.
+ * (reactive key, enabled-gating). The `key` thunk reads signals —
+ * re-evaluating when they change re-keys the subscription.
+ *
+ * A `select` projection that maps the underlying data shape to a view
+ * shape is accepted via a dedicated overload on `Ctx.use` rather than this
+ * options bag — the overload threads `T → U` types through cleanly.
  */
 type UseOptions<Args extends readonly unknown[]> = {
   key?: () => Args;
@@ -754,6 +808,10 @@ interface AmbientDeps {
  * `ctx.field(initial, validators?)`. Spec §8, §20.7.
  */
 type Field<T> = ReadSignal<T> & {
+  /**
+   * All errors currently surfaced on this field — validator errors first,
+   * server errors after. See `setErrors` for the server-error channel.
+   */
   errors: ReadSignal<string[]>;
   isValid: ReadSignal<boolean>;
   isDirty: ReadSignal<boolean>;
@@ -770,7 +828,16 @@ type Field<T> = ReadSignal<T> & {
   setAsInitial(value: T): void;
   reset(): void;
   markTouched(): void;
-  revalidate(): Promise<boolean>; /** Idempotent. Called by the owning controller's dispose. */
+  revalidate(): Promise<boolean>;
+  /**
+   * Pin externally-sourced errors on the field — typically server-side
+   * validation results returned from a failed submit. These errors live in
+   * a separate channel from validator output, so a re-run of local
+   * validators (triggered by a new value or `revalidate()`) does NOT clear
+   * them. They're cleared automatically the next time the user writes to
+   * the field (via `set`), or explicitly via `setErrors([])` / `reset()`.
+   */
+  setErrors(errors: ReadonlyArray<string>): void; /** Idempotent. Called by the owning controller's dispose. */
   dispose(): void;
 };
 /**
@@ -789,6 +856,76 @@ type ControllerDef<Props, Api> = {
 type CtrlProps<C> = C extends ControllerDef<infer P, unknown> ? P : never;
 /** Extract a controller's Api type. */
 type CtrlApi<C> = C extends ControllerDef<unknown, infer A> ? A : never;
+/**
+ * The reactive surface returned by `ctx.collection(...)`. `items` is the
+ * canonical ordered view (source-order, with any construction-failed items
+ * filtered out); `size` mirrors `items.length`; `get` / `has` are
+ * imperative key lookups. SPEC §11.1.
+ */
+type Collection<K, Api> = {
+  readonly items: ReadSignal<ReadonlyArray<{
+    readonly key: K;
+    readonly api: Api;
+  }>>;
+  readonly size: ReadSignal<number>;
+  get(key: K): Api | undefined;
+  has(key: K): boolean;
+};
+/**
+ * Homogeneous form of `ctx.collection`: one controller def for every item,
+ * with `propsOf` projecting each item to the controller's `Props`. Construct
+ * happens once per new key — `propsOf` is **not** re-applied for unchanged
+ * keys.
+ */
+type CollectionHomogeneousOptions<Item, K, Props, Api, TDeps = AmbientDeps> = {
+  readonly source: ReadSignal<readonly Item[]>;
+  readonly keyOf: (item: Item) => K;
+  readonly controller: ControllerDef<Props, Api>;
+  readonly propsOf: (item: Item) => Props;
+  readonly factory?: never;
+  readonly propsFor?: never;
+  readonly deps?: Partial<TDeps>;
+};
+/**
+ * Heterogeneous form of `ctx.collection`: a single `factory` decides per-item
+ * which controller + props to construct. When a key's factory result picks a
+ * *different* controller than last time, the existing child is disposed and
+ * the new one constructed (type-discriminant rebuild).
+ *
+ * `R` is the factory's *return type* (typically inferred as the union of the
+ * branches' `{ controller, props }` shapes). `Api` is then projected out as
+ * the union of every branch's controller Api via `CollectionFactoryApi<R>` —
+ * unlike a single `Api` generic, the union doesn't collapse to the first
+ * branch.
+ */
+type CollectionFactoryOptions<Item, K, R, TDeps = AmbientDeps> = {
+  readonly source: ReadSignal<readonly Item[]>;
+  readonly keyOf: (item: Item) => K;
+  readonly controller?: never;
+  readonly propsOf?: never;
+  readonly factory: (item: Item) => R;
+  readonly deps?: Partial<TDeps>;
+};
+/** Constraint for the factory form's return shape. */
+type CollectionFactoryResult = {
+  controller: ControllerDef<any, any>;
+  props: any;
+};
+/** Extract the union of every branch's controller Api. Distributes over R. */
+type CollectionFactoryApi<R> = R extends {
+  controller: ControllerDef<any, infer A>;
+} ? A : never;
+/**
+ * Handle returned by `ctx.lazyChild(...)`. `status` walks `idle → loading →
+ * (ready | error)`; `api` becomes defined once `status === 'ready'`. SPEC §16.5.
+ */
+type LazyChild<Api> = {
+  readonly status: ReadSignal<'idle' | 'loading' | 'ready' | 'error'>;
+  readonly api: ReadSignal<Api | undefined>;
+  readonly error: ReadSignal<unknown | undefined>;
+  load(): Promise<Api>;
+  dispose(): void;
+};
 /**
  * `ctx` is the lifecycle-bound surface every controller factory receives.
  * Every primitive constructed through `ctx` is owned by the controller and
@@ -806,6 +943,11 @@ type Ctx<TDeps = AmbientDeps> = {
   }): LocalCache<T>;
   use<Args extends unknown[], T>(source: Query<Args, T>, keyOrOptions?: (() => Args) | UseOptions<Args>): QuerySubscription<T>;
   use<Args extends unknown[], TPage, TItem>(source: InfiniteQuery<Args, TPage, TItem>, keyOrOptions?: (() => Args) | UseOptions<Args>): InfiniteQuerySubscription<TPage, TItem>;
+  use<Args extends unknown[], T, U>(source: Query<Args, T>, options: {
+    key?: () => Args;
+    enabled?: () => boolean;
+    select: (data: T) => U;
+  }): QuerySubscription<U>;
   mutation<V, R>(spec: MutationSpec<V, R>): Mutation<V, R>;
   emitter<T = void>(): Emitter<T>;
   field<T>(initial: T, validators?: ReadonlyArray<Validator<T>>): Field<T>;
@@ -840,6 +982,52 @@ type Ctx<TDeps = AmbientDeps> = {
     suspend: () => void;
     resume: () => void;
   };
+  /**
+   * Ephemeral child controller bound to either (a) the explicit `dispose()`
+   * call returned in the tuple, or (b) the parent's disposal — whichever
+   * comes first. Same lifecycle semantics as `ctx.attach` minus suspend /
+   * resume (sessions are short-lived, not pause-able). Returns a `[api,
+   * dispose]` tuple so the api shape is exactly the controller's return
+   * type, with no wrapper to unpack.
+   *
+   * Use cases: modal forms, inline edit sessions, wizards, command palette.
+   * SPEC §11.1.
+   */
+  session<Props, Api>(def: ControllerDef<Props, Api>, props: Props, options?: {
+    deps?: Partial<TDeps>;
+  }): readonly [api: Api, dispose: () => void];
+  /**
+   * Diff-by-key set of child controllers driven by a reactive `source`.
+   * On every change to `source`, the collection:
+   *   - **new keys** → construct a child via `controller` + `propsOf(item)`
+   *     (or `factory(item)` for the heterogeneous form);
+   *   - **removed keys** → dispose that child;
+   *   - **unchanged keys** → leave it alone (`propsOf` is NOT re-applied).
+   *
+   * For per-item type-discriminated children, use the `factory` form —
+   * type changes for an existing key dispose and reconstruct.
+   *
+   * Construction errors (factory or controller throw) are routed to
+   * `onError` with `kind: 'construction'` and the item is **skipped** —
+   * the collection's surface shows one fewer entry. The diff loop does
+   * not re-throw. SPEC §11.1, §12.1.6.
+   */
+  collection<Item, K, Props, Api>(options: CollectionHomogeneousOptions<Item, K, Props, Api, TDeps>): Collection<K, Api>;
+  collection<Item, K, R extends CollectionFactoryResult>(options: CollectionFactoryOptions<Item, K, R, TDeps>): Collection<K, CollectionFactoryApi<R>>;
+  /**
+   * Code-split child controller. The loader is invoked on `load()`
+   * (idempotent), then the controller is constructed with the supplied
+   * `props`. `status` / `api` / `error` are reactive signals; subscribe
+   * via `use(child.api)` in your view layer.
+   *
+   * Parent disposal disposes the loaded child (if any) and flags any
+   * in-flight load so its eventual settle is dropped on the floor.
+   * Construction or import failures route through `onError` with
+   * `kind: 'construction'`. SPEC §16.5.
+   */
+  lazyChild<Props, Api>(loader: () => Promise<ControllerDef<Props, Api>>, props: Props, options?: {
+    deps?: Partial<TDeps>;
+  }): LazyChild<Api>;
   effect(fn: () => void | (() => void)): void;
   on<T>(emitter: Emitter<T>, handler: (value: T) => void): void;
   provide<T>(scope: Scope<T>, value: T): void;
@@ -884,5 +1072,5 @@ type Root<Api> = Api & {
   readonly __debug: DebugBus;
 };
 //#endregion
-export { Validator as $, DehydratedEntry as A, DeepPartial as B, DebugCacheEntry as C, InfiniteQuerySubscription as D, InfiniteQuerySpec as E, QuerySubscription as F, FieldArrayValue as G, FieldArrayItemErrors as H, RetryDelay as I, FormOptions as J, Form as K, RetryPolicy as L, LocalCache as M, Query as N, AsyncState as O, QuerySpec as P, ItemInitial as Q, Snapshot as R, DebugBus as S, InfiniteQuery as T, FieldArrayOptions as U, FieldArray as V, FieldArrayValidator as W, FormValidator as X, FormSchema as Y, FormValue as Z, SetDataEvent as _, Ctx as a, createEmitter as at, MutationConcurrency as b, RootOptions as c, defineScope as d, Computed as et, GcEvent as f, RegisteredQuery as g, QueryClientPluginApi as h, CtrlProps as i, Emitter as it, DehydratedState as j, AsyncStatus as k, Scope as l, QueryClientPlugin as m, ControllerDef as n, Signal as nt, Field as o, InvalidateEvent as p, FormErrors as q, CtrlApi as r, ErrorContext as rt, Root as s, AmbientDeps as t, ReadSignal as tt, ScopeOptions as u, lookupRegisteredQuery as v, DebugEvent as w, MutationSpec as x, Mutation as y, UseOptions as z };
-//# sourceMappingURL=types-DSlDowpE.d.mts.map
+export { FormErrors as $, DebugEvent as A, QuerySpec as B, SetDataEvent as C, MutationSpec as D, MutationConcurrency as E, AsyncStatus as F, UseOptions as G, RetryDelay as H, DehydratedEntry as I, FieldArrayItemErrors as J, DeepPartial as K, DehydratedState as L, InfiniteQuerySpec as M, InfiniteQuerySubscription as N, DebugBus as O, AsyncState as P, Form as Q, LocalCache as R, RegisteredQuery as S, Mutation as T, RetryPolicy as U, QuerySubscription as V, Snapshot as W, FieldArrayValidator as X, FieldArrayOptions as Y, FieldArrayValue as Z, defineScope as _, CollectionFactoryResult as a, Validator as at, QueryClientPlugin as b, CtrlApi as c, Signal as ct, Field as d, EmitterErrorReporter as dt, FormOptions as et, LazyChild as f, createEmitter as ft, ScopeOptions as g, Scope as h, CollectionFactoryOptions as i, ItemInitial as it, InfiniteQuery as j, DebugCacheEntry as k, CtrlProps as l, ErrorContext as lt, RootOptions as m, Collection as n, FormValidator as nt, CollectionHomogeneousOptions as o, Computed as ot, Root as p, FieldArray as q, CollectionFactoryApi as r, FormValue as rt, ControllerDef as s, ReadSignal as st, AmbientDeps as t, FormSchema as tt, Ctx as u, Emitter as ut, GcEvent as v, lookupRegisteredQuery as w, QueryClientPluginApi as x, InvalidateEvent as y, Query as z };
+//# sourceMappingURL=types-r_TVaRkD.d.cts.map

package/dist/types-r_TVaRkD.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-r_TVaRkD.d.cts","names":[],"sources":["../src/emitter.ts","../src/errors.ts","../src/signals/types.ts","../src/forms/types.ts","../src/forms/form-types.ts","../src/query/types.ts","../src/query/infinite.ts","../src/devtools.ts","../src/query/mutation.ts","../src/query/plugin.ts","../src/scope.ts","../src/controller/types.ts"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kontsedal/olas-core",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Olas core — controller-tree state management with signals, queries, mutations, and forms. Framework-agnostic.",
   "keywords": [
     "olas",

package/src/controller/index.ts

@@ -2,11 +2,17 @@ export { defineController } from './define'
 export { createRoot, createRootWithProps } from './root'
 export type {
   AmbientDeps,
+  Collection,
+  CollectionFactoryApi,
+  CollectionFactoryOptions,
+  CollectionFactoryResult,
+  CollectionHomogeneousOptions,
   ControllerDef,
   CtrlApi,
   CtrlProps,
   Ctx,
   Field,
+  LazyChild,
   Root,
   RootOptions,
 } from './types'

package/src/controller/instance.ts

@@ -24,9 +24,19 @@ import { createMutation, type Mutation, type MutationSpec } from '../query/mutat
 import type { LocalCache, Query } from '../query/types'
 import { createInfiniteUse, createUse } from '../query/use'
 import type { Scope } from '../scope'
-import { effect as standaloneEffect } from '../signals'
+import { computed, signal, effect as standaloneEffect } from '../signals'
 import { getFactory, getName } from './define'
-import type { ControllerDef, Ctx, Field } from './types'
+import type {
+  Collection,
+  CollectionFactoryApi,
+  CollectionFactoryOptions,
+  CollectionFactoryResult,
+  CollectionHomogeneousOptions,
+  ControllerDef,
+  Ctx,
+  Field,
+  LazyChild,
+} from './types'
 
 export type RootShared = {
   readonly devtools: DevtoolsEmitter
@@ -342,7 +352,17 @@ export class ControllerInstance {
       },
 
       emitter<T>(): Emitter<T> {
-        const e = createEmitter<T>()
+        const e = createEmitter<T>({
+          // Spec §20.6: emit-time handler throws must not block sibling
+          // handlers. Route to the root's onError with kind: 'emitter' and
+          // this controller's path.
+          onError: (err) => {
+            dispatchError(self.rootShared.onError, err, {
+              kind: 'emitter',
+              controllerPath: self.path,
+            })
+          },
+        })
         self.entries.push({ kind: 'cleanup', dispose: () => e.dispose() })
         return e
       },
@@ -535,6 +555,300 @@ export class ControllerInstance {
         }
       },
 
+      session<Props, Api>(
+        def: ControllerDef<Props, Api>,
+        props: Props,
+        options?: { deps?: Partial<Record<string, unknown>> },
+      ): readonly [Api, () => void] {
+        const segment = self.makeChildSegment(getFactory(def), getName(def))
+        const override = options?.deps
+        const childDeps = override !== undefined ? { ...self.deps, ...override } : self.deps
+        const childInstance = new ControllerInstance(self, self.rootShared, segment, childDeps)
+        const api = childInstance.construct(getFactory(def), props)
+        const entry: LifecycleEntry = { kind: 'child', instance: childInstance }
+        self.entries.push(entry)
+        let disposed = false
+        const dispose = (): void => {
+          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] as const
+      },
+
+      collection<Item, K, Props, Api, R extends CollectionFactoryResult>(
+        options:
+          | CollectionHomogeneousOptions<Item, K, Props, Api>
+          | CollectionFactoryOptions<Item, K, R>,
+      ): Collection<K, Api> | Collection<K, CollectionFactoryApi<R>> {
+        type ChildInfo = {
+          instance: ControllerInstance
+          api: Api
+          entry: LifecycleEntry
+          // For factory form: the controller def used to construct this child.
+          // A different def on a future render means "rebuild with new type".
+          def: ControllerDef<unknown, unknown>
+        }
+        const childMap = new Map<K, ChildInfo>()
+        const items$ = signal<ReadonlyArray<{ key: K; api: Api }>>([])
+        const size$ = computed(() => items$.value.length)
+
+        const isFactoryForm =
+          (options as CollectionFactoryOptions<Item, K, R>).factory !== undefined
+
+        const buildChild = (
+          item: Item,
+        ): {
+          instance: ControllerInstance
+          api: Api
+          def: ControllerDef<unknown, unknown>
+        } | null => {
+          let def: ControllerDef<unknown, unknown>
+          let childProps: unknown
+          if (isFactoryForm) {
+            const factoryOpts = options as CollectionFactoryOptions<Item, K, R>
+            const result = factoryOpts.factory(item) as CollectionFactoryResult
+            def = result.controller as ControllerDef<unknown, unknown>
+            childProps = result.props
+          } else {
+            const homoOpts = options as CollectionHomogeneousOptions<Item, K, Props, Api>
+            def = homoOpts.controller as unknown as ControllerDef<unknown, unknown>
+            childProps = homoOpts.propsOf(item)
+          }
+          const segment = self.makeChildSegment(getFactory(def), getName(def))
+          const childDeps =
+            options.deps !== undefined ? { ...self.deps, ...options.deps } : self.deps
+          const instance = new ControllerInstance(self, self.rootShared, segment, childDeps)
+          try {
+            const api = instance.construct(
+              getFactory(def) as (ctx: Ctx, props: unknown) => Api,
+              childProps,
+            )
+            return { instance, api, def }
+          } catch (err) {
+            // SPEC §12.1.6: runtime construction errors in collection items
+            // route to onError; the bad item is skipped.
+            dispatchError(self.rootShared.onError, err, {
+              kind: 'construction',
+              controllerPath: self.path,
+            })
+            return null
+          }
+        }
+
+        const removeKey = (key: K): void => {
+          const info = childMap.get(key)
+          if (info === undefined) 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 = (): void => {
+          const source = options.source.value
+          const itemByKey = new Map<K, Item>()
+          for (const item of source) {
+            const key = options.keyOf(item)
+            if (!itemByKey.has(key)) itemByKey.set(key, item)
+          }
+
+          // Drop removed keys.
+          for (const key of [...childMap.keys()]) {
+            if (!itemByKey.has(key)) removeKey(key)
+          }
+
+          // Add new keys + rebuild factory-form type changes.
+          for (const [key, item] of itemByKey) {
+            const existing = childMap.get(key)
+            if (existing !== undefined) {
+              if (isFactoryForm) {
+                const result = (options as CollectionFactoryOptions<Item, K, R>).factory(
+                  item,
+                ) as CollectionFactoryResult
+                if ((result.controller as unknown) !== existing.def) {
+                  removeKey(key)
+                  const built = buildChild(item)
+                  if (built !== null) {
+                    const entry: LifecycleEntry = { kind: 'child', instance: built.instance }
+                    self.entries.push(entry)
+                    childMap.set(key, { ...built, entry })
+                  }
+                }
+              }
+              continue
+            }
+            const built = buildChild(item)
+            if (built !== null) {
+              const entry: LifecycleEntry = { kind: 'child', instance: built.instance }
+              self.entries.push(entry)
+              childMap.set(key, { ...built, entry })
+            }
+          }
+
+          // Project to items signal in source order, deduped, skipping failures.
+          const next: Array<{ key: K; api: Api }> = []
+          const seen = new Set<K>()
+          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 !== undefined) next.push({ key, api: info.api })
+          }
+          items$.set(next)
+        }
+
+        // Register the diff loop as an 'effect' entry so it pauses on suspend
+        // and re-runs on resume — mirrors how `ctx.effect` is wired.
+        const wrapped = (): void => {
+          try {
+            reconcile()
+          } catch (err) {
+            dispatchError(self.rootShared.onError, err, {
+              kind: 'effect',
+              controllerPath: self.path,
+            })
+          }
+        }
+        const effectEntry: LifecycleEntry = {
+          kind: 'effect',
+          factory: wrapped,
+          dispose: null,
+        }
+        if (self.state !== 'suspended') {
+          effectEntry.dispose = standaloneEffect(wrapped)
+        }
+        self.entries.push(effectEntry)
+
+        return {
+          items: items$,
+          size: size$,
+          get: (key: K) => childMap.get(key)?.api,
+          has: (key: K) => childMap.has(key),
+        }
+      },
+
+      lazyChild<Props, Api>(
+        loader: () => Promise<ControllerDef<Props, Api>>,
+        props: Props,
+        options?: { deps?: Partial<Record<string, unknown>> },
+      ): LazyChild<Api> {
+        const status$ = signal<'idle' | 'loading' | 'ready' | 'error'>('idle')
+        const api$ = signal<Api | undefined>(undefined)
+        const error$ = signal<unknown | undefined>(undefined)
+
+        let childInstance: ControllerInstance | null = null
+        let childEntry: LifecycleEntry | null = null
+        let pendingLoad: Promise<Api> | null = null
+        let disposed = false
+
+        // Parent dispose flag; the child entry (when present) is disposed
+        // via the parent's normal cascade, so we don't double-tear-down.
+        const flagEntry: LifecycleEntry = {
+          kind: 'onDispose',
+          fn: () => {
+            disposed = true
+          },
+        }
+        self.entries.push(flagEntry)
+
+        const handleFailure = (err: unknown): void => {
+          status$.set('error')
+          error$.set(err)
+          dispatchError(self.rootShared.onError, err, {
+            kind: 'construction',
+            controllerPath: self.path,
+          })
+        }
+
+        const load = (): Promise<Api> => {
+          if (disposed) {
+            return Promise.reject(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 !== undefined ? { ...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 = (): void => {
+          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
+          }
+          // Splice the parent-dispose flag entry too — its only job was to
+          // signal disposal to an in-flight loader, and `disposed` is now
+          // already true. Leaving it behind leaks one closure per ever-
+          // disposed lazyChild for the parent's remaining lifetime.
+          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',