synstate 6.2.1 → 7.0.1

package/dist/core/utils/is-development-build.d.mts

@@ -0,0 +1,15 @@
+/**
+ * Whether this is a development build: `NODE_ENV` is not `production`.
+ *
+ * `process.env.NODE_ENV` is written out in full because that is the expression
+ * bundlers (Vite, webpack, esbuild) replace, in the application's build and in
+ * a pre-bundled dependency alike: with the string `"development"` in a
+ * development build and `"production"` in a production one. Where nothing
+ * replaces it and there is no `process` (an unbundled module in a browser),
+ * reading it throws and the answer is `false`.
+ *
+ * synstate-router reads it the same way
+ * (`libs/synstate-router/src/internal/is-development.mts`).
+ */
+export declare const isDevelopmentBuild: () => boolean;
+//# sourceMappingURL=is-development-build.d.mts.map

package/dist/core/utils/is-development-build.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-development-build.d.mts","sourceRoot":"","sources":["../../../src/core/utils/is-development-build.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,kBAAkB,QAAO,OAOrC,CAAC"}

package/dist/core/utils/is-development-build.mjs

@@ -0,0 +1,23 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const isDevelopmentBuild = () => {
+
+    try {
+        return process.env.NODE_ENV !== 'production';
+    }
+    catch {
+        return false;
+    }
+};
+//# sourceMappingURL=is-development-build.mjs.map

package/dist/core/utils/is-development-build.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-development-build.mjs","sourceRoot":"","sources":["../../../src/core/utils/is-development-build.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,GAAY,EAAE;IAC9C,uCAAuC;IACvC,IAAI,CAAC;QACH,OAAO,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,YAAY,CAAC;IAC/C,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC,CAAC"}

package/dist/core/utils/rethrow-out-of-promise.d.mts

@@ -0,0 +1,10 @@
+/**
+ * Throws `error` again from a task of its own, for a `.catch` after each step
+ * of a promise chain that runs subscribers (`fromPromise`): after the step that
+ * emits and after the one that completes, so that neither exception replaces
+ * the other. A subscriber's exception then surfaces as an uncaught error, as
+ * one thrown during an update a timer started does (`debounce`, `timer`),
+ * rather than as a rejection or not at all.
+ */
+export declare const rethrowOutOfPromise: (error: unknown) => void;
+//# sourceMappingURL=rethrow-out-of-promise.d.mts.map

package/dist/core/utils/rethrow-out-of-promise.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rethrow-out-of-promise.d.mts","sourceRoot":"","sources":["../../../src/core/utils/rethrow-out-of-promise.mts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,UAAW,OAAO,KAAG,IAOpD,CAAC"}

package/dist/core/utils/rethrow-out-of-promise.mjs

@@ -0,0 +1,17 @@
+
+
+
+
+
+
+
+
+export const rethrowOutOfPromise = (error) => {
+    setTimeout(() => {
+
+
+
+        throw error;
+    }, 0);
+};
+//# sourceMappingURL=rethrow-out-of-promise.mjs.map

package/dist/core/utils/rethrow-out-of-promise.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"rethrow-out-of-promise.mjs","sourceRoot":"","sources":["../../../src/core/utils/rethrow-out-of-promise.mts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,KAAc,EAAQ,EAAE;IAC1D,UAAU,CAAC,GAAG,EAAE;QACd,uDAAuD;QACvD,yCAAyC;QACzC,sHAAsH;QACtH,MAAM,KAAK,CAAC;IACd,CAAC,EAAE,CAAC,CAAC,CAAC;AACR,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "synstate",
-  "version": "6.2.1",
+  "version": "7.0.1",
   "description": "Type-safe State Management Library for TypeScript/JavaScript",
   "repository": {
     "type": "git",
@@ -29,21 +29,22 @@
     "LICENSE"
   ],
   "dependencies": {
-    "ts-data-forge": "^14.10.2",
-    "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.5",
+    "@sumi-lang/cli": "0.1.7",
     "@types/react": "19.3.0",
     "@vitest/browser-playwright": "5.0.5",
     "argparse": "3.0.3",
-    "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",
+    "eslint": "10.13.0",
+    "eslint-config-typed": "7.5.0",
+    "eslint-plugin-ts-data-forge": "0.10.10",
+    "eslint-plugin-ts-fortress": "1.3.14",
+    "eslint-plugin-ts-type-forge": "0.8.19",
     "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.2.1",
-    "synstate-react-hooks-compat": "6.2.1",
-    "ts-repo-utils": "10.7.1",
+    "synstate-react-hooks": "7.0.1",
+    "synstate-react-hooks-compat": "7.0.1",
+    "ts-repo-utils": "10.7.3",
     "valtio": "2.3.2",
     "zustand": "5.0.15"
   },

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 { 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,11 @@ import type {
   WithInitialValueOperator,
   Wrap,
 } from '../types/index.mjs';
-import { maxDepth } from '../utils/index.mjs';
+import {
+  isDevelopmentBuild,
+  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';
@@ -198,6 +202,45 @@ 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.
@@ -212,10 +255,13 @@ export class AsyncChildObservableClass<A, const P extends NonEmptyUnknownList>
    * 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;
 
@@ -225,7 +271,7 @@ export class AsyncChildObservableClass<A, const P extends NonEmptyUnknownList>
       } else {
         this.startUpdate(value);
       }
-    });
+    }, onComplete);
 
     mut_isSubscribing = false;
 
