effect 2.0.0-next.57 → 2.0.0-next.59

package/src/internal/config.ts

@@ -1,7 +1,6 @@
 import * as Chunk from "../Chunk.js"
 import type * as Config from "../Config.js"
 import * as ConfigError from "../ConfigError.js"
-import type * as ConfigSecret from "../ConfigSecret.js"
 import * as Either from "../Either.js"
 import type { LazyArg } from "../Function.js"
 import { constTrue, dual, pipe } from "../Function.js"
@@ -11,10 +10,11 @@ import type * as LogLevel from "../LogLevel.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import { hasProperty, type Predicate, type Refinement } from "../Predicate.js"
+import type * as Secret from "../Secret.js"
 import * as configError from "./configError.js"
-import * as configSecret from "./configSecret.js"
 import * as core from "./core.js"
 import * as OpCodes from "./opCodes/config.js"
+import * as InternalSecret from "./secret.js"
 
 const ConfigSymbolKey = "effect/Config"
 
@@ -380,10 +380,10 @@ export const repeat = <A>(self: Config.Config<A>): Config.Config<Array<A>> => {
 }
 
 /** @internal */
-export const secret = (name?: string): Config.Config<ConfigSecret.ConfigSecret> => {
+export const secret = (name?: string): Config.Config<Secret.Secret> => {
   const config = primitive(
     "a secret property",
-    (text) => Either.right(configSecret.fromString(text))
+    (text) => Either.right(InternalSecret.fromString(text))
   )
   return name === undefined ? config : nested(config, name)
 }

package/src/internal/console.ts

@@ -3,6 +3,7 @@ import * as Context from "../Context.js"
 import type * as Effect from "../Effect.js"
 import { dual } from "../Function.js"
 import type * as Layer from "../Layer.js"
+import type * as Scope from "../Scope.js"
 import * as core from "./core.js"
 import * as defaultServices from "./defaultServices.js"
 import * as defaultConsole from "./defaultServices/console.js"
@@ -33,6 +34,13 @@ export const withConsole = dual<
     Context.add(defaultConsole.consoleTag, value)
   ))
 
+/** @internal */
+export const withConsoleScoped = <A extends Console.Console>(console: A): Effect.Effect<Scope.Scope, never, void> =>
+  fiberRuntime.fiberRefLocallyScopedWith(
+    defaultServices.currentServices,
+    Context.add(defaultConsole.consoleTag, console)
+  )
+
 /** @internal */
 export const setConsole = <A extends Console.Console>(console: A): Layer.Layer<never, never, never> =>
   layer.scopedDiscard(

package/src/internal/core-effect.ts

@@ -1398,17 +1398,9 @@ export const tagMetrics = dual<
 export const labelMetrics = dual<
   (labels: Iterable<MetricLabel.MetricLabel>) => <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
   <R, E, A>(self: Effect.Effect<R, E, A>, labels: Iterable<MetricLabel.MetricLabel>) => Effect.Effect<R, E, A>
->(2, (self, labels) => labelMetricsSet(self, HashSet.fromIterable(labels)))
-
-/* @internal */
-export const labelMetricsSet = dual<
-  (labels: HashSet.HashSet<MetricLabel.MetricLabel>) => <R, E, A>(
-    self: Effect.Effect<R, E, A>
-  ) => Effect.Effect<R, E, A>,
-  <R, E, A>(self: Effect.Effect<R, E, A>, labels: HashSet.HashSet<MetricLabel.MetricLabel>) => Effect.Effect<R, E, A>
 >(
   2,
-  (self, labels) => core.fiberRefLocallyWith(core.currentMetricLabels, (set) => pipe(set, HashSet.union(labels)))(self)
+  (self, labels) => core.fiberRefLocallyWith(self, core.currentMetricLabels, (old) => ReadonlyArray.union(old, labels))
 )
 
 /* @internal */

package/src/internal/core.ts

@@ -17,7 +17,7 @@ import { dual, identity, pipe } from "../Function.js"
 import { globalValue } from "../GlobalValue.js"
 import * as Hash from "../Hash.js"
 import * as HashMap from "../HashMap.js"
-import * as HashSet from "../HashSet.js"
+import type * as HashSet from "../HashSet.js"
 import { format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
 import * as List from "../List.js"
 import type * as LogLevel from "../LogLevel.js"
@@ -1770,6 +1770,17 @@ export const fiberRefUnsafeMakeHashSet = <A>(
   })
 }
 
