effect 4.0.0-beta.100 → 4.0.0-beta.102

package/src/Data.ts

@@ -10,6 +10,7 @@
  */
 import type * as Cause from "./Cause.ts"
 import * as core from "./internal/core.ts"
+import * as InternalRecord from "./internal/record.ts"
 import * as Pipeable from "./Pipeable.ts"
 import * as Predicate from "./Predicate.ts"
 import type * as Types from "./Types.ts"
@@ -51,10 +52,10 @@ import type { Unify } from "./Unify.ts"
 export const Class: new<A extends Record<string, any> = {}>(
   args: Types.VoidIfEmpty<{ readonly [P in keyof A]: A[P] }>
 ) => Readonly<A> & Pipeable.Pipeable = class extends Pipeable.Class {
-  constructor(props: any) {
+  constructor(props: object | undefined) {
     super()
     if (props) {
-      Object.assign(this, props)
+      InternalRecord.assignProperties(this, props)
     }
   }
 } as any

package/src/Effect.ts

@@ -26,6 +26,7 @@ import * as core from "./internal/core.ts"
 import * as internal from "./internal/effect.ts"
 import * as internalExecutionPlan from "./internal/executionPlan.ts"
 import * as internalLayer from "./internal/layer.ts"
+import * as InternalRecord from "./internal/record.ts"
 import * as internalRequest from "./internal/request.ts"
 import * as internalSchedule from "./internal/schedule.ts"
 import type * as Layer from "./Layer.ts"
@@ -12319,6 +12320,72 @@ export const updateService: {
   <XA, E, R, I, A>(self: Effect<XA, E, R>, service: Context.Key<I, A>, f: (value: A) => A): Effect<XA, E, R | I>
 } = internal.updateService
 
+/**
+ * Updates a service for the lifetime of the current scope and restores its
+ * previous value when the scope closes.
+ *
+ * **When to use**
+ *
+ * Use when you need a setup effect to change a service for subsequent effects
+ * in the same scope.
+ *
+ * **Details**
+ *
+ * The updater receives the currently visible service value. A
+ * `Context.Service` remains in the requirements, while a `Context.Reference`
+ * uses its default when no override is present and adds no service requirement.
+ * The returned effect always requires `Scope`. The optional `reset` function
+ * receives the original, updated, and current values when the scope closes,
+ * allowing changes to be merged during restoration. It defaults to returning
+ * the original value.
+ *
+ * **Example** (Updating a reference within a scope)
+ *
+ * ```ts
+ * import { Context, Effect } from "effect"
+ *
+ * const CurrentNumber = Context.Reference<number>("CurrentNumber", {
+ *   defaultValue: () => 1
+ * })
+ *
+ * const program = Effect.gen(function*() {
+ *   const before = yield* CurrentNumber
+ *   const during = yield* Effect.scoped(
+ *     Effect.gen(function*() {
+ *       yield* Effect.updateServiceScoped(
+ *         CurrentNumber,
+ *         (value) => value + 1,
+ *         {
+ *           // Optional: when omitted, the original value is restored
+ *           reset: (original, updated, current) =>
+ *             Math.max(original, updated, current) + 1
+ *         }
+ *       )
+ *       return yield* CurrentNumber
+ *     })
+ *   )
+ *   const after = yield* CurrentNumber
+ *
+ *   console.log([before, during, after])
+ *   // [1, 2, 3]
+ * })
+ *
+ * Effect.runPromise(program)
+ * ```
+ *
+ * @see {@link updateService} for updating a service only within a wrapped effect
+ *
+ * @category context
+ * @since 4.0.0
+ */
+export const updateServiceScoped: <I, A>(
+  service: Context.Key<I, A>,
+  f: (value: A) => A,
+  options?: {
+    readonly reset?: ((original: A, updated: A, current: A) => A) | undefined
+  } | undefined
+) => Effect<void, never, I | Scope> = internal.updateServiceScoped
+
 /**
  * Provides one concrete service implementation to an effect.
  *
@@ -12805,119 +12872,6 @@ export const provideServiceEffect: {
   ): Effect<A, E | E2, Exclude<R, I> | R2>
 } = internal.provideServiceEffect
 
-// -----------------------------------------------------------------------------
-// References
-// -----------------------------------------------------------------------------
-
-/**
- * Sets the concurrency level for parallel operations within an effect.
- *
- * **Example** (Setting local concurrency)
- *
- * ```ts
- * import { Console, Effect } from "effect"
- *
- * const task = (id: number) =>
- *   Effect.gen(function*() {
- *     yield* Console.log(`Task ${id} starting`)
- *     yield* Effect.sleep("100 millis")
- *     yield* Console.log(`Task ${id} completed`)
- *     return id
- *   })
- *
- * // Run tasks with limited concurrency (max 2 at a time)
- * const program = Effect.gen(function*() {
- *   const tasks = [1, 2, 3, 4, 5].map(task)
- *   return yield* Effect.all(tasks, { concurrency: 2 })
- * }).pipe(
- *   Effect.withConcurrency(2)
- * )
- *
- * Effect.runPromise(program).then(console.log)
- * // Tasks will run with max 2 concurrent operations
- * // [1, 2, 3, 4, 5]
- * ```
- *
- * @category references
- * @since 2.0.0
- */
-export const withConcurrency: {
-  // -----------------------------------------------------------------------------
-  // References
-  // -----------------------------------------------------------------------------
-
-  /**
-   * Sets the concurrency level for parallel operations within an effect.
-   *
-   * **Example** (Setting local concurrency)
-   *
-   * ```ts
-   * import { Console, Effect } from "effect"
-   *
-   * const task = (id: number) =>
-   *   Effect.gen(function*() {
-   *     yield* Console.log(`Task ${id} starting`)
-   *     yield* Effect.sleep("100 millis")
-   *     yield* Console.log(`Task ${id} completed`)
-   *     return id
-   *   })
-   *
-   * // Run tasks with limited concurrency (max 2 at a time)
-   * const program = Effect.gen(function*() {
-   *   const tasks = [1, 2, 3, 4, 5].map(task)
-   *   return yield* Effect.all(tasks, { concurrency: 2 })
-   * }).pipe(
-   *   Effect.withConcurrency(2)
-   * )
-   *
-   * Effect.runPromise(program).then(console.log)
-   * // Tasks will run with max 2 concurrent operations
-   * // [1, 2, 3, 4, 5]
-   * ```
-   *
-   * @category references
-   * @since 2.0.0
-   */
-  (concurrency: number | "unbounded"): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>
-  // -----------------------------------------------------------------------------
-  // References
-  // -----------------------------------------------------------------------------
-
-  /**
-   * Sets the concurrency level for parallel operations within an effect.
-   *
-   * **Example** (Setting local concurrency)
-   *
-   * ```ts
-   * import { Console, Effect } from "effect"
-   *
-   * const task = (id: number) =>
-   *   Effect.gen(function*() {
-   *     yield* Console.log(`Task ${id} starting`)
-   *     yield* Effect.sleep("100 millis")
-   *     yield* Console.log(`Task ${id} completed`)
-   *     return id
-   *   })
-   *
-   * // Run tasks with limited concurrency (max 2 at a time)
-   * const program = Effect.gen(function*() {
-   *   const tasks = [1, 2, 3, 4, 5].map(task)
-   *   return yield* Effect.all(tasks, { concurrency: 2 })
-   * }).pipe(
-   *   Effect.withConcurrency(2)
-   * )
-   *
-   * Effect.runPromise(program).then(console.log)
-   * // Tasks will run with max 2 concurrent operations
-   * // [1, 2, 3, 4, 5]
-   * ```
-   *
-   * @category references
-   * @since 2.0.0
-   */
-  <A, E, R>(self: Effect<A, E, R>, concurrency: number | "unbounded"): Effect<A, E, R>
-} = internal.withConcurrency
-
 // -----------------------------------------------------------------------------
 // Resource management & finalization
 // -----------------------------------------------------------------------------
@@ -22911,11 +22865,11 @@ export const annotateLogs = dual<
     ...args: [Record<string, unknown>] | [key: string, value: unknown]
   ): Effect<A, E, R> =>
     internal.updateService(effect, CurrentLogAnnotations, (annotations) => {
-      const newAnnotations = { ...annotations }
+      const newAnnotations = args.length === 1 ? { ...annotations, ...args[0] } : { ...annotations }
       if (args.length === 1) {
-        Object.assign(newAnnotations, args[0])
+        return newAnnotations
       } else {
-        newAnnotations[args[0]] = args[1]
+        InternalRecord.assignProperty(newAnnotations, args[0], args[1])
       }
       return newAnnotations
     })

