synstate 1.0.2 → 2.0.0

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

@@ -32,7 +32,7 @@ import { type InitializedObservable } from '../core/index.mjs';
  * assert.deepStrictEqual(stateHistory, [0, 10, 11, 0]);
  * ```
  */
-export declare const createState: <S>(initialState: S) => readonly [state: InitializedObservable<S>, setState: (v: S) => S, Readonly<{
+export declare const createState: <S>(initialState: 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,EAC3B,cAAc,CAAC,KACd,SAAS,CACV,KAAK,EAAE,qBAAqB,CAAC,CAAC,CAAC,EAC/B,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,EACrB,QAAQ,CAAC;IACP,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,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"}

package/dist/utils/create-state.mjs

@@ -1,61 +1,31 @@
 import { createReducer } from './create-reducer.mjs';
 
 const reducer = (state, action) => {
-    switch (action.type) {
-        case 'set':
-            return action.nextState;
-        case 'update':
-            return action.updateFn(state);
-    }
+  switch (action.type) {
+    case "set":
+      return action.nextState;
+    case "update":
+      return action.updateFn(state);
+  }
 };
-/**
- * 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
- * @returns A 3-element tuple: `[state, setState, { updateState, resetState, getSnapshot, initialState }]`
- *
- * @example
- * ```ts
- * const [state, setState, { updateState, resetState }] = createState(0);
- *
- * const stateHistory: number[] = [];
- *
- * state.subscribe((value: number) => {
- *   stateHistory.push(value);
- * });
- *
- * assert.deepStrictEqual(stateHistory, [0]);
- *
- * setState(10); // logs: 10
- *
- * assert.deepStrictEqual(stateHistory, [0, 10]);
- *
- * updateState((prev: number) => prev + 1); // logs: 11
- *
- * assert.deepStrictEqual(stateHistory, [0, 10, 11]);
- *
- * resetState(); // logs: 0
- *
- * assert.deepStrictEqual(stateHistory, [0, 10, 11, 0]);
- * ```
- */
 const createState = (initialState) => {
-    const [state, dispatch, { getSnapshot }] = createReducer(reducer, initialState);
-    const updateState = (updateFn) => dispatch({ type: 'update', updateFn });
-    const setState = (nextState) => dispatch({ type: 'set', nextState });
-    const resetState = () => dispatch({ type: 'set', nextState: initialState });
-    return [
-        state,
-        setState,
-        {
-            updateState,
-            resetState,
-            getSnapshot,
-            initialState,
-        },
-    ];
+  const [state, dispatch, { getSnapshot }] = createReducer(
+    reducer,
+    initialState
+  );
+  const updateState = (updateFn) => dispatch({ type: "update", updateFn });
+  const setState = (nextState) => dispatch({ type: "set", nextState });
+  const resetState = () => dispatch({ type: "set", nextState: initialState });
+  return [
+    state,
+    setState,
+    {
+      updateState,
+      resetState,
+      getSnapshot,
+      initialState
+    }
+  ];
 };
 
 export { createState };

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

@@ -1 +1 @@
-{"version":3,"file":"create-state.mjs","sources":["../../src/utils/create-state.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAcA,MAAM,OAAO,GAAG,CAAK,KAAQ,EAAE,MAAiB,KAAO;AACrD,IAAA,QAAQ,MAAM,CAAC,IAAI;AACjB,QAAA,KAAK,KAAK;YACR,OAAO,MAAM,CAAC,SAAS;AAEzB,QAAA,KAAK,QAAQ;AACX,YAAA,OAAO,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;;AAEnC,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCG;AACI,MAAM,WAAW,GAAG,CACzB,YAAe,KAUb;AACF,IAAA,MAAM,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,WAAW,EAAE,CAAC,GAAG,aAAa,CACtD,OAAO,EACP,YAAY,CACb;AAED,IAAA,MAAM,WAAW,GAAG,CAAC,QAAwB,KAC3C,QAAQ,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC;AAExC,IAAA,MAAM,QAAQ,GAAG,CAAC,SAAY,KAAQ,QAAQ,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC;AAE1E,IAAA,MAAM,UAAU,GAAG,MACjB,QAAQ,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,CAAC;IAEpD,OAAO;QACL,KAAK;QACL,QAAQ;AACR,QAAA;YACE,WAAW;YACX,UAAU;YACV,WAAW;YACX,YAAY;AACb,SAAA;KACO;AACZ;;;;"}
+{"version":3,"file":"create-state.mjs","sources":["../../src/utils/create-state.mts"],"sourcesContent":["import { type InitializedObservable } from '../core/index.mjs';\nimport { createReducer } from './create-reducer.mjs';\n\ntype Action<S> = Readonly<\n  | {\n      type: 'set';\n      nextState: S;\n    }\n  | {\n      type: 'update';\n      updateFn: (a: S) => S;\n    }\n>;\n\nconst reducer = <S,>(state: S, action: Action<S>): S => {\n  switch (action.type) {\n    case 'set':\n      return action.nextState;\n\n    case 'update':\n      return action.updateFn(state);\n  }\n};\n\n/**\n * Creates a reactive state container with getter and setter methods.\n * Provides a simple state management solution with observable state.\n *\n * @template S - The type of the state\n * @param initialState - The initial value of the state\n * @returns A 3-element tuple: `[state, setState, { updateState, resetState, getSnapshot, initialState }]`\n *\n * @example\n * ```ts\n * const [state, setState, { updateState, resetState }] = createState(0);\n *\n * const stateHistory: number[] = [];\n *\n * state.subscribe((value: number) => {\n *   stateHistory.push(value);\n * });\n *\n * assert.deepStrictEqual(stateHistory, [0]);\n *\n * setState(10); // logs: 10\n *\n * assert.deepStrictEqual(stateHistory, [0, 10]);\n *\n * updateState((prev: number) => prev + 1); // logs: 11\n *\n * assert.deepStrictEqual(stateHistory, [0, 10, 11]);\n *\n * resetState(); // logs: 0\n *\n * assert.deepStrictEqual(stateHistory, [0, 10, 11, 0]);\n * ```\n */\nexport const createState = <S,>(\n  initialState: S,\n): readonly [\n  state: InitializedObservable<S>,\n  setState: (v: S) => S,\n  utils: Readonly<{\n    updateState: (updateFn: (prev: S) => S) => S;\n    resetState: () => S;\n    getSnapshot: () => S;\n    initialState: S;\n  }>,\n] => {\n  const [state, dispatch, { getSnapshot }] = createReducer<S, Action<S>>(\n    reducer,\n    initialState,\n  );\n\n  const updateState = (updateFn: (prev: S) => S): S =>\n    dispatch({ type: 'update', updateFn });\n\n  const setState = (nextState: S): S => dispatch({ type: 'set', nextState });\n\n  const resetState = (): S =>\n    dispatch({ type: 'set', nextState: initialState });\n\n  return [\n    state,\n    setState,\n    {\n      updateState,\n      resetState,\n      getSnapshot,\n      initialState,\n    },\n  ] as const;\n};\n"],"names":[],"mappings":";;AAcA,MAAM,OAAA,GAAU,CAAK,KAAA,EAAU,MAAA,KAAyB;AACtD,EAAA,QAAQ,OAAO,IAAA;AAAM,IACnB,KAAK,KAAA;AACH,MAAA,OAAO,MAAA,CAAO,SAAA;AAAA,IAEhB,KAAK,QAAA;AACH,MAAA,OAAO,MAAA,CAAO,SAAS,KAAK,CAAA;AAAA;AAElC,CAAA;AAmCO,MAAM,WAAA,GAAc,CACzB,YAAA,KAUG;AACH,EAAA,MAAM,CAAC,KAAA,EAAO,QAAA,EAAU,EAAE,WAAA,EAAa,CAAA,GAAI,aAAA;AAAA,IACzC,OAAA;AAAA,IACA;AAAA,GACF;AAEA,EAAA,MAAM,WAAA,GAAc,CAAC,QAAA,KACnB,QAAA,CAAS,EAAE,IAAA,EAAM,QAAA,EAAU,UAAU,CAAA;AAEvC,EAAA,MAAM,QAAA,GAAW,CAAC,SAAA,KAAoB,QAAA,CAAS,EAAE,IAAA,EAAM,KAAA,EAAO,WAAW,CAAA;AAEzE,EAAA,MAAM,UAAA,GAAa,MACjB,QAAA,CAAS,EAAE,MAAM,KAAA,EAAO,SAAA,EAAW,cAAc,CAAA;AAEnD,EAAA,OAAO;AAAA,IACL,KAAA;AAAA,IACA,QAAA;AAAA,IACA;AAAA,MACE,WAAA;AAAA,MACA,UAAA;AAAA,MACA,WAAA;AAAA,MACA;AAAA;AACF,GACF;AACF;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "synstate",
-  "version": "1.0.2",
+  "version": "2.0.0",
   "description": "Type-safe State Management Library for TypeScript/JavaScript",
   "repository": {
     "type": "git",
@@ -28,20 +28,20 @@
     "LICENSE"
   ],
   "dependencies": {
-    "ts-data-forge": "^6.9.6",
-    "ts-type-forge": "^3.1.0"
+    "ts-data-forge": "^14.2.0",
+    "ts-type-forge": "^9.2.0"
   },
   "devDependencies": {
     "@reduxjs/toolkit": "2.12.0",
     "@types/argparse": "2.0.17",
-    "@types/react": "19.2.14",
-    "argparse": "2.0.1",
-    "jotai": "2.19.1",
-    "mobx": "6.15.0",
-    "react": "19.2.5",
+    "@types/react": "19.2.18",
+    "argparse": "3.0.0",
+    "jotai": "2.20.2",
+    "mobx": "7.0.0",
+    "react": "19.2.8",
     "rxjs": "7.8.2",
-    "valtio": "2.3.1",
-    "zustand": "5.0.12"
+    "valtio": "2.3.2",
+    "zustand": "5.0.14"
   },
   "scripts": {
     "benchmark": "tsx ./scripts/cmd/run-benchmark.mts",
@@ -68,10 +68,9 @@
     "test:cov:ui": "vite preview --outDir ./coverage",
     "test:ui": "pnpm run z:vitest:node --ui",
     "testw": "pnpm run z:vitest:node watch",
-    "tsc": "tsc --noEmit",
-    "tscw": "tsc --noEmit --watch",
-    "type-check": "tsc --noEmit",
-    "update-packages": "pnpm update --latest",
+    "tsc": "node ../../node_modules/typescript-native/bin/tsc --noEmit",
+    "tscw": "node ../../node_modules/typescript-native/bin/tsc --noEmit --watch",
+    "type-check": "node ../../node_modules/typescript-native/bin/tsc --noEmit",
     "z:prettier": "prettier --config ../../.prettierrc --ignore-path ../../.prettierignore --ignore-path ../../.gitignore --ignore-unknown --no-error-on-unmatched-pattern --write",
     "z:vitest": "vitest --config ./configs/vitest.config.mts",
     "z:vitest:node": "pnpm run z:vitest --project='Node.js'",

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

@@ -128,8 +128,8 @@ export class AsyncChildObservableClass<A, const P extends NonEmptyUnknownList>
   extends ObservableBaseClass<A, 'async child', number>
   implements AsyncChildObservable<A, P>
 {
-  readonly parents;
   #mut_propagationOrder: readonly ChildObservable<unknown>[];
+  readonly parents;
   protected readonly descendantsIdSet: MutableSet<ObservableId>;
 
   constructor({

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

@@ -24,14 +24,14 @@ export class ObservableBaseClass<
   Kind extends ObservableBase<A>['kind'],
   Depth extends ObservableBase<A>['depth'],
 > implements ObservableBase<A> {
-  readonly id;
-  readonly kind: Kind;
-  readonly depth: Depth;
   #mut_children: readonly ChildObservable<unknown>[];
   readonly #subscribers: MutableMap<SubscriberId, Subscriber<A>>;
   #mut_currentValue: ReturnType<ObservableBase<A>['getSnapshot']>;
   #mut_isCompleted: ObservableBase<A>['isCompleted'];
   #mut_updateToken: ObservableBase<A>['updateToken'];
+  readonly id;
+  readonly kind: Kind;
+  readonly depth: Depth;
 
   constructor({
     kind,
@@ -59,6 +59,19 @@ export class ObservableBaseClass<
     this.#mut_updateToken = issueUpdateToken();
   }
 
+  #addSubscriber(s: Subscriber<A>): SubscriberId {
+    // return the id of added subscriber
+    const id = issueSubscriberId();
+
+    this.#subscribers.set(id, s);
+
+    return id;
+  }
+
+  #removeSubscriber(id: SubscriberId): void {
+    this.#subscribers.delete(id);
+  }
+
   addChild<B>(child: ChildObservable<B>): void {
     this.#mut_children = Arr.toPushed(
       this.#mut_children,
@@ -171,17 +184,4 @@ export class ObservableBaseClass<
       },
     };
   }
-
-  #addSubscriber(s: Subscriber<A>): SubscriberId {
-    // return the id of added subscriber
-    const id = issueSubscriberId();
-
-    this.#subscribers.set(id, s);
-
-    return id;
-  }
-
-  #removeSubscriber(id: SubscriberId): void {
-    this.#subscribers.delete(id);
-  }
 }

