effect 4.0.0-beta.43 → 4.0.0-beta.45

package/src/internal/layer.ts

@@ -1,7 +1,7 @@
+import * as Context from "../Context.ts"
 import type { Effect } from "../Effect.ts"
 import { dual } from "../Function.ts"
 import * as Layer from "../Layer.ts"
-import * as ServiceMap from "../ServiceMap.ts"
 import { isEffect } from "./core.ts"
 import * as effect from "./effect.ts"
 
@@ -17,7 +17,7 @@ const provideLayer = <A, E, R, ROut, E2, RIn>(
       options?.local
         ? Layer.buildWithMemoMap(layer, Layer.makeMemoMapUnsafe(), scope)
         : Layer.buildWithScope(layer, scope),
-      (context) => effect.provideServices(self, context)
+      (context) => effect.provideContext(self, context)
     )
   )
 
@@ -43,7 +43,7 @@ export const provide = dual<
         readonly local?: boolean | undefined
       } | undefined
     ): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E | E2, RIn | Exclude<R, ROut>>
-    <R2>(services: ServiceMap.ServiceMap<R2>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, R2>>
+    <R2>(context: Context.Context<R2>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, R2>>
   },
   {
     <A, E, R, const Layers extends [Layer.Any, ...Array<Layer.Any>]>(
@@ -67,7 +67,7 @@ export const provide = dual<
     ): Effect<A, E | E2, RIn | Exclude<R, ROut>>
     <A, E, R, R2>(
       self: Effect<A, E, R>,
-      services: ServiceMap.ServiceMap<R2>
+      context: Context.Context<R2>
     ): Effect<A, E, Exclude<R, R2>>
   }
 >(
@@ -76,13 +76,13 @@ export const provide = dual<
     self: Effect<A, E, R>,
     source:
       | Layer.Layer<ROut, any, any>
-      | ServiceMap.ServiceMap<ROut>
+      | Context.Context<ROut>
       | Array<Layer.Any>,
     options?: {
       readonly local?: boolean | undefined
     } | undefined
   ): Effect<any, any, Exclude<R, ROut>> =>
-    ServiceMap.isServiceMap(source)
-      ? effect.provideServices(self, source)
+    Context.isContext(source)
+      ? effect.provideContext(self, source)
       : provideLayer(self, Array.isArray(source) ? Layer.mergeAll(...source as any) : source, options)
 )

package/src/internal/random.ts