package/src/FiberHandle.ts

@@ -621,10 +621,11 @@ export const clear = <A, E>(self: FiberHandle<A, E>): Effect.Effect<void> =>
     if (self.state._tag === "Closed" || self.state.fiber === undefined) {
       return Effect.void
     }
+    const fiber = self.state.fiber
     return Effect.andThen(
-      restore(Fiber.interruptAs(self.state.fiber, internalFiberId)),
+      restore(Fiber.interruptAs(fiber, internalFiberId)),
       Effect.sync(() => {
-        if (self.state._tag === "Open") {
+        if (self.state._tag === "Open" && self.state.fiber === fiber) {
           self.state.fiber = undefined
         }
       })

package/src/Iterable.ts

@@ -12,6 +12,7 @@
 import type { NonEmptyArray } from "./Array.ts"
 import * as Equal from "./Equal.ts"
 import { dual } from "./Function.ts"
+import * as InternalRecord from "./internal/record.ts"
 import type { Option } from "./Option.ts"
 import * as O from "./Option.ts"
 import { isBoolean } from "./Predicate.ts"
@@ -3023,7 +3024,7 @@ export const groupBy: {
     if (Object.hasOwn(out, k)) {
       out[k].push(a)
     } else {
-      out[k] = [a]
+      InternalRecord.assignProperty(out, k, [a])
     }
   }
   return out

package/src/JsonPatch.ts

@@ -8,6 +8,7 @@
  * @since 4.0.0
  */
 import { format } from "./Formatter.ts"
+import * as InternalRecord from "./internal/record.ts"
 import { escapeToken, unescapeToken } from "./JsonPointer.ts"
 import * as Predicate from "./Predicate.ts"
 import type * as Schema from "./Schema.ts"
@@ -358,7 +359,7 @@ function addAt(doc: Schema.Json, pointer: string, val: Schema.Json): Schema.Json
 
   if (isJsonObject(parent)) {
     const updated = { ...parent }
-    updated[lastToken] = val
+    InternalRecord.assignProperty(updated, lastToken, val)
     return rebuildFromStack(stack, updated)
   }
 
@@ -399,7 +400,7 @@ function setAt(
     }
     const updated = { ...parent }
     if (mode === "remove") delete updated[lastToken]
-    else updated[lastToken] = val!
+    else InternalRecord.assignProperty(updated, lastToken, val!)
     return rebuildFromStack(stack, updated)
   }
 
@@ -460,7 +461,7 @@ function rebuildFromStack(stack: ReadonlyArray<StackEntry>, newParent: Schema.Js
       acc = copy
     } else {
       const copy = { ...(container as Schema.JsonObject) }
-      copy[token as string] = acc
+      InternalRecord.assignProperty(copy, token as string, acc)
       acc = copy
     }
   }

