effect 4.0.0-beta.33 → 4.0.0-beta.35

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/MutableHashMap.ts

@@ -33,6 +33,7 @@ import { type Inspectable, NodeInspectSymbol, toJson } from "./Inspectable.ts"
 import * as Option from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { pipeArguments } from "./Pipeable.ts"
+import { hasProperty } from "./Predicate.ts"
 
 const TypeId = "~effect/collections/MutableHashMap"
 
@@ -71,6 +72,14 @@ export interface MutableHashMap<out K, out V> extends Iterable<[K, V]>, Pipeable
   readonly buckets: Map<number, NonEmptyArray<K>>
 }
 
+/**
+ * Checks if the specified value is a `MutableHashMap`, `false` otherwise.
+ *
+ * @category refinements
+ * @since 4.0.0
+ */
+export const isMutableHashMap = <K, V>(value: unknown): value is MutableHashMap<K, V> => hasProperty(value, TypeId)
+
 const MutableHashMapProto: Omit<MutableHashMap<unknown, unknown>, "backing" | "buckets" | "bucketsSize"> = {
   [TypeId]: TypeId,
   [Symbol.iterator](this: MutableHashMap<unknown, unknown>): Iterator<[unknown, unknown]> {

package/src/MutableHashSet.ts

@@ -30,6 +30,7 @@ import { type Inspectable, NodeInspectSymbol, toJson } from "./Inspectable.ts"
 import * as MutableHashMap from "./MutableHashMap.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { pipeArguments } from "./Pipeable.ts"
+import { hasProperty } from "./Predicate.ts"
 
 const TypeId = "~effect/collections/MutableHashSet"
 
@@ -68,6 +69,14 @@ export interface MutableHashSet<out V> extends Iterable<V>, Pipeable, Inspectabl
   readonly keyMap: MutableHashMap.MutableHashMap<V, boolean>
 }
 
+/**
+ * Checks if the specified value is a `MutableHashSet`, `false` otherwise.
+ *
+ * @category refinements
+ * @since 4.0.0
+ */
+export const isMutableHashSet = <V>(value: unknown): value is MutableHashSet<V> => hasProperty(value, TypeId)
+
 const MutableHashSetProto: Omit<MutableHashSet<unknown>, "keyMap"> = {
   [TypeId]: TypeId,
   [Symbol.iterator](this: MutableHashSet<unknown>): Iterator<unknown> {

package/src/Resource.ts

@@ -6,6 +6,7 @@ import * as Exit from "./Exit.ts"
 import { identity } from "./Function.ts"
 import { PipeInspectableProto } from "./internal/core.ts"
 import type { Pipeable } from "./Pipeable.ts"
+import { hasProperty } from "./Predicate.ts"
 import type * as Schedule from "./Schedule.ts"
 import type * as Scope from "./Scope.ts"
 import * as ScopedRef from "./ScopedRef.ts"
@@ -32,7 +33,7 @@ export interface Resource<in out A, in out E = never> extends Pipeable {
  */
 export const isResource: (u: unknown) => u is Resource<unknown, unknown> = (
   u: unknown
-): u is Resource<unknown, unknown> => typeof u === "object" && u !== null && TypeId in u
+): u is Resource<unknown, unknown> => hasProperty(u, TypeId)
 
 const Proto = {
   ...PipeInspectableProto,

package/src/Schema.ts

@@ -3262,6 +3262,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/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/SubscriptionRef.ts

@@ -6,6 +6,7 @@ import { dual, identity } from "./Function.ts"
 import { PipeInspectableProto } from "./internal/core.ts"
 import * as Option from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
+import { hasProperty } from "./Predicate.ts"
 import * as PubSub from "./PubSub.ts"
 import * as Semaphore from "./Semaphore.ts"
 import * as Stream from "./Stream.ts"
@@ -29,7 +30,7 @@ export interface SubscriptionRef<in out A> extends SubscriptionRef.Variance<A>,
  */
 export const isSubscriptionRef: (u: unknown) => u is SubscriptionRef<unknown> = (
   u: unknown
-): u is SubscriptionRef<unknown> => typeof u === "object" && u != null && TypeId in u
+): u is SubscriptionRef<unknown> => hasProperty(u, TypeId)
 
 /**
  * The `SynchronizedRef` namespace containing type definitions and utilities.

package/src/TxDeferred.ts

@@ -13,6 +13,7 @@ import type { Option } from "./Option.ts"
 import * as O from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { pipeArguments } from "./Pipeable.ts"
+import { hasProperty } from "./Predicate.ts"
 import type { Result } from "./Result.ts"
 import * as Res from "./Result.ts"
 import * as TxRef from "./TxRef.ts"
@@ -390,5 +391,4 @@ export const fail: {
  * @since 4.0.0
  * @category guards
  */
-export const isTxDeferred = (u: unknown): u is TxDeferred<unknown, unknown> =>
-  typeof u === "object" && u !== null && TypeId in u
+export const isTxDeferred = (u: unknown): u is TxDeferred<unknown, unknown> => hasProperty(u, TypeId)

package/src/TxHashMap.ts

@@ -11,6 +11,7 @@ import { NodeInspectSymbol, toJson } from "./Inspectable.ts"
 import * as Option from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { pipeArguments } from "./Pipeable.ts"
+import { hasProperty } from "./Predicate.ts"
 import type { Result } from "./Result.ts"
 import * as TxRef from "./TxRef.ts"
 
@@ -1882,7 +1883,7 @@ export const setMany: {
  * @category guards
  */
 export const isTxHashMap = <K, V>(value: unknown): value is TxHashMap<K, V> => {
-  return typeof value === "object" && value !== null && TypeId in value
+  return hasProperty(value, TypeId)
 }
 
 /**

package/src/TxHashSet.ts

@@ -10,7 +10,7 @@ import type { Inspectable } from "./Inspectable.ts"
 import { NodeInspectSymbol, toJson } from "./Inspectable.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { pipeArguments } from "./Pipeable.ts"
-import type { Predicate, Refinement } from "./Predicate.ts"
+import { hasProperty, type Predicate, type Refinement } from "./Predicate.ts"
 import * as TxRef from "./TxRef.ts"
 import type { NoInfer } from "./Types.ts"
 
@@ -286,7 +286,7 @@ export const fromHashSet = <V>(hashSet: HashSet.HashSet<V>): Effect.Effect<TxHas
  * @since 2.0.0
  * @category guards
  */
-export const isTxHashSet = (u: unknown): u is TxHashSet<unknown> => typeof u === "object" && u !== null && TypeId in u
+export const isTxHashSet = (u: unknown): u is TxHashSet<unknown> => hasProperty(u, TypeId)
 
 /**
  * Adds a value to the TxHashSet. If the value already exists, the operation has no effect.

package/src/TxPriorityQueue.ts

@@ -16,7 +16,7 @@ import * as O from "./Option.ts"
 import type { Order } from "./Order.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { pipeArguments } from "./Pipeable.ts"
-import type { Predicate } from "./Predicate.ts"
+import { hasProperty, type Predicate } from "./Predicate.ts"
 import * as TxRef from "./TxRef.ts"
 
 const TypeId = "~effect/transactions/TxPriorityQueue"
@@ -763,5 +763,4 @@ export const toArray = <A>(self: TxPriorityQueue<A>): Effect.Effect<Array<A>, ne
  * @since 4.0.0
  * @category guards
  */
-export const isTxPriorityQueue = (u: unknown): u is TxPriorityQueue<unknown> =>
-  typeof u === "object" && u !== null && TypeId in u
+export const isTxPriorityQueue = (u: unknown): u is TxPriorityQueue<unknown> => hasProperty(u, TypeId)

package/src/TxSemaphore.ts

@@ -7,6 +7,7 @@ import type { Inspectable } from "./Inspectable.ts"
 import { NodeInspectSymbol, toJson } from "./Inspectable.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { pipeArguments } from "./Pipeable.ts"
+import { hasProperty } from "./Predicate.ts"
 import type * as Scope from "./Scope.ts"
 import * as TxRef from "./TxRef.ts"
 
@@ -738,4 +739,4 @@ export const withPermitScoped = (self: TxSemaphore): Effect.Effect<void, never,
  * @since 4.0.0
  * @category guards
  */
-export const isTxSemaphore = (u: unknown): u is TxSemaphore => typeof u === "object" && u !== null && TypeId in u
+export const isTxSemaphore = (u: unknown): u is TxSemaphore => hasProperty(u, TypeId)

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,13 +3792,22 @@ 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>
-): Effect.Effect<A, E, R | Scope.Scope> =>
-  uninterruptible(
-    flatMap(scope, (scope) =>
-      tap(acquire, (a) => scopeAddFinalizerExit(scope, (exit) => internalCall(() => release(a, exit)))))
+  release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<unknown, never, R2>,
+  options?: { readonly interruptible?: boolean }
+): 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))
+          )
+      )
+    )
   )
 
 /** @internal */

