synstate 1.0.2 → 2.0.1

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()));
+  });
+});

package/src/core/operators/throttle.mts

@@ -117,6 +117,12 @@ class ThrottleObservableClass<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 ThrottleObservableClass<A>
     }, this.#milliSeconds);
   }
 
-  #resetTimer(): void {
-    if (this.#mut_timerId !== undefined) {
-      clearTimeout(this.#mut_timerId);
-    }
-  }
-
   override complete(): void {
     this.#resetTimer();
 

package/src/core/operators/with-buffered-from.mts

@@ -105,6 +105,10 @@ class WithBufferedFromObservableClass<A, B>
     });
   }
 
+  #clearBuffer(): void {
+    this.#mut_bufferedValues = [];
+  }
+
   override tryUpdate(updateToken: UpdateToken): void {
     const par = this.parents[0];
 
@@ -118,8 +122,4 @@ class WithBufferedFromObservableClass<A, B>
 
     this.#clearBuffer();
   }
-
-  #clearBuffer(): void {
-    this.#mut_bufferedValues = [];
-  }
 }

package/src/core/predefined/operators/map-optional.mts

@@ -51,5 +51,4 @@ import { type KeepInitialValueOperator } from '../../types/index.mjs';
  */
 export const mapOptional = <O extends UnknownOptional, B>(
   mapFn: (x: Optional.Unwrap<O>) => B,
-): KeepInitialValueOperator<O, Optional<B>> =>
-  map((a) => Optional.map(a, mapFn));
+): KeepInitialValueOperator<O, Optional<B>> => map(Optional.map(mapFn));

package/src/core/predefined/operators/map-result-err.mts

@@ -52,4 +52,4 @@ import { type KeepInitialValueOperator } from '../../types/index.mjs';
 export const mapResultErr = <R extends UnknownResult, E2>(
   mapFn: (x: Result.UnwrapErr<R>) => E2,
 ): KeepInitialValueOperator<R, Result<Result.UnwrapOk<R>, E2>> =>
-  map((a) => Result.mapErr(a, mapFn));
+  map(Result.mapErr(mapFn));

package/src/core/predefined/operators/map-result-ok.mts

@@ -52,4 +52,4 @@ import { type KeepInitialValueOperator } from '../../types/index.mjs';
 export const mapResultOk = <R extends UnknownResult, S2>(
   mapFn: (x: Result.UnwrapOk<R>) => S2,
 ): KeepInitialValueOperator<R, Result<S2, Result.UnwrapErr<R>>> =>
-  map((a) => Result.map(a, mapFn));
+  map(Result.map(mapFn));

package/src/core/types/observable-family.mts