package/src/JsonSchema.ts

@@ -9,6 +9,7 @@
  * @since 4.0.0
  */
 import * as Arr from "./Array.ts"
+import * as InternalRecord from "./internal/record.ts"
 import { unescapeToken } from "./JsonPointer.ts"
 import * as Predicate from "./Predicate.ts"
 import * as Rec from "./Record.ts"
@@ -745,11 +746,11 @@ function rewrite_refs(node: unknown, f: ($ref: string) => string): unknown {
     const v = node[k]
 
     if (k === "$ref") {
-      out[k] = typeof v === "string" ? f(v) : v
+      InternalRecord.assignProperty(out, k, typeof v === "string" ? f(v) : v)
     } else if (Array.isArray(v) || Predicate.isObject(v)) {
-      out[k] = rewrite_refs(v, f)
+      InternalRecord.assignProperty(out, k, rewrite_refs(v, f))
     } else {
-      out[k] = v
+      InternalRecord.assignProperty(out, k, v)
     }
   }
 
@@ -762,7 +763,7 @@ function walk_object(
 ): Record<string, unknown> | undefined {
   if (!Predicate.isObject(value)) return undefined
   const out: Record<string, unknown> = {}
-  for (const k of Object.keys(value)) out[k] = walk(value[k], false)
+  for (const k of Object.keys(value)) InternalRecord.assignProperty(out, k, walk(value[k], false))
   return out
 }
 
