effect 4.0.0-beta.34 → 4.0.0-beta.36

package/src/Effect.ts

@@ -11999,11 +11999,11 @@ export const scopedWith: <A, E, R>(
  * @since 2.0.0
  * @category Resource Management & Finalization
  */
-export const acquireRelease: <A, E, R>(
+export const acquireRelease: <A, E, R, R2>(
   acquire: Effect<A, E, R>,
-  release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect<unknown>,
+  release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect<unknown, never, R2>,
   options?: { readonly interruptible?: boolean }
-) => Effect<A, E, Scope | R> = internal.acquireRelease
+) => Effect<A, E, R | R2 | Scope> = internal.acquireRelease
 
 /**
  * This function is used to ensure that an `Effect` value that represents the

package/src/Equivalence.ts

@@ -1060,3 +1060,59 @@ export function makeReducer<A>() {
     combineAll
   )
 }
+
+/**
+ * An `Equivalence` instance for `Date` objects.
+ *
+ * Dates are compared by their time value (milliseconds since the Unix epoch),
+ * using {@link Date.prototype.getTime}.
+ *
+ * When to use this:
+ * - When comparing `Date` objects by their exact point in time
+ * - When you need value-based equality instead of reference equality
+ * - When working with collections that contain `Date` values
+ *
+ * Behavior:
+ * - Does not mutate inputs
+ * - Two dates are equivalent if `self.getTime() === that.getTime()`
+ * - Internally uses {@link Number} equivalence
+ * - Different `Date` instances representing the same time are considered equivalent
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Equivalence } from "effect"
+ *
+ * const d1 = new Date("2020-01-01T00:00:00.000Z")
+ * const d2 = new Date("2020-01-01T00:00:00.000Z")
+ * const d3 = new Date("2021-01-01T00:00:00.000Z")
+ * const invalidDate1 = new Date("foo")
+ * const invalidDate2 = new Date("bar")
+ *
+ * console.log(Equivalence.Date(d1, d2)) // true
+ * console.log(Equivalence.Date(d1, d3)) // false
+ * console.log(Equivalence.Date(invalidDate1, invalidDate2)) // true
+ * console.log(Equivalence.Date(invalidDate1, d1)) // false
+ * ```
+ *
+ * **Example** (Reference vs value equality)
+ *
+ * ```ts
+ * import { Equivalence } from "effect"
+ *
+ * const d1 = new Date(0)
+ * const d2 = new Date(0)
+ *
+ * console.log(d1 === d2) // false (different references)
+ * console.log(Equivalence.Date(d1, d2)) // true (same time value)
+ * ```
+ *
+ * See also: {@link Number}, {@link mapInput}, {@link strictEqual}
+ *
+ * @category instances
+ * @since 4.0.0
+ */
+export const Date: Equivalence<Date> = mapInput(
+  Number,
+  (d: Date) => d.getTime()
+)

package/src/Layer.ts

@@ -19,6 +19,7 @@
  */
 import type { NonEmptyArray, NonEmptyReadonlyArray } from "./Array.ts"
 import type * as Cause from "./Cause.ts"
+import type * as Channel from "./Channel.ts"
 import * as Deferred from "./Deferred.ts"
 import type { Effect } from "./Effect.ts"
 import type * as Exit from "./Exit.ts"
@@ -33,6 +34,7 @@ import { hasProperty } from "./Predicate.ts"
 import { CurrentStackFrame } from "./References.ts"
 import * as Scope from "./Scope.ts"
 import * as ServiceMap from "./ServiceMap.ts"
+import type * as Stream from "./Stream.ts"
 import * as Tracer from "./Tracer.ts"
 import type * as Types from "./Types.ts"
 
@@ -3148,19 +3150,21 @@ export const launch = <RIn, E, ROut>(self: Layer<ROut, E, RIn>): Effect<never, E
  */
 export type PartialEffectful<A extends object> = Types.Simplify<
   & {
-    [
-      K in keyof A as A[K] extends Effect<any, any, any> | ((...args: any) => Effect<any, any, any>) ? K
-        : never
-    ]?: A[K]
+    [K in keyof A as A[K] extends AnyEffectOrStream ? K : never]?: A[K]
   }
   & {
-    [
-      K in keyof A as A[K] extends Effect<any, any, any> | ((...args: any) => Effect<any, any, any>) ? never
-        : K
-    ]: A[K]
+    [K in keyof A as A[K] extends AnyEffectOrStream ? never : K]: A[K]
   }
 >
 
+type AnyEffectOrStream =
+  | Effect<any, any, any>
+  | Stream.Stream<any, any, any>
+  | Channel.Channel<any, any, any, any, any, any, any>
+  | ((...args: any) => Effect<any, any, any>)
+  | ((...args: any) => Stream.Stream<any, any, any>)
+  | ((...args: any) => Channel.Channel<any, any, any, any, any, any, any>)
+
 /**
  * Creates a mock layer for testing purposes. You can provide a partial
  * implementation of the service, and any methods not provided will
@@ -3331,7 +3335,18 @@ const mockImpl = <I, S extends object>(service: ServiceMap.Key<I, S>, implementa
   )
 
 const makeUnimplemented = (error: globalThis.Error) => {
-  const dead = internalEffect.die(error)
+  const dead = Object.assign(internalEffect.die(error), {
+    [StreamTypeId]: StreamTypeId,
+    channel: {
+      [ChannelTypeId]: ChannelTypeId,
+      transform: () => internalEffect.succeed(dead),
+      pipe() {
+        return pipeArguments(this, arguments)
+      }
+    },
+    [ChannelTypeId]: ChannelTypeId,
+    transform: () => internalEffect.succeed(dead)
+  })
   function unimplemented() {
     return dead
   }
@@ -3341,6 +3356,9 @@ const makeUnimplemented = (error: globalThis.Error) => {
   return unimplemented
 }
 
+const StreamTypeId: Stream.TypeId = "~effect/Stream"
+const ChannelTypeId: Channel.TypeId = "~effect/Channel"
+
 // -----------------------------------------------------------------------------
 // Type constraints
 // -----------------------------------------------------------------------------

package/src/LayerMap.ts

@@ -12,6 +12,8 @@ import type { Mutable, NoExcessProperties } from "./Types.ts"
 
 const TypeId = "~effect/LayerMap"
 
+type IdleTimeToLiveInput<K> = Duration.Input | ((key: K) => Duration.Input)
+
 /**
  * @since 3.14.0
  * @category Models
@@ -119,7 +121,7 @@ export const make: <
 >(
   lookup: (key: K) => L,
   options?: {
-    readonly idleTimeToLive?: Duration.Input | undefined
+    readonly idleTimeToLive?: IdleTimeToLiveInput<K> | undefined
     readonly preloadKeys?: PreloadKeys
   } | undefined
 ) => Effect.Effect<
@@ -129,7 +131,7 @@ export const make: <
 > = Effect.fnUntraced(function*<I, K, EL, RL>(
   lookup: (key: K) => Layer.Layer<I, EL, RL>,
   options?: {
-    readonly idleTimeToLive?: Duration.Input | undefined
+    readonly idleTimeToLive?: IdleTimeToLiveInput<K> | undefined
   } | undefined
 ) {
   const services = yield* Effect.services<never>()
@@ -198,7 +200,7 @@ export const fromRecord = <
 >(
   layers: Layers,
   options?: {
-    readonly idleTimeToLive?: Duration.Input | undefined
+    readonly idleTimeToLive?: IdleTimeToLiveInput<keyof Layers> | undefined
     readonly preload?: Preload | undefined
   } | undefined
 ): Effect.Effect<
@@ -309,7 +311,7 @@ export const Service = <Self>() =>
     | NoExcessProperties<{
       readonly lookup: (key: any) => Layer.Layer<any, any, any>
       readonly dependencies?: ReadonlyArray<Layer.Layer<any, any, any>> | undefined
-      readonly idleTimeToLive?: Duration.Input | undefined
+      readonly idleTimeToLive?: IdleTimeToLiveInput<any> | undefined
       readonly preloadKeys?:
         | Iterable<Options extends { readonly lookup: (key: infer K) => any } ? K : never>
         | undefined
@@ -317,7 +319,7 @@ export const Service = <Self>() =>
     | NoExcessProperties<{
       readonly layers: Record<string, Layer.Layer<any, any, any>>
       readonly dependencies?: ReadonlyArray<Layer.Layer<any, any, any>> | undefined
-      readonly idleTimeToLive?: Duration.Input | undefined
+      readonly idleTimeToLive?: IdleTimeToLiveInput<any> | undefined
       readonly preload?: boolean | undefined
     }, Options>
 >(

package/src/PubSub.ts

@@ -41,6 +41,7 @@ import { nextPow2 } from "./Number.ts"
 import * as Option from "./Option.ts"
 import { type Pipeable, pipeArguments } from "./Pipeable.ts"
 import * as Scope from "./Scope.ts"
+import * as ServiceMap from "./ServiceMap.ts"
 import type { Covariant, Invariant } from "./Types.ts"
 
 const TypeId = "~effect/PubSub"
@@ -881,7 +882,7 @@ export const publish: {
 } = dual(2, <A>(self: PubSub<A>, value: A): Effect.Effect<boolean> =>
   Effect.suspend(() => {
     if (self.shutdownFlag.current) {
-      return Effect.interrupt
+      return Effect.succeed(false)
     }
 
     if (self.pubsub.publish(value)) {
@@ -1110,7 +1111,7 @@ export const publishAll: {
 } = dual(2, <A>(self: PubSub<A>, elements: Iterable<A>): Effect.Effect<boolean> =>
   Effect.suspend(() => {
     if (self.shutdownFlag.current) {
-      return Effect.interrupt
+      return Effect.succeed(false)
     }
     const surplus = self.pubsub.publishAll(elements)
     self.strategy.completeSubscribersUnsafe(self.pubsub, self.subscribers)
@@ -1173,9 +1174,16 @@ export const publishAll: {
  * @category subscription
  */
 export const subscribe = <A>(self: PubSub<A>): Effect.Effect<Subscription<A>, never, Scope.Scope> =>
-  Effect.acquireRelease(
-    Effect.sync(() => makeSubscriptionUnsafe(self.pubsub, self.subscribers, self.strategy)),
-    unsubscribe
+  Effect.uninterruptible(
+    Effect.servicesWith((services) => {
+      const localScope = ServiceMap.get(services, Scope.Scope)
+      const scope = Scope.forkUnsafe(self.scope)
+      const subscription = makeSubscriptionUnsafe(self.pubsub, self.subscribers, self.strategy)
+      return Scope.addFinalizer(scope, unsubscribe(subscription)).pipe(
+        Effect.andThen(Scope.addFinalizerExit(localScope, (exit) => Scope.close(scope, exit))),
+        Effect.as(subscription)
+      )
+    })
   )
 
 const unsubscribe = <A>(self: Subscription<A>): Effect.Effect<void> =>

package/src/Schema.ts

@@ -1209,6 +1209,18 @@ export const decodeOption = Parser.decodeOption
  * @category Decoding
  * @since 4.0.0
  */
+export const decodeUnknownResult = Parser.decodeUnknownResult
+
+/**
+ * @category Decoding
+ * @since 4.0.0
+ */
+export const decodeResult = Parser.decodeResult
+
+/**
+ * @category Decoding
+ * @since 4.0.0
+ */
 export const decodeUnknownPromise = Parser.decodeUnknownPromise
 
 /**
@@ -1367,6 +1379,18 @@ export const encodeOption = Parser.encodeOption
  * @category Encoding
  * @since 4.0.0
  */
+export const encodeUnknownResult = Parser.encodeUnknownResult
+
+/**
+ * @category Encoding
+ * @since 4.0.0
+ */
+export const encodeResult = Parser.encodeResult
+
+/**
+ * @category Encoding
+ * @since 4.0.0
+ */
 export const encodeUnknownPromise = Parser.encodeUnknownPromise
 
 /**
@@ -2276,7 +2300,7 @@ export declare namespace Struct {
   /**
    * @since 4.0.0
    */
-  export type Type<F extends Fields> = Type_<F>
+  export type Type<F extends Fields> = Simplify<Type_<F>>
 
   type Iso_<
     F extends Fields,
@@ -2291,7 +2315,7 @@ export declare namespace Struct {
   /**
    * @since 4.0.0
    */
-  export type Iso<F extends Fields> = Iso_<F>
+  export type Iso<F extends Fields> = Simplify<Iso_<F>>
 
   type EncodedOptionalKeys<Fields extends Struct.Fields> = {
     [K in keyof Fields]: Fields[K] extends { readonly "~encoded.optionality": "optional" } ? K
@@ -2316,7 +2340,7 @@ export declare namespace Struct {
   /**
    * @since 4.0.0
    */
-  export type Encoded<F extends Fields> = Encoded_<F>
+  export type Encoded<F extends Fields> = Simplify<Encoded_<F>>
 
   /**
    * @since 4.0.0
@@ -2343,7 +2367,7 @@ export declare namespace Struct {
   /**
    * @since 4.0.0
    */
-  export type MakeIn<F extends Fields> = MakeIn_<F>
+  export type MakeIn<F extends Fields> = Simplify<MakeIn_<F>>
 }
 
 /**
@@ -2351,14 +2375,14 @@ export declare namespace Struct {
  */
 export interface Struct<Fields extends Struct.Fields> extends
   Bottom<
-    Simplify<Struct.Type<Fields>>,
-    Simplify<Struct.Encoded<Fields>>,
+    Struct.Type<Fields>,
+    Struct.Encoded<Fields>,
     Struct.DecodingServices<Fields>,
     Struct.EncodingServices<Fields>,
     AST.Objects,
     Struct<Fields>,
-    Simplify<Struct.MakeIn<Fields>>,
-    Simplify<Struct.Iso<Fields>>
+    Struct.MakeIn<Fields>,
+    Struct.Iso<Fields>
   >
 {
   readonly "~rebuild.out": this
@@ -3262,6 +3286,36 @@ export const NonEmptyArray = Struct_.lambda<NonEmptyArrayLambda>((schema) =>
   make(new AST.Arrays(false, [schema.ast], [schema.ast]), { schema })
 )
 
+/**
+ * @category Arrays
+ * @since 4.0.0
+ */
+export interface ArrayEnsure<S extends Top> extends decodeTo<$Array<toType<S>>, Union<readonly [S, $Array<S>]>> {}
+
+/**
+ * Decodes a single value or an array of values into an array.
+ *
+ * Decoding:
+ * - a single value is decoded as a one-element array
+ * - an array is decoded as-is
+ *
+ * Encoding:
+ * - a one-element array is encoded as a single value
+ * - arrays with more than one element are encoded as arrays
+ *
+ * @category Arrays
+ * @since 4.0.0
+ */
+export function ArrayEnsure<S extends Top>(schema: S): ArrayEnsure<S> {
+  return Union([schema, Array(schema)]).pipe(decodeTo(
+    Array(toType(schema)),
+    Transformation.transform({
+      decode: Arr.ensure,
+      encode: (array) => array.length === 1 ? array[0] : array
+    })
+  ))
+}
+
 /**
  * Schema type for an array with unique elements. Produced by {@link UniqueArray}.
  *

package/src/SchemaParser.ts

@@ -204,6 +204,24 @@ export const decodeOption: <S extends Schema.Top & { readonly DecodingServices:
   schema: S
 ) => (input: S["Encoded"], options?: AST.ParseOptions) => Option.Option<S["Type"]> = decodeUnknownOption
 
+/**
+ * @category Decoding
+ * @since 4.0.0
+ */
+export function decodeUnknownResult<S extends Schema.Top & { readonly DecodingServices: never }>(
+  schema: S
+): (input: unknown, options?: AST.ParseOptions) => Result.Result<S["Type"], Issue.Issue> {
+  return asResult(decodeUnknownEffect(schema))
+}
+
+/**
+ * @category Decoding
+ * @since 4.0.0
+ */
+export const decodeResult: <S extends Schema.Top & { readonly DecodingServices: never }>(
+  schema: S
+) => (input: S["Encoded"], options?: AST.ParseOptions) => Result.Result<S["Type"], Issue.Issue> = decodeUnknownResult
+
 /**
  * @category Decoding
  * @since 4.0.0
@@ -293,6 +311,24 @@ export const encodeOption: <S extends Schema.Top & { readonly EncodingServices:
   schema: S
 ) => (input: S["Type"], options?: AST.ParseOptions) => Option.Option<S["Encoded"]> = encodeUnknownOption
 
+/**
+ * @category Encoding
+ * @since 4.0.0
+ */
+export function encodeUnknownResult<S extends Schema.Top & { readonly EncodingServices: never }>(
+  schema: S
+): (input: unknown, options?: AST.ParseOptions) => Result.Result<S["Encoded"], Issue.Issue> {
+  return asResult(encodeUnknownEffect(schema))
+}
+
+/**
+ * @category Encoding
+ * @since 4.0.0
+ */
+export const encodeResult: <S extends Schema.Top & { readonly EncodingServices: never }>(
+  schema: S
+) => (input: S["Type"], options?: AST.ParseOptions) => Result.Result<S["Encoded"], Issue.Issue> = encodeUnknownResult
+
 /**
  * @category Encoding
  * @since 4.0.0
@@ -343,6 +379,23 @@ export function asOption<T, E, R>(
   return (input: E, options?: AST.ParseOptions) => Exit.getSuccess(parserExit(input, options))
 }
 
+function asResult<T, E, R>(
+  parser: (input: E, options?: AST.ParseOptions) => Effect.Effect<T, Issue.Issue, R>
+): (input: E, options?: AST.ParseOptions) => Result.Result<T, Issue.Issue> {
+  const parserExit = asExit(parser)
+  return (input: E, options?: AST.ParseOptions) => {
+    const exit = parserExit(input, options)
+    if (Exit.isSuccess(exit)) {
+      return Result.succeed(exit.value)
+    }
+    const error = Cause.findError(exit.cause)
+    if (Result.isFailure(error)) {
+      throw Cause.squash(error.failure)
+    }
+    return Result.fail(error.success)
+  }
+}
+
 function asSync<T, E, R>(
   parser: (input: E, options?: AST.ParseOptions) => Effect.Effect<T, Issue.Issue, R>
 ): (input: E, options?: AST.ParseOptions) => T {

package/src/Stream.ts

@@ -57,7 +57,17 @@ import type {
 } from "./Types.ts"
 import type * as Unify from "./Unify.ts"
 
-const TypeId = "~effect/Stream"
+/**
+ * @since 4.0.0
+ * @category Type Identifiers
+ */
+export type TypeId = "~effect/Stream"
+
+/**
+ * @since 4.0.0
+ * @category Type Identifiers
+ */
+export const TypeId: TypeId = "~effect/Stream"
 
 /**
  * A `Stream<A, E, R>` describes a program that can emit many `A` values, fail

package/src/internal/dateTime.ts

@@ -232,7 +232,14 @@ export const makeUnsafe = <A extends DateTime.DateTime.Input>(input: A): DateTim
   return fromDateUnsafe(new Date(input)) as DateTime.DateTime.PreserveZone<A>
 }
 
-const hasZone = (input: string): boolean => /Z|[+-]\d{2}$|[+-]\d{2}:?\d{2}$|\]$/.test(input)
+/**
+ * Detects whether a date string already contains timezone info.
+ * Without a zone, `new Date("2024-01-01T12:00:00")` is parsed as local time,
+ * so `makeUnsafe` appends "Z" to force UTC interpretation.
+ * This check prevents appending "Z" to strings that already have a zone
+ * (e.g. "2024-01-01T12:00:00Z", "...+05:30", "...GMT"), which would produce invalid dates.
+ */
+const hasZone = (input: string): boolean => /Z|GMT|[+-]\d{2}$|[+-]\d{2}:?\d{2}$|\]$/.test(input)
 
 const minEpochMillis = -8640000000000000 + (12 * 60 * 60 * 1000)
 const maxEpochMillis = 8640000000000000 - (14 * 60 * 60 * 1000)

package/src/internal/effect.ts

@@ -3792,19 +3792,21 @@ export const scopedWith = <A, E, R>(
   })
 
 /** @internal */
-export const acquireRelease = <A, E, R>(
+export const acquireRelease = <A, E, R, R2>(
   acquire: Effect.Effect<A, E, R>,
-  release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<unknown>,
+  release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<unknown, never, R2>,
   options?: { readonly interruptible?: boolean }
-): Effect.Effect<A, E, R | Scope.Scope> =>
-  uninterruptibleMask((restore) =>
-    flatMap(
-      scope,
-      (scope) =>
-        tap(
-          options?.interruptible ? restore(acquire) : acquire,
-          (a) => scopeAddFinalizerExit(scope, (exit) => release(a, exit))
-        )
+): Effect.Effect<A, E, R | R2 | Scope.Scope> =>
+  servicesWith((services: ServiceMap.ServiceMap<R2>) =>
+    uninterruptibleMask((restore) =>
+      flatMap(
+        scope,
+        (scope) =>
+          tap(
+            options?.interruptible ? restore(acquire) : acquire,
+            (a) => scopeAddFinalizerExit(scope, (exit) => provideServices(release(a, exit), services))
+          )
+      )
     )
   )
 
@@ -4061,7 +4063,8 @@ export const cachedInvalidateWithTTL: {
     const wait = flatMap(latch.await, () => exit!)
     return [
       withFiber((fiber) => {
-        const now = isFinite ? fiber.getRef(ClockRef).currentTimeMillisUnsafe() : 0
+        const clock = fiber.getRef(ClockRef)
+        const now = isFinite ? clock.currentTimeMillisUnsafe() : 0
         if (running || now < expiresAt) return exit ?? wait
         running = true
         latch.closeUnsafe()
@@ -4069,7 +4072,7 @@ export const cachedInvalidateWithTTL: {
         return onExit(self, (exit_) =>
           sync(() => {
             running = false
-            expiresAt = now + ttlMillis
+            expiresAt = clock.currentTimeMillisUnsafe() + ttlMillis
             exit = exit_
             latch.openUnsafe()
           }))

package/src/unstable/ai/AiError.ts

@@ -1532,11 +1532,13 @@ export const reasonFromHttpStatus = (params: {
   readonly body?: unknown
   readonly http?: typeof HttpContext.Type
   readonly metadata?: typeof ProviderMetadata.Type
+  readonly description?: string | undefined
 }): AiErrorReason => {
-  const { status, http, metadata } = params
+  const { status, http, metadata, description } = params
   const common = {
     http,
-    ...(Predicate.isNotUndefined(metadata) ? { metadata } : {})
+    ...(metadata ? { metadata } : undefined),
+    ...(description ? { description } : undefined)
   }
   switch (status) {
     case 400: