synstate 3.2.1 → 3.4.0

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

@@ -1 +1 @@
-{"version":3,"file":"create-reducer.d.mts","sourceRoot":"","sources":["../../src/utils/create-reducer.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAU,KAAK,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,EAAE,CAAC,WACvB,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,gBACR,CAAC,YACL,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KACjC,SAAS,CACV,KAAK,EAAE,qBAAqB,CAAC,CAAC,CAAC,EAC/B,QAAQ,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,EAC1B,KAAK,EAAE,QAAQ,CAAC;IACd,WAAW,EAAE,MAAM,CAAC,CAAC;IACrB,YAAY,EAAE,CAAC,CAAC;CACjB,CAAC,CAuBH,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,QAAQ,CAAC;IACrC;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC;CAC3C,CAAC,CAAC"}
+{"version":3,"file":"create-reducer.d.mts","sourceRoot":"","sources":["../../src/utils/create-reducer.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAU,KAAK,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2EG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,EAAE,CAAC,WACvB,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,gBACR,CAAC,YACL,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KACjC,SAAS,CACV,KAAK,EAAE,qBAAqB,CAAC,CAAC,CAAC,EAC/B,QAAQ,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,EAC1B,KAAK,EAAE,QAAQ,CAAC;IACd,WAAW,EAAE,MAAM,CAAC,CAAC;IACrB,YAAY,EAAE,CAAC,CAAC;CACjB,CAAC,CAoBH,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,QAAQ,CAAC;IACrC;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC;CAC3C,CAAC,CAAC"}

package/dist/utils/create-reducer.mjs

@@ -56,6 +56,15 @@ import { source } from '../core/index.mjs';
 
 
 
+
+
+
+
+
+
+
+
+
 
 
 
@@ -72,11 +81,10 @@ export const createReducer = (reducer, initialState, options) => {
     const dispatch = (action) => {
         const currentState = state.getSnapshot().value;
         const nextState = reducer(currentState, action);
-        if (equals?.(currentState, nextState) === true) {
-            return currentState;
-        }
-        state.next(nextState);
-        return nextState;
+
+        return equals?.(currentState, nextState) === true
+            ? currentState
+            : state.next(nextState);
     };
     const getSnapshot = () => state.getSnapshot().value;
     return [state, dispatch, { getSnapshot, initialState }];

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

@@ -1 +1 @@
-{"version":3,"file":"create-reducer.mjs","sourceRoot":"","sources":["../../src/utils/create-reducer.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAA8B,MAAM,mBAAmB,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAC3B,OAAsB,EACtB,YAAe,EACf,OAAkC,EAQlC,EAAE;IACF,MAAM,KAAK,GAAG,MAAM,CAAI,YAAY,CAAC,CAAC;IAEtC,MAAM,MAAM,GAAG,OAAO,EAAE,MAAM,CAAC;IAE/B,MAAM,QAAQ,GAAG,CAAC,MAAS,EAAK,EAAE;QAChC,MAAM,YAAY,GAAG,KAAK,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC;QAE/C,MAAM,SAAS,GAAG,OAAO,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;QAEhD,IAAI,MAAM,EAAE,CAAC,YAAY,EAAE,SAAS,CAAC,KAAK,IAAI,EAAE,CAAC;YAC/C,OAAO,YAAY,CAAC;QACtB,CAAC;QAED,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAEtB,OAAO,SAAS,CAAC;IACnB,CAAC,CAAC;IAEF,MAAM,WAAW,GAAG,GAAM,EAAE,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC;IAEvD,OAAO,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,WAAW,EAAE,YAAY,EAAE,CAAU,CAAC;AACnE,CAAC,CAAC"}
+{"version":3,"file":"create-reducer.mjs","sourceRoot":"","sources":["../../src/utils/create-reducer.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAA8B,MAAM,mBAAmB,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2EG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAC3B,OAAsB,EACtB,YAAe,EACf,OAAkC,EAQlC,EAAE;IACF,MAAM,KAAK,GAAG,MAAM,CAAI,YAAY,CAAC,CAAC;IAEtC,MAAM,MAAM,GAAG,OAAO,EAAE,MAAM,CAAC;IAE/B,MAAM,QAAQ,GAAG,CAAC,MAAS,EAAK,EAAE;QAChC,MAAM,YAAY,GAAG,KAAK,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC;QAE/C,MAAM,SAAS,GAAG,OAAO,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;QAEhD,8DAA8D;QAC9D,OAAO,MAAM,EAAE,CAAC,YAAY,EAAE,SAAS,CAAC,KAAK,IAAI;YAC/C,CAAC,CAAC,YAAY;YACd,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IAC5B,CAAC,CAAC;IAEF,MAAM,WAAW,GAAG,GAAM,EAAE,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC;IAEvD,OAAO,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,WAAW,EAAE,YAAY,EAAE,CAAU,CAAC;AACnE,CAAC,CAAC"}

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

@@ -66,6 +66,13 @@ import { type StateOptions } from './create-reducer.mjs';
  *   'label:bug page:2',
  * ]);
  * ```
+ *
+ * @note Do not call `setState`, `updateState` or `resetState` from a subscriber or a projection while another
+ * update is propagating: the write propagates immediately, so subscribers can
+ * see an intermediate state, and it logs a `console.warn` (once per
+ * observable). Derive the value from its source instead —
+ * `const b$ = a$.pipe(map((a) => a * 2))` rather than
+ * `a$.subscribe((a) => { setB(a * 2); })`.
  */
 export declare const createState: <S>(initialState: S, options?: StateOptions<NoInfer<S>>) => readonly [state: InitializedObservable<S>, setState: (v: S) => S, utils: Readonly<{
     updateState: (updateFn: (prev: S) => S) => S;

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

@@ -1 +1 @@
-{"version":3,"file":"create-state.d.mts","sourceRoot":"","sources":["../../src/utils/create-state.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,EAAiB,KAAK,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAuBxE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,gBACb,CAAC,YACL,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KACjC,SAAS,CACV,KAAK,EAAE,qBAAqB,CAAC,CAAC,CAAC,EAC/B,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,EACrB,KAAK,EAAE,QAAQ,CAAC;IACd,WAAW,EAAE,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC7C,UAAU,EAAE,MAAM,CAAC,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC,CAAC;IACrB,YAAY,EAAE,CAAC,CAAC;CACjB,CAAC,CA0BH,CAAC"}
+{"version":3,"file":"create-state.d.mts","sourceRoot":"","sources":["../../src/utils/create-state.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,EAAiB,KAAK,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAuBxE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,gBACb,CAAC,YACL,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KACjC,SAAS,CACV,KAAK,EAAE,qBAAqB,CAAC,CAAC,CAAC,EAC/B,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,EACrB,KAAK,EAAE,QAAQ,CAAC;IACd,WAAW,EAAE,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC7C,UAAU,EAAE,MAAM,CAAC,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC,CAAC;IACrB,YAAY,EAAE,CAAC,CAAC;CACjB,CAAC,CA0BH,CAAC"}

package/dist/utils/create-state.mjs

@@ -66,6 +66,13 @@ const reducer = (state, action) => {
 
 
 
+
+
+
+
+
+
+
 
 
 

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;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":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "synstate",
-  "version": "3.2.1",
+  "version": "3.4.0",
   "description": "Type-safe State Management Library for TypeScript/JavaScript",
   "repository": {
     "type": "git",
@@ -39,7 +39,7 @@
     "@types/react": "19.3.0",
     "@vitest/browser-playwright": "5.0.3",
     "argparse": "3.0.2",
-    "eslint-config-typed": "5.17.4",
+    "eslint-config-typed": "5.18.0",
     "eslint-plugin-ts-data-forge": "0.8.6",
     "eslint-plugin-ts-fortress": "1.3.3",
     "eslint-plugin-ts-type-forge": "0.8.8",
@@ -51,8 +51,8 @@
     "prettier-plugin-packagejson": "3.0.2",
     "react": "19.3.0",
     "rxjs": "7.8.2",
-    "synstate-react-hooks": "3.2.1",
-    "synstate-react-hooks-compat": "3.2.1",
+    "synstate-react-hooks": "3.4.0",
+    "synstate-react-hooks-compat": "3.4.0",
     "ts-repo-utils": "10.7.1",
     "valtio": "2.3.2",
     "zustand": "5.0.15"

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

@@ -57,6 +57,14 @@ type ChildObservableConfigBase<P extends NonEmptyUnknownList> = Readonly<{
    * `override complete() { teardown(); super.complete(); }`.
    */
   onComplete?: () => 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).
+   */
+  canEmitNoMore?: () => boolean;
 }>;
 
 export type ChildObservableConfig<
@@ -91,6 +99,7 @@ export const createSyncChildObservable = <A, P extends NonEmptyUnknownList>(
     depth = 1 + maxDepth(parents),
     initialValue,
     onComplete,
+    canEmitNoMore,
   }: ChildObservableConfig<A, P>,
   createTryUpdate: (
     tools: SyncChildObservableTools<A>,
@@ -101,7 +110,10 @@ export const createSyncChildObservable = <A, P extends NonEmptyUnknownList>(
   /** Set once assembled; see {@link unregisterChild}. */
   let mut_self: ChildObservable<A> | undefined = undefined;
 
-  const complete = (): void => {
+  const autoComplete =
+    onComplete !== undefined || parents.some((p) => p.autoComplete);
+
+  const dispose = (): void => {
     // A completed node is reached again through every parent and child that
     // completes after it; running again would repeat the teardown and the
     // ancestor walk in `unregisterChild` for each of them.
@@ -116,6 +128,14 @@ export const createSyncChildObservable = <A, P extends NonEmptyUnknownList>(
     if (mut_self !== undefined) {
       unregisterChild(mut_self, parents);
     }
+  };
+
+  const complete = (): void => {
+    if (handle.isCompleted()) {
+      return;
+    }
+
+    dispose();
 
     // propagate to parents
     for (const par of parents) {
@@ -129,8 +149,10 @@ export const createSyncChildObservable = <A, P extends NonEmptyUnknownList>(
     }
 
     tryCompleteChild({
+      canEmitNoMore,
       hasSubscriber: handle.hasSubscriber(),
       hasActiveChild: handle.hasActiveChild(),
+      autoComplete,
       parents,
       complete,
     });
@@ -149,12 +171,21 @@ export const createSyncChildObservable = <A, P extends NonEmptyUnknownList>(
     tryUpdate,
     tryComplete,
     complete,
+    dispose,
+    autoComplete,
     extra: { parents },
   });
 
-  registerChild(observable, parents);
+  // Completed parents never update again, so a child created under them is
+  // complete from the start; registering it would only leave a reference in
+  // each parent (#2248).
+  if (parents.every((p) => p.isCompleted)) {
+    dispose();
+  } else {
+    registerChild(observable, parents);
 
-  mut_self = observable;
+    mut_self = observable;
+  }
 
   return observable;
 };
@@ -196,6 +227,7 @@ export const createAsyncChildObservable = <A, P extends NonEmptyUnknownList>(
     depth = 1 + maxDepth(parents),
     initialValue,
     onComplete,
+    canEmitNoMore,
   }: ChildObservableConfig<A, P>,
   createTryUpdate: (
     tools: AsyncChildObservableTools<A>,
@@ -209,7 +241,10 @@ export const createAsyncChildObservable = <A, P extends NonEmptyUnknownList>(
   /** Set once assembled; see {@link unregisterChild}. */
   let mut_self: ChildObservable<A> | undefined = undefined;
 
-  const complete = (): void => {
+  const autoComplete =
+    onComplete !== undefined || parents.some((p) => p.autoComplete);
+
+  const dispose = (): void => {
     // A completed node is reached again through every parent and child that
     // completes after it; running again would repeat the teardown and the
     // ancestor walk in `unregisterChild` for each of them.
@@ -224,6 +259,14 @@ export const createAsyncChildObservable = <A, P extends NonEmptyUnknownList>(
     if (mut_self !== undefined) {
       unregisterChild(mut_self, parents);
     }
+  };
+
+  const complete = (): void => {
+    if (handle.isCompleted()) {
+      return;
+    }
+
+    dispose();
 
     // propagate to parents
     for (const par of parents) {
@@ -237,8 +280,10 @@ export const createAsyncChildObservable = <A, P extends NonEmptyUnknownList>(
     }
 
     tryCompleteChild({
+      canEmitNoMore,
       hasSubscriber: handle.hasSubscriber(),
       hasActiveChild: handle.hasActiveChild(),
+      autoComplete,
       parents,
       complete,
     });
@@ -258,12 +303,21 @@ export const createAsyncChildObservable = <A, P extends NonEmptyUnknownList>(
     tryUpdate,
     tryComplete,
     complete,
+    dispose,
+    autoComplete,
     extra: { parents, addDescendant, deleteDescendant },
   });
 
-  registerChild(observable, parents);
+  // Completed parents never update again, so a child created under them is
+  // complete from the start; registering it would only leave a reference in
+  // each parent (#2248).
+  if (parents.every((p) => p.isCompleted)) {
+    dispose();
+  } else {
+    registerChild(observable, parents);
 
-  mut_self = observable;
+    mut_self = observable;
+  }
 
   return observable;
 };
@@ -398,25 +452,29 @@ const unregisterChild = <A,>(
 };
 
 const tryCompleteChild = <A,>({
+  canEmitNoMore,
   hasSubscriber,
   hasActiveChild,
+  autoComplete,
   parents,
   complete,
 }: Readonly<{
+  canEmitNoMore: (() => boolean) | undefined;
   hasSubscriber: boolean;
   hasActiveChild: boolean;
+  autoComplete: boolean;
   parents: ChildObservable<A>['parents'];
   complete: () => void;
 }>): void => {
-  // If there is no working parent node
-  if (parents.every((r) => r.isCompleted)) {
+  // If there is no working parent node, or no value can come from the live ones
+  if (parents.every((r) => r.isCompleted) || canEmitNoMore?.() === true) {
     complete();
 
     return;
   }
 
-  // If there are no active child node
-  if (!hasSubscriber && !hasActiveChild) {
+  // If there are no active child node, and completing releases something
+  if (autoComplete && !hasSubscriber && !hasActiveChild) {
     complete();
   }
 

package/src/core/base/create-observable-base.mts

@@ -285,6 +285,16 @@ export const createObservableBaseHandle = <A,>(
   };
 };
 
+/**
+ * How many `startUpdate` calls are running, across every observable. A root
+ * written to while this is non-zero is written to from inside a subscriber or
+ * a projection, which {@link isPropagating} lets it detect (#2336).
+ */
+const mut_propagation = { depth: 0 };
+
+/** Whether some observable's update is propagating right now. */
+export const isPropagating = (): boolean => mut_propagation.depth > 0;
+
 /**
  * The extra members every manager observable — a root or an async child — owns:
  * the depth-ordered descendant list and the update propagation that walks it.
@@ -389,10 +399,20 @@ export const createManagerObservableParts = <A,>(
   const startUpdate = (nextValue: A): void => {
     const updateToken = issueUpdateToken();
 
-    handle.setNext(nextValue, updateToken);
+    mut_propagation.depth += 1;
 
-    for (const p of getPropagationOrder()) {
-      p.tryUpdate(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.
+    // @sumi-expect-error exceptions/no-try
+    try {
+      handle.setNext(nextValue, updateToken);
+
+      for (const p of getPropagationOrder()) {
+        p.tryUpdate(updateToken);
+      }
+    } finally {
+      mut_propagation.depth -= 1;
     }
   };
 
@@ -425,6 +445,8 @@ type AssembleObservableArgs<
   tryUpdate: (updateToken: UpdateToken) => void;
   tryComplete: () => void;
   complete: () => void;
+  dispose: () => void;
+  autoComplete: boolean;
   /**
    * Kind-specific public members (`parents`, `addDescendant`) and leaf
    * extensions (`next`, `start`). They are merged here, in the one place the
@@ -454,6 +476,8 @@ export const assembleObservable = <
   tryUpdate,
   tryComplete,
   complete,
+  dispose,
+  autoComplete,
   extra,
 }: AssembleObservableArgs<A, Kind, Extra>): Extra &
   ObservableBase<A> &
@@ -507,12 +531,16 @@ export const assembleObservable = <
 
     hasActiveChild: handle.hasActiveChild,
 
+    autoComplete,
+
     tryUpdate,
 
     tryComplete,
 
     complete,
 
+    dispose,
+
     subscribe: handle.subscribe,
 
     pipe,

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

@@ -6,6 +6,7 @@ import {
   createManagerObservableParts,
   createObservableBaseHandle,
   createTryUpdateNotImplemented,
+  isPropagating,
 } from './create-observable-base.mjs';
 
 /**
@@ -17,6 +18,8 @@ export type RootObservableTools<A> = Readonly<{
   /** Emits `nextValue` and propagates the update to all descendants. */
   startUpdate: (nextValue: A) => void;
 
+  getSnapshot: () => Optional<A>;
+
   isCompleted: () => boolean;
 
   /** Completes this observable (leaf teardown included). */
@@ -68,18 +71,43 @@ export const createRootObservable = <
     handle.completeBase();
   };
 
+  // A root without a teardown (`source`, `createState`, `just`) releases
+  // nothing by completing, so a child completing never completes it (#2133).
+  const autoComplete = onComplete !== undefined;
+
   const tryComplete = (): void => {
-    if (!handle.hasSubscriber() && !handle.hasActiveChild()) {
+    if (autoComplete && !handle.hasSubscriber() && !handle.hasActiveChild()) {
       complete();
     }
   };
 
+  // A root created while an update propagates (inside a `switchMap`
+  // projection, say) may emit synchronously while `init` runs, as
+  // `fromSubscribable` does for a synchronous source. Nothing is derived from
+  // it yet, so that is its initial value rather than a write (#2336).
+  let mut_isInitializing = true;
+
+  let mut_hasWarned = false;
+
+  const startUpdateWithWarning = (nextValue: A): void => {
+    if (!mut_isInitializing && !mut_hasWarned && isPropagating()) {
+      mut_hasWarned = true;
+
+      console.warn(writeDuringPropagationWarning);
+    }
+
+    startUpdate(nextValue);
+  };
+
   const extension: Extension = init({
-    startUpdate,
+    startUpdate: startUpdateWithWarning,
+    getSnapshot: handle.getSnapshot,
     isCompleted: handle.isCompleted,
     complete,
   });
 
+  mut_isInitializing = false;
+
   return assembleObservable({
     kind: 'root',
     depth: 0,
@@ -87,6 +115,9 @@ export const createRootObservable = <
     tryUpdate: createTryUpdateNotImplemented,
     tryComplete,
     complete,
+    // A root has no parents to keep out of it.
+    dispose: complete,
+    autoComplete,
     extra: {
       ...extension,
       addDescendant,
@@ -95,6 +126,16 @@ export const createRootObservable = <
   });
 };
 
+/**
+ * Shown once per root observable, the first time it is written to (`next`,
+ * `setState`, `dispatch`, …) while another update is still propagating —
+ * from a subscriber or a projection. The write still propagates immediately,
+ * as it always has; the warning is there because the pattern is wrong, not
+ * because anything was refused.
+ */
+export const writeDuringPropagationWarning =
+  'synstate: an observable was written to (next / setState / dispatch) while an update was propagating, so subscribers can see intermediate states. Derive the value with map / combine instead of writing from a subscriber or a projection.';
+
 if (import.meta.vitest !== undefined) {
   test('isRootObservable', () => {
     assert.isTrue(