effect 4.0.0-beta.28 → 4.0.0-beta.29

package/src/Newtype.ts

@@ -0,0 +1,308 @@
+/**
+ * Lightweight wrapper types that prevent accidental mixing of structurally
+ * identical values (e.g. `UserId` vs `OrderId`, both `string` at runtime).
+ *
+ * **Mental model**
+ *
+ * - **Newtype** — a compile-time wrapper around a **carrier** type (the
+ *   underlying primitive or object). At runtime the value is unchanged; the
+ *   tag exists only in the type system.
+ * - **Key** — a unique string literal that distinguishes one newtype from
+ *   another (e.g. `"Label"`, `"UserId"`).
+ * - **Carrier** — the underlying type the newtype wraps (e.g. `string`,
+ *   `number`).
+ * - **Iso** — a lossless two-way conversion between a newtype and its carrier,
+ *   created with {@link makeIso}. Use `iso.set(carrier)` to wrap and
+ *   `iso.get(newtype)` to unwrap.
+ *
+ * **Common tasks**
+ *
+ * - Define a newtype → declare an `interface` extending
+ *   `Newtype.Newtype<Key, Carrier>`
+ * - Wrap / unwrap values → {@link makeIso} (returns an `Optic.Iso`)
+ * - Unwrap only → {@link value}
+ * - Lift an `Equivalence` → {@link makeEquivalence}
+ * - Lift an `Order` → {@link makeOrder}
+ * - Lift a `Combiner` → {@link makeCombiner}
+ * - Lift a `Reducer` → {@link makeReducer}
+ *
+ * **Gotchas**
+ *
+ * - Newtypes are **purely compile-time**. There is zero runtime overhead;
+ *   `value` and `makeIso` use identity casts.
+ * - Two newtypes sharing the same key string will be assignable to each other.
+ *   Choose unique key strings.
+ * - A newtype value is **not** assignable to its carrier type without
+ *   explicitly unwrapping via {@link value} or an iso.
+ *
+ * **Quickstart**
+ *
+ * **Example** (defining and using a newtype)
+ *
+ * ```ts
+ * import { Newtype } from "effect"
+ *
+ * // 1. Define a newtype
+ * interface Label extends Newtype.Newtype<"Label", string> {}
+ *
+ * // 2. Create an iso for wrapping/unwrapping
+ * const labelIso = Newtype.makeIso<Label>()
+ *
+ * // 3. Wrap a raw string
+ * const myLabel: Label = labelIso.set("hello")
+ *
+ * // 4. Unwrap back to string
+ * const raw: string = labelIso.get(myLabel) // "hello"
+ * ```
+ *
+ * **See also**
+ *
+ * - {@link Newtype} (the tagged interface)
+ * - {@link makeIso} (wrap and unwrap)
+ * - {@link value} (unwrap only)
+ *
+ * @since 4.0.0
+ */
+import type * as Combiner from "./Combiner.ts"
+import type * as Equivalence from "./Equivalence.ts"
+import { cast } from "./Function.ts"
+import * as Optic from "./Optic.ts"
+import type * as Order from "./Order.ts"
+import type * as Reducer from "./Reducer.ts"
+
+const TypeId = "~effect/Newtype"
+
+/**
+ * A tagged interface that wraps a carrier type under a unique key, preventing
+ * accidental interchange of structurally identical values.
+ *
+ * - Define your newtype as an `interface` extending
+ *   `Newtype<"MyKey", CarrierType>`.
+ * - The tag is compile-time only; no runtime wrapper is allocated.
+ * - Use {@link makeIso} to create a two-way conversion, or {@link value} to
+ *   unwrap.
+ *
+ * **Example** (defining a newtype)
+ *
+ * ```ts
+ * import { Newtype } from "effect"
+ *
+ * interface UserId extends Newtype.Newtype<"UserId", number> {}
+ * interface OrderId extends Newtype.Newtype<"OrderId", number> {}
+ *
+ * // UserId and OrderId are not assignable to each other
+ * // even though both wrap `number`.
+ * ```
+ *
+ * @see {@link makeIso} — create an iso to wrap and unwrap
+ * @see {@link value} — unwrap a newtype value
+ *
+ * @since 4.0.0
+ */
+export interface Newtype<in out Key extends string, out Carrier> {
+  readonly [TypeId]: {
+    readonly key: Key
+    readonly carrier: Carrier
+  }
+}
+
+/**
+ * @since 4.0.0
+ */
+export declare namespace Newtype {
+  /**
+   * A type that matches any `Newtype`, useful as a generic constraint:
+   * `<N extends Newtype.Any>`.
+   *
+   * @see {@link Newtype} — the base tagged interface
+   *
+   * @since 4.0.0
+   */
+  export type Any = Newtype<any, unknown>
+
+  /**
+   * Extracts the key literal type from a newtype.
+   *
+   * - Useful in generic code that needs to inspect or constrain the key.
+   *
+   * @since 4.0.0
+   */
+  export type Key<N extends Any> = N extends Newtype<infer Key, unknown> ? Key : never
+
+  /**
+   * Extracts the carrier (underlying) type from a newtype.
+   *
+   * - Useful when you need to refer to the wrapped type in generic utilities.
+   *
+   * @since 4.0.0
+   */
+  export type Carrier<N extends Any> = N extends Newtype<infer _Key, infer Carrier> ? Carrier : never
+}
+
+/**
+ * Unwraps a newtype value, returning the underlying carrier value.
+ *
+ * - Use when you only need to read the inner value and do not need to wrap new
+ *   values.
+ * - For both wrapping and unwrapping, prefer {@link makeIso}.
+ * - Zero runtime cost: this is an identity cast.
+ *
+ * **Example** (unwrapping a newtype)
+ *
+ * ```ts
+ * import { Newtype } from "effect"
+ *
+ * interface Label extends Newtype.Newtype<"Label", string> {}
+ *
+ * const iso = Newtype.makeIso<Label>()
+ * const label = iso.set("hello")
+ *
+ * const raw: string = Newtype.value(label) // "hello"
+ * ```
+ *
+ * @see {@link makeIso} — two-way conversion (wrap and unwrap)
+ *
+ * @since 4.0.0
+ */
+export const value: <N extends Newtype.Any>(newtype: N) => Newtype.Carrier<N> = cast
+
+/**
+ * Creates an `Optic.Iso` for a newtype, providing both wrapping (`set`) and
+ * unwrapping (`get`).
+ *
+ * - Use this as the primary way to construct and deconstruct newtype values.
+ * - The returned iso composes with other optics via the standard `Optic` API.
+ * - Zero runtime cost: both directions are identity casts.
+ *
+ * **Example** (wrapping and unwrapping with an iso)
+ *
+ * ```ts
+ * import { Newtype } from "effect"
+ *
+ * interface Label extends Newtype.Newtype<"Label", string> {}
+ *
+ * const labelIso = Newtype.makeIso<Label>()
+ *
+ * const label: Label = labelIso.set("world")
+ * const str: string = labelIso.get(label) // "world"
+ * ```
+ *
+ * @see {@link value} — unwrap only
+ *
+ * @since 4.0.0
+ */
+export function makeIso<N extends Newtype.Any>(): Optic.Iso<N, Newtype.Carrier<N>> {
+  return Optic.makeIso(value, cast)
+}
+
+/**
+ * Lifts an `Equivalence` for the carrier type into an `Equivalence` for the
+ * newtype.
+ *
+ * - Use when you need to compare two newtype values for equality.
+ * - The returned equivalence delegates to the provided carrier equivalence.
+ * - Zero runtime cost beyond the underlying equivalence check.
+ *
+ * **Example** (comparing newtypes)
+ *
+ * ```ts
+ * import { Newtype, Equivalence } from "effect"
+ *
+ * interface Label extends Newtype.Newtype<"Label", string> {}
+ *
+ * const eq = Newtype.makeEquivalence<Label>(Equivalence.String)
+ * const iso = Newtype.makeIso<Label>()
+ *
+ * eq(iso.set("a"), iso.set("a")) // true
+ * eq(iso.set("a"), iso.set("b")) // false
+ * ```
+ *
+ * @see {@link makeOrder} — lift an `Order` for the carrier
+ *
+ * @since 4.0.0
+ */
+export const makeEquivalence: <N extends Newtype.Any>(
+  equivalence: Equivalence.Equivalence<Newtype.Carrier<N>>
+) => Equivalence.Equivalence<N> = cast
+
+/**
+ * Lifts an `Order` for the carrier type into an `Order` for the newtype.
+ *
+ * - Use when you need to sort or compare newtype values.
+ * - The returned order delegates to the provided carrier order.
+ *
+ * **Example** (ordering newtypes)
+ *
+ * ```ts
+ * import { Newtype, Order } from "effect"
+ *
+ * interface Score extends Newtype.Newtype<"Score", number> {}
+ *
+ * const ord = Newtype.makeOrder<Score>(Order.Number)
+ * const iso = Newtype.makeIso<Score>()
+ *
+ * ord(iso.set(1), iso.set(2)) // -1
+ * ```
+ *
+ * @see {@link makeEquivalence} — lift an `Equivalence` for the carrier
+ *
+ * @since 4.0.0
+ */
+export const makeOrder: <N extends Newtype.Any>(order: Order.Order<Newtype.Carrier<N>>) => Order.Order<N> = cast
+
+/**
+ * Lifts a `Combiner` for the carrier type into a `Combiner` for the newtype.
+ *
+ * - Use when you need to combine (e.g. concatenate, add) newtype values.
+ * - The returned combiner delegates to the provided carrier combiner.
+ *
+ * **Example** (combining newtypes)
+ *
+ * ```ts
+ * import { Newtype, Combiner } from "effect"
+ *
+ * interface Amount extends Newtype.Newtype<"Amount", number> {}
+ *
+ * const sum = Combiner.make<number>((a, b) => a + b)
+ * const combiner = Newtype.makeCombiner<Amount>(sum)
+ * const iso = Newtype.makeIso<Amount>()
+ *
+ * const total = combiner.combine(iso.set(10), iso.set(20))
+ * Newtype.value(total) // 30
+ * ```
+ *
+ * @see {@link makeReducer} — lift a `Reducer` for the carrier
+ *
+ * @since 4.0.0
+ */
+export const makeCombiner: <N extends Newtype.Any>(
+  combiner: Combiner.Combiner<Newtype.Carrier<N>>
+) => Combiner.Combiner<N> = cast
+
+/**
+ * Lifts a `Reducer` for the carrier type into a `Reducer` for the newtype.
+ *
+ * - Use when you need to fold/reduce over a collection of newtype values.
+ * - The returned reducer delegates to the provided carrier reducer.
+ *
+ * **Example** (reducing newtypes)
+ *
+ * ```ts
+ * import { Newtype, Reducer } from "effect"
+ *
+ * interface Score extends Newtype.Newtype<"Score", number> {}
+ *
+ * const sum = Reducer.make<number>((a, b) => a + b, 0)
+ * const reducer = Newtype.makeReducer<Score>(sum)
+ * const iso = Newtype.makeIso<Score>()
+ *
+ * const total = reducer.combineAll([iso.set(1), iso.set(2), iso.set(3)])
+ * Newtype.value(total) // 6
+ * ```
+ *
+ * @see {@link makeCombiner} — lift a `Combiner` for the carrier
+ *
+ * @since 4.0.0
+ */
+export const makeReducer: <N extends Newtype.Any>(reducer: Reducer.Reducer<Newtype.Carrier<N>>) => Reducer.Reducer<N> =
+  cast