@@ -353,17 +399,6 @@ const unregisterChild = (child: ChildNode): void => {
   }
 };
 
-const isDevelopmentProcess = (): boolean => {
-  const proc: unknown = Reflect.get(globalThis, 'process');
-
-  return (
-    isRecord(proc) &&
-    hasKey(proc, 'env') &&
-    isRecord(proc.env) &&
-    (!hasKey(proc.env, 'NODE_ENV') || proc.env.NODE_ENV !== 'production')
-  );
-};
-
 /**
  * Whether {@link registerChild} checks for a circular dependency: on in
  * development, off in production. The public API cannot make a cycle — a
@@ -372,7 +407,8 @@ const isDevelopmentProcess = (): boolean => {
  * node) against code that rewrites an observable's readonly `parents`, and
  * development is where that code runs first. It walks every ancestor of each
  * new observable, a cost production does not pay: the check is off when
- * `NODE_ENV` is `production`, and where there is no `process` (a browser
- * bundle).
+ * `NODE_ENV` is `production`, including a bundle whose bundler replaced
+ * `process.env.NODE_ENV`, and where nothing replaced it and there is no
+ * `process` (see {@link isDevelopmentBuild}).
  */
-export const checksCircularDependency: boolean = isDevelopmentProcess();
+const checksCircularDependency: boolean = isDevelopmentBuild();

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

@@ -14,7 +14,6 @@ import { Optional } from 'ts-data-forge';
 import { combine } from '../combine/index.mjs';
 import { source } from '../create/index.mjs';
 import { map } from '../operators/index.mjs';
