synstate 6.1.1 → 7.0.0

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

@@ -2,14 +2,15 @@
 // @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';
 
 /**
- * The tools a custom root's `init` receives: the `protected` methods a
- * subclass of `RootObservableClass` inherits.
+ * The tools a custom root's `init` receives: the `protected` methods a subclass
+ * of `RootObservableClass` inherits.
  */
 export type RootObservableTools<A> = Readonly<{
   /** Emits `nextValue` and propagates the update to all descendants. */
@@ -23,9 +24,9 @@ export type RootObservableTools<A> = Readonly<{
   complete: () => void;
 
   /**
-   * Registers a teardown (clear timers, abort requests, remove listeners, …)
-   * to run at the beginning of `complete()`, in the order registered. Called
-   * from `init`, it lets the teardown close over what `init` creates.
+   * Registers a teardown (clear timers, abort requests, remove listeners, …) to
+   * run at the beginning of `complete()`, in the order registered. Called from
+   * `init`, it lets the teardown close over what `init` creates.
    * Registered once the observable has completed — `init` may complete it
    * synchronously first — the teardown runs at once.
    */
@@ -37,13 +38,13 @@ export type RootObservableConfig<A> = Readonly<{
 }>;
 
 /**
- * Creates a root observable, for a custom creator written without a class
- * of its own.
+ * Creates a root observable, for a custom creator written without a class of
+ * its own.
  *
- * `init` runs during construction, receives the tools, and returns extra
- * public members to merge into the observable (e.g. `next` for a source,
- * `start` for a timer). It may register asynchronous callbacks that use the
- * tools, and may call `complete` synchronously.
+ * `init` runs during construction, receives the tools, and returns extra public
+ * members to merge into the observable (e.g. `next` for a source, `start` for a
+ * timer). It may register asynchronous callbacks that use the tools, and may
+ * call `complete` synchronously.
  */
 export const createRootObservable = <
   A,

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

@@ -12,12 +12,12 @@ import {
 } from './propagation-state.mjs';
 
 /**
- * The base of the observables that start updates of their own: a root, and
- * an async child (`debounce`, `switchMap`), which emits later than its
- * parents do. Its update visits, shallowest first, the nodes its value
- * reaches: each node that emits puts its children in the update's queue
- * (`propagation-state.mts`), so that each sees its parents' values of that
- * update (no glitch) and a node no value reached is not visited.
+ * The base of the observables that start updates of their own: a root, and an
+ * async child (`debounce`, `switchMap`), which emits later than its parents do.
+ * Its update visits, shallowest first, the nodes its value reaches: each node
+ * that emits puts its children in the update's queue (`propagation-state.mts`),
+ * so that each sees its parents' values of that update (no glitch) and a node
+ * no value reached is not visited.
  */
 export class ManagerObservableClass<
   A,
@@ -26,9 +26,9 @@ export class ManagerObservableClass<
 > extends ObservableBaseClass<A, Kind, Depth> {
   /** Emits `nextValue` and propagates it to the descendants. */
   protected startUpdate(nextValue: A): void {
-    // Nothing to propagate to (a branch no `switchMap` follows, a state
-    // written before anything subscribes): the update is the value alone,
-    // and opening one would cost more than storing it.
+    // Nothing to propagate to (a branch no `switchMap` follows, a state written
+    // before anything subscribes): the update is the value alone, and opening
+    // one would cost more than storing it.
     if (this.setNextIfUnobserved(nextValue)) {
       return;
     }
@@ -37,9 +37,9 @@ export class ManagerObservableClass<
 
     beginPropagation(updateToken);
 
-    // A subscriber or projection may throw, and the depth has to come back
-    // down regardless, or every later write would warn. The exception itself
-    // is not caught: it reaches the caller of `next` as it always has.
+    // A subscriber or projection may throw, and the depth has to come back down
+    // regardless, or every later write would warn. The exception itself is not
+    // caught: it reaches the caller of `next` as it always has.
     // @sumi-expect-error exceptions/no-try
     try {
       this.setNext(nextValue, updateToken);

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

@@ -1,6 +1,6 @@
 // Sumi bans classes, `this`, method syntax and writes to `this` outside a
-// `mut_` binding. The observables are classes (why is on
-// `ObservableBaseClass` below), so those four rules are waived here (D-63).
+// `mut_` binding. The observables are classes (why is on `ObservableBaseClass`
+// below), so those four rules are waived here (D-63).
 // @sumi-expect-error-file classes/no-class
 // @sumi-expect-error-file banned-syntax/no-this
 // @sumi-expect-error-file functions/prefer-arrow-function
@@ -35,25 +35,23 @@ import { enqueueChildren } from './propagation-state.mjs';
 /**
  * The base of every observable, and the reason an observable is a class.
  *
- * A node is created for every derived value of a UI, so creating one has to
- * be cheap, and most of its cost was its methods: each observable used to be
- * a set of closures made for it, a dozen or more per node (#2421). Sharing
- * the methods among all nodes removes that cost, and a shared method has to
- * read the node it is called on from `this`. Once `this` is unavoidable, a
- * class is the plainest way to say it: the methods live once on the
- * prototype, `this` is typed, a creator or operator is a subclass that
- * overrides `tryUpdate` (and `flush` / `teardown` where it holds something),
- * and assigning every field in the constructor gives the nodes of one class
- * one shape for V8. The collections (`children`, subscribers) are made when
- * the first one arrives.
+ * A node is created for every derived value of a UI, so creating one has to be
+ * cheap, and most of its cost was its methods: each observable used to be a set
+ * of closures made for it, a dozen or more per node (#2421). Sharing the
+ * methods among all nodes removes that cost, and a shared method has to read
+ * the node it is called on from `this`. Once `this` is unavoidable, a class is
+ * the plainest way to say it: the methods live once on the prototype, `this` is
+ * typed, a creator or operator is a subclass that overrides `tryUpdate` (and
+ * `flush` / `teardown` where it holds something), and assigning every field in
+ * the constructor gives the nodes of one class one shape for V8. The
+ * collections (`children`, subscribers) are made when the first one arrives.
  *
  * The methods read the observable they are called on, so taking one off it
  * (`const { subscribe } = obs$`) is not supported.
  *
- * A node reaches another node only through its methods and its public
- * fields, never through a `#private` one: the other node may be an instance
- * of another copy of synstate in the same program, whose classes are not
- * these.
+ * A node reaches another node only through its methods and its public fields,
+ * never through a `#private` one: the other node may be an instance of another
+ * copy of synstate in the same program, whose classes are not these.
  */
 export class ObservableBaseClass<
   A,
@@ -144,8 +142,8 @@ export class ObservableBaseClass<
   }
 
   addChild(child: ChildNode): void {
-    // A set, not an array: a completed child removes itself, and that has to
-    // be O(1) for a UI that creates and completes derived nodes on every mount.
+    // A set, not an array: a completed child removes itself, and that has to be
+    // O(1) for a UI that creates and completes derived nodes on every mount.
     if (this.#mut_children === undefined) {
       this.#mut_children = new Set<ChildNode>([child]);
     } else {
@@ -158,10 +156,10 @@ export class ObservableBaseClass<
   }
 
   /**
-   * Stores `nextValue` as the current value, queues the children for the
-   * update `updateToken`, and notifies subscribers. The children are queued
-   * first, so that a child a subscriber creates, which starts from this
-   * value, is not visited for it again.
+   * Stores `nextValue` as the current value, queues the children for the update
+   * `updateToken`, and notifies subscribers. The children are queued first, so
+   * that a child a subscriber creates, which starts from this value, is not
+   * visited for it again.
    */
   protected setNext(nextValue: A, updateToken: UpdateToken): void {
     this.#mut_updateToken = updateToken;
@@ -180,11 +178,11 @@ export class ObservableBaseClass<
   }
 
   /**
-   * Stores `nextValue` and returns `true` when nothing observes this
-   * observable — no child to queue and no subscriber to call — so that the
-   * caller need not open an update; returns `false`, storing nothing,
-   * otherwise. The value still gets a token of its own, so that whoever
-   * stored the last one sees that it emitted.
+   * Stores `nextValue` and returns `true` when nothing observes this observable
+   * — no child to queue and no subscriber to call — so that the caller need not
+   * open an update; returns `false`, storing nothing, otherwise. The value
+   * still gets a token of its own, so that whoever stored the last one sees
+   * that it emitted.
    */
   protected setNextIfUnobserved(nextValue: A): boolean {
     if (this.hasChild || this.hasSubscriber) {
@@ -220,9 +218,9 @@ export class ObservableBaseClass<
 
   /**
    * Completes the observable: an async child first passes on what it still
-   * holds (`flush`), then it is disposed. Completing never reaches the
-   * parents: an upstream observable may be shared, and only whoever owns it
-   * decides when it ends (#2133).
+   * holds (`flush`), then it is disposed. Completing never reaches the parents:
+   * an upstream observable may be shared, and only whoever owns it decides when
+   * it ends (#2133).
    */
   complete(): void {
     if (this.#mut_isCompleted) {
@@ -235,8 +233,8 @@ export class ObservableBaseClass<
   }
 
   /**
-   * Completes the observable without passing on anything it still holds,
-   * runs its teardown, and takes it out of the graph.
+   * Completes the observable without passing on anything it still holds, runs
+   * its teardown, and takes it out of the graph.
    */
   dispose(): void {
     // A completed node is reached again through every parent that completes
@@ -275,8 +273,8 @@ export class ObservableBaseClass<
   }
 
   /**
-   * Passes on what the observable still holds, at the beginning of
-   * `complete()` and never in `dispose()` (`debounce`'s pending value).
+   * Passes on what the observable still holds, at the beginning of `complete()`
+   * and never in `dispose()` (`debounce`'s pending value).
    */
   // eslint-disable-next-line @typescript-eslint/class-methods-use-this
   protected flush(): void {}

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

@@ -38,10 +38,9 @@ export type ChildNode = NodeInternals &
   }>;
 
 /**
- * The one place a public observable is seen as the node it is. Every
- * observable is built by a synstate class, and the public types carry a
- * brand an object literal cannot supply, so this holds for every value of
- * those types.
+ * The one place a public observable is seen as the node it is. Every observable
+ * is built by a synstate class, and the public types carry a brand an object
+ * literal cannot supply, so this holds for every value of those types.
  */
 export const toNode = <A,>(observable: Observable<A>): ObservableNode<A> =>
   // @sumi-expect-error banned-syntax/no-unsafe-type-assertion

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

@@ -11,15 +11,15 @@
  * 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';
 import type { ChildNode } from './observable-node.mjs';
 
 /**
- * How many updates are propagating, across every observable, and the token
- * of the outermost one. A write nothing observes opens none
+ * How many updates are propagating, across every observable, and the token of
+ * the outermost one. A write nothing observes opens none
  * (`setNextIfUnobserved`).
  */
 const mut_propagation: {
@@ -28,15 +28,14 @@ const mut_propagation: {
 } = { depth: 0, outermostToken: undefined };
 
 /**
- * Work deferred by {@link runAfterPropagation}, run once the outermost
- * update has reached every descendant.
+ * Work deferred by {@link runAfterPropagation}, run once the outermost update
+ * has reached every descendant.
  */
 const mut_afterPropagation: (() => void)[] = [];
 
 /**
- * Whether some observable's update is propagating right now. A root written
- * to while one is, is written to from inside a subscriber or a projection
- * (#2336).
+ * Whether some observable's update is propagating right now. A root written to
+ * while one is, is written to from inside a subscriber or a projection (#2336).
  */
 export const isPropagating = (): boolean => mut_propagation.depth > 0;
 
@@ -71,8 +70,7 @@ export const beginPropagation = (updateToken: UpdateToken): void => {
 };
 
 /**
- * Ends one update, and runs the deferred work once the outermost one has
- * ended.
+ * Ends one update, and runs the deferred work once the outermost one has ended.
  */
 export const endPropagation = (): void => {
   mut_propagation.depth -= 1;
@@ -91,11 +89,11 @@ export const endPropagation = (): void => {
 };
 
 /**
- * The buckets of this copy's open updates, one set per nesting level: a
- * bucket per depth below the node that started the update, holding the
- * queued nodes and how many of its slots are in use. Kept from update to
- * update, so that an update allocates nothing but its token; emptying a
- * bucket is setting its length to 0.
+ * The buckets of this copy's open updates, one set per nesting level: a bucket
+ * per depth below the node that started the update, holding the queued nodes
+ * and how many of its slots are in use. Kept from update to update, so that an
+ * update allocates nothing but its token; emptying a bucket is setting its
+ * length to 0.
  */
 const mut_bucketSets: Bucket[][] = [];
 
@@ -125,9 +123,9 @@ export const openUpdate = (depth: number): UpdateToken => {
 
 /**
  * How many updates of one copy may be open at once, one inside another. An
- * update opens inside another only when a subscriber or projection writes to
- * a root while the outer one is propagating; a chain of such writes this deep
- * is a loop that would otherwise run until the stack overflows.
+ * update opens inside another only when a subscriber or projection writes to a
+ * root while the outer one is propagating; a chain of such writes this deep is
+ * a loop that would otherwise run until the stack overflows.
  */
 export const maxUpdateNesting = 100;
 
@@ -173,10 +171,10 @@ type Bucket = {
  *
  * A queued node is marked with the token of the update that queued it
  * (`queuedFor`), which is how an update queues a node once. The mark is not
- * cleared after the visit: a later update has another token. An update does
- * not overwrite the mark of an update that is still open — one it is nested
- * in, or one of another copy of synstate — and remembers the nodes it
- * queues despite such a mark in a set of its own instead.
+ * cleared after the visit: a later update has another token. An update does not
+ * overwrite the mark of an update that is still open — one it is nested in, or
+ * one of another copy of synstate — and remembers the nodes it queues despite
+ * such a mark in a set of its own instead.
  */
 class UpdateQueue {
   readonly #base: number;
@@ -252,8 +250,8 @@ class UpdateQueue {
       }
 
       if (mark !== undefined && toQueue(mark).isOpen) {
-        // Another open update has queued `child` and may not have visited
-        // it yet: leave its mark alone.
+        // Another open update has queued `child` and may not have visited it
+        // yet: leave its mark alone.
         if (this.#mut_queuedDespiteMark === undefined) {
           this.#mut_queuedDespiteMark = new Set<ChildNode>();
         } else if (this.#mut_queuedDespiteMark.has(child)) {
@@ -274,8 +272,8 @@ class UpdateQueue {
 
     const mut_buckets = this.#mut_buckets;
 
-    // `size` grows while the buckets are visited, always past `index`, which
-    // a `range` built at the start would miss.
+    // `size` grows while the buckets are visited, always past `index`, which a
+    // `range` built at the start would miss.
     // eslint-disable-next-line ts-data-forge/prefer-range-for-loop
     for (let mut_index = 0; mut_index < this.#mut_size; mut_index += 1) {
       const mut_bucket = mut_buckets[mut_index];
@@ -284,9 +282,9 @@ class UpdateQueue {
         continue;
       }
 
-      // A node visited here queues only deeper nodes, so this bucket does
-      // not grow while it is visited. Its length is kept until the end, so
-      // that `close` can clear what an exception leaves.
+      // A node visited here queues only deeper nodes, so this bucket does not
+      // grow while it is visited. Its length is kept until the end, so that
+      // `close` can clear what an exception leaves.
       const { nodes: mut_nodes, length } = mut_bucket;
 
       // eslint-disable-next-line ts-data-forge/prefer-range-for-loop

package/src/core/class/remove-completed.test.mts

@@ -202,8 +202,8 @@ describe('a completed observable leaves the propagation graph', () => {
 
     const mut_got: number[] = [];
 
-    // Subscribed on a child, so the node is created while the update of `s`
-    // is under way.
+    // Subscribed on a child, so the node is created while the update of `s` is
+    // under way.
     s.pipe(map((x) => x)).subscribe((x) => {
       if (x === 1) {
         s.pipe(

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

@@ -16,11 +16,11 @@ export class RootObservableClass<A>
   implements RootObservable<A>
 {
   /**
-   * The outermost update propagating when this root was created. A root
-   * created while an update propagates (inside a `switchMap` projection,
-   * say) may emit while it is created, as `fromSubscribable` does for a
-   * synchronous source. Nothing is derived from it yet, so that is its
-   * initial value rather than a write (#2336).
+   * The outermost update propagating when this root was created. A root created
+   * while an update propagates (inside a `switchMap` projection, say) may emit
+   * while it is created, as `fromSubscribable` does for a synchronous source.
+   * Nothing is derived from it yet, so that is its initial value rather than a
+   * write (#2336).
    */
   readonly #createdDuring: UpdateToken | undefined;
   #mut_hasWarned: boolean;
@@ -64,10 +64,10 @@ export class RootObservableClass<A>
 
 /**
  * Shown once per root observable, the first time it is written to (`next`,
- * `setState`, `dispatch`, …) while another update is still propagating —
- * from a subscriber or a projection. The write still propagates immediately,
- * as it always has; the warning is there because the pattern is wrong, not
- * because anything was refused.
+ * `setState`, `dispatch`, …) while another update is still propagating — from a
+ * subscriber or a projection. The write still propagates immediately, as it
+ * always has; the warning is there because the pattern is wrong, not because
+ * anything was refused.
  */
 export const writeDuringPropagationWarning =
   'synstate: an observable was written to (next / setState / dispatch) while an update was propagating, so subscribers can see intermediate states. Derive the value with map / combine instead of writing from a subscriber or a projection.';

package/src/core/class/unobserved-write.test.mts

@@ -6,8 +6,8 @@ import { debounce, map, switchMap } from '../operators/index.mjs';
 import { writeDuringPropagationWarning } from './root-observable-class.mjs';
 
 // A write to an observable with no child and no subscriber stores the value
-// without opening an update (`ManagerObservableClass.startUpdate`). These
-// pin what that must not change.
+// without opening an update (`ManagerObservableClass.startUpdate`). These pin
+// what that must not change.
 describe('a write nothing observes', () => {
   test('is held, and a later subscriber receives the last one', () => {
     const s$ = source<number>(0);
@@ -98,8 +98,8 @@ describe('a write nothing observes', () => {
 
     a$.next(6);
 
-    // merge passes on the parents that emitted in an update: only b$, then
-    // only a$, never the value a$ was given while nothing observed it.
+    // merge passes on the parents that emitted in an update: only b$, then only
+    // a$, never the value a$ was given while nothing observed it.
     assert.deepStrictEqual(mut_merged, [1, 6]);
 
     assert.deepStrictEqual(mut_derived, [

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

@@ -1,11 +1,12 @@
 // Sumi bans classes, `this`, method syntax and writes to `this` outside a
-// `mut_` binding; an observable is a class (`ObservableBaseClass` says why),
-// so those rules are waived here (D-63).
+// `mut_` binding; an observable is a class (`ObservableBaseClass` says why), so
+// those rules are waived here (D-63).
 // @sumi-expect-error-file classes/no-class
 // @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 {
@@ -20,14 +21,13 @@ import type {
 
 /**
  * Derives one value from the latest values of several observables: one
- * observable that calls `project` with them, as arguments, and emits the
- * result unless it equals the one already held.
+ * observable that calls `project` with them, as arguments, and emits the result
+ * unless it equals the one already held.
  *
- * It emits once every parent has a value, and then whenever any of them
- * emits, as `combine` does; but where `combine(parents).pipe(map(fn))` is two
- * observables and a tuple per update, `derive` is one, and passes the values
- * as arguments (a rest parameter in `project` collects them into an array
- * again).
+ * It emits once every parent has a value, and then whenever any of them emits,
+ * as `combine` does; but where `combine(parents).pipe(map(fn))` is two
+ * observables and a tuple per update, `derive` is one, and passes the values as
+ * arguments (a rest parameter in `project` collects them into an array again).
  * The comparison is `Object.is` unless `equals` says otherwise.
  *
  * @template OS - Tuple type of the parent observables
@@ -83,8 +83,8 @@ export const derive = <const OS extends NonEmptyTuple<Observable<unknown>>, B>(
   // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
   new DeriveObservableClass(
     parents,
-    // `project` is called with the values of `parents`, position by
-    // position, which the checker cannot follow through an index.
+    // `project` is called with the values of `parents`, position by position,
+    // which the checker cannot follow through an index.
     // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
     project as (...values: readonly unknown[]) => B,
     options?.equals ?? Object.is,

package/src/core/combine/merge.mts

@@ -1,6 +1,6 @@
 // Sumi bans classes, `this`, method syntax and writes to `this` outside a
-// `mut_` binding; an observable is a class (`ObservableBaseClass` says why),
-// so those rules are waived here (D-63).
+// `mut_` binding; an observable is a class (`ObservableBaseClass` says why), so
+// those rules are waived here (D-63).
 // @sumi-expect-error-file classes/no-class
 // @sumi-expect-error-file banned-syntax/no-this
 // @sumi-expect-error-file functions/prefer-arrow-function

package/src/core/combine/zip.mts

@@ -1,11 +1,12 @@
 // Sumi bans classes, `this`, method syntax and writes to `this` outside a
-// `mut_` binding; an observable is a class (`ObservableBaseClass` says why),
-// so those rules are waived here (D-63).
+// `mut_` binding; an observable is a class (`ObservableBaseClass` says why), so
+// those rules are waived here (D-63).
 // @sumi-expect-error-file classes/no-class
 // @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';
@@ -26,9 +27,9 @@ import type {
 /**
  * Combines multiple observables by pairing their emissions by index.
  * Waits for all sources to emit their nth value before emitting the nth tuple.
- * Completes once a completed source has no value left to pair, as RxJS's
- * `zip` does: at once if it completes with nothing queued, otherwise after
- * the tuple that takes its last queued value.
+ * Completes once a completed source has no value left to pair, as RxJS's `zip`
+ * does: at once if it completes with nothing queued, otherwise after the tuple
+ * that takes its last queued value.
  *
  * @template OS - Tuple type of source observables
  * @param parents - Array of observables to zip
@@ -150,14 +151,16 @@ 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();
     }
   }
 
   /**
-   * No tuple can be completed any more once a completed source has nothing
-   * left to pair (#2343).
+   * No tuple can be completed any more once a completed source has nothing left
+   * to pair (#2343).
    */
   override canEmitNoMore(): boolean {
     return this.parents.some(