synstate 6.1.1 → 6.2.1

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

@@ -30,11 +30,11 @@ type ChildObservableConfig<A, P extends NonEmptyUnknownList> = Readonly<{
   parents: Wrap<P>;
 
   /**
-   * Defaults to one more than the deepest parent. An update reaches
-   * observables in ascending depth, so an observable `tryUpdate` reads with
-   * `getSnapshot` without being its child (`withCurrentValueFrom`'s second
-   * source) has to be shallower than this one too, or this one reads its value
-   * from before the update: pass `1 + Math.max(...)` over both then.
+   * Defaults to one more than the deepest parent. An update reaches observables
+   * in ascending depth, so an observable `tryUpdate` reads with `getSnapshot`
+   * without being its child (`withCurrentValueFrom`'s second source) has to be
+   * shallower than this one too, or this one reads its value from before the
+   * update: pass `1 + Math.max(...)` over both then.
    */
   depth?: number;
 
@@ -45,9 +45,9 @@ type ChildObservableConfig<A, P extends NonEmptyUnknownList> = Readonly<{
  * An observable derived from `parents` that emits, if at all, in the same
  * update as they do (`map`, `filter`, `combine`, …).
  *
- * A subclass overrides `tryUpdate`, and, when it holds something to
- * release, `teardown`; its constructor ends with `this.attach()`, once
- * everything `tryUpdate` and `teardown` read is in place.
+ * A subclass overrides `tryUpdate`, and, when it holds something to release,
+ * `teardown`; its constructor ends with `this.attach()`, once everything
+ * `tryUpdate` and `teardown` read is in place.
  */
 export class SyncChildObservableClass<A, const P extends NonEmptyUnknownList>
   extends ObservableBaseClass<A, 'sync child', number>
@@ -107,10 +107,9 @@ export class SyncChildObservableClass<A, const P extends NonEmptyUnknownList>
   }
 
   /**
-   * Whether this observable can emit nothing more although some parent is
-   * still live, asked whenever a parent completes. `true` completes it then,
-   * as all parents completing does (`zip` once a completed source's queue is
-   * empty).
+   * Whether this observable can emit nothing more although some parent is still
+   * live, asked whenever a parent completes. `true` completes it then, as all
+   * parents completing does (`zip` once a completed source's queue is empty).
    */
   // eslint-disable-next-line @typescript-eslint/class-methods-use-this
   canEmitNoMore(): boolean {
@@ -118,8 +117,8 @@ export class SyncChildObservableClass<A, const P extends NonEmptyUnknownList>
   }
 
   /**
-   * Completes this observable once the update now propagating has reached
-   * every descendant, so that they see the value just passed on first.
+   * Completes this observable once the update now propagating has reached every
+   * descendant, so that they see the value just passed on first.
    */
   protected completeAfterPropagation(): void {
     runAfterPropagation(() => {
@@ -129,8 +128,8 @@ export class SyncChildObservableClass<A, const P extends NonEmptyUnknownList>
 }
 
 /**
- * An observable derived from `parents` that may emit later, in an update of
- * its own, through `startUpdate` (`debounce`, `switchMap`). It may also emit
+ * An observable derived from `parents` that may emit later, in an update of its
+ * own, through `startUpdate` (`debounce`, `switchMap`). It may also emit
  * synchronously with `setNext`, as a sync child does. A subclass may also
  * override `flush`, to pass on at completion what it still holds.
  */
@@ -204,13 +203,13 @@ export class AsyncChildObservableClass<A, const P extends NonEmptyUnknownList>
    * `mergeMap` returned.
    *
    * If the inner observable already holds a value (`just(x)`, a state), it
-   * emits that value synchronously while being subscribed. That first value
-   * is emitted with `updateToken`, the token of the update that ran the
-   * projection, so it joins the propagation in progress like a sync
-   * operator's value would. Starting an update of its own instead would
-   * reach the nodes below before the current update reached this
-   * observable's siblings: a node reading both would see the new inner value
-   * beside stale sibling values (a glitch), and would emit twice.
+   * emits that value synchronously while being subscribed. That first value is
+   * emitted with `updateToken`, the token of the update that ran the
+   * projection, so it joins the propagation in progress like a sync operator's
+   * value would. Starting an update of its own instead would reach the nodes
+   * below before the current update reached this observable's siblings: a node
+   * reading both would see the new inner value beside stale sibling values (a
+   * glitch), and would emit twice.
    *
    * Values the inner observable emits later start updates of their own.
    */
@@ -236,8 +235,8 @@ export class AsyncChildObservableClass<A, const P extends NonEmptyUnknownList>
 
 /**
  * A sync child that always holds a value: a subclass passes a `Some` as its
- * `initialValue`. It differs from its base only in the types of
- * `getSnapshot` and `pipe`.
+ * `initialValue`. It differs from its base only in the types of `getSnapshot`
+ * and `pipe`.
  */
 export class InitializedSyncChildObservableClass<
   A,
@@ -266,8 +265,8 @@ export class InitializedSyncChildObservableClass<
 /* helpers */
 
 /**
- * Called by a parent that has completed: whether no live parent is left, or
- * no value can come from the live ones.
+ * Called by a parent that has completed: whether no live parent is left, or no
+ * value can come from the live ones.
  */
 const shouldComplete = (
   child: ChildNode & Readonly<{ canEmitNoMore: () => boolean }>,
@@ -275,6 +274,63 @@ const shouldComplete = (
   !child.isCompleted &&
   (child.parents.every((p) => p.isCompleted) || child.canEmitNoMore());
 
+const hasCircularDependencyFrom = (
+  node: Observable<unknown>,
+  mut_visited: MutableSet<Observable<unknown>>,
+  mut_inPath: MutableSet<Observable<unknown>>,
+): boolean => {
+  if (mut_inPath.has(node)) {
+    return true;
+  }
+
+  if (mut_visited.has(node)) {
+    return false;
+  }
+
+  mut_visited.add(node);
+
+  mut_inPath.add(node);
+
+  if (node.kind !== 'root') {
+    for (const parent of node.parents) {
+      if (hasCircularDependencyFrom(parent, mut_visited, mut_inPath)) {
+        return true;
+      }
+    }
+  }
+
+  mut_inPath.delete(node);
+
+  return false;
+};
+
+/**
+ * Detects circular dependencies by walking the full ancestor chain of the
+ * child's parents and checking whether the child already appears among them.
+ *
+ * @throws {Error} if a circular dependency is detected
+ */
+const detectCircularDependency = (child: ChildNode): void => {
+  const mut_visited = new Set<Observable<unknown>>();
+
+  const mut_inPath = new Set<Observable<unknown>>([
+    // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
+    child as Observable<unknown>,
+  ]);
+
+  for (const parent of child.parents) {
+    if (hasCircularDependencyFrom(parent, mut_visited, mut_inPath)) {
+      // A programming error (invariant violation), not a recoverable failure.
+      // `panic` marks the error it throws, so the `Result` / `AsyncResult`
+      // boundaries rethrow it rather than turning an invariant violation into
+      // an `Err` a caller might handle (Sumi D-48 / D-53).
+      panic(
+        'Circular dependency detected in observable graph: a child observable cannot be its own ancestor.',
+      );
+    }
+  }
+};
+
 /** Registers a child to its parents. */
 const registerChild = (child: ChildNode): void => {
   if (checksCircularDependency) {
@@ -287,9 +343,9 @@ const registerChild = (child: ChildNode): void => {
 };
 
 /**
- * Undoes {@link registerChild} for a completed child: its parents forget it,
- * so that no update puts it in its queue again. Without this a completed
- * node stayed reachable for as long as its root lived (#2134).
+ * Undoes {@link registerChild} for a completed child: its parents forget it, so
+ * that no update puts it in its queue again. Without this a completed node
+ * stayed reachable for as long as its root lived (#2134).
  */
 const unregisterChild = (child: ChildNode): void => {
   for (const p of child.parents) {
@@ -320,60 +376,3 @@ const isDevelopmentProcess = (): boolean => {
  * bundle).
  */
 export const checksCircularDependency: boolean = isDevelopmentProcess();
-
-/**
- * Detects circular dependencies by walking the full ancestor chain of the
- * child's parents and checking whether the child already appears among them.
- *
- * @throws {Error} if a circular dependency is detected
- */
-const detectCircularDependency = (child: ChildNode): void => {
-  const mut_visited = new Set<Observable<unknown>>();
-
-  const mut_inPath = new Set<Observable<unknown>>([
-    // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
-    child as Observable<unknown>,
-  ]);
-
-  for (const parent of child.parents) {
-    if (hasCircularDependencyFrom(parent, mut_visited, mut_inPath)) {
-      // A programming error (invariant violation), not a recoverable
-      // failure. `panic` marks the error it throws, so the `Result` /
-      // `AsyncResult` boundaries rethrow it rather than turning an invariant
-      // violation into an `Err` a caller might handle (Sumi D-48 / D-53).
-      panic(
-        'Circular dependency detected in observable graph: a child observable cannot be its own ancestor.',
-      );
-    }
-  }
-};
-
-const hasCircularDependencyFrom = (
-  node: Observable<unknown>,
-  mut_visited: MutableSet<Observable<unknown>>,
-  mut_inPath: MutableSet<Observable<unknown>>,
-): boolean => {
-  if (mut_inPath.has(node)) {
-    return true;
-  }
-
-  if (mut_visited.has(node)) {
-    return false;
-  }
-
-  mut_visited.add(node);
-
-  mut_inPath.add(node);
-
-  if (node.kind !== 'root') {
-    for (const parent of node.parents) {
-      if (hasCircularDependencyFrom(parent, mut_visited, mut_inPath)) {
-        return true;
-      }
-    }
-  }
-
-  mut_inPath.delete(node);
-
-  return false;
-};

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

@@ -49,8 +49,8 @@ describe('circular dependency comparison', () => {
         );
 
         // 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.
+        // 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,

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

@@ -31,17 +31,16 @@ export type SyncChildObservableTools<A> = Readonly<{
   complete: () => void;
 
   /**
-   * Completes this observable once the update now propagating has reached
-   * every descendant, so that they see the value just passed on first.
+   * Completes this observable once the update now propagating has reached every
+   * descendant, so that they see the value just passed on first.
    */
   completeAfterPropagation: () => void;
 
   /**
    * Registers a teardown (clear timers, unsubscribe inner observables, …) to
-   * run when this observable completes or is disposed, in the order
-   * registered. Called from `init`, it lets the teardown close over what
-   * `init` creates. Registered once the observable has completed, the
-   * teardown runs at once.
+   * run when this observable completes or is disposed, in the order registered.
+   * Called from `init`, it lets the teardown close over what `init` creates.
+   * Registered once the observable has completed, the teardown runs at once.
    */
   onComplete: (teardown: () => void) => void;
 }>;
@@ -57,21 +56,20 @@ export type AsyncChildObservableTools<A> = Readonly<{
   SyncChildObservableTools<A>;
 
 /**
- * What a sync child's `init` may return instead of `tryUpdate` alone: the
- * hooks the factory calls, which read the state `init` creates.
+ * What a sync child's `init` may return instead of `tryUpdate` alone: the hooks
+ * the factory calls, which read the state `init` creates.
  */
 export type SyncChildObservableHooks = Readonly<{
   /**
-   * Called with the token of every update in which a parent of this
-   * observable emitted.
+   * Called with the token of every update in which a parent of this observable
+   * emitted.
    */
   tryUpdate: (updateToken: UpdateToken) => void;
 
   /**
-   * Whether this observable can emit nothing more although some parent is
-   * still live, asked whenever a parent completes. `true` completes it then,
-   * as all parents completing does (`zip` once a completed source's queue is
-   * empty).
+   * Whether this observable can emit nothing more although some parent is still
+   * live, asked whenever a parent completes. `true` completes it then, as all
+   * parents completing does (`zip` once a completed source's queue is empty).
    */
   canEmitNoMore?: () => boolean;
 }>;
@@ -84,8 +82,8 @@ export type SyncChildObservableHooks = Readonly<{
 export type AsyncChildObservableHooks = SyncChildObservableHooks &
   Readonly<{
     /**
-     * Run at the beginning of `complete()`, before the teardowns, and never
-     * by `dispose()`: passes on what this observable still holds through
+     * Run at the beginning of `complete()`, before the teardowns, and never by
+     * `dispose()`: passes on what this observable still holds through
      * `startUpdate`, so that its subscribers see it before they see the
      * completion. A disposed observable has no one left to tell.
      */
@@ -96,11 +94,11 @@ type ChildObservableConfigBase<P extends NonEmptyUnknownList> = Readonly<{
   parents: Wrap<P>;
 
   /**
-   * Defaults to one more than the deepest parent. An update reaches
-   * observables in ascending depth, so an observable `tryUpdate` reads with
-   * `getSnapshot` without being its child (`withCurrentValueFrom`'s second
-   * source) has to be shallower than this one too, or this one reads its value
-   * from before the update: pass `1 + Math.max(...)` over both then.
+   * Defaults to one more than the deepest parent. An update reaches observables
+   * in ascending depth, so an observable `tryUpdate` reads with `getSnapshot`
+   * without being its child (`withCurrentValueFrom`'s second source) has to be
+   * shallower than this one too, or this one reads its value from before the
+   * update: pass `1 + Math.max(...)` over both then.
    */
   depth?: number;
 }>;
@@ -122,15 +120,15 @@ export type InitializedChildObservableConfig<
   }>;
 
 /**
- * Creates a sync-child observable: one derived from `parents` that emits, if
- * at all, in the same update as they do. `map`, `filter`, `combine` and the
- * other synchronous operators are built with it.
+ * Creates a sync-child observable: one derived from `parents` that emits, if at
+ * all, in the same update as they do. `map`, `filter`, `combine` and the other
+ * synchronous operators are built with it.
  *
  * `init` runs during construction and receives the tools. It returns
  * `tryUpdate`, which is called with the token of every update in which some
- * parent of this observable emitted — a parent that did not emit in that
- * update has a different `updateToken`; to emit, call `setNext` with the
- * token received — or an object holding `tryUpdate` and the other hooks
+ * parent of this observable emitted — a parent that did not emit in that update
+ * has a different `updateToken`; to emit, call `setNext` with the token
+ * received — or an object holding `tryUpdate` and the other hooks
  * ({@link SyncChildObservableHooks}). State the hooks share can live inside
  * `init`, next to the teardown it registers with the `onComplete` tool.
  * `init` may complete the observable; it is then never registered to its
@@ -211,8 +209,8 @@ export const createInitializedSyncChildObservable = <
  * Creates an async-child observable: one derived from `parents` that may emit
  * later, in an update of its own, through `startUpdate` (`debounce`,
  * `switchMap`). It may also emit synchronously with `setNext`, as a sync child
- * does. See {@link createSyncChildObservable} for the `init` contract; an
- * async child's `init` may also return a `flush` hook
+ * does. See {@link createSyncChildObservable} for the `init` contract; an async
+ * child's `init` may also return a `flush` hook
  * ({@link AsyncChildObservableHooks}).
  */
 export const createAsyncChildObservable = <A, P extends NonEmptyUnknownList>(

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

@@ -8,8 +8,8 @@ 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 +23,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 +37,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