@@ -1,7 +1,8 @@
 import { expectType, type Result } from 'ts-data-forge';
 import {
   type ArrayElement,
-  type NonEmptyArray,
+  type FixedLengthTuple,
+  type NonEmptyTuple,
   type SafeUint,
 } from 'ts-type-forge';
 import {
@@ -63,8 +64,8 @@ export type ScanOperatorObservable<A, B> = InitializedSyncChildObservable<
 namespace SynStateInternals {
   type Cast<A> = A extends NonEmptyUnknownList ? A : never;
 
-  type EveryInitialized<OS extends NonEmptyArray<Observable<unknown>>> =
-    OS extends NonEmptyArray<InitializedObservable<unknown>> ? true : false;
+  type EveryInitialized<OS extends NonEmptyTuple<Observable<unknown>>> =
+    OS extends NonEmptyTuple<InitializedObservable<unknown>> ? true : false;
 
   type IsInitialized<O> = readonly [O] extends readonly [
     InitializedObservable<unknown>,
@@ -83,7 +84,7 @@ namespace SynStateInternals {
     // union distribution
     LogicalValue<OS extends OS ? IsInitialized<OS> : never>;
 
-  type SomeInitialized<OS extends NonEmptyArray<Observable<unknown>>> =
+  type SomeInitialized<OS extends NonEmptyTuple<Observable<unknown>>> =
     SomeInitializedImpl<OS[number]>;
 
   expectType<EveryInitialized<readonly [Observable<1>]>, false>('=');
@@ -125,7 +126,7 @@ namespace SynStateInternals {
     SyncChildObservable<A, A>;
 
   export type CombineObservableRefinedImpl<
-    OS extends NonEmptyArray<Observable<unknown>>,
+    OS extends NonEmptyTuple<Observable<unknown>>,
   > =
     EveryInitialized<OS> extends true
       ? InitializedCombineObservableImpl<Cast<Unwrap<OS>>>
@@ -138,7 +139,7 @@ namespace SynStateInternals {
     SyncChildObservable<A, A>;
 
   export type ZipObservableRefinedImpl<
-    OS extends NonEmptyArray<Observable<unknown>>,
+    OS extends NonEmptyTuple<Observable<unknown>>,
   > =
     EveryInitialized<OS> extends true
       ? InitializedZipObservableImpl<Cast<Unwrap<OS>>>
@@ -151,7 +152,7 @@ namespace SynStateInternals {
     SyncChildObservable<ArrayElement<P>, P>;
 
   export type MergeObservableRefinedImpl<
-    OS extends NonEmptyArray<Observable<unknown>>,
+    OS extends NonEmptyTuple<Observable<unknown>>,
   > =
     SomeInitialized<OS> extends true
       ? InitializedMergeObservableImpl<Cast<Unwrap<OS>>>
@@ -162,27 +163,27 @@ export type CombineObservable<A extends NonEmptyUnknownList> =
   SynStateInternals.CombineObservableImpl<A>;
 
 export type CombineObservableRefined<
-  OS extends NonEmptyArray<Observable<unknown>>,
+  OS extends NonEmptyTuple<Observable<unknown>>,
 > = SynStateInternals.CombineObservableRefinedImpl<OS>;
 
 export type ZipObservable<A extends NonEmptyUnknownList> =
   SynStateInternals.ZipObservableImpl<A>;
 
 export type ZipObservableRefined<
-  OS extends NonEmptyArray<Observable<unknown>>,
+  OS extends NonEmptyTuple<Observable<unknown>>,
 > = SynStateInternals.ZipObservableRefinedImpl<OS>;
 
 export type MergeObservable<A extends NonEmptyUnknownList> =
   SynStateInternals.MergeObservableImpl<A>;
 
 export type MergeObservableRefined<
-  OS extends NonEmptyArray<Observable<unknown>>,
+  OS extends NonEmptyTuple<Observable<unknown>>,
 > = SynStateInternals.MergeObservableRefinedImpl<OS>;
 
 export type MapOperatorObservable<A, B> = SyncChildObservable<B, readonly [A]>;
 
 export type PairwiseOperatorObservable<A> = SyncChildObservable<
-  readonly [A, A],
+  FixedLengthTuple<2, A>,
   readonly [A]
 >;
 

package/src/core/types/observable.mts

@@ -1,5 +1,5 @@
 import { expectType, type Optional, type Some } from 'ts-data-forge';
-import { type StrictOmit } from 'ts-type-forge';
+import { type FixedLengthTuple, type StrictOmit } from 'ts-type-forge';
 import { type ObservableId, type UpdateToken } from './id.mjs';
 import { type ObservableKind } from './observable-kind.mjs';
 import { type NonEmptyUnknownList, type Subscription } from './types.mjs';
@@ -128,9 +128,7 @@ export type InitializedRootObservable<A> =
   ObservableTypeConverter.ToInitialized<A, RootObservable<A>>;
 
 export type Observable<A> =
-  | AsyncChildObservable<A>
-  | RootObservable<A>
-  | SyncChildObservable<A>;
+  AsyncChildObservable<A> | RootObservable<A> | SyncChildObservable<A>;
 
 export type InitializedObservable<A> =
   | InitializedAsyncChildObservable<A>
@@ -209,11 +207,11 @@ expectType<
 expectType<number, ObservableValue<Observable<string>>>('!<=');
 
 expectType<
-  readonly [Observable<number>, Observable<number>],
-  Wrap<readonly [number, number]>
+  FixedLengthTuple<2, Observable<number>>,
+  Wrap<FixedLengthTuple<2, number>>
 >('<=');
 
 expectType<
   readonly [Observable<number>, Observable<string>],
-  Wrap<readonly [number, number]>
+  Wrap<FixedLengthTuple<2, number>>
 >('!<=');

package/src/core/types/types.mts

@@ -1,10 +1,11 @@
 import { expectType, type Queue } from 'ts-data-forge';
+import { type NonEmptyTuple } from 'ts-type-forge';
 
 export type TupleToQueueTuple<T extends readonly unknown[]> = Readonly<{
   [P in keyof T]: Queue<T[P]>;
 }>;
 
-export type NonEmptyUnknownList = readonly [unknown, ...unknown[]];
+export type NonEmptyUnknownList = NonEmptyTuple<unknown>;
 
 export type Subscriber<A> = Readonly<{
   onNext: (v: A) => void;

package/src/core/utils/max-depth.mts

@@ -3,5 +3,9 @@ import { type Observable } from '../types/index.mjs';
 
 export const maxDepth = (parents: readonly Observable<unknown>[]): number =>
   pipe(Arr.maxBy(parents, (p) => p.depth))
-    .mapOptional((o) => o.depth)
+    // Explicit return type + non-curried `Optional.unwrapOr` call: TypeScript
+    // 7 (native)'s inference for this chained generic call resolves to
+    // `unknown` without them, even though TypeScript <= 6.0's checker
+    // resolves this fine.
+    .mapOptional((o): number => o.depth)
     .map(Optional.unwrapOr(0)).value;

package/src/core/utils/utils.mts

@@ -15,7 +15,7 @@ export const binarySearch = <N extends number>(
 ): NegativeInt32 | Uint32 => {
   const uint32Result = asUint32(0);
 
-  if (Arr.isArrayOfLength(sortedArray, 0)) {
+  if (Arr.isEmpty(sortedArray)) {
     return uint32Result;
   }
 

package/src/utils/create-boolean-state.mts

@@ -34,7 +34,7 @@ export const createBooleanState = (
   initialState: boolean,
 ): readonly [
   state: InitializedObservable<boolean>,
-  Readonly<{
+  utils: Readonly<{
     setTrue: () => void;
     setFalse: () => void;
     setState: (next: boolean) => boolean;