effect 4.0.0-beta.27 → 4.0.0-beta.29

package/src/Scheduler.ts

@@ -280,3 +280,15 @@ export class MixedScheduler implements Scheduler {
 export const MaxOpsBeforeYield = ServiceMap.Reference<number>("effect/Scheduler/MaxOpsBeforeYield", {
   defaultValue: () => 2048
 })
+
+/**
+ * A service reference that controls whether the runtime should bypass scheduler
+ * yield checks. When set to `true`, the fiber run loop won't call
+ * `Scheduler.shouldYield`.
+ *
+ * @since 4.0.0
+ * @category references
+ */
+export const PreventSchedulerYield = ServiceMap.Reference<boolean>("effect/Scheduler/PreventSchedulerYield", {
+  defaultValue: () => false
+})

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,
@@ -8348,7 +8348,9 @@ export const ErrorClass: {
   annotations?: Annotations.Declaration<Self, readonly [Struct<Struct.Fields>]>
 ): ErrorClass<Self, Struct<Struct.Fields>, Cause_.YieldableError & Brand> => {
   const struct = isStruct(schema) ? schema : Struct(schema)
-  return makeClass(core.Error, identifier, struct, annotations)
+  const self = makeClass(core.Error, identifier, struct, annotations)
+  ;(self.prototype as any).name = identifier
+  return self
 }
 
 /**

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

@@ -27,8 +27,12 @@ export const TypeId: TypeId = "~effect/Stdio"
 export interface Stdio {
   readonly [TypeId]: TypeId
   readonly args: Effect.Effect<ReadonlyArray<string>>
-  readonly stdout: Sink.Sink<void, string | Uint8Array, never, PlatformError>
-  readonly stderr: Sink.Sink<void, string | Uint8Array, never, PlatformError>
+  stdout(options?: {
+    readonly endOnDone?: boolean | undefined
+  }): Sink.Sink<void, string | Uint8Array, never, PlatformError>
+  stderr(options?: {
+    readonly endOnDone?: boolean | undefined
+  }): Sink.Sink<void, string | Uint8Array, never, PlatformError>
   readonly stdin: Stream.Stream<Uint8Array, PlatformError>
 }
 /**
@@ -55,8 +59,8 @@ export const layerTest = (impl: Partial<Stdio>): Layer.Layer<Stdio> =>
     Stdio,
     make({
       args: Effect.succeed([]),
-      stdout: Sink.drain,
-      stderr: Sink.drain,
+      stdout: () => Sink.drain,
+      stderr: () => Sink.drain,
       stdin: Stream.empty,
       ...impl
     })

package/src/Stream.ts

@@ -1254,7 +1254,9 @@ export const fromPubSubTake = <A, E>(pubsub: PubSub.PubSub<Take.Take<A, E>>): St
  *
  * @example
  * ```ts
- * import { Console, Effect, Stream } from "effect"
+ * import { Console, Data, Effect, Stream } from "effect"
+ *
+ * class StreamError extends Data.TaggedError("StreamError")<{ readonly cause: unknown }> {}
  *
  * const readableStream = new ReadableStream({
  *   start(controller) {
@@ -1268,7 +1270,7 @@ export const fromPubSubTake = <A, E>(pubsub: PubSub.PubSub<Take.Take<A, E>>): St
  * const program = Effect.gen(function*() {
  *   const stream = Stream.fromReadableStream({
  *     evaluate: () => readableStream,
- *     onError: (error) => new Error(String(error))
+ *     onError: (cause) => new StreamError({ cause })
  *   })
  *   const values = yield* Stream.runCollect(stream)
  *   yield* Console.log(values)
@@ -1310,7 +1312,9 @@ export const fromReadableStream = <A, E>(
  *
  * @example
  * ```ts
- * import { Console, Effect, Stream } from "effect"
+ * import { Console, Data, Effect, Stream } from "effect"
+ *
+ * class StreamError extends Data.TaggedError("StreamError")<{ readonly cause: unknown }> {}
  *
  * const iterable = (async function*() {
  *   yield 1
@@ -1319,7 +1323,7 @@ export const fromReadableStream = <A, E>(
  * })()
  *
  * const program = Effect.gen(function*() {
- *   const stream = Stream.fromAsyncIterable(iterable, (error) => new Error(String(error)))
+ *   const stream = Stream.fromAsyncIterable(iterable, (cause) => new StreamError({ cause }))
  *   const values = yield* Stream.runCollect(stream)
  *   yield* Console.log(values)
  * })

package/src/Types.ts

@@ -707,28 +707,6 @@ export declare namespace Contravariant {
   export type Type<A> = A extends Contravariant<infer U> ? U : never
 }
 
-/**
- * Conditional type that checks if `S` is an empty object type.
- *
- * - Returns `onTrue` if `S` matches `{}` (i.e., has no required properties).
- * - Returns `onFalse` otherwise.
- * - Useful for branching type-level logic based on whether a service/context
- *   type has requirements.
- *
- * **Example** (Branching on empty record)
- *
- * ```ts
- * import type { Types } from "effect"
- *
- * type A = Types.MatchRecord<{}, "empty", "not empty"> // "empty"
- * type B = Types.MatchRecord<{ a: number }, "empty", "not empty"> // "not empty"
- * ```
- *
- * @since 2.0.0
- * @category types
- */
-export type MatchRecord<S, onTrue, onFalse> = {} extends S ? onTrue : onFalse
-
 /**
  * Conditional type that returns `void` if `S` is an empty object type,
  * otherwise returns `S`.
@@ -736,7 +714,7 @@ export type MatchRecord<S, onTrue, onFalse> = {} extends S ? onTrue : onFalse
  * @since 4.0.0
  * @category types
  */
-export type VoidIfEmpty<S> = MatchRecord<S, void, S>
+export type VoidIfEmpty<S> = keyof S extends never ? void : S
 
 /**
  * Excludes function types from a union, keeping only non-function members.

package/src/index.ts

@@ -10,7 +10,7 @@ export {
   /**
    * @since 2.0.0
    */
-  coerceUnsafe,
+  cast,
   /**
    * @since 2.0.0
    */
@@ -956,12 +956,14 @@ export * as Duration from "./Duration.ts"
  *
  * @example
  * ```ts
- * import { Effect } from "effect"
+ * import { Data, Effect } from "effect"
+ *
+ * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
  *
  * // Effect that may fail
  * const divide = (a: number, b: number) =>
  *   b === 0
- *     ? Effect.fail(new Error("Division by zero"))
+ *     ? Effect.fail(new DiscountRateError())
  *     : Effect.succeed(a / b)
  *
  * // Error handling
@@ -2312,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/internal/effect.ts

@@ -537,6 +537,7 @@ export class FiberImpl<A = any, E = any> implements Fiber.Fiber<A, E> {
   currentStackFrame: StackFrame | undefined
   runtimeMetrics: Metric.FiberRuntimeMetricsService | undefined
   maxOpsBeforeYield!: number
+  currentPreventYield!: boolean
 
   getRef<X>(ref: ServiceMap.Reference<X>): X {
     return ServiceMap.getReferenceUnsafe(this.services, ref)
@@ -615,6 +616,7 @@ export class FiberImpl<A = any, E = any> implements Fiber.Fiber<A, E> {
         this.currentOpCount++
         if (
           !yielding &&
+          !this.currentPreventYield &&
           this.currentScheduler.shouldYield(this as any)
         ) {
           yielding = true
@@ -678,6 +680,7 @@ export class FiberImpl<A = any, E = any> implements Fiber.Fiber<A, E> {
     this.minimumLogLevel = this.getRef(MinimumLogLevel)
     this.currentStackFrame = services.mapUnsafe.get(CurrentStackFrame.key)
     this.maxOpsBeforeYield = this.getRef(Scheduler.MaxOpsBeforeYield)
+    this.currentPreventYield = this.getRef(Scheduler.PreventSchedulerYield)
     this.runtimeMetrics = services.mapUnsafe.get(InternalMetric.FiberRuntimeMetricsKey)
     const currentTracer = services.mapUnsafe.get(Tracer.TracerKey)
     this.currentTracerContext = currentTracer ? currentTracer["context"] : undefined

package/src/unstable/ai/LanguageModel.ts

@@ -180,22 +180,6 @@ export type CodecTransformer = <T, E, RD, RE>(schema: Schema.Codec<T, E, RD, RE>
   readonly jsonSchema: JsonSchema.JsonSchema
 }
 
-/**
- * A `ServiceMap.Reference` that holds the current `CodecTransformer` used by
- * `LanguageModel.generateObject` to adapt structured output schemas for the
- * active provider.
- *
- * By default, this is the identity function (no transformation). Provider
- * packages (e.g. `@effect/ai-anthropic`) override this reference with a
- * provider-specific transformer so that schemas are automatically rewritten
- * before being sent to the model as well as before decoding the generated value.
- *
- * @since 4.0.0
- * @category services
- */
-export const CurrentCodecTransformer: ServiceMap.Reference<CodecTransformer> =
-  InternalCodecTransformer.CurrentCodecTransformer
-
 /**
  * The default codec transformer that passes schemas through without
  * provider-specific rewrites.
@@ -625,12 +609,15 @@ export interface ProviderOptions {
 }
 
 /**
- * Parameters required to construct a LanguageModel service.
+ * Creates a LanguageModel service from provider-specific implementations.
+ *
+ * This constructor takes provider-specific implementations for text generation
+ * and streaming text generation and returns a LanguageModel service.
  *
  * @since 4.0.0
- * @category models
+ * @category constructors
  */
-export interface ConstructorParams {
+export const make: (params: {
   /**
    * A method which requests text generation from the large language model
    * provider.
@@ -651,19 +638,14 @@ export interface ConstructorParams {
   readonly streamText: (
     options: ProviderOptions
   ) => Stream.Stream<Response.StreamPartEncoded, AiError.AiError, IdGenerator>
-}
 
-/**
- * Creates a LanguageModel service from provider-specific implementations.
- *
- * This constructor takes provider-specific implementations for text generation
- * and streaming text generation and returns a LanguageModel service.
- *
- * @since 4.0.0
- * @category constructors
- */
-export const make: (params: ConstructorParams) => Effect.Effect<Service> = Effect.fnUntraced(function*(params) {
-  const codecTransformer = yield* InternalCodecTransformer.CurrentCodecTransformer
+  /**
+   * A function that transforms a `Schema.Codec` into a provider-compatible form
+   * for structured output generation.
+   */
+  readonly codecTransformer?: CodecTransformer | undefined
+}) => Effect.Effect<Service> = Effect.fnUntraced(function*(params) {
+  const codecTransformer = params.codecTransformer ?? defaultCodecTransformer
 
   const parentSpanTransformer = yield* Effect.serviceOption(
     CurrentSpanTransformer
@@ -724,8 +706,7 @@ export const make: (params: ConstructorParams) => Effect.Effect<Service> = Effec
             })
           )),
         (effect, span) => Effect.withParentSpan(effect, span, { captureStackTrace: false }),
-        Effect.provideService(IdGenerator, idGenerator),
-        Effect.provideService(InternalCodecTransformer.CurrentCodecTransformer, codecTransformer)
+        Effect.provideService(IdGenerator, idGenerator)
       )
     ) as any
 
@@ -803,8 +784,7 @@ export const make: (params: ConstructorParams) => Effect.Effect<Service> = Effec
             })
           )),
         (effect, span) => Effect.withParentSpan(effect, span, { captureStackTrace: false }),
-        Effect.provideService(IdGenerator, idGenerator),
-        Effect.provideService(InternalCodecTransformer.CurrentCodecTransformer, codecTransformer)
+        Effect.provideService(IdGenerator, idGenerator)
       )
     ) as any
   }
@@ -875,8 +855,7 @@ export const make: (params: ConstructorParams) => Effect.Effect<Service> = Effec
         })
         : error
     ),
-    Stream.provideService(IdGenerator, idGenerator),
-    Stream.provideService(InternalCodecTransformer.CurrentCodecTransformer, codecTransformer)
+    Stream.provideService(IdGenerator, idGenerator)
   ) as any
 
   const generateContent: <

package/src/unstable/ai/McpSchema.ts

@@ -1842,6 +1842,7 @@ export class ElicitationDeclined
  */
 export class McpServerClient extends ServiceMap.Service<McpServerClient, {
   readonly clientId: number
+  readonly initializePayload: typeof Initialize.payloadSchema["Type"]
   readonly getClient: Effect.Effect<
     RpcClient.RpcClient<RpcGroup.Rpcs<typeof ServerRequestRpcs>, RpcClientError>,
     never,
@@ -2121,3 +2122,16 @@ export function param<const Name extends string, S extends Schema.Top>(
 ): Param<Name, S> {
   return Schema.make(schema.ast, { [ParamSchemaTypeId]: ParamSchemaTypeId, name, schema })
 }
+
+/**
+ * Annotation to conditionally enable or disable tools based on client
+ * information.
+ *
+ * @since 4.0.0
+ * @category annotations
+ */
+export class EnabledWhen
+  extends ServiceMap.Service<EnabledWhen, Predicate.Predicate<typeof Initialize.payloadSchema.Type>>()(
+    "effect/unstable/ai/McpSchema/EnabledWhen"
+  )
+{}