package/src/core/combine/combine.mts

@@ -1,5 +1,5 @@
-import { Arr, Optional, expectType } from 'ts-data-forge';
-import { type NonEmptyArray } from 'ts-type-forge';
+import { Arr, expectType, Optional } from 'ts-data-forge';
+import { type NonEmptyTuple, type Tuple } from 'ts-type-forge';
 import { SyncChildObservableClass } from '../class/index.mjs';
 import { source } from '../create/index.mjs';
 import { withInitialValue } from '../operators/index.mjs';
@@ -72,7 +72,7 @@ import {
  * ]);
  * ```
  */
-export const combine = <const OS extends NonEmptyArray<Observable<unknown>>>(
+export const combine = <const OS extends NonEmptyTuple<Observable<unknown>>>(
   parents: OS,
 ): CombineObservableRefined<OS> =>
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
@@ -91,35 +91,57 @@ class CombineObservableClass<const A extends NonEmptyUnknownList>
   implements CombineObservable<A>
 {
   constructor(parents: Wrap<A>) {
-    const parentsValues = parents.map((p) => p.getSnapshot());
+    const parentsValues: Tuple.MapTo<Optional<A[number]>, A> = Arr.map(
+      parents,
+      (p) => p.getSnapshot(),
+    );
+
+    // The annotation on `initialValue` is what replaces the type assertion.
+    // `Arr.map` carries a single result element type, so it reports `A[number]`
+    // at every position, and `Tuple.MapTo<A[number], A>` — the uniform mapping
+    // — is *not* assignable back to `A`. The positional
+    // `Readonly<{ [K in keyof A]: A[K] }>` is, and TypeScript accepts the
+    // uniform result into it because the two mapped types share `keyof A`. So
+    // it is the annotation, not an assertion, that records the position-wise
+    // fact the checker cannot derive on its own.
+    const initialValue: Optional<Readonly<{ [K in keyof A]: A[K] }>> =
+      Arr.every(parentsValues, Optional.isSome)
+        ? Optional.some(Arr.map(parentsValues, (c) => c.value))
+        : Optional.none;
 
     super({
       parents,
-      initialValue: parentsValues.every(Optional.isSome)
-        ? Optional.some(
-            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-            Arr.map(parentsValues, (c) => c.value) as A,
-          )
-        : Optional.none,
+      initialValue,
     });
   }
 
   override tryUpdate(updateToken: UpdateToken): void {
     if (this.parents.every((o) => o.updateToken !== updateToken)) return; // all parents are skipped
 
-    const parentValues = this.parents.map((a) => a.getSnapshot());
+    // Same shape-preserving chain as the constructor: `Arr.map` (not the
+    // native one, which drops the tuple shape) into the uniform
+    // `Tuple.MapTo`, then a positional annotation to get back to `A`.
+    const parentValues: Tuple.MapTo<Optional<A[number]>, A> = Arr.map(
+      this.parents,
+      (a) => a.getSnapshot(),
+    );
 
-    if (parentValues.every(Optional.isSome)) {
-      const nextValue =
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-        Arr.map(parentValues, (a) => a.value) as A;
+    if (Arr.every(parentValues, Optional.isSome)) {
+      const nextValue: Readonly<{ [K in keyof A]: A[K] }> = Arr.map(
+        parentValues,
+        (a) => a.value,
+      );
 
       this.setNext(nextValue, updateToken);
     }
   }
 }
 
-{
+if (import.meta.vitest !== undefined) {
+  test('type test', () => {
+    expect(1).toBe(1); // dummy
+  });
+
   {
     const s1: Observable<1> = source<1>();
 

package/src/core/combine/merge.mts

@@ -1,5 +1,5 @@
 import { Optional, expectType } from 'ts-data-forge';
-import { type ArrayElement, type NonEmptyArray } from 'ts-type-forge';
+import { type ArrayElement, type NonEmptyTuple } from 'ts-type-forge';
 import { SyncChildObservableClass } from '../class/index.mjs';
 import { source } from '../create/index.mjs';
 import {
@@ -63,7 +63,7 @@ import {
  * @note To improve code readability, consider using `createState` instead of `merge`,
  * subscribing to `parents` and calling `setState` within it.
  */
-export const merge = <const OS extends NonEmptyArray<Observable<unknown>>>(
+export const merge = <const OS extends NonEmptyTuple<Observable<unknown>>>(
   parents: OS,
 ): MergeObservableRefined<OS> =>
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
@@ -104,7 +104,7 @@ if (import.meta.vitest !== undefined) {
 
   const r2 = source('a');
 
-  const _m = merge([r1, r2] as const);
+  const _m = merge([r1, r2]);
 
   expectType<typeof _m, SyncChildObservable<number | string>>('<=');
 }

package/src/core/combine/zip.mts

@@ -1,5 +1,5 @@
 import { Arr, Optional, createQueue, expectType } from 'ts-data-forge';
-import { type NonEmptyArray } from 'ts-type-forge';
+import { type NonEmptyTuple, type Tuple } from 'ts-type-forge';
 import { SyncChildObservableClass } from '../class/index.mjs';
 import { source } from '../create/index.mjs';
 import { withInitialValue } from '../operators/index.mjs';
@@ -65,7 +65,7 @@ import {
  * ]);
  * ```
  */