@@ -776,15 +777,15 @@ function normalize_OpenApi3_0_to_Draft07(node: unknown): unknown {
   for (const k of Object.keys(src)) {
     const v = src[k]
     if (k === "$ref" && typeof v === "string") {
-      out[k] = v.replace(RE_COMPONENTS_SCHEMAS, "#/definitions")
+      InternalRecord.assignProperty(out, k, v.replace(RE_COMPONENTS_SCHEMAS, "#/definitions"))
     } else if (k === "example") {
       if (src.examples === undefined) {
         out.examples = [v]
       }
     } else if (Array.isArray(v) || Predicate.isObject(v)) {
-      out[k] = normalize_OpenApi3_0_to_Draft07(v)
+      InternalRecord.assignProperty(out, k, normalize_OpenApi3_0_to_Draft07(v))
     } else {
-      out[k] = v
+      InternalRecord.assignProperty(out, k, v)
     }
   }
 
@@ -895,10 +896,7 @@ export function resolve$ref($ref: string, definitions: Definitions): JsonSchema
   const tokens = $ref.split("/")
   if (tokens.length > 0) {
     const identifier = unescapeToken(tokens[tokens.length - 1])
-    const definition = definitions[identifier]
-    if (definition !== undefined) {
-      return definition
-    }
+    if (Object.hasOwn(definitions, identifier)) return definitions[identifier]
   }
 }
 

package/src/Logger.ts

@@ -20,6 +20,7 @@ import * as Formatter from "./Formatter.ts"
 import { dual } from "./Function.ts"
 import { isEffect, withFiber } from "./internal/core.ts"
 import * as effect from "./internal/effect.ts"
+import * as InternalRecord from "./internal/record.ts"
 import * as Layer from "./Layer.ts"
 import type * as LogLevel from "./LogLevel.ts"
 import type { Pipeable } from "./Pipeable.ts"