-import { checksCircularDependency } from './child-observable-class.mjs';
 import {
   createSyncChildObservable,
   createTryUpdateNotImplemented,
@@ -23,53 +22,50 @@ import { createRootObservable } from './create-root-observable.mjs';
 
 describe('circular dependency comparison', () => {
   describe('SynState', () => {
-    // Only where the check runs: see `checksCircularDependency`.
-    test.runIf(checksCircularDependency)(
-      'detects cycle at construction time with a clear error message',
-      () => {
-        const root = createRootObservable(
-          { initialValue: Optional.some(0) },
-          () => ({}),
-        );
+    // The check is on in both test runs: see `circular-dependency.test.mts`.
+    test('detects cycle at construction time with a clear error message', () => {
+      const root = createRootObservable(
+        { initialValue: Optional.some(0) },
+        () => ({}),
+      );
 
-        const mut_childA = createSyncChildObservable(
-          {
-            parents: [root],
-            initialValue: Optional.some(0),
-          },
-          createTryUpdateNotImplemented,
-        );
+      const mut_childA = createSyncChildObservable(
+        {
+          parents: [root],
+          initialValue: Optional.some(0),
+        },
+        createTryUpdateNotImplemented,
+      );
 
-        const childB = createSyncChildObservable(
+      const childB = createSyncChildObservable(
+        {
+          parents: [mut_childA],
+          initialValue: Optional.some(0),
+        },
+        createTryUpdateNotImplemented,
+      );
+
+      // 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.
+      Object.defineProperty(mut_childA, 'parents', {
+        value: [childB],
+        writable: false,
+        configurable: true,
+      });
+
+      expect(() => {
+        createSyncChildObservable(
           {
             parents: [mut_childA],
             initialValue: Optional.some(0),
           },
           createTryUpdateNotImplemented,
         );
-
-        // 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.
-        Object.defineProperty(mut_childA, 'parents', {
-          value: [childB],
-          writable: false,
-          configurable: true,
-        });
-
-        expect(() => {
-          createSyncChildObservable(
-            {
-              parents: [mut_childA],
-              initialValue: Optional.some(0),
-            },
-            createTryUpdateNotImplemented,
-          );
-        }).toThrow(
-          'Circular dependency detected in observable graph: a child observable cannot be its own ancestor.',
-        );
-      },
-    );
+      }).toThrow(
+        'Circular dependency detected in observable graph: a child observable cannot be its own ancestor.',
+      );
+    });
 
     test('accepts valid DAG (diamond dependency)', () => {
       const a$ = source(0);

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

@@ -2,7 +2,6 @@ import { Optional } from 'ts-data-forge';
 import { combine, merge } from '../combine/index.mjs';
 import { source } from '../create/index.mjs';
 import { map } from '../operators/index.mjs';
-import { checksCircularDependency } from './child-observable-class.mjs';
 import {
   createAsyncChildObservable,
   createSyncChildObservable,
@@ -11,9 +10,12 @@ import {
 import { createRootObservable } from './create-root-observable.mjs';
 
 describe('circular dependency detection', () => {
-  // The check runs only in a process whose `NODE_ENV` is not `production`;
-  // the browser run has no `process`, and there nothing is checked.
-  describe.runIf(checksCircularDependency)('cycle in ancestor graph', () => {
+  // The check runs only where `NODE_ENV` is not `production`, which is so in
+  // both test runs: in the browser run because Vite replaced
+  // `process.env.NODE_ENV`, so these tests also fail if it stops being
+  // replaced. `test/circular-dependency-check-off.test.mts` loads a production
+  // copy.
+  describe('cycle in ancestor graph', () => {
     test('should throw when parent chain contains a cycle (A -> B -> A)', () => {
       const root = createRootObservable(
         { initialValue: Optional.some(0) },
@@ -183,39 +185,6 @@ describe('circular dependency detection', () => {
     });
   });
 
-  describe.skipIf(checksCircularDependency)('with the check off', () => {
-    test('does not walk the ancestors of a new child', () => {
-      const root = createRootObservable(
-        { initialValue: Optional.some(0) },
-        () => ({}),
-      );
-
-      const mut_childA = createSyncChildObservable(
-        {
-          parents: [root],
-          initialValue: Optional.some(0),
-        },
-        createTryUpdateNotImplemented,
-      );
-
-      Object.defineProperty(mut_childA, 'parents', {
-        value: [mut_childA],
-        writable: false,
-        configurable: true,
-      });
-
-      expect(() => {
-        createSyncChildObservable(
-          {
-            parents: [mut_childA],
-            initialValue: Optional.some(0),
-          },
-          createTryUpdateNotImplemented,
-        );
-      }).not.toThrow();
-    });
-  });
-
   describe('valid DAG patterns should not throw', () => {
     test('diamond dependency is not a cycle', () => {
       const root = createRootObservable(

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,
@@ -300,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>,
@@ -344,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 {

package/src/core/class/create-root-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 } from 'ts-data-forge';
+import type { Optional } from 'ts-data-forge';
+import * as Arr from 'ts-data-forge/array';
 import type { ReadonlyRecord } from 'ts-type-forge';
 import type { RootObservable } from '../types/index.mjs';
 import { RootObservableClass } from './root-observable-class.mjs';

package/src/core/class/propagation-state.mts

@@ -11,7 +11,7 @@
  * costs about twice as much per access as a module binding, on a path every
  * update takes.
  */
-import { Arr } from 'ts-data-forge';
+import * as Arr from 'ts-data-forge/array';
 import { panic } from 'ts-std-forge';
 import type { MutableSet } from 'ts-type-forge';
 import type { UpdateToken } from '../types/index.mjs';

package/src/core/class/write-during-propagation.test.mts

@@ -4,7 +4,12 @@ import type { FixedLengthTuple } from 'ts-type-forge';
 import { createState } from '../../utils/index.mjs';
 import { combine } from '../combine/index.mjs';
 import { fromSubscribable, source } from '../create/index.mjs';
-import { map, switchMap } from '../operators/index.mjs';
+import {
+  map,
+  switchMap,
+  throttle,
+  withBufferedFrom,
+} from '../operators/index.mjs';
 import { writeDuringPropagationWarning } from './root-observable-class.mjs';
 
 describe('a write to a root observable while an update is propagating (#2336)', () => {
@@ -156,7 +161,8 @@ describe('a write to a root observable while an update is propagating (#2336)',
 
     assert.deepStrictEqual(warn, []);
 
-    assert.deepStrictEqual(mut_history, [10]);
+    // 0 from the value `outer$` held when `switchMap` was created.
+    assert.deepStrictEqual(mut_history, [0, 10]);
   });
 
   test('does not warn when a root created during propagation emits while it is created', async () => {
@@ -188,7 +194,8 @@ describe('a write to a root observable while an update is propagating (#2336)',
 
     assert.deepStrictEqual(warn, []);
 
-    assert.deepStrictEqual(mut_history, [10]);
+    // 0 from the value `outer$` held when `switchMap` was created.
+    assert.deepStrictEqual(mut_history, [0, 10]);
   });
 
   test('a subscriber that throws does not leave the propagation flag set', async () => {
@@ -214,12 +221,76 @@ describe('a write to a root observable while an update is propagating (#2336)',
   });
 });
 
+describe('a stateful operator updates its state before setNext, which a write from a subscriber re-enters', () => {
+  test('withBufferedFrom keeps a value written to the buffered observable for the next batch', async () => {
+    const [data$, setData] = createState('a');
+
+    const [trigger$, setTrigger] = createState(0);
+
+    const result$ = trigger$.pipe(withBufferedFrom(data$));
+
+    const mut_history: (readonly [number, readonly string[]])[] = [];
+
+    result$.subscribe((v) => {
+      mut_history.push(v);
+
+      if (v[0] === 1) {
+        setData('b');
+      }
+    });
+
+    await captureWarnings(() => {
+      setTrigger(1);
+    });
+
+    setTrigger(2);
+
+    assert.deepStrictEqual(mut_history, [
+      [0, ['a']],
+      [1, []],
+      [2, ['b']],
+    ]);
+  });
+
+  test('throttle drops a value a subscriber writes to the parent inside the window, and keeps one timer', async () => {
+    vi.useFakeTimers();
+
+    onTestFinished(() => {
+      vi.useRealTimers();
+    });
+
+    const [src$, setSrc] = createState(0);
+
+    const throttled$ = src$.pipe(throttle(1000));
+
+    const mut_history: number[] = [];
+
+    throttled$.subscribe((v) => {
+      mut_history.push(v);
+
+      if (v === 1) {
+        setSrc(2);
+      }
+    });
+
+    await captureWarnings(() => {
+      setSrc(1);
+    });
+
+    assert.deepStrictEqual(mut_history, [0, 1]);
+
+    throttled$.complete();
+
+    assert.strictEqual(vi.getTimerCount(), 0);
+  });
+});
+
 /**
  * Runs `run` with `console.warn` replaced by a mock, and returns the messages
  * it was called with.
  */
 const captureWarnings = async (
-  run: () => Promise<void> | void,
+  run: () => Promise<void> | undefined,
 ): Promise<readonly unknown[]> => {
   const warn = vi.fn();
 

package/src/core/combine/derive.mts

@@ -5,7 +5,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, Optional } from 'ts-data-forge';
+import { Optional } from 'ts-data-forge';
+import * as Arr from 'ts-data-forge/array';
 import type { NonEmptyTuple } from 'ts-type-forge';
 import { SyncChildObservableClass } from '../class/index.mjs';
 import type {

package/src/core/combine/zip.mts

@@ -5,7 +5,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, Optional, createQueue, expectType } from 'ts-data-forge';
+import { Optional, createQueue, expectType } from 'ts-data-forge';
+import * as Arr from 'ts-data-forge/array';
 import type { NonEmptyTuple, Tuple } from 'ts-type-forge';
 import { SyncChildObservableClass } from '../class/index.mjs';
 import { source } from '../create/index.mjs';
@@ -150,8 +151,10 @@ class ZipObservableClass<const A extends NonEmptyUnknownList>
 
     this.setNext(nextValue, updateToken);
 
+    // After the update has reached what is derived from it, as in `take`
+    // (#2371).
     if (this.canEmitNoMore()) {
-      this.complete();
+      this.completeAfterPropagation();
     }
   }
 

package/src/core/create/counter.mts

@@ -5,7 +5,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 { asSafeUint, Optional, SafeUint } from 'ts-data-forge';
+import { asSafeUint, Optional, type SafeUint } from 'ts-data-forge';
 import type { PositiveSafeIntWithSmallInt } from 'ts-type-forge';
 import { RootObservableClass } from '../class/index.mjs';
 import type { CounterObservable, TimerId } from '../types/index.mjs';
@@ -154,7 +154,7 @@ class CounterObservableClass
     }
 
     this.#mut_timerId = setInterval(() => {
-      this.#mut_counter = SafeUint.add(1, this.#mut_counter);
+      this.#mut_counter = asSafeUint(this.#mut_counter + 1);
 
       this.#emit(this.#mut_counter);
     }, this.#intervalMilliSeconds);