+/** @internal */
+export const fiberRefUnsafeMakeReadonlyArray = <A>(
+  initial: ReadonlyArray<A>
+): FiberRef.FiberRef<ReadonlyArray<A>> => {
+  const differ = internalDiffer.readonlyArray(internalDiffer.update<A>())
+  return fiberRefUnsafeMakePatch(initial, {
+    differ,
+    fork: differ.empty
+  })
+}
+
 /** @internal */
 export const fiberRefUnsafeMakeContext = <A>(
   initial: Context.Context<A>
@@ -1886,13 +1897,13 @@ export const withUnhandledErrorLogLevel = dual<
 >(2, (self, level) => fiberRefLocally(self, currentUnhandledErrorLogLevel, level))
 
 /** @internal */
-export const currentMetricLabels: FiberRef.FiberRef<HashSet.HashSet<MetricLabel.MetricLabel>> = globalValue(
+export const currentMetricLabels: FiberRef.FiberRef<ReadonlyArray<MetricLabel.MetricLabel>> = globalValue(
   Symbol.for("effect/FiberRef/currentMetricLabels"),
-  () => fiberRefUnsafeMakeHashSet(HashSet.empty())
+  () => fiberRefUnsafeMakeReadonlyArray(ReadonlyArray.empty())
 )
 
 /* @internal */
-export const metricLabels: Effect.Effect<never, never, HashSet.HashSet<MetricLabel.MetricLabel>> = fiberRefGet(
+export const metricLabels: Effect.Effect<never, never, ReadonlyArray<MetricLabel.MetricLabel>> = fiberRefGet(
   currentMetricLabels
 )
 

package/src/internal/differ/chunkPatch.ts

@@ -170,6 +170,9 @@ export const patch = Dual.dual<
   oldValue: Chunk.Chunk<Value>,
   differ: Differ.Differ<Value, Patch>
 ) => {
+  if ((self as Instruction)._tag === "Empty") {
+    return oldValue
+  }
   let chunk = oldValue
   let patches: Chunk.Chunk<Differ.Differ.Chunk.Patch<Value, Patch>> = Chunk.of(self)
   while (Chunk.isNonEmpty(patches)) {

package/src/internal/differ/contextPatch.ts

@@ -177,6 +177,9 @@ export const patch = Dual.dual<
     context: Context<Input>
   ) => Context<Output>
 >(2, <Input, Output>(self: Differ.Context.Patch<Input, Output>, context: Context<Input>) => {
+  if ((self as Instruction)._tag === "Empty") {
+    return context as any
+  }
   let wasServiceUpdated = false
   let patches: Chunk.Chunk<Differ.Context.Patch<unknown, unknown>> = Chunk.of(
     self as Differ.Context.Patch<unknown, unknown>

package/src/internal/differ/hashMapPatch.ts

@@ -179,6 +179,9 @@ export const patch = Dual.dual<
   oldValue: HashMap.HashMap<Key, Value>,
   differ: Differ.Differ<Value, Patch>
 ) => {
+  if ((self as Instruction)._tag === "Empty") {
+    return oldValue
+  }
   let map = oldValue
   let patches: Chunk.Chunk<Differ.Differ.HashMap.Patch<Key, Value, Patch>> = Chunk.of(self)
   while (Chunk.isNonEmpty(patches)) {

package/src/internal/differ/hashSetPatch.ts

@@ -144,6 +144,9 @@ export const patch = Dual.dual<
   self: Differ.HashSet.Patch<Value>,
   oldValue: HashSet.HashSet<Value>
 ) => {
+  if ((self as Instruction)._tag === "Empty") {
+    return oldValue
+  }
   let set = oldValue
   let patches: Chunk.Chunk<Differ.HashSet.Patch<Value>> = Chunk.of(self)
   while (Chunk.isNonEmpty(patches)) {

package/src/internal/differ/orPatch.ts

@@ -264,6 +264,9 @@ export const patch = Dual.dual<
     right: Differ<Value2, Patch2>
   }
 ) => {
+  if ((self as Instruction)._tag === "Empty") {
+    return oldValue
+  }
   let patches: Chunk.Chunk<Differ.Or.Patch<Value, Value2, Patch, Patch2>> = Chunk.of(self)
   let result = oldValue
   while (Chunk.isNonEmpty(patches)) {

package/src/internal/differ/readonlyArrayPatch.ts

@@ -0,0 +1,208 @@
+import type * as Differ from "../../Differ.js"
+import * as Equal from "../../Equal.js"
+import * as Dual from "../../Function.js"
+import * as ReadonlyArray from "../../ReadonlyArray.js"
+import * as Data from "../data.js"
+
+/** @internal */
+export const ReadonlyArrayPatchTypeId: Differ.Differ.ReadonlyArray.TypeId = Symbol.for(
+  "effect/DifferReadonlyArrayPatch"
+) as Differ.Differ.ReadonlyArray.TypeId
+
+function variance<A, B>(a: A): B {
+  return a as unknown as B
+}
+
+const PatchProto = {
+  ...Data.Structural.prototype,
+  [ReadonlyArrayPatchTypeId]: {
+    _Value: variance,
+    _Patch: variance
+  }
+}
+
+interface Empty<Value, Patch> extends Differ.Differ.ReadonlyArray.Patch<Value, Patch> {
+  readonly _tag: "Empty"
+}
+
+const EmptyProto = Object.assign(Object.create(PatchProto), {
+  _tag: "Empty"
+})
+
+const _empty = Object.create(EmptyProto)
+
+/**
+ * @internal
+ */
+export const empty = <Value, Patch>(): Differ.Differ.ReadonlyArray.Patch<Value, Patch> => _empty
+
+interface AndThen<Value, Patch> extends Differ.Differ.ReadonlyArray.Patch<Value, Patch> {
+  readonly _tag: "AndThen"
+  readonly first: Differ.Differ.ReadonlyArray.Patch<Value, Patch>
+  readonly second: Differ.Differ.ReadonlyArray.Patch<Value, Patch>
+}
+
+const AndThenProto = Object.assign(Object.create(PatchProto), {
+  _tag: "AndThen"
+})
+
+const makeAndThen = <Value, Patch>(
+  first: Differ.Differ.ReadonlyArray.Patch<Value, Patch>,
+  second: Differ.Differ.ReadonlyArray.Patch<Value, Patch>
+): Differ.Differ.ReadonlyArray.Patch<Value, Patch> => {
+  const o = Object.create(AndThenProto)
+  o.first = first
+  o.second = second
+  return o
+}
+
+interface Append<Value, Patch> extends Differ.Differ.ReadonlyArray.Patch<Value, Patch> {
+  readonly _tag: "Append"
+  readonly values: ReadonlyArray<Value>
+}
+
+const AppendProto = Object.assign(Object.create(PatchProto), {
+  _tag: "Append"
+})
+
+const makeAppend = <Value, Patch>(values: ReadonlyArray<Value>): Differ.Differ.ReadonlyArray.Patch<Value, Patch> => {
+  const o = Object.create(AppendProto)
+  o.values = values
+  return o
+}
+
+interface Slice<Value, Patch> extends Differ.Differ.ReadonlyArray.Patch<Value, Patch> {
+  readonly _tag: "Slice"
+  readonly from: number
+  readonly until: number
+}
+
+const SliceProto = Object.assign(Object.create(PatchProto), {
+  _tag: "Slice"
+})
+
+const makeSlice = <Value, Patch>(from: number, until: number): Differ.Differ.ReadonlyArray.Patch<Value, Patch> => {
+  const o = Object.create(SliceProto)
+  o.from = from
+  o.until = until
+  return o
+}
+
+interface Update<Value, Patch> extends Differ.Differ.ReadonlyArray.Patch<Value, Patch> {
+  readonly _tag: "Update"
+  readonly index: number
+  readonly patch: Patch
+}
+
+const UpdateProto = Object.assign(Object.create(PatchProto), {
+  _tag: "Update"
+})
+
+const makeUpdate = <Value, Patch>(index: number, patch: Patch): Differ.Differ.ReadonlyArray.Patch<Value, Patch> => {
+  const o = Object.create(UpdateProto)
+  o.index = index
+  o.patch = patch
+  return o
+}
+
+type Instruction =
+  | Empty<any, any>
+  | AndThen<any, any>
+  | Append<any, any>
+  | Slice<any, any>
+  | Update<any, any>
+
+/** @internal */
+export const diff = <Value, Patch>(
+  options: {
+    readonly oldValue: ReadonlyArray<Value>
+    readonly newValue: ReadonlyArray<Value>
+    readonly differ: Differ.Differ<Value, Patch>
+  }
+): Differ.Differ.ReadonlyArray.Patch<Value, Patch> => {
+  let i = 0
+  let patch = empty<Value, Patch>()
+  while (i < options.oldValue.length && i < options.newValue.length) {
+    const oldElement = options.oldValue[i]!
+    const newElement = options.newValue[i]!
+    const valuePatch = options.differ.diff(oldElement, newElement)
+    if (!Equal.equals(valuePatch, options.differ.empty)) {
+      patch = combine(patch, makeUpdate(i, valuePatch))
+    }
+    i = i + 1
+  }
+  if (i < options.oldValue.length) {
+    patch = combine(patch, makeSlice(0, i))
+  }
+  if (i < options.newValue.length) {
+    patch = combine(patch, makeAppend(ReadonlyArray.drop(i)(options.newValue)))
+  }
+  return patch
+}
+
+/** @internal */
+export const combine = Dual.dual<
+  <Value, Patch>(
+    that: Differ.Differ.ReadonlyArray.Patch<Value, Patch>
+  ) => (
+    self: Differ.Differ.ReadonlyArray.Patch<Value, Patch>
+  ) => Differ.Differ.ReadonlyArray.Patch<Value, Patch>,
+  <Value, Patch>(
+    self: Differ.Differ.ReadonlyArray.Patch<Value, Patch>,
+    that: Differ.Differ.ReadonlyArray.Patch<Value, Patch>
+  ) => Differ.Differ.ReadonlyArray.Patch<Value, Patch>
+>(2, (self, that) => makeAndThen(self, that))
+
+/** @internal */
+export const patch = Dual.dual<
+  <Value, Patch>(
+    oldValue: ReadonlyArray<Value>,
+    differ: Differ.Differ<Value, Patch>
+  ) => (self: Differ.Differ.ReadonlyArray.Patch<Value, Patch>) => ReadonlyArray<Value>,
+  <Value, Patch>(
+    self: Differ.Differ.ReadonlyArray.Patch<Value, Patch>,
+    oldValue: ReadonlyArray<Value>,
+    differ: Differ.Differ<Value, Patch>
+  ) => ReadonlyArray<Value>
+>(3, <Value, Patch>(
+  self: Differ.Differ.ReadonlyArray.Patch<Value, Patch>,
+  oldValue: ReadonlyArray<Value>,
+  differ: Differ.Differ<Value, Patch>
+) => {
+  if ((self as Instruction)._tag === "Empty") {
+    return oldValue
+  }
+  let readonlyArray = oldValue.slice()
+  let patches: Array<Differ.Differ.ReadonlyArray.Patch<Value, Patch>> = ReadonlyArray.of(self)
+  while (ReadonlyArray.isNonEmptyArray(patches)) {
+    const head: Instruction = ReadonlyArray.headNonEmpty(patches) as Instruction
+    const tail = ReadonlyArray.tailNonEmpty(patches)
+    switch (head._tag) {
+      case "Empty": {
+        patches = tail
+        break
+      }
+      case "AndThen": {
+        tail.unshift(head.first, head.second)
+        patches = tail
+        break
+      }
+      case "Append": {
+        readonlyArray.push(...head.values)
+        patches = tail
+        break
+      }
+      case "Slice": {
+        readonlyArray = readonlyArray.slice(head.from, head.until)
+        patches = tail
+        break
+      }
+      case "Update": {
+        readonlyArray[head.index] = differ.patch(head.patch, readonlyArray[head.index]!)
+        patches = tail
+        break
+      }
+    }
+  }
+  return readonlyArray
+})

package/src/internal/differ.ts

@@ -12,6 +12,7 @@ import * as ContextPatch from "./differ/contextPatch.js"
 import * as HashMapPatch from "./differ/hashMapPatch.js"
 import * as HashSetPatch from "./differ/hashSetPatch.js"
 import * as OrPatch from "./differ/orPatch.js"
+import * as ReadonlyArrayPatch from "./differ/readonlyArrayPatch.js"
 
 /** @internal */
 export const DifferTypeId: Differ.TypeId = Symbol.for("effect/Differ") as Differ.TypeId
@@ -109,6 +110,17 @@ export const orElseEither = Dual.dual<
       })
   }))
 
+/** @internal */
+export const readonlyArray = <Value, Patch>(
+  differ: Differ.Differ<Value, Patch>
+): Differ.Differ<ReadonlyArray<Value>, Differ.Differ.ReadonlyArray.Patch<Value, Patch>> =>
+  make({
+    empty: ReadonlyArrayPatch.empty(),
+    combine: (first, second) => ReadonlyArrayPatch.combine(first, second),
+    diff: (oldValue, newValue) => ReadonlyArrayPatch.diff({ oldValue, newValue, differ }),
+    patch: (patch, oldValue) => ReadonlyArrayPatch.patch(patch, oldValue, differ)
+  })
+
 /** @internal */
 export const transform = Dual.dual<
   <Value, Value2>(

package/src/internal/fiberId.ts

@@ -265,5 +265,5 @@ export const toSet = (self: FiberId.FiberId): HashSet.HashSet<FiberId.Runtime> =
 export const unsafeMake = (): FiberId.Runtime => {
   const id = MutableRef.get(_fiberCounter)
   pipe(_fiberCounter, MutableRef.set(id + 1))
-  return new Runtime(id, new Date().getTime())
+  return new Runtime(id, Date.now())
 }

package/src/internal/fiberRefs/patch.ts

@@ -111,7 +111,7 @@ export const patch = dual<
         break
       }
       case OP_ADD: {
-        fiberRefs = _fiberRefs.updatedAs(fiberRefs, {
+        fiberRefs = _fiberRefs.updateAs(fiberRefs, {
           fiberId,
           fiberRef: head.fiberRef,
           value: head.value
@@ -126,7 +126,7 @@ export const patch = dual<
       }
       case OP_UPDATE: {
         const value = _fiberRefs.getOrDefault(fiberRefs, head.fiberRef)
-        fiberRefs = _fiberRefs.updatedAs(fiberRefs, {
+        fiberRefs = _fiberRefs.updateAs(fiberRefs, {
           fiberId,
           fiberRef: head.fiberRef,
           value: head.fiberRef.patch(head.patch)(value)

package/src/internal/fiberRefs.ts

@@ -87,18 +87,18 @@ export const joinAs = dual<
   (self: FiberRefs.FiberRefs, fiberId: FiberId.Runtime, that: FiberRefs.FiberRefs) => FiberRefs.FiberRefs
 >(3, (self, fiberId, that) => {
   const parentFiberRefs = new Map(self.locals)
-  for (const [fiberRef, childStack] of that.locals) {
-    const childValue = Arr.headNonEmpty(childStack)[1]
-    if (!Equal.equals(Arr.headNonEmpty(childStack)[0], fiberId)) {
+  that.locals.forEach((childStack, fiberRef) => {
+    const childValue = childStack[0][1]
+    if (!childStack[0][0][Equal.symbol](fiberId)) {
       if (!parentFiberRefs.has(fiberRef)) {
         if (Equal.equals(childValue, fiberRef.initial)) {
-          continue
+          return
         }
         parentFiberRefs.set(
           fiberRef,
           [[fiberId, fiberRef.join(fiberRef.initial, childValue)]]
         )
-        continue
+        return
       }
       const parentStack = parentFiberRefs.get(fiberRef)!
       const [ancestor, wasModified] = findAncestor(
@@ -108,26 +108,22 @@ export const joinAs = dual<
       )
       if (wasModified) {
         const patch = fiberRef.diff(ancestor, childValue)
-        const oldValue = Arr.headNonEmpty(parentStack)[1]
+        const oldValue = parentStack[0][1]
         const newValue = fiberRef.join(oldValue, fiberRef.patch(patch)(oldValue))
         if (!Equal.equals(oldValue, newValue)) {
           let newStack: Arr.NonEmptyReadonlyArray<readonly [FiberId.Runtime, unknown]>
-          const parentFiberId = Arr.headNonEmpty(parentStack)[0]
-          if (Equal.equals(parentFiberId, fiberId)) {
-            newStack = Arr.prepend([parentFiberId, newValue] as const)(
-              Arr.tailNonEmpty(parentStack)
-            ) as Arr.NonEmptyReadonlyArray<readonly [FiberId.Runtime, unknown]>
+          const parentFiberId = parentStack[0][0]
+          if (parentFiberId[Equal.symbol](fiberId)) {
+            newStack = [[parentFiberId, newValue] as const, ...parentStack.slice(1)]
           } else {
-            newStack = Arr.prepend([fiberId, newValue] as const)(
-              parentStack
-            ) as Arr.NonEmptyReadonlyArray<readonly [FiberId.Runtime, unknown]>
+            newStack = [[fiberId, newValue] as const, ...parentStack]
           }
           parentFiberRefs.set(fiberRef, newStack)
         }
       }
     }
-  }
-  return new FiberRefsImpl(new Map(parentFiberRefs))
+  })
+  return new FiberRefsImpl(parentFiberRefs)
 })
 
 /** @internal */
@@ -136,17 +132,25 @@ export const forkAs = dual<
   (self: FiberRefs.FiberRefs, childId: FiberId.Runtime) => FiberRefs.FiberRefs
 >(2, (self, childId) => {
   const map = new Map<FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Runtime, unknown]>>()
-  for (const [fiberRef, stack] of self.locals.entries()) {
-    const oldValue = Arr.headNonEmpty(stack)[1]
+  unsafeForkAs(self, map, childId)
+  return new FiberRefsImpl(map)
+})
+
+const unsafeForkAs = (
+  self: FiberRefs.FiberRefs,
+  map: Map<FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Runtime, any]>>,
+  fiberId: FiberId.Runtime
+) => {
+  self.locals.forEach((stack, fiberRef) => {
+    const oldValue = stack[0][1]
     const newValue = fiberRef.patch(fiberRef.fork)(oldValue)
     if (Equal.equals(oldValue, newValue)) {
       map.set(fiberRef, stack)
     } else {
-      map.set(fiberRef, Arr.prepend([childId, newValue] as const)(stack) as typeof stack)
+      map.set(fiberRef, [[fiberId, newValue] as const, ...stack])
     }
-  }
-  return new FiberRefsImpl(map)
-})
+  })
+}
 
 /** @internal */
 export const fiberRefs = (self: FiberRefs.FiberRefs) => HashSet.fromIterable(self.locals.keys())
@@ -186,7 +190,7 @@ export const getOrDefault = dual<
 >(2, (self, fiberRef) => pipe(get(self, fiberRef), Option.getOrElse(() => fiberRef.initial)))
 
 /** @internal */
-export const updatedAs = dual<
+export const updateAs = dual<
   <A>(
     options: {
       readonly fiberId: FiberId.Runtime
@@ -207,33 +211,88 @@ export const updatedAs = dual<
   readonly fiberRef: FiberRef.FiberRef<A>
   readonly value: A
 }) => {
-  const oldStack = self.locals.has(fiberRef) ?
-    self.locals.get(fiberRef)! :
-    Arr.empty<readonly [FiberId.Runtime, any]>()
+  if (self.locals.size === 0) {
+    return new FiberRefsImpl(new Map([[fiberRef, [[fiberId, value] as const]]]))
+  }
+  const locals = new Map(self.locals)
+  unsafeUpdateAs(locals, fiberId, fiberRef, value)
+  return new FiberRefsImpl(locals)
+})
 
-  let newStack: ReadonlyArray<readonly [FiberId.Runtime, A]> | undefined
+const unsafeUpdateAs = (
+  locals: Map<FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Runtime, any]>>,
+  fiberId: FiberId.Runtime,
+  fiberRef: FiberRef.FiberRef<any>,
+  value: any
+) => {
+  const oldStack: ReadonlyArray<readonly [FiberId.Runtime, any]> = locals.get(fiberRef) ?? []
+  let newStack: Arr.NonEmptyReadonlyArray<readonly [FiberId.Runtime, any]> | undefined
 
-  if (Arr.isEmptyReadonlyArray(oldStack)) {
-    newStack = Arr.of([fiberId, value] as const)
-  } else {
-    const [currentId, currentValue] = Arr.headNonEmpty(
-      oldStack as Arr.NonEmptyReadonlyArray<readonly [FiberId.Runtime, any]>
-    )
-    if (Equal.equals(currentId, fiberId)) {
+  if (Arr.isNonEmptyReadonlyArray(oldStack)) {
+    const [currentId, currentValue] = Arr.headNonEmpty(oldStack)
+    if (currentId[Equal.symbol](fiberId)) {
       if (Equal.equals(currentValue, value)) {
-        return self
+        return
       } else {
-        newStack = Arr.prepend([fiberId, value] as const)(
-          Arr.tailNonEmpty(oldStack as Arr.NonEmptyReadonlyArray<readonly [FiberId.Runtime, any]>)
-        )
+        newStack = [
+          [fiberId, value] as const,
+          ...oldStack.slice(1)
+        ]
       }
     } else {
-      newStack = Arr.prepend([fiberId, value] as const)(oldStack)
+      newStack = [
+        [fiberId, value] as const,
+        ...oldStack
+      ]
     }
+  } else {
+    newStack = [[fiberId, value] as const]
+  }
+
+  locals.set(fiberRef, newStack)
+}
+
+/** @internal */
+export const updateManyAs = dual<
+  (
+    options: {
+      readonly forkAs?: FiberId.Runtime | undefined
+      readonly entries: Arr.NonEmptyReadonlyArray<
+        readonly [FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Runtime, any]>]
+      >
+    }
+  ) => (self: FiberRefs.FiberRefs) => FiberRefs.FiberRefs,
+  (
+    self: FiberRefs.FiberRefs,
+    options: {
+      readonly forkAs?: FiberId.Runtime | undefined
+      readonly entries: Arr.NonEmptyReadonlyArray<
+        readonly [FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Runtime, any]>]
+      >
+    }
+  ) => FiberRefs.FiberRefs
+>(2, (self: FiberRefs.FiberRefs, { entries, forkAs }: {
+  readonly forkAs?: FiberId.Runtime | undefined
+  readonly entries: Arr.NonEmptyReadonlyArray<
+    readonly [FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Runtime, any]>]
+  >
+}) => {
+  if (self.locals.size === 0) {
+    return new FiberRefsImpl(new Map(entries))
   }
 
   const locals = new Map(self.locals)
-  return new FiberRefsImpl(
-    locals.set(fiberRef, newStack as Arr.NonEmptyReadonlyArray<readonly [FiberId.Runtime, any]>)
-  )
+  if (forkAs !== undefined) {
+    unsafeForkAs(self, locals, forkAs)
+  }
+  entries.forEach(([fiberRef, values]) => {
+    if (values.length === 1) {
+      unsafeUpdateAs(locals, values[0][0], fiberRef, values[0][1])
+    } else {
+      values.forEach(([fiberId, value]) => {
+        unsafeUpdateAs(locals, fiberId, fiberRef, value)
+      })
+    }
+  })
+  return new FiberRefsImpl(locals)
 })