@@ -704,13 +705,13 @@ export const formatStructured: Logger<unknown, {
 
   const annotations = fiber.getRef(CurrentLogAnnotations)
   for (const [key, value] of Object.entries(annotations)) {
-    annotationsObj[key] = effect.structuredMessage(value)
+    InternalRecord.assignProperty(annotationsObj, key, effect.structuredMessage(value))
   }
 
   const now = date.getTime()
   const spans = fiber.getRef(CurrentLogSpans)
   for (const [label, timestamp] of spans) {
-    spansObj[label] = now - timestamp
+    InternalRecord.assignProperty(spansObj, label, now - timestamp)
   }
 
   const messageArr = Array.ensure(message)

package/src/ManagedRuntime.ts

@@ -207,6 +207,16 @@ export interface ManagedRuntime<in R, out ER> {
    */
   readonly dispose: () => Promise<void>
 
+  /**
+   * Dispose of the resources associated with the runtime.
+   *
+   * **When to use**
+   *
+   * Use with the `await using` syntax to automatically dispose the runtime
+   * when it goes out of scope.
+   */
+  readonly [Symbol.asyncDispose]: () => Promise<void>
+
   /**
    * Dispose of the resources associated with the runtime.
    *
@@ -324,6 +334,9 @@ export const make = <R, ER>(
     dispose(): Promise<void> {
       return Effect.runPromise(self.disposeEffect)
     },
+    [Symbol.asyncDispose](): Promise<void> {
+      return self.dispose()
+    },
     disposeEffect: Effect.suspend(() => {
       ;(self as Mutable<ManagedRuntime<R, ER>>).contextEffect = Effect.die("ManagedRuntime disposed")
       self.cachedContext = undefined

package/src/Metric.ts

@@ -19,6 +19,7 @@ import type { Exit } from "./Exit.ts"
 import { constUndefined, dual } from "./Function.ts"
 import * as InternalEffect from "./internal/effect.ts"
 import * as InternalMetric from "./internal/metric.ts"
+import * as InternalRecord from "./internal/record.ts"
 import * as Layer from "./Layer.ts"
 import * as Order from "./Order.ts"
 import type { Pipeable } from "./Pipeable.ts"
@@ -1912,7 +1913,7 @@ class HistogramMetric extends Metric$<number, HistogramState> {
     let count = 0
     let sum = 0
     let min = Number.MAX_VALUE
-    let max = Number.MIN_VALUE
+    let max = -Number.MAX_VALUE
 
     Arr.map(Arr.sort(bounds, Order.Number), (n, i) => {
       boundaries[i] = n
@@ -1999,7 +2000,7 @@ class SummaryMetric extends Metric$<readonly [value: number, timestamp: number],
     let count = 0
     let sum = 0
     let min = Number.MAX_VALUE
-    let max = Number.MIN_VALUE
+    let max = -Number.MAX_VALUE
 
     const snapshot = (now: number): ReadonlyArray<[number, number | undefined]> => {
       const builder: Array<number> = []
@@ -5195,7 +5196,7 @@ function mergeAttributes(
 function attributesToRecord(attributes?: Metric.Attributes): Metric.AttributeSet | undefined {
   if (Predicate.isNotUndefined(attributes) && Array.isArray(attributes)) {
     return attributes.reduce((acc, [key, value]) => {
-      acc[key] = value
+      InternalRecord.assignProperty(acc, key, value)
       return acc
     }, {} as Metric.AttributeSet)
   }

package/src/MutableList.ts

@@ -899,6 +899,10 @@ export const filter = <A>(self: MutableList<A>, f: (value: A, i: number) => bool
     }
     chunk = chunk.next
   }
+  if (array.length === 0) {
+    clear(self)
+    return
+  }
   self.head = self.tail = {
     array,
     mutable: true,

package/src/Optic.ts

@@ -14,6 +14,7 @@
 
 import { format } from "./Formatter.ts"
 import { identity, memoize } from "./Function.ts"
+import * as InternalRecord from "./internal/record.ts"
 import * as Option from "./Option.ts"
 import * as Predicate from "./Predicate.ts"
 import * as Result from "./Result.ts"
@@ -1072,7 +1073,7 @@ class OptionalImpl<S, A> implements Optional<S, A> {
                 delete copy[key]
               }
             } else {
-              copy[key] = a
+              InternalRecord.assignProperty(copy, key, a)
             }
             return copy
           }
@@ -1110,7 +1111,7 @@ class OptionalImpl<S, A> implements Optional<S, A> {
           (a, s) => {
             if (Object.hasOwn(s, key)) {
               const copy = cloneShallow(s)
-              copy[key] = a
+              InternalRecord.assignProperty(copy, key, a)
               return Result.succeed(copy)
             } else {
               return err
@@ -1283,12 +1284,12 @@ const recur = memoize((node: Node): Op => {
           let i = 0
           for (; i < path.length - 1; i++) {
             const key = path[i]
-            current[key] = cloneShallow(current[key])
+            InternalRecord.assignProperty(current, key, cloneShallow(current[key]))
             current = current[key]
           }
 
           const finalKey = path[i]
-          current[finalKey] = a
+          InternalRecord.assignProperty(current, finalKey, a)
 
           return out
         }

package/src/Option.ts

@@ -20,6 +20,7 @@ import type { TypeLambda } from "./HKT.ts"
 import type { Inspectable } from "./Inspectable.ts"
 import * as doNotation from "./internal/doNotation.ts"
 import * as option from "./internal/option.ts"
+import * as InternalRecord from "./internal/record.ts"
 import * as result from "./internal/result.ts"
 import type { Order } from "./Order.ts"
 import * as order from "./Order.ts"
@@ -3025,7 +3026,7 @@ export const all: <const I extends Iterable<Option<any>> | Record<string, Option
       if (isNone(o)) {
         return none()
       }
-      out[key] = o.value
+      InternalRecord.assignProperty(out, key, o.value)
     }
     return some(out)
   }

package/src/PartitionedSemaphore.ts

@@ -193,7 +193,6 @@ export const makeUnsafe = <K = unknown>(options: {
       }
 
       const needed = permits - totalPermits
-      const taken = permits - needed
       if (totalPermits > 0) {
         totalPermits = 0
       }
@@ -228,9 +227,7 @@ export const makeUnsafe = <K = unknown>(options: {
       return Effect.sync(() => {
         cleanup()
         waitingPermits -= entry.permits
-        if (taken > 0) {
-          releaseUnsafe(taken)
-        }
+        releaseUnsafe(permits - entry.permits)
       })
     })
   }