package/src/Schema.ts

@@ -3590,7 +3590,7 @@ const getUUIDRegExp = (version?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8): globalThis.RegE
  * @category String checks
  * @since 4.0.0
  */
-export function isUUID(version: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | undefined, annotations?: Annotations.Filter) {
+export function isUUID(version?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8, annotations?: Annotations.Filter) {
   const regExp = getUUIDRegExp(version)
   return isPattern(
     regExp,

package/src/SchemaAST.ts

@@ -3206,10 +3206,7 @@ export const bigIntString = appendChecks(string, [isStringBigInt()])
 
 const bigIntToString = new Link(
   bigIntString,
-  new Transformation.Transformation(
-    Getter.transform(globalThis.BigInt),
-    Getter.String()
-  )
+  Transformation.bigintFromString
 )
 
 const REGEXP_PATTERN = "Symbol\\((.*)\\)"

package/src/index.ts

@@ -10,7 +10,7 @@ export {
   /**
    * @since 2.0.0
    */
-  coerceUnsafe,
+  cast,
   /**
    * @since 2.0.0
    */
@@ -958,12 +958,12 @@ export * as Duration from "./Duration.ts"
  * ```ts
  * import { Data, Effect } from "effect"
  *
- * class DivisionByZeroError extends Data.TaggedError("DivisionByZeroError")<{}> {}
+ * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
  *
  * // Effect that may fail
  * const divide = (a: number, b: number) =>
  *   b === 0
- *     ? Effect.fail(new DivisionByZeroError())
+ *     ? Effect.fail(new DiscountRateError())
  *     : Effect.succeed(a / b)
  *
  * // Error handling
@@ -2314,6 +2314,73 @@ export * as MutableList from "./MutableList.ts"
  */
 export * as MutableRef from "./MutableRef.ts"
 
+/**
+ * Lightweight wrapper types that prevent accidental mixing of structurally
+ * identical values (e.g. `UserId` vs `OrderId`, both `string` at runtime).
+ *
+ * **Mental model**
+ *
+ * - **Newtype** — a compile-time wrapper around a **carrier** type (the
+ *   underlying primitive or object). At runtime the value is unchanged; the
+ *   tag exists only in the type system.
+ * - **Key** — a unique string literal that distinguishes one newtype from
+ *   another (e.g. `"Label"`, `"UserId"`).
+ * - **Carrier** — the underlying type the newtype wraps (e.g. `string`,
+ *   `number`).
+ * - **Iso** — a lossless two-way conversion between a newtype and its carrier,
+ *   created with {@link makeIso}. Use `iso.set(carrier)` to wrap and
+ *   `iso.get(newtype)` to unwrap.
+ *
+ * **Common tasks**
+ *
+ * - Define a newtype → declare an `interface` extending
+ *   `Newtype.Newtype<Key, Carrier>`
+ * - Wrap / unwrap values → {@link makeIso} (returns an `Optic.Iso`)
+ * - Unwrap only → {@link value}
+ * - Lift an `Equivalence` → {@link makeEquivalence}
+ * - Lift an `Order` → {@link makeOrder}
+ * - Lift a `Combiner` → {@link makeCombiner}
+ * - Lift a `Reducer` → {@link makeReducer}
+ *
+ * **Gotchas**
+ *
+ * - Newtypes are **purely compile-time**. There is zero runtime overhead;
+ *   `value` and `makeIso` use identity casts.
+ * - Two newtypes sharing the same key string will be assignable to each other.
+ *   Choose unique key strings.
+ * - A newtype value is **not** assignable to its carrier type without
+ *   explicitly unwrapping via {@link value} or an iso.
+ *
+ * **Quickstart**
+ *
+ * **Example** (defining and using a newtype)
+ *
+ * ```ts
+ * import { Newtype } from "effect"
+ *
+ * // 1. Define a newtype
+ * interface Label extends Newtype.Newtype<"Label", string> {}
+ *
+ * // 2. Create an iso for wrapping/unwrapping
+ * const labelIso = Newtype.makeIso<Label>()
+ *
+ * // 3. Wrap a raw string
+ * const myLabel: Label = labelIso.set("hello")
+ *
+ * // 4. Unwrap back to string
+ * const raw: string = labelIso.get(myLabel) // "hello"
+ * ```
+ *
+ * **See also**
+ *
+ * - {@link Newtype} (the tagged interface)
+ * - {@link makeIso} (wrap and unwrap)
+ * - {@link value} (unwrap only)
+ *
+ * @since 4.0.0
+ */
+export * as Newtype from "./Newtype.ts"
+
 /**
  * @since 2.0.0
  *

package/src/unstable/cli/Prompt.ts

@@ -3108,10 +3108,6 @@ interface TextState {
   readonly error: string | undefined
 }
 
-const getValue = (state: TextState, options: TextOptionsReq): string => {
-  return state.value.length > 0 ? state.value : options.default
-}
-
 const renderClearScreen = Effect.fnUntraced(function*(state: TextState, options: TextOptionsReq) {
   const terminal = yield* Terminal.Terminal
   const columns = yield* terminal.columns
@@ -3132,7 +3128,7 @@ const renderTextInput = (
   submitted: boolean,
   renderOptions?: RenderOptions | undefined
 ) => {
-  const text = getValue(nextState, options)
+  const text = nextState.value
   if (renderOptions?.plain === true) {
     switch (options.type) {
       case "hidden": {
@@ -3269,11 +3265,10 @@ const processTab = (state: TextState, options: TextOptionsReq) => {
   if (state.value === options.default) {
     return Effect.succeed(Action.Beep())
   }
-  const value = getValue(state, options)
-  const cursor = value.length
+  const value = state.value.length === 0 ? options.default : state.value
   return Effect.succeed(
     Action.NextFrame({
-      state: { ...state, value, cursor, error: undefined }
+      state: { ...state, value, cursor: value.length, error: undefined }
     })
   )
 }
@@ -3317,7 +3312,7 @@ const handleTextProcess = (options: TextOptionsReq) => {
       }
       case "enter":
       case "return": {
-        const value = getValue(state, options)
+        const value = state.value
         return Effect.match(options.validate(value), {
           onFailure: (error) =>
             Action.NextFrame({

package/src/unstable/http/HttpClient.ts

@@ -6,7 +6,6 @@ import * as Cause from "../../Cause.ts"
 import { Clock } from "../../Clock.ts"
 import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
-import * as Exit from "../../Exit.ts"
 import * as Fiber from "../../Fiber.ts"
 import { constant, constFalse, constTrue, dual, flow, identity } from "../../Function.ts"
 import * as Inspectable from "../../Inspectable.ts"
@@ -1735,12 +1734,12 @@ class InterruptibleResponse implements HttpClientResponse.HttpClientResponse {
   get stream() {
     return Stream.suspend(() => {
       responseRegistry.unregister(this.original)
-      return Stream.onExit(this.original.stream, (exit) => {
-        if (Exit.hasInterrupts(exit)) {
+      return Stream.ensuring(
+        this.original.stream,
+        Effect.sync(() => {
           this.controller.abort()
-        }
-        return Effect.void
-      })
+        })
+      )
     })
   }
 

package/src/unstable/reactivity/Atom.ts

@@ -25,7 +25,7 @@ import * as Scope from "../../Scope.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
 import * as SubscriptionRef from "../../SubscriptionRef.ts"
-import type { NoInfer } from "../../Types.ts"
+import type { Mutable, NoInfer } from "../../Types.ts"
 import * as KeyValueStore from "../persistence/KeyValueStore.ts"
 import * as AsyncResult from "./AsyncResult.ts"
 import { AtomRegistry } from "./AtomRegistry.ts"
@@ -56,6 +56,7 @@ export interface Atom<A> extends Pipeable, Inspectable.Inspectable {
   readonly refresh?: (f: <A>(atom: Atom<A>) => void) => void
   readonly label?: readonly [name: string, stack: string]
   readonly idleTTL?: number
+  readonly initialValueTarget?: Atom<A>
 }
 
 /**
@@ -792,7 +793,7 @@ export const context: (options: {
         }))
         get.subscribe(atom, (value) => get.setSelf(value))
         return get.once(atom)
-      }) as any as A
+      }, { initialValueTarget: atom }) as any as A
   return factory
 }
 
@@ -1600,16 +1601,35 @@ export const transform: {
    * @since 4.0.0
    * @category combinators
    */
-  <R extends Atom<any>, B>(f: (get: Context, atom: R) => B): (self: R) => [R] extends [Writable<infer _, infer RW>] ? Writable<B, RW> : Atom<B>
+  <R extends Atom<any>, B>(
+    f: (get: Context, atom: R) => B,
+    options?: {
+      readonly initialValueTarget?: Atom<B> | undefined
+    }
+  ): (self: R) => [R] extends [Writable<infer _, infer RW>] ? Writable<B, RW> : Atom<B>
   /**
    * @since 4.0.0
    * @category combinators
    */
-  <R extends Atom<any>, B>(self: R, f: (get: Context, atom: R) => B): [R] extends [Writable<infer _, infer RW>] ? Writable<B, RW> : Atom<B>
+  <R extends Atom<any>, B>(
+    self: R,
+    f: (get: Context, atom: R) => B,
+    options?: {
+      readonly initialValueTarget?: Atom<B> | undefined
+    }
+  ): [R] extends [Writable<infer _, infer RW>] ? Writable<B, RW> : Atom<B>
 } = dual(
-  2,
-  (<A, B>(self: Atom<A>, f: (get: Context, atom: Atom<A>) => B): Atom<B> =>
-    removeTtl(
+  (args) => isAtom(args[0]),
+  (<A, B>(
+    self: Atom<A>,
+    f: (get: Context, atom: Atom<A>, options?: {
+      readonly initialValueTarget?: Atom<B> | undefined
+    }) => B,
+    options?: {
+      readonly initialValueTarget?: Atom<B> | undefined
+    }
+  ): Atom<B> => {
+    const atom = removeTtl(
       isWritable(self)
         ? writable(
           (get) => f(get, self),
@@ -1626,9 +1646,22 @@ export const transform: {
             refresh(self)
           }
         )
-    )) as any
+    )
+    if (options?.initialValueTarget) {
+      ;(atom as Mutable<Atom<B>>).initialValueTarget = getInitialValueTarget(options.initialValueTarget)
+    }
+    return atom
+  }) as any
 )
 
+const getInitialValueTarget = <A>(atom: Atom<A>): Atom<A> => {
+  let target = atom
+  while (target.initialValueTarget) {
+    target = target.initialValueTarget
+  }
+  return target
+}
+
 /**
  * @since 4.0.0
  * @category combinators
@@ -1712,7 +1745,7 @@ export const debounce: {
         timeout = setTimeout(update, millis) as any
       })
       return value
-    })
+    }, { initialValueTarget: self })
   }
 )
 
@@ -1748,7 +1781,7 @@ export const withRefresh: {
       const handle = setTimeout(() => get.refresh(self), millis) as any
       get.addFinalizer(() => clearTimeout(handle))
       return get(self)
-    })
+    }, { initialValueTarget: self })
   }
 )
 
@@ -1849,7 +1882,7 @@ export const swr: {
         get.refresh(self)
       }
       return current
-    })
+    }, { initialValueTarget: self })
   }
 ) as any
 
@@ -2088,7 +2121,7 @@ export const makeRefreshOnSignal = <_>(signal: Atom<_>) => <A extends Atom<any>>
     get.subscribe(signal, (_) => get.refresh(self))
     get.subscribe(self, (value) => get.setSelf(value))
     return get.once(self)
-  }) as any
+  }, { initialValueTarget: self }) as any
 
 /**
  * @since 4.0.0

package/src/unstable/reactivity/AtomRegistry.ts

@@ -317,7 +317,11 @@ class RegistryImpl implements AtomRegistry {
     }
     if (initialValues !== undefined) {
       for (const [atom, value] of initialValues) {
-        this.ensureNode(atom).setValue(value)
+        let target = atom
+        while (target.initialValueTarget) {
+          target = target.initialValueTarget
+        }
+        this.ensureNode(target).setInitialValue(value)
       }
     }
   }
@@ -558,6 +562,7 @@ class NodeImpl<A> {
   state: NodeState = NodeState.uninitialized
   lifetime: Lifetime<A> | undefined
   writeContext: WriteContextImpl<A>
+  preserveInitialValueOnBuild = false
 
   parents: Array<NodeImpl<any>> = []
   previousParents: Array<NodeImpl<any>> | undefined
@@ -588,7 +593,12 @@ class NodeImpl<A> {
       this.lifetime = makeLifetime(this)
       const value = this.atom.read(this.lifetime)
       if ((this.state & NodeFlags.waitingForValue) !== 0) {
-        this.setValue(value)
+        if (this.preserveInitialValueOnBuild) {
+          this.preserveInitialValueOnBuild = false
+          this.state = NodeState.valid
+        } else {
+          this.setValue(value)
+        }
       }
 
       if (this.previousParents) {
@@ -613,6 +623,24 @@ class NodeImpl<A> {
     return Option.some(this._value)
   }
 
+  setInitialValue(value: A): void {
+    if ((this.state & NodeFlags.initialized) === 0) {
+      this.preserveInitialValueOnBuild = true
+      this.state = NodeState.stale
+      this._value = value
+
+      if (batchState.phase === BatchPhase.collect) {
+        batchState.notify.add(this)
+      } else {
+        this.notify()
+      }
+
+      return
+    }
+
+    this.setValue(value)
+  }
+
   setValue(value: A): void {
     if ((this.state & NodeFlags.initialized) === 0) {
       this.state = NodeState.valid