synstate 3.0.5 → 3.1.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,EAAE,KAAK,OAAO,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAU,KAAK,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,EAAE,CAAC,WACvB,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,gBACR,CAAC,KACd,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,CAeH,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}

package/dist/utils/create-reducer.mjs

@@ -42,10 +42,39 @@ import { source } from '../core/index.mjs';
 
 
 
-export const createReducer = (reducer, initialState) => {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const createReducer = (reducer, initialState, options) => {
     const state = source(initialState);
+    const equals = options?.equals;
     const dispatch = (action) => {
-        const nextState = reducer(state.getSnapshot().value, action);
+        const currentState = state.getSnapshot().value;
+        const nextState = reducer(currentState, action);
+        if (equals?.(currentState, nextState) === true) {
+            return currentState;
+        }
         state.next(nextState);
         return nextState;
     };

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAC3B,OAAsB,EACtB,YAAe,EAQf,EAAE;IACF,MAAM,KAAK,GAAG,MAAM,CAAI,YAAY,CAAC,CAAC;IAEtC,MAAM,QAAQ,GAAG,CAAC,MAAS,EAAK,EAAE;QAChC,MAAM,SAAS,GAAG,OAAO,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QAE7D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}

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

@@ -1,10 +1,13 @@
-import { type InitializedObservable } from '../core/index.mjs';
+import type { InitializedObservable } from '../core/index.mjs';
+import { type StateOptions } from './create-reducer.mjs';
 /**
  * Creates a reactive state container with getter and setter methods.
  * Provides a simple state management solution with observable state.
  *
  * @template S - The type of the state
  * @param initialState - The initial value of the state
+ * @param options - {@link StateOptions}: `equals`, to pass on only the
+ *   updates that change the state
  * @returns A 3-element tuple: `[state, setState, { updateState, resetState, getSnapshot, initialState }]`
  *
  * @example
@@ -31,8 +34,40 @@ import { type InitializedObservable } from '../core/index.mjs';
  *
  * assert.deepStrictEqual(stateHistory, [0, 10, 11, 0]);
  * ```
+ *
+ * @example
+ * ```ts
+ * const [filters, setFilters] = createState(
+ *   { label: 'bug', page: 1 },
+ *   { equals: fastDeepEqual },
+ * );
+ *
+ * const before = filters.getSnapshot().value;
+ *
+ * // Derived state is recomputed only when the state really changes.
+ * const query = filters.pipe(
+ *   map(({ label, page }) => `label:${label} page:${page}`),
+ * );
+ *
+ * const queryHistory: string[] = [];
+ *
+ * query.subscribe((value: string) => {
+ *   queryHistory.push(value);
+ * });
+ *
+ * setFilters({ label: 'bug', page: 1 }); // equal: nothing is passed on
+ *
+ * assert.strictEqual(filters.getSnapshot().value, before);
+ *
+ * setFilters({ label: 'bug', page: 2 });
+ *
+ * assert.deepStrictEqual(queryHistory, [
+ *   'label:bug page:1',
+ *   'label:bug page:2',
+ * ]);
+ * ```
  */
-export declare const createState: <S>(initialState: S) => readonly [state: InitializedObservable<S>, setState: (v: S) => S, utils: Readonly<{
+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;
     resetState: () => S;
     getSnapshot: () => 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,EAAE,KAAK,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAwB/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,gBACb,CAAC,KACd,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,CAyBH,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}

package/dist/utils/create-state.mjs

@@ -40,8 +40,42 @@ const reducer = (state, action) => {
 
 
 
-export const createState = (initialState) => {
-    const [state, dispatch, { getSnapshot }] = createReducer(reducer, initialState);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+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 });

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,EAAE,MAAM,sBAAsB,CAAC;AAarD,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CACzB,YAAe,EAUf,EAAE;IACF,MAAM,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,WAAW,EAAE,CAAC,GAAG,aAAa,CACtD,OAAO,EACP,YAAY,CACb,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "synstate",
-  "version": "3.0.5",
+  "version": "3.1.0",
   "description": "Type-safe State Management Library for TypeScript/JavaScript",
   "repository": {
     "type": "git",
@@ -35,24 +35,24 @@
   },
   "devDependencies": {
     "@reduxjs/toolkit": "2.12.0",
-    "@sumi-lang/cli": "0.0.4",
+    "@sumi-lang/cli": "0.0.5",
     "@types/react": "19.3.0",
-    "@vitest/browser-playwright": "5.0.1",
+    "@vitest/browser-playwright": "5.0.2",
     "argparse": "3.0.2",
-    "eslint-config-typed": "5.15.0",
-    "eslint-plugin-ts-data-forge": "0.8.1",
-    "eslint-plugin-ts-fortress": "1.2.3",
-    "eslint-plugin-ts-type-forge": "0.8.4",
+    "eslint-config-typed": "5.17.0",
+    "eslint-plugin-ts-data-forge": "0.8.3",
+    "eslint-plugin-ts-fortress": "1.3.0",
+    "eslint-plugin-ts-type-forge": "0.8.5",
     "jotai": "3.0.0",
-    "mobx": "7.0.3",
+    "mobx": "7.0.5",
     "playwright": "1.63.0",
-    "prettier": "3.9.8",
+    "prettier": "3.9.9",
     "prettier-plugin-organize-imports": "4.3.0",
     "prettier-plugin-packagejson": "3.0.2",
     "react": "19.3.0",
     "rxjs": "7.8.2",
-    "synstate-react-hooks": "3.0.5",
-    "synstate-react-hooks-compat": "3.0.5",
+    "synstate-react-hooks": "3.1.0",
+    "synstate-react-hooks-compat": "3.1.0",
     "ts-repo-utils": "10.7.1",
     "valtio": "2.3.2",
     "zustand": "5.0.15"

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

@@ -1,6 +1,6 @@
 import { Arr, type Optional, type Some } from 'ts-data-forge';
 import { panic } from 'ts-std-forge';
-import { type MutableSet } from 'ts-type-forge';
+import type { MutableSet } from 'ts-type-forge';
 import {
   isChildObservable,
   isManagerObservable,

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

@@ -1,23 +1,19 @@
 import { Arr, Optional } from 'ts-data-forge';
 import { unreachable } from 'ts-std-forge';
-import {
-  type MutableMap,
-  type MutableSet,
-  type ReadonlyRecord,
-} from 'ts-type-forge';
-import {
-  type ChildObservable,
-  type InitializedObservable,
-  type Observable,
-  type ObservableBase,
-  type ObservableId,
-  type ObservableKind,
-  type Operator,
-  type Subscriber,
-  type SubscriberId,
-  type Subscription,
-  type UpdateToken,
-  type WithInitialValueOperator,
+import type { MutableMap, MutableSet, ReadonlyRecord } from 'ts-type-forge';
+import type {
+  ChildObservable,
+  InitializedObservable,
+  Observable,
+  ObservableBase,
+  ObservableId,
+  ObservableKind,
+  Operator,
+  Subscriber,
+  SubscriberId,
+  Subscription,
+  UpdateToken,
+  WithInitialValueOperator,
 } from '../types/index.mjs';
 import {
   binarySearch,
@@ -42,6 +38,38 @@ import {
 export type ObservableBaseHandle<A> = Readonly<{
   id: ObservableId;
 
+  /**
+   * Registers the public object {@link assembleObservable} built from this
+   * handle, so that its four state flags (`isCompleted`, `updateToken`,
+   * `hasSubscriber`, `hasChild`) can be mirrored onto it as plain data
+   * properties.
+   *
+   * They used to be getters delegating to this handle's closures, and that
+   * costs more than it looks. Reading one was an accessor call plus a closure
+   * call where a field read would do — `updateToken` is read once per child
+   * per update, so the propagation path paid it on every step — and an object
+   * literal carrying accessors is far more expensive to create than one
+   * carrying data, which is most of what building a graph costs. Measured on
+   * one machine with `pnpm run benchmark`: the derived chain's 100,000 updates
+   * 16.7 ms -> 13.6 ms, and the cascaded diamond at N=20, whose measurement is
+   * dominated by graph construction, 587 ms -> 362 ms.
+   *
+   * Every write below therefore has to keep the mirror in step; that is the
+   * price of not reading through a closure on the hot path. It is paid in
+   * clarity too, and on purpose: `hasSubscriber` and `hasChild` are derived
+   * from `mut_subscribers` and `mut_children`, which a getter stated once and
+   * declaratively, whereas the mirror restates it at every write.
+   *
+   * Nor can the rarely read flags alone go back to getters while `updateToken`
+   * stays data. A single accessor in the literal is enough to lose nearly all
+   * of the gain: measured on Node 26 with the `...extra` spread followed by
+   * these properties, one getter among data properties made the literal about
+   * 10x slower to create than all data (four getters: about 15x) and gave
+   * every instance its own hidden class (`%HaveSameMap` false). Keep all four
+   * as data, or measure again before changing that.
+   */
+  attach: (writers: ObservableStateWriters) => void;
+
   addChild: <B>(child: ChildObservable<B>) => void;
 
   getSnapshot: () => Optional<A>;
@@ -52,8 +80,6 @@ export type ObservableBaseHandle<A> = Readonly<{
 
   hasSubscriber: () => boolean;
 
-  hasChild: () => boolean;
-
   hasActiveChild: () => boolean;
 
   subscribe: (onNext: (v: A) => void, onComplete?: () => void) => Subscription;
@@ -70,6 +96,20 @@ export type ObservableBaseHandle<A> = Readonly<{
   completeBase: () => void;
 }>;
 
+/**
+ * How the handle writes the four state flags onto the public object. The
+ * writers are closures over that object rather than the object itself, because
+ * a parameter this side could mutate has to be a mutable type, which
+ * `@typescript-eslint/prefer-readonly-parameter-types` rejects — and the object
+ * is `Readonly` to everyone else.
+ */
+type ObservableStateWriters = Readonly<{
+  setIsCompleted: (value: boolean) => void;
+  setUpdateToken: (value: UpdateToken) => void;
+  setHasSubscriber: (value: boolean) => void;
+  setHasChild: (value: boolean) => void;
+}>;
+
 export const createObservableBaseHandle = <A,>(
   initialValue: Optional<A>,
 ): ObservableBaseHandle<A> => {
@@ -85,17 +125,41 @@ export const createObservableBaseHandle = <A,>(
 
   let mut_updateToken: UpdateToken = issueUpdateToken();
 
+  /**
+   * Set once {@link assembleObservable} has built the public object. It does
+   * not exist while a leaf factory's `init` callback runs — that callback may
+   * already subscribe or complete — so every write below is optional, and
+   * `attach` copies the state as it stands rather than assuming defaults.
+   */
+  let mut_writers: ObservableStateWriters | undefined;
+
+  const attach = (writers: ObservableStateWriters): void => {
+    mut_writers = writers;
+
+    writers.setIsCompleted(mut_isCompleted);
+
+    writers.setUpdateToken(mut_updateToken);
+
+    writers.setHasSubscriber(mut_subscribers.size > 0);
+
+    writers.setHasChild(Arr.isNonEmpty(mut_children));
+  };
+
   const addSubscriber = (s: Subscriber<A>): SubscriberId => {
     // return the id of added subscriber
     const subscriberId = issueSubscriberId();
 
     mut_subscribers.set(subscriberId, s);
 
+    mut_writers?.setHasSubscriber(true);
+
     return subscriberId;
   };
 
   const removeSubscriber = (subscriberId: SubscriberId): void => {
     mut_subscribers.delete(subscriberId);
+
+    mut_writers?.setHasSubscriber(mut_subscribers.size > 0);
   };
 
   const addChild = <B,>(child: ChildObservable<B>): void => {
@@ -104,6 +168,8 @@ export const createObservableBaseHandle = <A,>(
 
       child as ChildObservable<unknown>,
     );
+
+    mut_writers?.setHasChild(true);
   };
 
   const getSnapshot = (): Optional<A> => mut_currentValue;
@@ -114,14 +180,14 @@ export const createObservableBaseHandle = <A,>(
 
   const hasSubscriber = (): boolean => mut_subscribers.size > 0;
 
-  const hasChild = (): boolean => Arr.isNonEmpty(mut_children);
-
   const hasActiveChild = (): boolean =>
     mut_children.some((c) => !c.isCompleted);
 
   const setNext = (nextValue: A, nextUpdateToken: UpdateToken): void => {
     mut_updateToken = nextUpdateToken;
 
+    mut_writers?.setUpdateToken(nextUpdateToken);
+
     mut_currentValue = Optional.some(nextValue);
 
     for (const s of mut_subscribers.values()) {
@@ -137,6 +203,8 @@ export const createObservableBaseHandle = <A,>(
     // change state
     mut_isCompleted = true;
 
+    mut_writers?.setIsCompleted(true);
+
     // run subscribers for the current value
     for (const s of mut_subscribers.values()) {
       s.onComplete();
@@ -145,6 +213,8 @@ export const createObservableBaseHandle = <A,>(
     // remove all subscribers
     mut_subscribers.clear();
 
+    mut_writers?.setHasSubscriber(false);
+
     // propagate to children
     for (const o of mut_children) {
       o.tryComplete();
@@ -183,12 +253,12 @@ export const createObservableBaseHandle = <A,>(
 
   return {
     id,
+    attach,
     addChild,
     getSnapshot,
     isCompleted,
     updateToken,
     hasSubscriber,
-    hasChild,
     hasActiveChild,
     subscribe,
     setNext,
@@ -282,8 +352,9 @@ type AssembleObservableArgs<
   /**
    * Kind-specific public members (`parents`, `addDescendant`) and leaf
    * extensions (`next`, `start`). They are merged here, in the one place the
-   * final object literal is created, because the public getters below must not
-   * be copied by a spread (spreading would freeze their current values).
+   * final object literal is created, because the handle keeps the state flags
+   * up to date on that object alone: a copy made by spreading it afterwards
+   * would freeze their current values.
    */
   extra: Extra;
 }>;
@@ -291,9 +362,10 @@ type AssembleObservableArgs<
 /**
  * Builds the public observable object from a base handle. This replaces the
  * implicit assembly a `class` performs: state stays in the handle's closures,
- * `isCompleted` / `updateToken` / `hasSubscriber` / `hasChild` become getters
- * delegating to the handle, and the kind-specific behavior (`tryUpdate`,
- * `tryComplete`, `complete`) is passed in already composed.
+ * `isCompleted` / `updateToken` / `hasSubscriber` / `hasChild` become data
+ * properties the handle keeps in step through `attach`, and the kind-specific
+ * behavior (`tryUpdate`, `tryComplete`, `complete`) is passed in already
+ * composed.
  */
 export const assembleObservable = <
   A,
@@ -323,11 +395,16 @@ export const assembleObservable = <
     return operator(
       // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
       // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-      observable as unknown as InitializedObservable<A>,
+      mut_observable as unknown as InitializedObservable<A>,
     );
   }
 
-  const observable = {
+  // The four state flags are plain data properties kept in step by the handle,
+  // not getters delegating to it — see `ObservableBaseHandle.attach` for the
+  // measurements that decided this. `updateToken` in particular is read once
+  // per child per update, and `tryUpdate` reading a field rather than calling
+  // through an accessor is most of what the change buys.
+  const mut_observable = {
     ...extra,
 
     id: handle.id,
@@ -340,21 +417,13 @@ export const assembleObservable = <
 
     getSnapshot: handle.getSnapshot,
 
-    get isCompleted(): boolean {
-      return handle.isCompleted();
-    },
+    isCompleted: false,
 
-    get updateToken(): UpdateToken {
-      return handle.updateToken();
-    },
+    updateToken: handle.updateToken(),
 
-    get hasSubscriber(): boolean {
-      return handle.hasSubscriber();
-    },
+    hasSubscriber: false,
 
-    get hasChild(): boolean {
-      return handle.hasChild();
-    },
+    hasChild: false,
 
     hasActiveChild: handle.hasActiveChild,
 
@@ -367,7 +436,25 @@ export const assembleObservable = <
     subscribe: handle.subscribe,
 
     pipe,
-  } as const;
+  };
+
+  handle.attach({
+    setIsCompleted: (value) => {
+      mut_observable.isCompleted = value;
+    },
+
+    setUpdateToken: (value) => {
+      mut_observable.updateToken = value;
+    },
+
+    setHasSubscriber: (value) => {
+      mut_observable.hasSubscriber = value;
+    },
+
+    setHasChild: (value) => {
+      mut_observable.hasChild = value;
+    },
+  });
 
-  return observable;
+  return mut_observable;
 };

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

@@ -1,5 +1,5 @@
 import { Optional } from 'ts-data-forge';
-import { type ReadonlyRecord } from 'ts-type-forge';
+import type { ReadonlyRecord } from 'ts-type-forge';
 import { isRootObservable, type RootObservable } from '../types/index.mjs';
 import {
   assembleObservable,

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

@@ -1,11 +1,11 @@
 import { expectType, Optional } from 'ts-data-forge';
-import {
-  type AsyncChildObservable,
-  type ChildObservable,
-  type Observable,
-  type ObservableBase,
-  type RootObservable,
-  type SyncChildObservable,
+import type {
+  AsyncChildObservable,
+  ChildObservable,
+  Observable,
+  ObservableBase,
+  RootObservable,
+  SyncChildObservable,
 } from '../types/index.mjs';
 import {
   createAsyncChildObservable,

package/src/core/combine/combine.mts

@@ -1,17 +1,17 @@
 import { Arr, expectType, Optional } from 'ts-data-forge';
-import { type NonEmptyTuple, type Tuple } from 'ts-type-forge';
+import type { NonEmptyTuple, Tuple } from 'ts-type-forge';
 import { createSyncChildObservable } from '../base/index.mjs';
 import { source } from '../create/index.mjs';
 import { withInitialValue } from '../operators/index.mjs';
-import {
-  type CombineObservable,
-  type CombineObservableRefined,
-  type InitializedObservable,
-  type InitializedSyncChildObservable,
-  type NonEmptyUnknownList,
-  type Observable,
-  type SyncChildObservable,
-  type Wrap,
+import type {
+  CombineObservable,
+  CombineObservableRefined,
+  InitializedObservable,
+  InitializedSyncChildObservable,
+  NonEmptyUnknownList,
+  Observable,
+  SyncChildObservable,
+  Wrap,
 } from '../types/index.mjs';
 
 /**

package/src/core/combine/merge.mts

@@ -1,14 +1,14 @@
 import { Optional, expectType } from 'ts-data-forge';
-import { type ArrayElement, type NonEmptyTuple } from 'ts-type-forge';
+import type { ArrayElement, NonEmptyTuple } from 'ts-type-forge';
 import { createSyncChildObservable } from '../base/index.mjs';
 import { source } from '../create/index.mjs';
-import {
-  type MergeObservable,
-  type MergeObservableRefined,
-  type NonEmptyUnknownList,
-  type Observable,
-  type SyncChildObservable,
-  type Wrap,
+import type {
+  MergeObservable,
+  MergeObservableRefined,
+  NonEmptyUnknownList,
+  Observable,
+  SyncChildObservable,
+  Wrap,
 } from '../types/index.mjs';
 
 /**

package/src/core/combine/zip.mts

@@ -1,18 +1,18 @@
 import { Arr, Optional, createQueue, expectType } from 'ts-data-forge';
-import { type NonEmptyTuple, type Tuple } from 'ts-type-forge';
+import type { NonEmptyTuple, Tuple } from 'ts-type-forge';
 import { createSyncChildObservable } from '../base/index.mjs';
 import { source } from '../create/index.mjs';
 import { withInitialValue } from '../operators/index.mjs';
-import {
-  type InitializedObservable,
-  type InitializedSyncChildObservable,
-  type NonEmptyUnknownList,
-  type Observable,
-  type SyncChildObservable,
-  type TupleToQueueTuple,
-  type Wrap,
-  type ZipObservable,
-  type ZipObservableRefined,
+import type {
+  InitializedObservable,
+  InitializedSyncChildObservable,
+  NonEmptyUnknownList,
+  Observable,
+  SyncChildObservable,
+  TupleToQueueTuple,
+  Wrap,
+  ZipObservable,
+  ZipObservableRefined,
 } from '../types/index.mjs';
 
 /**

package/src/core/create/counter.mts

@@ -1,6 +1,6 @@
 import { asSafeUint, Optional, SafeUint } from 'ts-data-forge';
 import { createRootObservable } from '../base/index.mjs';
-import { type CounterObservable, type TimerId } from '../types/index.mjs';
+import type { CounterObservable, TimerId } from '../types/index.mjs';
 
 /**
  * Creates an observable that emits incremental numbers at a specified interval.

package/src/core/create/from-abortable-promise.mts

@@ -1,6 +1,6 @@
 import { Optional, Result } from 'ts-data-forge';
 import { createRootObservable } from '../base/index.mjs';
-import { type FromPromiseObservable } from '../types/index.mjs';
+import type { FromPromiseObservable } from '../types/index.mjs';
 
 /**
  * Creates an observable from a Promise factory that receives an `AbortSignal`.

package/src/core/create/from-promise.mts

@@ -1,6 +1,6 @@
 import { Optional, Result } from 'ts-data-forge';
 import { createRootObservable } from '../base/index.mjs';
-import { type FromPromiseObservable } from '../types/index.mjs';
+import type { FromPromiseObservable } from '../types/index.mjs';
 
 /**
  * Creates an observable from a Promise.