@@ -1,4 +1,4 @@
-import * as ServiceMap from "../ServiceMap.ts"
+import * as Context from "../Context.ts"
 
 /** @internal */
 export interface Random {
@@ -7,7 +7,7 @@ export interface Random {
 }
 
 /** @internal */
-export const Random: ServiceMap.Reference<Random> = ServiceMap.Reference<Random>("effect/Random", {
+export const Random: Context.Reference<Random> = Context.Reference<Random>("effect/Random", {
   defaultValue: () => ({
     nextIntUnsafe() {
       return Math.floor(Math.random() * (Number.MAX_SAFE_INTEGER - Number.MIN_SAFE_INTEGER + 1)) +

package/src/internal/rcRef.ts

@@ -1,3 +1,4 @@
+import * as Context from "../Context.ts"
 import * as Duration from "../Duration.ts"
 import * as Effect from "../Effect.ts"
 import * as Exit from "../Exit.ts"
@@ -7,7 +8,6 @@ import { pipeArguments } from "../Pipeable.ts"
 import type * as RcRef from "../RcRef.ts"
 import * as Scope from "../Scope.ts"
 import * as Semaphore from "../Semaphore.ts"
-import * as ServiceMap from "../ServiceMap.ts"
 
 const TypeId = "~effect/RcRef"
 
@@ -50,18 +50,18 @@ class RcRefImpl<A, E> implements RcRef.RcRef<A, E> {
   state: State<A> = stateEmpty
   readonly semaphore = Semaphore.makeUnsafe(1)
   readonly acquire: Effect.Effect<A, E>
-  readonly services: ServiceMap.ServiceMap<never>
+  readonly context: Context.Context<never>
   readonly scope: Scope.Scope
   readonly idleTimeToLive: Duration.Duration | undefined
 
   constructor(
     acquire: Effect.Effect<A, E>,
-    services: ServiceMap.ServiceMap<never>,
+    context: Context.Context<never>,
     scope: Scope.Scope,
     idleTimeToLive: Duration.Duration | undefined
   ) {
     this.acquire = acquire
-    this.services = services
+    this.context = context
     this.scope = scope
     this.idleTimeToLive = idleTimeToLive
   }
@@ -73,11 +73,11 @@ export const make = <A, E, R>(options: {
   readonly idleTimeToLive?: Duration.Input | undefined
 }) =>
   Effect.withFiber<RcRef.RcRef<A, E>, never, R | Scope.Scope>((fiber) => {
-    const services = fiber.services as ServiceMap.ServiceMap<R | Scope.Scope>
-    const scope = ServiceMap.get(services, Scope.Scope)
+    const context = fiber.context as Context.Context<R | Scope.Scope>
+    const scope = Context.get(context, Scope.Scope)
     const ref = new RcRefImpl<A, E>(
       options.acquire as Effect.Effect<A, E>,
-      services,
+      context,
       scope,
       options.idleTimeToLive ? Duration.fromInputUnsafe(options.idleTimeToLive) : undefined
     )
@@ -108,9 +108,9 @@ const getState = <A, E>(self: RcRefImpl<A, E>) =>
       case "Empty": {
         const scope = Scope.makeUnsafe()
         return self.semaphore.withPermits(1)(
-          restore(Effect.provideServices(
+          restore(Effect.provideContext(
             self.acquire as Effect.Effect<A, E>,
-            ServiceMap.add(self.services, Scope.Scope, scope)
+            Context.add(self.context, Scope.Scope, scope)
           )).pipe(Effect.map((value) => {
             const state: State.Acquired<A> = {
               _tag: "Acquired",
@@ -160,7 +160,7 @@ export const get = Effect.fnUntraced(function*<A, E>(
       Effect.ensuring(Effect.sync(() => {
         state.fiber = undefined
       })),
-      Effect.runForkWith(self.services),
+      Effect.runForkWith(self.context),
       Fiber.runIn(self.scope)
     )
     return Effect.void

package/src/internal/references.ts

@@ -1,72 +1,72 @@
+import * as Context from "../Context.ts"
 import type { ErrorReporter } from "../ErrorReporter.ts"
 import { constTrue, constUndefined } from "../Function.ts"
 import type { LogLevel, Severity } from "../LogLevel.ts"
 import type { ReadonlyRecord } from "../Record.ts"
 import type { StackFrame } from "../References.ts"
-import * as ServiceMap from "../ServiceMap.ts"
 import type { SpanLink } from "../Tracer.ts"
 
 /** @internal */
-export const CurrentConcurrency = ServiceMap.Reference<"unbounded" | number>("effect/References/CurrentConcurrency", {
+export const CurrentConcurrency = Context.Reference<"unbounded" | number>("effect/References/CurrentConcurrency", {
   defaultValue: () => "unbounded"
 })
 
 /** @internal */
-export const CurrentErrorReporters = ServiceMap.Reference<ReadonlySet<ErrorReporter>>(
+export const CurrentErrorReporters = Context.Reference<ReadonlySet<ErrorReporter>>(
   "effect/ErrorReporter/CurrentErrorReporters",
   { defaultValue: () => new Set() }
 )
 
 /** @internal */
-export const CurrentStackFrame = ServiceMap.Reference<StackFrame | undefined>("effect/References/CurrentStackFrame", {
+export const CurrentStackFrame = Context.Reference<StackFrame | undefined>("effect/References/CurrentStackFrame", {
   defaultValue: constUndefined
 })
 
 /** @internal */
-export const TracerEnabled = ServiceMap.Reference<boolean>("effect/References/TracerEnabled", {
+export const TracerEnabled = Context.Reference<boolean>("effect/References/TracerEnabled", {
   defaultValue: constTrue
 })
 
 /** @internal */
-export const TracerTimingEnabled = ServiceMap.Reference<boolean>("effect/References/TracerTimingEnabled", {
+export const TracerTimingEnabled = Context.Reference<boolean>("effect/References/TracerTimingEnabled", {
   defaultValue: constTrue
 })
 
 /** @internal */
-export const TracerSpanAnnotations = ServiceMap.Reference<ReadonlyRecord<string, unknown>>(
+export const TracerSpanAnnotations = Context.Reference<ReadonlyRecord<string, unknown>>(
   "effect/References/TracerSpanAnnotations",
   { defaultValue: () => ({}) }
 )
 
 /** @internal */
-export const TracerSpanLinks = ServiceMap.Reference<ReadonlyArray<SpanLink>>("effect/References/TracerSpanLinks", {
+export const TracerSpanLinks = Context.Reference<ReadonlyArray<SpanLink>>("effect/References/TracerSpanLinks", {
   defaultValue: () => []
 })
 
 /** @internal */
-export const CurrentLogAnnotations = ServiceMap.Reference<ReadonlyRecord<string, unknown>>(
+export const CurrentLogAnnotations = Context.Reference<ReadonlyRecord<string, unknown>>(
   "effect/References/CurrentLogAnnotations",
   { defaultValue: () => ({}) }
 )
 
 /** @internal */
-export const CurrentLogLevel: ServiceMap.Reference<Severity> = ServiceMap.Reference<Severity>(
+export const CurrentLogLevel: Context.Reference<Severity> = Context.Reference<Severity>(
   "effect/References/CurrentLogLevel",
   { defaultValue: () => "Info" }
 )
 
 /** @internal */
-export const MinimumLogLevel = ServiceMap.Reference<
+export const MinimumLogLevel = Context.Reference<
   LogLevel
 >("effect/References/MinimumLogLevel", { defaultValue: () => "Info" })
 
 /** @internal */
-export const UnhandledLogLevel: ServiceMap.Reference<Severity | undefined> = ServiceMap.Reference(
+export const UnhandledLogLevel: Context.Reference<Severity | undefined> = Context.Reference(
   "effect/References/UnhandledLogLevel",
   { defaultValue: (): Severity | undefined => "Error" }
 )
 
 /** @internal */
-export const CurrentLogSpans = ServiceMap.Reference<
+export const CurrentLogSpans = Context.Reference<
   ReadonlyArray<[label: string, timestamp: number]>
 >("effect/References/CurrentLogSpans", { defaultValue: () => [] })

package/src/internal/request.ts

@@ -1,4 +1,5 @@
 import type { NonEmptyArray } from "../Array.ts"
+import * as Context from "../Context.ts"
 import type { Effect } from "../Effect.ts"
 import type { Exit } from "../Exit.ts"
 import type { Fiber } from "../Fiber.ts"
@@ -7,7 +8,6 @@ import type * as Request from "../Request.ts"
 import { makeEntry } from "../Request.ts"
 import type { RequestResolver } from "../RequestResolver.ts"
 import { Scheduler } from "../Scheduler.ts"
-import * as ServiceMap from "../ServiceMap.ts"
 import { exitDie, isEffect } from "./core.ts"
 import * as effect from "./effect.ts"
 
@@ -57,12 +57,12 @@ export const requestUnsafe = <A extends Request.Any>(
   options: {
     readonly resolver: RequestResolver<A>
     readonly onExit: (exit: Exit<Request.Success<A>, Request.Error<A>>) => void
-    readonly services: ServiceMap.ServiceMap<never>
+    readonly context: Context.Context<never>
   }
 ): () => void => {
   const entry = addEntry(options.resolver, self, options.onExit, {
-    services: options.services,
-    currentScheduler: ServiceMap.get(options.services, Scheduler)
+    context: options.context,
+    currentScheduler: Context.get(options.context, Scheduler)
   })
   return () => removeEntryUnsafe(options.resolver, entry)
 }
@@ -86,7 +86,7 @@ const addEntry = <A extends Request.Any>(
   request: A,
   resume: (exit: Exit<any, any>) => void,
   fiber: {
-    readonly services: ServiceMap.ServiceMap<never>
+    readonly context: Context.Context<never>
     readonly currentScheduler: Scheduler
     readonly id?: number
   }
@@ -100,7 +100,7 @@ const addEntry = <A extends Request.Any>(
   let completed = false
   const entry = makeEntry({
     request,
-    services: fiber.services as any,
+    context: fiber.context as any,
     uninterruptible: false,
     completeUnsafe(effect) {
       if (completed) return
@@ -159,7 +159,7 @@ const addEntry = <A extends Request.Any>(
       batch = newBatch
     }
     batchMap.set(key, batch)
-    batch.fiber = effect.runForkWith(fiber.services)(batch.delayEffect, { scheduler: fiber.currentScheduler })
+    batch.fiber = effect.runForkWith(fiber.context)(batch.delayEffect, { scheduler: fiber.currentScheduler })
   }
 
   batch.entrySet.add(entry)
@@ -167,7 +167,7 @@ const addEntry = <A extends Request.Any>(
   if (batch.resolver.collectWhile(batch.entries)) return entry
 
   batch.fiber!.interruptUnsafe(fiber.id)
-  batch.fiber = effect.runForkWith(fiber.services)(runBatch(batch), { scheduler: fiber.currentScheduler })
+  batch.fiber = effect.runForkWith(fiber.context)(runBatch(batch), { scheduler: fiber.currentScheduler })
   return entry
 }
 

package/src/internal/schedule.ts

@@ -226,7 +226,9 @@ export const buildFromOptions = <Input>(options: {
   until?: ((input: Input) => boolean | Effect<boolean, any, any>) | undefined
   times?: number | undefined
 }) => {
-  let schedule: Schedule.Schedule<any, Input, any, any> = options.schedule ?? passthroughForever
+  let schedule: Schedule.Schedule<any, Input, any, any> = options.schedule
+    ? Schedule.passthrough(options.schedule)
+    : passthroughForever
   if (options.while) {
     schedule = Schedule.while(schedule, ({ input }) => {
       const applied = options.while!(input)

package/src/internal/schema/representation.ts

@@ -1,4 +1,5 @@
 import * as Arr from "../../Array.ts"
+import * as Equal from "../../Equal.ts"
 import { format } from "../../Formatter.ts"
 import { escapeToken } from "../../JsonPointer.ts"
 import type * as JsonSchema from "../../JsonSchema.ts"
@@ -33,7 +34,7 @@ export function fromASTs(asts: readonly [AST.AST, ...Array<AST.AST>]): SchemaRep
     references
   }
 
-  function gen(prefix: string = "_"): string {
+  function gen(prefix: string): string {
     let candidate = prefix
     let suffix = 0
 
@@ -63,6 +64,12 @@ export function fromASTs(asts: readonly [AST.AST, ...Array<AST.AST>]): SchemaRep
       const reference = gen(identifier)
       referenceMap.set(ast, reference)
       const out = on(ast)
+      const found = references[identifier]
+      // Reuse existing references when duplicate identifiers have the same representation
+      if (found !== undefined && Equal.equals(out, found)) {
+        referenceMap.set(ast, identifier)
+        return { _tag: "Reference", $ref: identifier }
+      }
       references[reference] = out
       return { _tag: "Reference", $ref: reference }
     }

package/src/internal/schema/schema.ts

@@ -1,6 +1,9 @@
+import * as Effect from "../../Effect.ts"
+import { flow } from "../../Function.ts"
 import * as Pipeable from "../../Pipeable.ts"
 import type * as Schema from "../../Schema.ts"
 import * as AST from "../../SchemaAST.ts"
+import type { Issue } from "../../SchemaIssue.ts"
 import * as Parser from "../../SchemaParser.ts"
 
 /** @internal */
@@ -30,7 +33,27 @@ export function make<S extends Schema.Top>(ast: S["ast"], options?: object): S {
   }
   self.ast = ast
   self.rebuild = (ast: AST.AST) => make(ast, options)
-  self.makeUnsafe = Parser.makeUnsafe(self)
+  self.makeEffect = flow(Parser.makeEffect(self), Effect.mapErrorEager((issue) => new SchemaError(issue)))
+  self.make = Parser.makeUnsafe(self)
   self.makeOption = Parser.makeOption(self)
   return self
 }
+
+/** @internal */
+export const SchemaErrorTypeId = "~effect/Schema/SchemaError"
+
+export class SchemaError {
+  readonly [SchemaErrorTypeId] = SchemaErrorTypeId
+  readonly _tag = "SchemaError"
+  readonly name: string = "SchemaError"
+  readonly issue: Issue
+  constructor(issue: Issue) {
+    this.issue = issue
+  }
+  get message() {
+    return this.issue.toString()
+  }
+  toString() {
+    return `SchemaError(${this.message})`
+  }
+}

package/src/testing/TestSchema.ts

@@ -67,6 +67,7 @@
  * @since 4.0.0
  */
 import * as assert from "node:assert"
+import type * as Context from "../Context.ts"
 import * as Effect from "../Effect.ts"
 import * as Record from "../Record.ts"
 import * as Result from "../Result.ts"
@@ -74,7 +75,6 @@ import * as Schema from "../Schema.ts"
 import * as AST from "../SchemaAST.ts"
 import type * as Issue from "../SchemaIssue.ts"
 import * as Parser from "../SchemaParser.ts"
-import type * as ServiceMap from "../ServiceMap.ts"
 import * as FastCheck from "../testing/FastCheck.ts"
 
 /**
@@ -438,7 +438,7 @@ export class Decoding<S extends Schema.Top> {
    * @see {@link Encoding.provide}
    */
   provide<Id, Service>(
-    service: ServiceMap.Key<Id, Service>,
+    service: Context.Key<Id, Service>,
     implementation: Service
   ): Decoding<Schema.middlewareDecoding<S, Exclude<S["DecodingServices"], Id>>> {
     return new Decoding(
@@ -573,7 +573,7 @@ class Encoding<S extends Schema.Top> {
    * @see {@link Decoding.provide}
    */
   provide<Id, Service>(
-    service: ServiceMap.Key<Id, Service>,
+    service: Context.Key<Id, Service>,
     implementation: Service
   ): Encoding<Schema.middlewareEncoding<S, Exclude<S["EncodingServices"], Id>>> {
     return new Encoding(

package/src/unstable/ai/AiError.ts

@@ -79,6 +79,7 @@
  * @since 1.0.0
  */
 import * as Duration from "../../Duration.ts"
+import * as Effect from "../../Effect.ts"
 import * as Option from "../../Option.ts"
 import * as Predicate from "../../Predicate.ts"
 import { redact } from "../../Redactable.ts"
@@ -91,8 +92,8 @@ const ReasonTypeId = "~effect/unstable/ai/AiError/Reason" as const
 
 const providerMetadataWithDefaults = <Metadata extends ProviderMetadata>() =>
   (ProviderMetadata as unknown as typeof ProviderMetadata & Schema.Schema<Metadata>).pipe(
-    Schema.withConstructorDefault(() => Option.some({} as Metadata)),
-    Schema.withDecodingDefault(() => ({} as Metadata))
+    Schema.withConstructorDefault(Effect.succeed({})),
+    Schema.withDecodingDefault(Effect.succeed({}))
   )
 
 const redactHeaders = (headers: Record<string, string>): Record<string, string> => {

package/src/unstable/ai/Chat.ts

@@ -46,6 +46,7 @@
  */
 import * as Channel from "../../Channel.ts"
 import * as Chunk from "../../Chunk.ts"
+import * as Context from "../../Context.ts"
 import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import * as Layer from "../../Layer.ts"
@@ -54,7 +55,6 @@ import * as Predicate from "../../Predicate.ts"
 import * as Ref from "../../Ref.ts"
 import * as Schema from "../../Schema.ts"
 import * as Semaphore from "../../Semaphore.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
 import type { NoExcessProperties } from "../../Types.ts"
 import type { PersistenceError } from "../persistence/Persistence.ts"
@@ -90,7 +90,7 @@ import type * as Tool from "./Tool.ts"
  * @since 4.0.0
  * @category services
  */
-export class Chat extends ServiceMap.Service<Chat, Service>()(
+export class Chat extends Context.Service<Chat, Service>()(
   "effect/ai/Chat"
 ) {}
 
@@ -649,7 +649,7 @@ export class ChatNotFoundError extends Schema.ErrorClass<ChatNotFoundError>(
  * @category services
  */
 // @effect-diagnostics effect/leakingRequirements:off
-export class Persistence extends ServiceMap.Service<Persistence, Persistence.Service>()(
+export class Persistence extends Context.Service<Persistence, Persistence.Service>()(
   "effect/ai/Chat/Persisted"
 ) {}
 

package/src/unstable/ai/EmbeddingModel.ts

@@ -14,12 +14,12 @@
  *
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 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"
 
 /**
@@ -28,7 +28,7 @@ import * as AiError from "./AiError.ts"
  * @since 4.0.0
  * @category services
  */
-export class EmbeddingModel extends ServiceMap.Service<EmbeddingModel, Service>()(
+export class EmbeddingModel extends Context.Service<EmbeddingModel, Service>()(
   "effect/unstable/ai/EmbeddingModel"
 ) {}
 
@@ -38,7 +38,7 @@ export class EmbeddingModel extends ServiceMap.Service<EmbeddingModel, Service>(
  * @since 4.0.0
  * @category services
  */
-export class Dimensions extends ServiceMap.Service<Dimensions, number>()(
+export class Dimensions extends Context.Service<Dimensions, number>()(
   "effect/unstable/ai/EmbeddingModel/Dimensions"
 ) {}
 

package/src/unstable/ai/IdGenerator.ts

@@ -46,11 +46,11 @@
  * @since 4.0.0
  */
 import * as Cause from "../../Cause.ts"
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Layer from "../../Layer.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Random from "../../Random.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 
 /**
  * The `IdGenerator` service tag for dependency injection.
@@ -74,7 +74,7 @@ import * as ServiceMap from "../../ServiceMap.ts"
  * @since 4.0.0
  * @category models
  */
-export class IdGenerator extends ServiceMap.Service<IdGenerator, Service>()(
+export class IdGenerator extends Context.Service<IdGenerator, Service>()(
   "@effect/ai/IdGenerator"
 ) {}
 

package/src/unstable/ai/LanguageModel.ts

@@ -49,6 +49,7 @@
  * @since 4.0.0
  */
 import type * as Cause from "../../Cause.ts"
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as FiberSet from "../../FiberSet.ts"
 import { constFalse, identity, pipe } from "../../Function.ts"
@@ -59,7 +60,6 @@ import * as Queue from "../../Queue.ts"
 import { CurrentConcurrency } from "../../References.ts"
 import * as Schema from "../../Schema.ts"
 import * as AST from "../../SchemaAST.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Sink from "../../Sink.ts"
 import * as Stream from "../../Stream.ts"
 import type { Span } from "../../Tracer.ts"
@@ -103,7 +103,7 @@ import * as Toolkit from "./Toolkit.ts"
  * @since 4.0.0
  * @category services
  */
-export class LanguageModel extends ServiceMap.Service<LanguageModel, Service>()(
+export class LanguageModel extends Context.Service<LanguageModel, Service>()(
   "effect/unstable/ai/LanguageModel"
 ) {}
 

package/src/unstable/ai/McpSchema.ts

@@ -1,14 +1,14 @@
 /**
  * @since 4.0.0
  */
-import type * as Effect from "../../Effect.ts"
+import * as Context from "../../Context.ts"
+import * as Effect from "../../Effect.ts"
 import { constFalse, constTrue } from "../../Function.ts"
 import * as Option from "../../Option.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Schema from "../../Schema.ts"
 import * as Getter from "../../SchemaGetter.ts"
 import type * as Scope from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Rpc from "../rpc/Rpc.ts"
 import type * as RpcClient from "../rpc/RpcClient.ts"
 import type { RpcClientError } from "../rpc/RpcClientError.ts"
@@ -28,16 +28,18 @@ export interface optionalWithDefault<S extends Schema.Top & Schema.WithoutConstr
 export const optionalWithDefault = <S extends Schema.Top & Schema.WithoutConstructorDefault>(
   schema: S,
   defaultValue: () => Schema.optionalKey<S>["Type"]
-): optionalWithDefault<S> =>
-  Schema.optionalKey(schema).pipe(
+): optionalWithDefault<S> => {
+  const effect = Effect.sync(defaultValue)
+  return Schema.optionalKey(schema).pipe(
     Schema.decode<Schema.optionalKey<S>>({
-      decode: Getter.withDefault(defaultValue),
+      decode: Getter.withDefault(effect),
       encode: Getter.passthrough()
     }),
     Schema.withConstructorDefault<
       Schema.decodeTo<Schema.toType<Schema.optionalKey<S>>, Schema.optionalKey<S>>
-    >(() => Option.some(defaultValue()))
+    >(effect)
   )
+}
 
 /**
  * @since 4.0.0
@@ -1616,7 +1618,7 @@ export class CompleteResult extends Schema.Opaque<CompleteResult>()(Schema.Struc
   /**
    * @since 4.0.0
    */
-  static readonly empty = CompleteResult.makeUnsafe({
+  static readonly empty = CompleteResult.make({
     completion: {
       values: [],
       total: 0,
@@ -1840,7 +1842,7 @@ export class ElicitationDeclined
  * @since 4.0.0
  * @category client
  */
-export class McpServerClient extends ServiceMap.Service<McpServerClient, {
+export class McpServerClient extends Context.Service<McpServerClient, {
   readonly clientId: number
   readonly initializePayload: typeof Initialize.payloadSchema["Type"]
   readonly getClient: Effect.Effect<
@@ -2131,7 +2133,7 @@ export function param<const Name extends string, S extends Schema.Top>(
  * @category annotations
  */
 export class EnabledWhen
-  extends ServiceMap.Service<EnabledWhen, Predicate.Predicate<typeof Initialize.payloadSchema.Type>>()(
+  extends Context.Service<EnabledWhen, Predicate.Predicate<typeof Initialize.payloadSchema.Type>>()(
     "effect/unstable/ai/McpSchema/EnabledWhen"
   )
 {}