-export const zip = <const OS extends NonEmptyArray<Observable<unknown>>>(
+export const zip = <const OS extends NonEmptyTuple<Observable<unknown>>>(
   parents: OS,
 ): ZipObservableRefined<OS> =>
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
@@ -78,21 +78,30 @@ class ZipObservableClass<const A extends NonEmptyUnknownList>
   readonly #queues: TupleToQueueTuple<A>;
 
   constructor(parents: Wrap<A>) {
-    const parentsValues = parents.map((p) => p.getSnapshot());
+    const parentsValues: Tuple.MapTo<Optional<A[number]>, A> = Arr.map(
+      parents,
+      (p) => p.getSnapshot(),
+    );
+
+    // The annotation on `initialValue` is what replaces the type assertion.
+    // `Arr.map` carries a single result element type, so it reports `A[number]`
+    // at every position, and `Tuple.MapTo<A[number], A>` — the uniform mapping
+    // — is *not* assignable back to `A`. The positional
+    // `Readonly<{ [K in keyof A]: A[K] }>` is, and TypeScript accepts the
+    // uniform result into it because the two mapped types share `keyof A`. So
+    // it is the annotation, not an assertion, that records the position-wise
+    // fact the checker cannot derive on its own.
+    const initialValue: Optional<Readonly<{ [K in keyof A]: A[K] }>> =
+      Arr.every(parentsValues, Optional.isSome)
+        ? Optional.some(Arr.map(parentsValues, (c) => c.value))
+        : Optional.none;
 
     super({
       parents,
-      initialValue: parentsValues.every(Optional.isSome)
-        ? Optional.some(
-            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-            Arr.map(parentsValues, (c) => c.value) as A,
-          )
-        : Optional.none,
+      initialValue,
     });
 
-    this.#queues = Arr.map(parents, () =>
-      createQueue(),
-    ) satisfies TupleToQueueTuple<A>;
+    this.#queues = Arr.map(parents, () => createQueue());
   }
 
   override tryUpdate(updateToken: UpdateToken): void {
@@ -108,6 +117,8 @@ class ZipObservableClass<const A extends NonEmptyUnknownList>
 
     if (queues.every((list) => !list.isEmpty)) {
       const nextValue =
+        // `Arr.map` has a single result element type, so it reports
+        // `A[number] | undefined` per position rather than `A[P]`.
         // eslint-disable-next-line total-functions/no-unsafe-type-assertion
         Arr.map(queues, (q) => Optional.unwrap(q.dequeue())) as A;
 
@@ -160,7 +171,7 @@ if (import.meta.vitest !== undefined) {
 
   const r2 = source('a');
 
-  const _z = zip([r1, r2] as const);
+  const _z = zip([r1, r2]);
 
   const _zi = zip([
     r1.pipe(withInitialValue(0)),

package/src/core/create/counter.mts

@@ -36,7 +36,7 @@ import { type CounterObservable, type TimerId } from '../types/index.mjs';
  *
  * subscription.unsubscribe();
  *
- * assert.isTrue(Arr.isArrayAtLeastLength(valueHistory, 3));
+ * assert.isTrue(Arr.isMinLengthArray(3, valueHistory));
  *
  * assert.deepStrictEqual(valueHistory[0], 0);
  *
@@ -84,6 +84,16 @@ class CounterObservableClass
     }
   }
 
+  #resetTimer(): void {
+    if (this.#mut_timerId0 === undefined || this.#mut_timerId === undefined) {
+      return;
+    }
+
+    clearInterval(this.#mut_timerId0);
+
+    clearInterval(this.#mut_timerId);
+  }
+
   start(): void {
     if (this.#mut_isStarted) {
       console.warn('cannot start twice');
@@ -110,14 +120,6 @@ class CounterObservableClass
     }, this.#intervalMilliSeconds);
   }
 
-  #resetTimer(): void {
-    if (this.#mut_timerId0 !== undefined && this.#mut_timerId !== undefined) {
-      clearInterval(this.#mut_timerId0);
-
-      clearInterval(this.#mut_timerId);
-    }
-  }
-
   override complete(): void {
     this.#resetTimer();
 

package/src/core/create/counter.test.mts

@@ -0,0 +1,11 @@
+import { counter } from './counter.mjs';
+
+describe(counter, () => {
+  test('completing before start() tears down without touching the timers', () => {
+    const counter$ = counter(10, { startManually: true });
+
+    counter$.complete();
+
+    assert.isTrue(counter$.isCompleted);
+  });
+});

package/src/core/create/timer.mts

@@ -68,6 +68,12 @@ class TimerObservableClass
     }
   }
 
+  #resetTimer(): void {
+    if (this.#mut_timerId !== undefined) {
+      clearTimeout(this.#mut_timerId);
+    }
+  }
+
   start(): void {
     if (this.#mut_isStarted) {
       console.warn('cannot start twice');
@@ -90,12 +96,6 @@ class TimerObservableClass
     }, this.#milliSeconds);
   }
 
-  #resetTimer(): void {
-    if (this.#mut_timerId !== undefined) {
-      clearTimeout(this.#mut_timerId);
-    }
-  }
-
   override complete(): void {
     this.#resetTimer();
 

package/src/core/create/timer.test.mts

@@ -0,0 +1,11 @@
+import { timer } from './timer.mjs';
+
+describe(timer, () => {
+  test('completing before start() tears down without touching the timer', () => {
+    const timer$ = timer(10, { startManually: true });
+
+    timer$.complete();
+
+    assert.isTrue(timer$.isCompleted);
+  });
+});

package/src/core/operators/audit-throttle-teardown.test.mts

@@ -0,0 +1,21 @@
+import { source } from '../create/index.mjs';
+import { audit } from './audit.mjs';
+import { throttle } from './throttle.mjs';
+
+describe('completing before any emission', () => {
+  test('audit tears down without a pending timer', () => {
+    const audited$ = source<number>().pipe(audit(10));
+
+    audited$.complete();
+
+    assert.isTrue(audited$.isCompleted);
+  });
+
+  test('throttle tears down without a pending timer', () => {
+    const throttled$ = source<number>().pipe(throttle(10));
+
+    throttled$.complete();
+
+    assert.isTrue(throttled$.isCompleted);
+  });
+});

package/src/core/operators/audit.mts

@@ -133,6 +133,12 @@ class AuditObservableClass<A>
     this.#milliSeconds = milliSeconds;
   }
 
+  #resetTimer(): void {
+    if (this.#mut_timerId !== undefined) {
+      clearTimeout(this.#mut_timerId);
+    }
+  }
+
   override tryUpdate(updateToken: UpdateToken): void {
     const par = this.parents[0];
 
@@ -158,12 +164,6 @@ class AuditObservableClass<A>
     }, this.#milliSeconds);
   }
 
-  #resetTimer(): void {
-    if (this.#mut_timerId !== undefined) {
-      clearTimeout(this.#mut_timerId);
-    }
-  }
-
   override complete(): void {
     this.#resetTimer();
 

package/src/core/operators/debounce.mts

@@ -121,6 +121,12 @@ class DebounceObservableClass<A>
     this.#milliSeconds = milliSeconds;
   }
 
+  #resetTimer(): void {
+    if (this.#mut_timerId !== undefined) {
+      clearTimeout(this.#mut_timerId);
+    }
+  }
+
   override tryUpdate(updateToken: UpdateToken): void {
     const par = this.parents[0];
 
@@ -140,12 +146,6 @@ class DebounceObservableClass<A>
     }, this.#milliSeconds);
   }
 
-  #resetTimer(): void {
-    if (this.#mut_timerId !== undefined) {
-      clearTimeout(this.#mut_timerId);
-    }
-  }
-
   override complete(): void {
     this.#resetTimer();
 

package/src/core/operators/pairwise.mts

@@ -1,4 +1,5 @@
 import { Optional } from 'ts-data-forge';
+import { type FixedLengthTuple } from 'ts-type-forge';
 import { SyncChildObservableClass } from '../class/index.mjs';
 import {
   type DropInitialValueOperator,
@@ -30,7 +31,7 @@ import {
  *
  * const pairs$ = num$.pipe(pairwise());
  *
- * const valueHistory: (readonly [number, number])[] = [];
+ * const valueHistory: FixedLengthTuple<2, number>[] = [];
  *
  * pairs$.subscribe(([prev, curr]) => {
  *   valueHistory.push([prev, curr]);
@@ -60,14 +61,18 @@ import {
  * ]);
  * ```
  */
-export const pairwise = <A,>(): DropInitialValueOperator<A, readonly [A, A]> =>
-  f;
+export const pairwise = <A,>(): DropInitialValueOperator<
+  A,
+  FixedLengthTuple<2, A>
+> => f;
 
-const f = <A,>(parentObservable: Observable<A>): Observable<readonly [A, A]> =>
+const f = <A,>(
+  parentObservable: Observable<A>,
+): Observable<FixedLengthTuple<2, A>> =>
   new PairwiseObservableClass(parentObservable);
 
 class PairwiseObservableClass<A>
-  extends SyncChildObservableClass<readonly [A, A], readonly [A]>
+  extends SyncChildObservableClass<FixedLengthTuple<2, A>, readonly [A]>
   implements PairwiseOperatorObservable<A>
 {
   #mut_previousValue: Optional<A>;

package/src/core/operators/skip-while.mts

@@ -89,11 +89,7 @@ class SkipWhileObservableClass<A>
     super({
       parents: [parentObservable],
       initialValue: pipe(parentObservable.getSnapshot()).map((sn) =>
-        Optional.isNone(sn)
-          ? Optional.none
-          : predicate(sn.value, -1)
-            ? Optional.none
-            : sn,
+        Optional.isNone(sn) || predicate(sn.value, -1) ? Optional.none : sn,
       ).value,
     });
 

package/src/core/operators/skip-while.test.mts

@@ -0,0 +1,20 @@
+import { Optional } from 'ts-data-forge';
+import { just } from '../create/index.mjs';
+import { skipWhile } from './skip-while.mjs';
+
+describe(skipWhile, () => {
+  // Widened so the predicate is not statically decidable.
+  const seed: number = 1;
+
+  test('keeps an initialized parent value the predicate does not skip', () => {
+    const kept$ = just(seed).pipe(skipWhile((x) => x > 10));
+
+    expect(Optional.unwrapOr(kept$.getSnapshot(), -1)).toBe(1);
+  });
+
+  test('drops an initialized parent value the predicate skips', () => {
+    const dropped$ = just(seed).pipe(skipWhile((x) => x < 10));
+
+    assert.isTrue(Optional.isNone(dropped$.getSnapshot()));
+  });
+});