package/src/unstable/ai/AiError.ts

@@ -1396,10 +1396,8 @@ export class AiError extends Schema.ErrorClass<AiError>(
   method: Schema.String,
   reason: AiErrorReason
 }) {
-  /**
-   * @since 1.0.0
-   */
   readonly [TypeId] = TypeId
+  override readonly cause = this.reason
 
   /**
    * Delegates to the underlying reason's `isRetryable` getter.
@@ -1534,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:

package/src/unstable/ai/EmbeddingModel.ts

@@ -0,0 +1,209 @@
+/**
+ * The `EmbeddingModel` module provides provider-agnostic text embedding capabilities.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import { EmbeddingModel } from "effect/unstable/ai"
+ *
+ * const program = Effect.gen(function*() {
+ *   const model = yield* EmbeddingModel.EmbeddingModel
+ *   return yield* model.embed("hello world")
+ * })
+ * ```
+ *
+ * @since 4.0.0
+ */
+import * as Effect from "../../Effect.ts"
+import * as Exit from "../../Exit.ts"
+import * as Request from "../../Request.ts"
+import * as RequestResolver from "../../RequestResolver.ts"
+import * as Schema from "../../Schema.ts"
+import * as ServiceMap from "../../ServiceMap.ts"
+import * as AiError from "./AiError.ts"
+
+/**
+ * Service tag for embedding model operations.
+ *
+ * @since 4.0.0
+ * @category services
+ */
+export class EmbeddingModel extends ServiceMap.Service<EmbeddingModel, Service>()(
+  "effect/unstable/ai/EmbeddingModel"
+) {}
+
+/**
+ * Service tag that provides the current embedding dimensions.
+ *
+ * @since 4.0.0
+ * @category services
+ */
+export class Dimensions extends ServiceMap.Service<Dimensions, number>()(
+  "effect/unstable/ai/EmbeddingModel/Dimensions"
+) {}
+
+/**
+ * Token usage metadata for embedding operations.
+ *
+ * @since 4.0.0
+ * @category models
+ */
+export class EmbeddingUsage extends Schema.Class<EmbeddingUsage>(
+  "effect/ai/EmbeddingModel/EmbeddingUsage"
+)({
+  inputTokens: Schema.UndefinedOr(Schema.Finite)
+}) {}
+
+/**
+ * Response for a single embedding request.
+ *
+ * @since 4.0.0
+ * @category models
+ */
+export class EmbedResponse extends Schema.Class<EmbedResponse>(
+  "effect/ai/EmbeddingModel/EmbedResponse"
+)({
+  vector: Schema.Array(Schema.Finite)
+}) {}
+
+/**
+ * Response for multiple embeddings.
+ *
+ * @since 4.0.0
+ * @category models
+ */
+export class EmbedManyResponse extends Schema.Class<EmbedManyResponse>(
+  "effect/ai/EmbeddingModel/EmbedManyResponse"
+)({
+  embeddings: Schema.Array(EmbedResponse),
+  usage: EmbeddingUsage
+}) {}
+
+/**
+ * Provider input options for embedding requests.
+ *
+ * @since 4.0.0
+ * @category models
+ */
+export interface ProviderOptions {
+  readonly inputs: ReadonlyArray<string>
+}
+
+/**
+ * Provider response for batch embedding requests.
+ *
+ * @since 4.0.0
+ * @category models
+ */
+export interface ProviderResponse {
+  readonly results: Array<Array<number>>
+  readonly usage: {
+    readonly inputTokens: number | undefined
+  }
+}
+
+/**
+ * Tagged request used by request resolvers for embedding operations.
+ *
+ * @since 4.0.0
+ * @category constructors
+ */
+export class EmbeddingRequest extends Request.TaggedClass("EmbeddingRequest")<
+  { readonly input: string },
+  EmbedResponse,
+  AiError.AiError
+> {}
+
+/**
+ * Service interface for embedding operations.
+ *
+ * @since 4.0.0
+ * @category models
+ */
+export interface Service {
+  readonly resolver: RequestResolver.RequestResolver<EmbeddingRequest>
+  readonly embed: (input: string) => Effect.Effect<EmbedResponse, AiError.AiError>
+  readonly embedMany: (input: ReadonlyArray<string>) => Effect.Effect<EmbedManyResponse, AiError.AiError>
+}
+
+const invalidProviderResponse = (description: string): AiError.AiError =>
+  AiError.make({
+    module: "EmbeddingModel",
+    method: "embedMany",
+    reason: new AiError.InvalidOutputError({ description })
+  })
+
+/**
+ * Creates an EmbeddingModel service from a provider embedMany implementation.
+ *
+ * @since 4.0.0
+ * @category constructors
+ */
+export const make: (params: {
+  readonly embedMany: (options: ProviderOptions) => Effect.Effect<ProviderResponse, AiError.AiError>
+}) => Effect.Effect<Service> = Effect.fnUntraced(function*(params) {
+  const resolver = RequestResolver.make<EmbeddingRequest>((entries) =>
+    Effect.flatMap(
+      params.embedMany({
+        inputs: entries.map((entry) => entry.request.input)
+      }),
+      (response) =>
+        Effect.map(mapProviderResults(entries.length, response.results), (embeddings) => {
+          for (let i = 0; i < entries.length; i++) {
+            entries[i].completeUnsafe(Exit.succeed(embeddings[i]))
+          }
+        })
+    )
+  ).pipe(
+    RequestResolver.withSpan("EmbeddingModel.resolver")
+  )
+
+  return EmbeddingModel.of({
+    resolver,
+    embed: (input) =>
+      Effect.request(new EmbeddingRequest({ input }), resolver).pipe(
+        Effect.withSpan("EmbeddingModel.embed")
+      ),
+    embedMany: (input) =>
+      (input.length === 0
+        ? Effect.succeed(
+          new EmbedManyResponse({
+            embeddings: [],
+            usage: new EmbeddingUsage({ inputTokens: undefined })
+          })
+        )
+        : params.embedMany({ inputs: input }).pipe(
+          Effect.flatMap((response) =>
+            mapProviderResults(input.length, response.results).pipe(
+              Effect.map((embeddings) =>
+                new EmbedManyResponse({
+                  embeddings,
+                  usage: new EmbeddingUsage({
+                    inputTokens: response.usage.inputTokens
+                  })
+                })
+              )
+            )
+          )
+        )).pipe(Effect.withSpan("EmbeddingModel.embedMany"))
+  })
+})
+
+const mapProviderResults = (
+  inputLength: number,
+  results: Array<Array<number>>
+): Effect.Effect<Array<EmbedResponse>, AiError.AiError> => {
+  const embeddings = new Array<EmbedResponse>(inputLength)
+  if (results.length !== inputLength) {
+    return Effect.fail(
+      invalidProviderResponse(
+        `Provider returned ${results.length} embeddings but expected ${inputLength}`
+      )
+    )
+  }
+  for (let i = 0; i < results.length; i++) {
+    const vector = results[i]
+    embeddings[i] = new EmbedResponse({ vector })
+  }
+  return Effect.succeed(embeddings)
+}