synstate 6.1.0 → 6.2.1

package/dist/utils/create-state.mjs

@@ -1,12 +1,4 @@
-import { createReducer } from './create-reducer.mjs';
-const reducer = (state, action) => {
-    switch (action.type) {
-        case 'set':
-            return action.nextState;
-        case 'update':
-            return action.updateFn(state);
-    }
-};
+import { createStateSource } from './state-source.mjs';
 
 
 
@@ -134,10 +126,15 @@ const reducer = (state, action) => {
 
 
 export const createState = (initialState, options) => {
-    const [state, dispatch, { getSnapshot }] = createReducer(reducer, initialState, options);
-    const updateState = (updateFn) => dispatch({ type: 'update', updateFn });
-    const setState = (nextState) => dispatch({ type: 'set', nextState });
-    const resetState = () => dispatch({ type: 'set', nextState: initialState });
+    const { state, getSnapshot, commit } = createStateSource(initialState, options);
+
+
+    const updateState = (updateFn) => {
+        const currentState = getSnapshot();
+        return commit(currentState, updateFn(currentState));
+    };
+    const setState = (nextState) => commit(getSnapshot(), nextState);
+    const resetState = () => commit(getSnapshot(), initialState);
     return [
         state,
         setState,

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

@@ -1 +1 @@
-{"version":3,"file":"create-state.mjs","sourceRoot":"","sources":["../../src/utils/create-state.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAqB,MAAM,sBAAsB,CAAC;AAaxE,MAAM,OAAO,GAAG,CAAK,KAAQ,EAAE,MAAiB,EAAK,EAAE;IACrD,QAAQ,MAAM,CAAC,IAAI,EAAE,CAAC;QACpB,KAAK,KAAK;YACR,OAAO,MAAM,CAAC,SAAS,CAAC;QAE1B,KAAK,QAAQ;YACX,OAAO,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAClC,CAAC;AACH,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6HG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CACzB,YAAe,EACf,OAAkC,EAUlC,EAAE;IACF,MAAM,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,WAAW,EAAE,CAAC,GAAG,aAAa,CACtD,OAAO,EACP,YAAY,EACZ,OAAO,CACR,CAAC;IAEF,MAAM,WAAW,GAAG,CAAC,QAAwB,EAAK,EAAE,CAClD,QAAQ,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC,CAAC;IAEzC,MAAM,QAAQ,GAAG,CAAC,SAAY,EAAK,EAAE,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC;IAE3E,MAAM,UAAU,GAAG,GAAM,EAAE,CACzB,QAAQ,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,CAAC,CAAC;IAErD,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

@@ -0,0 +1,19 @@
+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
+ * `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.
+ *
+ * Not part of the package's API: `gen:index:src` leaves this file out of the
+ * barrel.
+ */
+export declare const createStateSource: <S>(initialState: S, options: StateOptions<S> | undefined) => Readonly<{
+    state: InitializedSourceObservable<S>;
+    getSnapshot: () => S;
+    commit: (currentState: S, reduced: S) => S;
+}>;
+//# sourceMappingURL=state-source.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"state-source.d.mts","sourceRoot":"","sources":["../../src/utils/state-source.mts"],"names":[],"mappings":"AACA,OAAO,EAAU,KAAK,2BAA2B,EAAE,MAAM,mBAAmB,CAAC;AAC7E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB,GAAI,CAAC,gBACnB,CAAC,WACN,YAAY,CAAC,CAAC,CAAC,GAAG,SAAS,KACnC,QAAQ,CAAC;IACV,KAAK,EAAE,2BAA2B,CAAC,CAAC,CAAC,CAAC;IACtC,WAAW,EAAE,MAAM,CAAC,CAAC;IACrB,MAAM,EAAE,CAAC,YAAY,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC;CAC5C,CAyBA,CAAC"}

package/dist/utils/state-source.mjs

@@ -0,0 +1,31 @@
+import { replaceEqualDeep } from 'ts-data-forge';
+import { source } from '../core/index.mjs';
+
+
+
+
+
+
+
+
+
+
+
+export const createStateSource = (initialState, options) => {
+    const state = source(initialState);
+    const getSnapshot = () => state.getSnapshot().value;
+    const equals = options?.equals ?? Object.is;
+    const keepEqualParts = options?.keepEqualParts ?? false;
+    const keepOptions = typeof keepEqualParts === 'boolean' ? undefined : keepEqualParts;
+    const commit = (currentState, reduced) => {
+        const nextState = keepEqualParts === false
+            ? reduced
+            : replaceEqualDeep(currentState, reduced, keepOptions);
+
+        return equals(currentState, nextState)
+            ? currentState
+            : state.next(nextState);
+    };
+    return { state, getSnapshot, commit };
+};
+//# sourceMappingURL=state-source.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"state-source.mjs","sourceRoot":"","sources":["../../src/utils/state-source.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,MAAM,EAAoC,MAAM,mBAAmB,CAAC;AAG7E;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAC/B,YAAe,EACf,OAAoC,EAKnC,EAAE;IACH,MAAM,KAAK,GAAG,MAAM,CAAI,YAAY,CAAC,CAAC;IAEtC,MAAM,WAAW,GAAG,GAAM,EAAE,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC;IAEvD,MAAM,MAAM,GAAG,OAAO,EAAE,MAAM,IAAI,MAAM,CAAC,EAAE,CAAC;IAE5C,MAAM,cAAc,GAAG,OAAO,EAAE,cAAc,IAAI,KAAK,CAAC;IAExD,MAAM,WAAW,GACf,OAAO,cAAc,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,cAAc,CAAC;IAEnE,MAAM,MAAM,GAAG,CAAC,YAAe,EAAE,OAAU,EAAK,EAAE;QAChD,MAAM,SAAS,GACb,cAAc,KAAK,KAAK;YACtB,CAAC,CAAC,OAAO;YACT,CAAC,CAAC,gBAAgB,CAAC,YAAY,EAAE,OAAO,EAAE,WAAW,CAAC,CAAC;QAE3D,8DAA8D;QAC9D,OAAO,MAAM,CAAC,YAAY,EAAE,SAAS,CAAC;YACpC,CAAC,CAAC,YAAY;YACd,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IAC5B,CAAC,CAAC;IAEF,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,CAAC;AACxC,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "synstate",
-  "version": "6.1.0",
+  "version": "6.2.1",
   "description": "Type-safe State Management Library for TypeScript/JavaScript",
   "repository": {
     "type": "git",
@@ -29,21 +29,21 @@
     "LICENSE"
   ],
   "dependencies": {
-    "ts-data-forge": "^14.10.0",
+    "ts-data-forge": "^14.10.2",
     "ts-std-forge": "^0.5.2",
     "ts-type-forge": "^9.2.2"
   },
   "devDependencies": {
     "@preact/signals-core": "1.14.4",
     "@reduxjs/toolkit": "2.13.0",
-    "@sumi-lang/cli": "0.1.2",
+    "@sumi-lang/cli": "0.1.5",
     "@types/react": "19.3.0",
     "@vitest/browser-playwright": "5.0.5",
     "argparse": "3.0.3",
-    "eslint-config-typed": "5.20.1",
-    "eslint-plugin-ts-data-forge": "0.10.4",
-    "eslint-plugin-ts-fortress": "1.3.9",
-    "eslint-plugin-ts-type-forge": "0.8.14",
+    "eslint-config-typed": "7.3.1",
+    "eslint-plugin-ts-data-forge": "0.10.8",
+    "eslint-plugin-ts-fortress": "1.3.12",
+    "eslint-plugin-ts-type-forge": "0.8.17",
     "jotai": "3.0.1",
     "mobx": "7.1.0",
     "playwright": "1.64.1",
@@ -53,8 +53,8 @@
     "react": "19.3.1",
     "rxjs": "7.8.2",
     "solid-js": "1.9.17",
-    "synstate-react-hooks": "6.1.0",
-    "synstate-react-hooks-compat": "6.1.0",
+    "synstate-react-hooks": "6.2.1",
+    "synstate-react-hooks-compat": "6.2.1",
     "ts-repo-utils": "10.7.1",
     "valtio": "2.3.2",
     "zustand": "5.0.15"
@@ -85,7 +85,7 @@
     "fmt": "pnpm run fix:fmt",
     "gen": "run-s gen:index gen:readme gen:jsdoc gen:sample-diffs",
     "gen:index": "run-s gen:index:src fix:fmt",
-    "gen:index:src": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../../libs/ts-repo-utils/src/cmd/gen-index-ts.mts ./src --index-ext .mts --export-ext .mjs --target-ext .mts --target-ext .tsx --exclude entry-point.mts --exclude \"core/class/**\" --exclude \"core/utils/**\"",
+    "gen:index:src": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../../libs/ts-repo-utils/src/cmd/gen-index-ts.mts ./src --index-ext .mts --export-ext .mjs --target-ext .mts --target-ext .tsx --exclude entry-point.mts --exclude \"core/class/**\" --exclude \"core/utils/**\" --exclude utils/state-source.mts",
     "gen:jsdoc": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ./scripts/cmd/embed-examples-in-jsdoc.mts",
     "gen:readme": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ./scripts/cmd/embed-examples.mts",
     "gen:sample-diffs": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ./scripts/cmd/generate-sample-diffs.mts",

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

@@ -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.
  */
@@ -204,13 +203,13 @@ export class AsyncChildObservableClass<A, const P extends NonEmptyUnknownList>
    * `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.
    */
@@ -236,8 +235,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 +265,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 +274,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 +343,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 +376,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

@@ -31,17 +31,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 +56,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 +82,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 +94,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 +120,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 +209,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>(

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

@@ -8,8 +8,8 @@ import type { RootObservable } from '../types/index.mjs';
 import { RootObservableClass } from './root-observable-class.mjs';
 
 /**
- * The tools a custom root's `init` receives: the `protected` methods a
- * subclass of `RootObservableClass` inherits.
+ * The tools a custom root's `init` receives: the `protected` methods a subclass
+ * of `RootObservableClass` inherits.
  */
 export type RootObservableTools<A> = Readonly<{
   /** Emits `nextValue` and propagates the update to all descendants. */
@@ -23,9 +23,9 @@ export type RootObservableTools<A> = Readonly<{
   complete: () => void;
 
   /**
-   * Registers a teardown (clear timers, abort requests, remove listeners, …)
-   * to run at the beginning of `complete()`, in the order registered. Called
-   * from `init`, it lets the teardown close over what `init` creates.
+   * Registers a teardown (clear timers, abort requests, remove listeners, …) to
+   * run at the beginning of `complete()`, in the order registered. Called from
+   * `init`, it lets the teardown close over what `init` creates.
    * Registered once the observable has completed — `init` may complete it
    * synchronously first — the teardown runs at once.
    */
@@ -37,13 +37,13 @@ export type RootObservableConfig<A> = Readonly<{
 }>;
 
 /**
- * Creates a root observable, for a custom creator written without a class
- * of its own.
+ * Creates a root observable, for a custom creator written without a class of
+ * its own.
  *
- * `init` runs during construction, receives the tools, and returns extra
- * public members to merge into the observable (e.g. `next` for a source,
- * `start` for a timer). It may register asynchronous callbacks that use the
- * tools, and may call `complete` synchronously.
+ * `init` runs during construction, receives the tools, and returns extra public
+ * members to merge into the observable (e.g. `next` for a source, `start` for a
+ * timer). It may register asynchronous callbacks that use the tools, and may
+ * call `complete` synchronously.
  */
 export const createRootObservable = <
   A,

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

@@ -12,12 +12,12 @@ import {
 } from './propagation-state.mjs';
 
 /**
- * The base of the observables that start updates of their own: a root, and
- * an async child (`debounce`, `switchMap`), which emits later than its
- * parents do. Its update visits, shallowest first, the nodes its value
- * reaches: each node that emits puts its children in the update's queue
- * (`propagation-state.mts`), so that each sees its parents' values of that
- * update (no glitch) and a node no value reached is not visited.
+ * The base of the observables that start updates of their own: a root, and an
+ * async child (`debounce`, `switchMap`), which emits later than its parents do.
+ * Its update visits, shallowest first, the nodes its value reaches: each node
+ * that emits puts its children in the update's queue (`propagation-state.mts`),
+ * so that each sees its parents' values of that update (no glitch) and a node
+ * no value reached is not visited.
  */
 export class ManagerObservableClass<
   A,
@@ -26,13 +26,20 @@ export class ManagerObservableClass<
 > extends ObservableBaseClass<A, Kind, Depth> {
   /** Emits `nextValue` and propagates it to the descendants. */
   protected startUpdate(nextValue: A): void {
+    // Nothing to propagate to (a branch no `switchMap` follows, a state written
+    // before anything subscribes): the update is the value alone, and opening
+    // one would cost more than storing it.
+    if (this.setNextIfUnobserved(nextValue)) {
+      return;
+    }
+
     const updateToken = openUpdate(this.depth);
 
     beginPropagation(updateToken);
 
-    // A subscriber or projection may throw, and the depth has to come back
-    // down regardless, or every later write would warn. The exception itself
-    // is not caught: it reaches the caller of `next` as it always has.
+    // A subscriber or projection may throw, and the depth has to come back down
+    // regardless, or every later write would warn. The exception itself is not
+    // caught: it reaches the caller of `next` as it always has.
     // @sumi-expect-error exceptions/no-try
     try {
       this.setNext(nextValue, updateToken);