synstate 6.1.1 → 7.0.0

package/dist/utils/create-reducer.d.mts

@@ -87,18 +87,18 @@ export declare const createReducer: <S, A>(reducer: Reducer<S, A>, initialState:
  */
 export type StateOptions<S> = Readonly<{
     /**
-     * Whether the next state is the same as the current one. When it says so,
-     * the update is not passed on — no subscriber, and nothing derived from
-     * the state, is told of it — and the current state is kept, along with its
-     * identity: `setState` and the like return the current state rather than
-     * the next.
+     * Whether the next state is the same as the current one. When it says so, the
+     * update is not passed on — no subscriber, and nothing derived from the
+     * state, is told of it — and the current state is kept, along with its
+     * identity: `setState` and the like return the current state rather than the
+     * next.
      *
      * Decide here, where the state is held, rather than downstream with
-     * `skipIfNoChange`: an update passed on here reaches whatever reads the
-     * state directly before any operator can thin it out.
+     * `skipIfNoChange`: an update passed on here reaches whatever reads the state
+     * directly before any operator can thin it out.
      *
-     * Defaults to `Object.is`, so writing the value already held passes
-     * nothing on. Pass `() => false` to pass on every update, equal or not.
+     * Defaults to `Object.is`, so writing the value already held passes nothing
+     * on. Pass `() => false` to pass on every update, equal or not.
      *
      * @param current - The state held now
      * @param next - The state the update would set
@@ -107,8 +107,8 @@ export type StateOptions<S> = Readonly<{
     /**
      * Whether an update keeps the parts of the state it did not change. With
      * `true`, the next state is compared with the current one before it is
-     * written, and every part of it deeply equal to the same part of the
-     * current state is replaced by that part (`replaceEqualDeep` of
+     * written, and every part of it deeply equal to the same part of the current
+     * state is replaced by that part (`replaceEqualDeep` of
      * ts-data-forge): a reader of an unchanged part keeps the object it has, so
      * `map`, comparing with `Object.is`, stops there. When the whole next state is
      * deeply equal, the current state is kept and nothing is passed on, so
@@ -121,14 +121,14 @@ export type StateOptions<S> = Readonly<{
      * arrays are walked into; a `Map`, a `Set`, a `Date` or a class instance is
      * compared and kept whole.
      *
-     * Prefer this over `keepEqualParts()` downstream: keeping the parts where
-     * the state is written means no update with nothing in it is passed on at
-     * all, and nothing downstream has anything to undo.
+     * Prefer this over `keepEqualParts()` downstream: keeping the parts where the
+     * state is written means no update with nothing in it is passed on at all,
+     * and nothing downstream has anything to undo.
      *
-     * Defaults to `false`: the next state is written as given. With it on,
-     * each update compares deeply every part of the next state that is not
-     * the very object of the current one; a state whose updates already keep
-     * what they do not change, as `{ ...prev, x }` does, gains nothing from it.
+     * Defaults to `false`: the next state is written as given. With it on, each
+     * update compares deeply every part of the next state that is not the very
+     * object of the current one; a state whose updates already keep what they do
+     * not change, as `{ ...prev, x }` does, gains nothing from it.
      */
     keepEqualParts?: boolean | ReplaceEqualDeepOptions;
 }>;

package/dist/utils/create-state.d.mts

@@ -105,8 +105,8 @@ import type { StateOptions } from './create-reducer.mjs';
  *
  * assert.strictEqual(report.getSnapshot().value, held);
  *
- * // An edited title: a new report and a new array, while the summary is
- * // the one held, so `summary` is not told of it.
+ * // An edited title: a new report and a new array, while the summary is the
+ * // one held, so `summary` is not told of it.
  * setReport({
  *   summary: { open: 1 },
  *   pulls: [{ number: 1, title: 'one (edited)' }],

package/dist/utils/create-state.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"create-state.mjs","sourceRoot":"","sources":["../../src/utils/create-state.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAEvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6HG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CACzB,YAAe,EACf,OAAkC,EAUlC,EAAE;IACF,MAAM,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,GAAG,iBAAiB,CACtD,YAAY,EACZ,OAAO,CACR,CAAC;IAEF,qEAAqE;IACrE,uCAAuC;IACvC,MAAM,WAAW,GAAG,CAAC,QAAwB,EAAK,EAAE;QAClD,MAAM,YAAY,GAAG,WAAW,EAAE,CAAC;QAEnC,OAAO,MAAM,CAAC,YAAY,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC,CAAC;IACtD,CAAC,CAAC;IAEF,MAAM,QAAQ,GAAG,CAAC,SAAY,EAAK,EAAE,CAAC,MAAM,CAAC,WAAW,EAAE,EAAE,SAAS,CAAC,CAAC;IAEvE,MAAM,UAAU,GAAG,GAAM,EAAE,CAAC,MAAM,CAAC,WAAW,EAAE,EAAE,YAAY,CAAC,CAAC;IAEhE,OAAO;QACL,KAAK;QACL,QAAQ;QACR;YACE,WAAW;YACX,UAAU;YACV,WAAW;YACX,YAAY;SACb;KACO,CAAC;AACb,CAAC,CAAC"}
+{"version":3,"file":"create-state.mjs","sourceRoot":"","sources":["../../src/utils/create-state.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAEvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6HG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CACzB,YAAe,EACf,OAAkC,EAUlC,EAAE;IACF,MAAM,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,GAAG,iBAAiB,CACtD,YAAY,EACZ,OAAO,CACR,CAAC;IAEF,2EAA2E;IAC3E,iCAAiC;IACjC,MAAM,WAAW,GAAG,CAAC,QAAwB,EAAK,EAAE;QAClD,MAAM,YAAY,GAAG,WAAW,EAAE,CAAC;QAEnC,OAAO,MAAM,CAAC,YAAY,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC,CAAC;IACtD,CAAC,CAAC;IAEF,MAAM,QAAQ,GAAG,CAAC,SAAY,EAAK,EAAE,CAAC,MAAM,CAAC,WAAW,EAAE,EAAE,SAAS,CAAC,CAAC;IAEvE,MAAM,UAAU,GAAG,GAAM,EAAE,CAAC,MAAM,CAAC,WAAW,EAAE,EAAE,YAAY,CAAC,CAAC;IAEhE,OAAO;QACL,KAAK;QACL,QAAQ;QACR;YACE,WAAW;YACX,UAAU;YACV,WAAW;YACX,YAAY;SACb;KACO,CAAC;AACb,CAAC,CAAC"}

package/dist/utils/state-source.d.mts

@@ -1,9 +1,9 @@
 import { type InitializedSourceObservable } from '../core/index.mjs';
 import type { StateOptions } from './create-reducer.mjs';
 /**
- * What `createState` and `createReducer` are both built on: the source
- * holding the state, its current value, and `commit`, the one way either
- * writes it. `commit` writes `reduced` unless `equals` finds it the same as
+ * What `createState` and `createReducer` are both built on: the source holding
+ * the state, its current value, and `commit`, the one way either writes it.
+ * `commit` writes `reduced` unless `equals` finds it the same as
  * `currentState`, after keeping the parts of `currentState` it did not change
  * when `keepEqualParts` asks for that, and returns the state written, or
  * `currentState` when nothing was.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "synstate",
-  "version": "6.1.1",
+  "version": "7.0.0",
   "description": "Type-safe State Management Library for TypeScript/JavaScript",
   "repository": {
     "type": "git",
@@ -29,21 +29,22 @@
     "LICENSE"
   ],
   "dependencies": {
-    "ts-data-forge": "^14.10.0",
-    "ts-std-forge": "^0.5.2",
+    "ts-data-forge": "^14.11.0",
+    "ts-std-forge": "^0.5.3",
     "ts-type-forge": "^9.2.2"
   },
   "devDependencies": {
     "@preact/signals-core": "1.14.4",
     "@reduxjs/toolkit": "2.13.0",
-    "@sumi-lang/cli": "0.1.3",
+    "@sumi-lang/cli": "0.1.6",
     "@types/react": "19.3.0",
     "@vitest/browser-playwright": "5.0.5",
     "argparse": "3.0.3",
-    "eslint-config-typed": "7.1.0",
-    "eslint-plugin-ts-data-forge": "0.10.5",
-    "eslint-plugin-ts-fortress": "1.3.10",
-    "eslint-plugin-ts-type-forge": "0.8.15",
+    "eslint": "10.13.0",
+    "eslint-config-typed": "7.4.0",
+    "eslint-plugin-ts-data-forge": "0.10.9",
+    "eslint-plugin-ts-fortress": "1.3.13",
+    "eslint-plugin-ts-type-forge": "0.8.18",
     "jotai": "3.0.1",
     "mobx": "7.1.0",
     "playwright": "1.64.1",
@@ -53,9 +54,9 @@
     "react": "19.3.1",
     "rxjs": "7.8.2",
     "solid-js": "1.9.17",
-    "synstate-react-hooks": "6.1.1",
-    "synstate-react-hooks-compat": "6.1.1",
-    "ts-repo-utils": "10.7.1",
+    "synstate-react-hooks": "7.0.0",
+    "synstate-react-hooks-compat": "7.0.0",
+    "ts-repo-utils": "10.7.2",
     "valtio": "2.3.2",
     "zustand": "5.0.15"
   },

package/src/core/authoring.mts

@@ -1,7 +1,7 @@
 /**
- * What custom creators and operators are written with: the factories every
- * built-in observable is made by (#2117). The rest of `core/base` stays
- * internal.
+ * What custom creators and operators are written with: factories that wrap the
+ * base classes the built-in observables extend (#2117). The rest of `core/base`
+ * stays internal.
  */
 export {
   createAsyncChildObservable,

package/src/core/class/child-observable-class.mts

@@ -2,7 +2,7 @@
 // @sumi-expect-error-file banned-syntax/no-this
 // @sumi-expect-error-file functions/prefer-arrow-function
 // @sumi-expect-error-file mutation/no-mutation-without-mut-prefix
-import { hasKey, isRecord, type Optional, type Some } from 'ts-data-forge';
+import { hasKey, isRecord, Optional, type Some } from 'ts-data-forge';
 import { panic } from 'ts-std-forge';
 import type { MutableSet } from 'ts-type-forge';
 import type {
@@ -20,7 +20,7 @@ import type {
   WithInitialValueOperator,
   Wrap,
 } from '../types/index.mjs';
-import { maxDepth } from '../utils/index.mjs';
+import { issueUnqueuedToken, maxDepth } from '../utils/index.mjs';
 import { ManagerObservableClass } from './manager-observable-class.mjs';
 import { ObservableBaseClass } from './observable-base-class.mjs';
 import { toNode, type ChildNode } from './observable-node.mjs';
@@ -30,11 +30,11 @@ type ChildObservableConfig<A, P extends NonEmptyUnknownList> = Readonly<{
   parents: Wrap<P>;
 
   /**
-   * Defaults to one more than the deepest parent. An update reaches
-   * observables in ascending depth, so an observable `tryUpdate` reads with
-   * `getSnapshot` without being its child (`withCurrentValueFrom`'s second
-   * source) has to be shallower than this one too, or this one reads its value
-   * from before the update: pass `1 + Math.max(...)` over both then.
+   * Defaults to one more than the deepest parent. An update reaches observables
+   * in ascending depth, so an observable `tryUpdate` reads with `getSnapshot`
+   * without being its child (`withCurrentValueFrom`'s second source) has to be
+   * shallower than this one too, or this one reads its value from before the
+   * update: pass `1 + Math.max(...)` over both then.
    */
   depth?: number;
 
@@ -45,9 +45,9 @@ type ChildObservableConfig<A, P extends NonEmptyUnknownList> = Readonly<{
  * An observable derived from `parents` that emits, if at all, in the same
  * update as they do (`map`, `filter`, `combine`, …).
  *
- * A subclass overrides `tryUpdate`, and, when it holds something to
- * release, `teardown`; its constructor ends with `this.attach()`, once
- * everything `tryUpdate` and `teardown` read is in place.
+ * A subclass overrides `tryUpdate`, and, when it holds something to release,
+ * `teardown`; its constructor ends with `this.attach()`, once everything
+ * `tryUpdate` and `teardown` read is in place.
  */
 export class SyncChildObservableClass<A, const P extends NonEmptyUnknownList>
   extends ObservableBaseClass<A, 'sync child', number>
@@ -107,10 +107,9 @@ export class SyncChildObservableClass<A, const P extends NonEmptyUnknownList>
   }
 
   /**
-   * Whether this observable can emit nothing more although some parent is
-   * still live, asked whenever a parent completes. `true` completes it then,
-   * as all parents completing does (`zip` once a completed source's queue is
-   * empty).
+   * Whether this observable can emit nothing more although some parent is still
+   * live, asked whenever a parent completes. `true` completes it then, as all
+   * parents completing does (`zip` once a completed source's queue is empty).
    */
   // eslint-disable-next-line @typescript-eslint/class-methods-use-this
   canEmitNoMore(): boolean {
@@ -118,8 +117,8 @@ export class SyncChildObservableClass<A, const P extends NonEmptyUnknownList>
   }
 
   /**
-   * Completes this observable once the update now propagating has reached
-   * every descendant, so that they see the value just passed on first.
+   * Completes this observable once the update now propagating has reached every
+   * descendant, so that they see the value just passed on first.
    */
   protected completeAfterPropagation(): void {
     runAfterPropagation(() => {
@@ -129,8 +128,8 @@ export class SyncChildObservableClass<A, const P extends NonEmptyUnknownList>
 }
 
 /**
- * An observable derived from `parents` that may emit later, in an update of
- * its own, through `startUpdate` (`debounce`, `switchMap`). It may also emit
+ * An observable derived from `parents` that may emit later, in an update of its
+ * own, through `startUpdate` (`debounce`, `switchMap`). It may also emit
  * synchronously with `setNext`, as a sync child does. A subclass may also
  * override `flush`, to pass on at completion what it still holds.
  */
@@ -199,24 +198,66 @@ export class AsyncChildObservableClass<A, const P extends NonEmptyUnknownList>
     });
   }
 
+  /**
+   * `attach`, then projects the value `parent` holds when `switchMap` /
+   * `mergeMap` is created, as `map` and `filter` start from it; a completed
+   * parent is not projected. Nothing observes the operator yet, so a value the
+   * inner observable emits while it is subscribed is only stored: the token is
+   * one no update is queued with.
+   *
+   * If the projection throws, the operator is disposed, which disposes what the
+   * projection made and takes the operator off its parent, and the exception
+   * goes on to the caller of `pipe`.
+   */
+  protected attachProjectingHeldValue<V>(
+    parent: Observable<V>,
+    project: (value: V, updateToken: UpdateToken) => void,
+  ): void {
+    this.attach();
+
+    const sn = parent.getSnapshot();
+
+    if (this.isCompleted || Optional.isNone(sn)) {
+      return;
+    }
+
+    // A flag and `finally` rather than `catch` and rethrow: Sumi bans
+    // `try..catch`, and the exception is never caught on its way to `pipe`.
+    let mut_projected = false;
+
+    // @sumi-expect-error exceptions/no-try
+    try {
+      project(sn.value, issueUnqueuedToken());
+
+      mut_projected = true;
+    } finally {
+      if (!mut_projected) {
+        this.dispose();
+      }
+    }
+  }
+
   /**
    * Subscribes to the inner observable that the projection of `switchMap` /
    * `mergeMap` returned.
    *
    * If the inner observable already holds a value (`just(x)`, a state), it
-   * emits that value synchronously while being subscribed. That first value
-   * is emitted with `updateToken`, the token of the update that ran the
-   * projection, so it joins the propagation in progress like a sync
-   * operator's value would. Starting an update of its own instead would
-   * reach the nodes below before the current update reached this
-   * observable's siblings: a node reading both would see the new inner value
-   * beside stale sibling values (a glitch), and would emit twice.
+   * emits that value synchronously while being subscribed. That first value is
+   * emitted with `updateToken`, the token of the update that ran the
+   * projection, so it joins the propagation in progress like a sync operator's
+   * value would. Starting an update of its own instead would reach the nodes
+   * below before the current update reached this observable's siblings: a node
+   * reading both would see the new inner value beside stale sibling values (a
+   * glitch), and would emit twice.
    *
    * Values the inner observable emits later start updates of their own.
+   * `onComplete` is called when it completes, which may be while it is being
+   * subscribed, before this returns.
    */
   protected subscribeInner(
     inner: Observable<A>,
     updateToken: UpdateToken,
+    onComplete?: () => void,
   ): Subscription {
     let mut_isSubscribing = true;
 
@@ -226,7 +267,7 @@ export class AsyncChildObservableClass<A, const P extends NonEmptyUnknownList>
       } else {
         this.startUpdate(value);
       }
-    });
+    }, onComplete);
 
     mut_isSubscribing = false;
 
@@ -236,8 +277,8 @@ export class AsyncChildObservableClass<A, const P extends NonEmptyUnknownList>
 
 /**
  * A sync child that always holds a value: a subclass passes a `Some` as its
- * `initialValue`. It differs from its base only in the types of
- * `getSnapshot` and `pipe`.
+ * `initialValue`. It differs from its base only in the types of `getSnapshot`
+ * and `pipe`.
  */
 export class InitializedSyncChildObservableClass<
   A,
@@ -266,8 +307,8 @@ export class InitializedSyncChildObservableClass<
 /* helpers */
 
 /**
- * Called by a parent that has completed: whether no live parent is left, or
- * no value can come from the live ones.
+ * Called by a parent that has completed: whether no live parent is left, or no
+ * value can come from the live ones.
  */
 const shouldComplete = (
   child: ChildNode & Readonly<{ canEmitNoMore: () => boolean }>,
@@ -275,6 +316,63 @@ const shouldComplete = (
   !child.isCompleted &&
   (child.parents.every((p) => p.isCompleted) || child.canEmitNoMore());
 
+const hasCircularDependencyFrom = (
+  node: Observable<unknown>,
+  mut_visited: MutableSet<Observable<unknown>>,
+  mut_inPath: MutableSet<Observable<unknown>>,
+): boolean => {
+  if (mut_inPath.has(node)) {
+    return true;
+  }
+
+  if (mut_visited.has(node)) {
+    return false;
+  }
+
+  mut_visited.add(node);
+
+  mut_inPath.add(node);
+
+  if (node.kind !== 'root') {
+    for (const parent of node.parents) {
+      if (hasCircularDependencyFrom(parent, mut_visited, mut_inPath)) {
+        return true;
+      }
+    }
+  }
+
+  mut_inPath.delete(node);
+
+  return false;
+};
+
+/**
+ * Detects circular dependencies by walking the full ancestor chain of the
+ * child's parents and checking whether the child already appears among them.
+ *
+ * @throws {Error} if a circular dependency is detected
+ */
+const detectCircularDependency = (child: ChildNode): void => {
+  const mut_visited = new Set<Observable<unknown>>();
+
+  const mut_inPath = new Set<Observable<unknown>>([
+    // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
+    child as Observable<unknown>,
+  ]);
+
+  for (const parent of child.parents) {
+    if (hasCircularDependencyFrom(parent, mut_visited, mut_inPath)) {
+      // A programming error (invariant violation), not a recoverable failure.
+      // `panic` marks the error it throws, so the `Result` / `AsyncResult`
+      // boundaries rethrow it rather than turning an invariant violation into
+      // an `Err` a caller might handle (Sumi D-48 / D-53).
+      panic(
+        'Circular dependency detected in observable graph: a child observable cannot be its own ancestor.',
+      );
+    }
+  }
+};
+
 /** Registers a child to its parents. */
 const registerChild = (child: ChildNode): void => {
   if (checksCircularDependency) {
@@ -287,9 +385,9 @@ const registerChild = (child: ChildNode): void => {
 };
 
 /**
- * Undoes {@link registerChild} for a completed child: its parents forget it,
- * so that no update puts it in its queue again. Without this a completed
- * node stayed reachable for as long as its root lived (#2134).
+ * Undoes {@link registerChild} for a completed child: its parents forget it, so
+ * that no update puts it in its queue again. Without this a completed node
+ * stayed reachable for as long as its root lived (#2134).
  */
 const unregisterChild = (child: ChildNode): void => {
   for (const p of child.parents) {
@@ -320,60 +418,3 @@ const isDevelopmentProcess = (): boolean => {
  * bundle).
  */
 export const checksCircularDependency: boolean = isDevelopmentProcess();
-
-/**
- * Detects circular dependencies by walking the full ancestor chain of the
- * child's parents and checking whether the child already appears among them.
- *
- * @throws {Error} if a circular dependency is detected
- */
-const detectCircularDependency = (child: ChildNode): void => {
-  const mut_visited = new Set<Observable<unknown>>();
-
-  const mut_inPath = new Set<Observable<unknown>>([
-    // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
-    child as Observable<unknown>,
-  ]);
-
-  for (const parent of child.parents) {
-    if (hasCircularDependencyFrom(parent, mut_visited, mut_inPath)) {
-      // A programming error (invariant violation), not a recoverable
-      // failure. `panic` marks the error it throws, so the `Result` /
-      // `AsyncResult` boundaries rethrow it rather than turning an invariant
-      // violation into an `Err` a caller might handle (Sumi D-48 / D-53).
-      panic(
-        'Circular dependency detected in observable graph: a child observable cannot be its own ancestor.',
-      );
-    }
-  }
-};
-
-const hasCircularDependencyFrom = (
-  node: Observable<unknown>,
-  mut_visited: MutableSet<Observable<unknown>>,
-  mut_inPath: MutableSet<Observable<unknown>>,
-): boolean => {
-  if (mut_inPath.has(node)) {
-    return true;
-  }
-
-  if (mut_visited.has(node)) {
-    return false;
-  }
-
-  mut_visited.add(node);
-
-  mut_inPath.add(node);
-
-  if (node.kind !== 'root') {
-    for (const parent of node.parents) {
-      if (hasCircularDependencyFrom(parent, mut_visited, mut_inPath)) {
-        return true;
-      }
-    }
-  }
-
-  mut_inPath.delete(node);
-
-  return false;
-};

package/src/core/class/circular-dependency-comparison.test.mts

@@ -49,8 +49,8 @@ describe('circular dependency comparison', () => {
         );
 
         // Simulate a cycle: mut_childA → childB → mut_childA
-        // In normal usage this is impossible — the check runs in every
-        // child constructor before the reference becomes available.
+        // In normal usage this is impossible — the check runs in every child
+        // constructor before the reference becomes available.
         Object.defineProperty(mut_childA, 'parents', {
           value: [childB],
           writable: false,

package/src/core/class/create-child-observable.mts

@@ -2,7 +2,8 @@
 // @sumi-expect-error-file banned-syntax/no-this
 // @sumi-expect-error-file functions/prefer-arrow-function
 // @sumi-expect-error-file mutation/no-mutation-without-mut-prefix
-import { Arr, type Optional, type Some } from 'ts-data-forge';
+import type { Optional, Some } from 'ts-data-forge';
+import * as Arr from 'ts-data-forge/array';
 import { unreachable } from 'ts-std-forge';
 import type {
   AsyncChildObservable,
@@ -31,17 +32,16 @@ export type SyncChildObservableTools<A> = Readonly<{
   complete: () => void;
 
   /**
-   * Completes this observable once the update now propagating has reached
-   * every descendant, so that they see the value just passed on first.
+   * Completes this observable once the update now propagating has reached every
+   * descendant, so that they see the value just passed on first.
    */
   completeAfterPropagation: () => void;
 
   /**
    * Registers a teardown (clear timers, unsubscribe inner observables, …) to
-   * run when this observable completes or is disposed, in the order
-   * registered. Called from `init`, it lets the teardown close over what
-   * `init` creates. Registered once the observable has completed, the
-   * teardown runs at once.
+   * run when this observable completes or is disposed, in the order registered.
+   * Called from `init`, it lets the teardown close over what `init` creates.
+   * Registered once the observable has completed, the teardown runs at once.
    */
   onComplete: (teardown: () => void) => void;
 }>;
@@ -57,21 +57,20 @@ export type AsyncChildObservableTools<A> = Readonly<{
   SyncChildObservableTools<A>;
 
 /**
- * What a sync child's `init` may return instead of `tryUpdate` alone: the
- * hooks the factory calls, which read the state `init` creates.
+ * What a sync child's `init` may return instead of `tryUpdate` alone: the hooks
+ * the factory calls, which read the state `init` creates.
  */
 export type SyncChildObservableHooks = Readonly<{
   /**
-   * Called with the token of every update in which a parent of this
-   * observable emitted.
+   * Called with the token of every update in which a parent of this observable
+   * emitted.
    */
   tryUpdate: (updateToken: UpdateToken) => void;
 
   /**
-   * Whether this observable can emit nothing more although some parent is
-   * still live, asked whenever a parent completes. `true` completes it then,
-   * as all parents completing does (`zip` once a completed source's queue is
-   * empty).
+   * Whether this observable can emit nothing more although some parent is still
+   * live, asked whenever a parent completes. `true` completes it then, as all
+   * parents completing does (`zip` once a completed source's queue is empty).
    */
   canEmitNoMore?: () => boolean;
 }>;
@@ -84,8 +83,8 @@ export type SyncChildObservableHooks = Readonly<{
 export type AsyncChildObservableHooks = SyncChildObservableHooks &
   Readonly<{
     /**
-     * Run at the beginning of `complete()`, before the teardowns, and never
-     * by `dispose()`: passes on what this observable still holds through
+     * Run at the beginning of `complete()`, before the teardowns, and never by
+     * `dispose()`: passes on what this observable still holds through
      * `startUpdate`, so that its subscribers see it before they see the
      * completion. A disposed observable has no one left to tell.
      */
@@ -96,11 +95,11 @@ type ChildObservableConfigBase<P extends NonEmptyUnknownList> = Readonly<{
   parents: Wrap<P>;
 
   /**
-   * Defaults to one more than the deepest parent. An update reaches
-   * observables in ascending depth, so an observable `tryUpdate` reads with
-   * `getSnapshot` without being its child (`withCurrentValueFrom`'s second
-   * source) has to be shallower than this one too, or this one reads its value
-   * from before the update: pass `1 + Math.max(...)` over both then.
+   * Defaults to one more than the deepest parent. An update reaches observables
+   * in ascending depth, so an observable `tryUpdate` reads with `getSnapshot`
+   * without being its child (`withCurrentValueFrom`'s second source) has to be
+   * shallower than this one too, or this one reads its value from before the
+   * update: pass `1 + Math.max(...)` over both then.
    */
   depth?: number;
 }>;
@@ -122,15 +121,15 @@ export type InitializedChildObservableConfig<
   }>;
 
 /**
- * Creates a sync-child observable: one derived from `parents` that emits, if
- * at all, in the same update as they do. `map`, `filter`, `combine` and the
- * other synchronous operators are built with it.
+ * Creates a sync-child observable: one derived from `parents` that emits, if at
+ * all, in the same update as they do. `map`, `filter`, `combine` and the other
+ * synchronous operators are built with it.
  *
  * `init` runs during construction and receives the tools. It returns
  * `tryUpdate`, which is called with the token of every update in which some
- * parent of this observable emitted — a parent that did not emit in that
- * update has a different `updateToken`; to emit, call `setNext` with the
- * token received — or an object holding `tryUpdate` and the other hooks
+ * parent of this observable emitted — a parent that did not emit in that update
+ * has a different `updateToken`; to emit, call `setNext` with the token
+ * received — or an object holding `tryUpdate` and the other hooks
  * ({@link SyncChildObservableHooks}). State the hooks share can live inside
  * `init`, next to the teardown it registers with the `onComplete` tool.
  * `init` may complete the observable; it is then never registered to its
@@ -211,8 +210,8 @@ export const createInitializedSyncChildObservable = <
  * Creates an async-child observable: one derived from `parents` that may emit
  * later, in an update of its own, through `startUpdate` (`debounce`,
  * `switchMap`). It may also emit synchronously with `setNext`, as a sync child
- * does. See {@link createSyncChildObservable} for the `init` contract; an
- * async child's `init` may also return a `flush` hook
+ * does. See {@link createSyncChildObservable} for the `init` contract; an async
+ * child's `init` may also return a `flush` hook
  * ({@link AsyncChildObservableHooks}).
  */
 export const createAsyncChildObservable = <A, P extends NonEmptyUnknownList>(
@@ -302,7 +301,9 @@ class CustomAsyncChildObservableClass<
   const P extends NonEmptyUnknownList,
 > extends AsyncChildObservableClass<A, P> {
   #mut_teardowns: readonly (() => void)[] | undefined;
-  readonly #hooks: AsyncChildObservableHooks;
+  // Undefined until `init` returns, which may complete the observable first;
+  // `complete` then calls `flush` before there is a hook to call.
+  readonly #hooks: AsyncChildObservableHooks | undefined;
 
   constructor(
     config: ChildObservableConfig<A, P>,
@@ -346,15 +347,15 @@ class CustomAsyncChildObservableClass<
   }
 
   override tryUpdate(updateToken: UpdateToken): void {
-    this.#hooks.tryUpdate(updateToken);
+    this.#hooks?.tryUpdate(updateToken);
   }
 
   override canEmitNoMore(): boolean {
-    return this.#hooks.canEmitNoMore?.() === true;
+    return this.#hooks?.canEmitNoMore?.() === true;
   }
 
   protected override flush(): void {
-    this.#hooks.flush?.();
+    this.#hooks?.flush?.();
   }
 
   protected override teardown(): void {