effect 4.0.0-beta.64 → 4.0.0-beta.66

package/src/internal/option.ts

@@ -7,7 +7,8 @@ import * as Hash from "../Hash.ts"
 import { toJson } from "../Inspectable.ts"
 import type * as Option from "../Option.ts"
 import { hasProperty } from "../Predicate.ts"
-import { exitFail, exitSucceed, NoSuchElementError, PipeInspectableProto, YieldableProto } from "./core.ts"
+import { SingleShotGen } from "../Utils.ts"
+import { PipeInspectableProto } from "./core.ts"
 
 const TypeId = "~effect/data/Option"
 
@@ -16,7 +17,9 @@ const CommonProto = {
     _A: (_: never) => _
   },
   ...PipeInspectableProto,
-  ...YieldableProto
+  [Symbol.iterator]() {
+    return new SingleShotGen(this)
+  }
 }
 
 const SomeProto = Object.assign(Object.create(CommonProto), {
@@ -39,9 +42,6 @@ const SomeProto = Object.assign(Object.create(CommonProto), {
       _tag: this._tag,
       value: toJson(this.value)
     }
-  },
-  asEffect(this: Option.Some<unknown>) {
-    return exitSucceed(this.value)
   }
 })
 
@@ -70,9 +70,6 @@ const NoneProto = Object.assign(Object.create(CommonProto), {
       _id: "Option",
       _tag: this._tag
     }
-  },
-  asEffect<A>(this: Option.None<A>) {
-    return exitFail(new NoSuchElementError())
   }
 })
 

package/src/internal/result.ts

@@ -6,7 +6,8 @@ import { toJson } from "../Inspectable.ts"
 import type { Option } from "../Option.ts"
 import { hasProperty } from "../Predicate.ts"
 import type * as Result from "../Result.ts"
-import { exitFail, exitSucceed, PipeInspectableProto, YieldableProto } from "./core.ts"
+import { SingleShotGen } from "../Utils.ts"
+import { PipeInspectableProto } from "./core.ts"
 import * as option from "./option.ts"
 
 const TypeId = "~effect/data/Result"
@@ -18,7 +19,9 @@ const CommonProto = {
     _E: (_: never) => _
   },
   ...PipeInspectableProto,
-  ...YieldableProto
+  [Symbol.iterator]() {
+    return new SingleShotGen(this)
+  }
 }
 
 const SuccessProto = Object.assign(Object.create(CommonProto), {
@@ -41,9 +44,6 @@ const SuccessProto = Object.assign(Object.create(CommonProto), {
       _tag: this._tag,
       value: toJson(this.success)
     }
-  },
-  asEffect<L, R>(this: Result.Success<L, R>) {
-    return exitSucceed(this.success)
   }
 })
 
@@ -65,9 +65,6 @@ const FailureProto = Object.assign(Object.create(CommonProto), {
       _tag: this._tag,
       failure: toJson(this.failure)
     }
-  },
-  asEffect<A, E>(this: Result.Failure<A, E>) {
-    return exitFail(this.failure)
   }
 })
 

package/src/unstable/ai/LanguageModel.ts

@@ -528,8 +528,7 @@ export type ToolkitOption<
   R = any
 > = Tools extends any ? (
     | Toolkit.WithHandler<Tools>
-    | Effect.Yieldable<
-      Toolkit.Toolkit<Tools>,
+    | Effect.Effect<
       Toolkit.WithHandler<Tools>,
       E,
       R
@@ -554,20 +553,18 @@ export type ToolkitInput<
 > =
   | ToolkitOption<Tools, E, R>
   | Toolkit.WithHandler<Tools>
-  | Effect.Yieldable<
-    Toolkit.Toolkit<Tools>,
+  | Effect.Effect<
     Toolkit.WithHandler<Tools>,
     E,
     R
   >
 
 type ExtractToolsFromToolkitOption<ToolkitValue> = ToolkitValue extends Toolkit.WithHandler<infer Tools> ? Tools
-  : ToolkitValue extends Effect.Yieldable<
-    Toolkit.Toolkit<infer Tools>,
+  : ToolkitValue extends Effect.Effect<
     Toolkit.WithHandler<infer _Tools>,
     infer _E,
     infer _R
-  > ? Tools
+  > ? _Tools
   : never
 
 /**
@@ -585,20 +582,18 @@ type ExtractErrorFromToolkitOption<ToolkitValue, DisableToolCallResolution exten
   Toolkit.WithHandler<infer Tools> ?
     | AiError.AiError
     | (DisableToolCallResolution extends true ? never : Tool.HandlerError<Tools[keyof Tools]>)
-  : ToolkitValue extends Effect.Yieldable<
-    Toolkit.Toolkit<infer Tools>,
+  : ToolkitValue extends Effect.Effect<
     Toolkit.WithHandler<infer _Tools>,
     infer E,
     infer _R
-  > ? AiError.AiError | E | (DisableToolCallResolution extends true ? never : Tool.HandlerError<Tools[keyof Tools]>)
+  > ? AiError.AiError | E | (DisableToolCallResolution extends true ? never : Tool.HandlerError<_Tools[keyof _Tools]>)
   : AiError.AiError
 
 type ExtractServicesFromToolkitOption<ToolkitValue> = ToolkitValue extends Toolkit.WithHandler<infer Tools> ?
     | Tool.HandlerServices<Tools[keyof Tools]>
     | Tool.ResultDecodingServices<Tools[keyof Tools]>
-  : ToolkitValue extends Effect.Yieldable<
-    Toolkit.Toolkit<infer Tools>,
-    Toolkit.WithHandler<infer _Tools>,
+  : ToolkitValue extends Effect.Effect<
+    Toolkit.WithHandler<infer Tools>,
     infer _E,
     infer R
   > ?
@@ -607,16 +602,14 @@ type ExtractServicesFromToolkitOption<ToolkitValue> = ToolkitValue extends Toolk
       | R
   : never
 
-type ExtractToolkitResolutionError<ToolkitValue> = ToolkitValue extends Effect.Yieldable<
-  Toolkit.Toolkit<infer _Tools>,
+type ExtractToolkitResolutionError<ToolkitValue> = ToolkitValue extends Effect.Effect<
   Toolkit.WithHandler<infer _Tools>,
   infer E,
   infer _R
 > ? E
   : never
 
-type ExtractToolkitResolutionServices<ToolkitValue> = ToolkitValue extends Effect.Yieldable<
-  Toolkit.Toolkit<infer _Tools>,
+type ExtractToolkitResolutionServices<ToolkitValue> = ToolkitValue extends Effect.Effect<
   Toolkit.WithHandler<infer _Tools>,
   infer _E,
   infer R
@@ -2163,8 +2156,8 @@ const resolveToolCalls = <Tools extends Record<string, Tool.Any>>(
 const resolveToolkit = <Tools extends Record<string, Tool.Any>, E, R>(
   toolkit: ToolkitInput<Tools, E, R>
 ): Effect.Effect<Toolkit.WithHandler<Tools>, E, R> =>
-  ("asEffect" in toolkit
-    ? toolkit.asEffect()
+  (Effect.isEffect(toolkit)
+    ? toolkit
     : Effect.succeed(toolkit as unknown as Toolkit.WithHandler<Tools>)) as any
 
 /** @internal */

package/src/unstable/ai/McpServer.ts

@@ -1280,9 +1280,9 @@ const layerHandlers = (serverInfo: {
             Effect.provideService(CurrentLogLevel, currentLogLevel)
           ),
         "resources/subscribe": () =>
-          InternalError.notImplemented.asEffect(),
+          InternalError.notImplemented,
         "resources/unsubscribe": () =>
-          InternalError.notImplemented.asEffect(),
+          InternalError.notImplemented,
         "resources/templates/list": (_, { client, headers }) =>
           Effect.sync(() => {
             const initialized = getInitializedClient(options.clientSessions, client.id, headers)

package/src/unstable/ai/Model.ts

@@ -31,7 +31,7 @@
 import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import { identity } from "../../Function.ts"
-import { PipeInspectableProto, YieldableProto } from "../../internal/core.ts"
+import { PipeInspectableProto } from "../../internal/core.ts"
 import * as Layer from "../../Layer.ts"
 
 const TypeId = "~effect/ai/Model" as const
@@ -54,20 +54,23 @@ const TypeId = "~effect/ai/Model" as const
  * @category models
  */
 export interface Model<in out Provider, in out Provides, in out Requires>
-  extends
-    Layer.Layer<Provides | ProviderName | ModelName, never, Requires>,
-    Effect.Yieldable<
-      Model<Provider, Provides, Requires>,
-      Layer.Layer<Provides | ProviderName | ModelName>,
-      never,
-      Requires
-    >
+  extends Layer.Layer<Provides | ProviderName | ModelName, never, Requires>
 {
   readonly [TypeId]: typeof TypeId
+
   /**
    * The provider identifier (e.g., "openai", "anthropic", "amazon-bedrock").
    */
   readonly provider: Provider
+
+  /**
+   * Returns a `Layer` with the requirements satisfied, using the current context.
+   */
+  readonly captureRequirements: Effect.Effect<
+    Layer.Layer<Provides | ProviderName | ModelName>,
+    never,
+    Requires
+  >
 }
 
 /**
@@ -99,7 +102,6 @@ export class ModelName extends Context.Service<ModelName, string>()(
 ) {}
 
 const Proto = {
-  ...YieldableProto,
   ...PipeInspectableProto,
   [TypeId]: TypeId,
   ["~effect/Layer"]: {
@@ -107,9 +109,10 @@ const Proto = {
     _E: identity,
     _RIn: identity
   },
-  asEffect(this: Model<any, any, any>) {
+  get captureRequirements() {
+    const self = this as any as Model<any, any, any>
     return Effect.contextWith((context: Context.Context<never>) =>
-      Effect.succeed(Layer.provide(this, Layer.succeedContext(context)))
+      Effect.succeed(Layer.provide(self, Layer.succeedContext(context)))
     )
   },
   toJSON(this: Model<any, any, any>): unknown {

package/src/unstable/ai/Toolkit.ts

@@ -41,12 +41,10 @@
 import type * as Cause from "../../Cause.ts"
 import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
+import * as Effectable from "../../Effectable.ts"
 import * as Fiber from "../../Fiber.ts"
 import { identity } from "../../Function.ts"
-import type { Inspectable } from "../../Inspectable.ts"
-import { PipeInspectableProto, YieldableProto } from "../../internal/core.ts"
 import * as Layer from "../../Layer.ts"
-import type { Pipeable } from "../../Pipeable.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Queue from "../../Queue.ts"
 import * as Schema from "../../Schema.ts"
@@ -98,14 +96,11 @@ const TypeId = "~effect/ai/Toolkit" as const
  * @category models
  */
 export interface Toolkit<in out Tools extends Record<string, Tool.Any>> extends
-  Effect.Yieldable<
-    Toolkit<Tools>,
+  Effect.Effect<
     WithHandler<Tools>,
     never,
     Tool.HandlersFor<Tools>
-  >,
-  Inspectable,
-  Pipeable
+  >
 {
   new(_: never): {}
 
@@ -257,37 +252,11 @@ export interface WithHandler<in out Tools extends Record<string, Tool.Any>> {
 export type WithHandlerTools<T> = T extends WithHandler<infer Tools> ? Tools : never
 
 const Proto = {
-  ...YieldableProto,
-  ...PipeInspectableProto,
-  [TypeId]: TypeId,
-  of: identity,
-  toHandlers(
-    this: Toolkit<Record<string, Tool.Any>>,
-    build: Record<string, (params: any) => any> | Effect.Effect<Record<string, (params: any) => any>>
-  ) {
-    return Effect.gen({ self: this }, function*() {
-      const services = yield* Effect.context<never>()
-      const handlers = Effect.isEffect(build) ? yield* build : build
-      const context = new Map<string, unknown>()
-      for (const [name, handler] of Object.entries(handlers)) {
-        const tool = this.tools[name]!
-        context.set(tool.id, { name, handler, context: services })
-      }
-      return Context.makeUnsafe(context)
-    })
-  },
-  toLayer(
-    this: Toolkit<Record<string, Tool.Any>>,
-    build: Record<string, (params: any) => any> | Effect.Effect<Record<string, (params: any) => any>>
-  ) {
-    return Layer.effectContext(this.toHandlers(build))
-  },
-  asEffect(this: Toolkit<Record<string, Tool.Any>>) {
-    return Effect.gen({ self: this }, function*() {
+  ...Effectable.Prototype({
+    label: "Toolkit",
+    evaluate: Effect.fnUntraced(function*(this: Toolkit<Record<string, Tool.Any>>, parent) {
       const tools = this.tools
-
-      const services = yield* Effect.context<never>()
-
+      const services = parent.context
       const schemasCache = new WeakMap<any, {
         readonly context: Context.Context<never>
         readonly handler: Tool.Handler<any>["handler"]
@@ -441,6 +410,29 @@ const Proto = {
         handle: handle as any
       } satisfies WithHandler<Record<string, any>>
     })
+  }),
+  [TypeId]: TypeId,
+  of: identity,
+  toHandlers(
+    this: Toolkit<Record<string, Tool.Any>>,
+    build: Record<string, (params: any) => any> | Effect.Effect<Record<string, (params: any) => any>>
+  ) {
+    return Effect.gen({ self: this }, function*() {
+      const services = yield* Effect.context<never>()
+      const handlers = Effect.isEffect(build) ? yield* build : build
+      const context = new Map<string, unknown>()
+      for (const [name, handler] of Object.entries(handlers)) {
+        const tool = this.tools[name]!
+        context.set(tool.id, { name, handler, context: services })
+      }
+      return Context.makeUnsafe(context)
+    })
+  },
+  toLayer(
+    this: Toolkit<Record<string, Tool.Any>>,
+    build: Record<string, (params: any) => any> | Effect.Effect<Record<string, (params: any) => any>>
+  ) {
+    return Layer.effectContext(this.toHandlers(build))
   },
   toJSON(this: Toolkit<any>): unknown {
     return {

package/src/unstable/cli/Command.ts

@@ -10,13 +10,12 @@ import { dual } from "../../Function.ts"
 import type * as Layer from "../../Layer.ts"
 import * as Option from "../../Option.ts"
 import type * as Path from "../../Path.ts"
-import type { Pipeable } from "../../Pipeable.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as References from "../../References.ts"
 import * as Result from "../../Result.ts"
 import * as Stdio from "../../Stdio.ts"
 import * as Terminal from "../../Terminal.ts"
-import type { NoInfer, Simplify } from "../../Types.ts"
+import type { Contravariant, Covariant, NoInfer, Simplify } from "../../Types.ts"
 import type { ChildProcessSpawner } from "../process/ChildProcessSpawner.ts"
 import * as CliError from "./CliError.ts"
 import * as CliOutput from "./CliOutput.ts"
@@ -77,17 +76,15 @@ import * as Param from "./Param.ts"
  * @since 4.0.0
  * @category models
  */
-export interface Command<Name extends string, Input, ContextInput = {}, E = never, R = never>
+export interface Command<in out Name extends string, in Input, out ContextInput = {}, out E = never, out R = never>
   extends
-    Pipeable,
-    Effect.Yieldable<
-      Command<Name, Input, ContextInput, E, R>,
+    Effect.Effect<
       ContextInput,
       never,
       CommandContext<Name>
     >
 {
-  readonly [TypeId]: typeof TypeId
+  readonly [TypeId]: Command.Variance<Input, E, R>
 
   /**
    * The name of the command.
@@ -132,6 +129,16 @@ export interface Command<Name extends string, Input, ContextInput = {}, E = neve
  * @since 4.0.0
  */
 export declare namespace Command {
+  /**
+   * @since 4.0.0
+   * @category models
+   */
+  export interface Variance<in Input, out E, out R> {
+    readonly Input: Contravariant<Input>
+    readonly E: Covariant<E>
+    readonly R: Covariant<R>
+  }
+
   /**
    * Represents a concrete usage example for a command.
    *
@@ -262,7 +269,19 @@ export declare namespace Command {
    * @since 4.0.0
    * @category models
    */
-  export type Any = Command<string, unknown, unknown, unknown, unknown>
+  export interface Any extends Effect.Effect<any, never, any> {
+    readonly [TypeId]: any
+    readonly name: string
+    readonly description: string | undefined
+    readonly shortDescription: string | undefined
+    readonly alias: string | undefined
+    readonly examples: ReadonlyArray<Command.Example>
+    readonly subcommands: ReadonlyArray<{
+      readonly group: string | undefined
+      readonly commands: NonEmptyReadonlyArray<Command.Any>
+    }>
+    readonly annotations: Context.Context<never>
+  }
 
   /**
    * A grouped set of subcommands used by `Command.withSubcommands`.
@@ -719,7 +738,7 @@ export const withHandler: {
   self: Command<Name, A, ContextInput, XE, XR>,
   handler: (value: A) => Effect.Effect<void, E, R>
 ): Command<Name, A, ContextInput, E, Exclude<R, GlobalFlag.BuiltInSettingContext>> =>
-  makeCommand({ ...toImpl(self), handle: handler }))
+  makeCommand({ ...toImpl(self), handle: handler } as any))
 
 interface SubcommandGroupInternal {
   readonly group: string | undefined
@@ -931,7 +950,7 @@ export const withSubcommands: {
   checkForDuplicateFlags(self, normalized.flat)
 
   const impl = toImpl(self)
-  const byName = new Map(normalized.flat.map((s) => [s.name, toImpl(s)] as const))
+  const byName = new Map(normalized.flat.map((s) => [s.name, toImpl(s as any)] as const))
 
   type NextInput = Simplify<Input | ContextInput>
   const SubcommandStateSymbol = Symbol("effect/cli/SubcommandState")
@@ -984,7 +1003,7 @@ export const withSubcommands: {
     parse,
     parseContext: impl.parseContext,
     handle
-  })
+  }) as any
 })
 
 /**
@@ -1096,7 +1115,7 @@ export const withSharedFlags: {
       parse,
       parseContext,
       handle
-    })
+    }) as any
   }
 )
 
@@ -1151,7 +1170,7 @@ export const withGlobalFlags: {
   ): Command<Name, Input, ContextInput, E, Exclude<R, ExtractGlobalFlagContext<GlobalFlags>>> => {
     const impl = toImpl(self)
     const next = Array.from(new Set([...impl.globalFlags, ...globalFlags]))
-    return makeCommand({ ...impl, globalFlags: next })
+    return makeCommand({ ...impl, globalFlags: next }) as any
   }
 )
 

package/src/unstable/cli/GlobalFlag.ts

@@ -25,7 +25,7 @@ import * as HelpInternal from "./internal/help.ts"
  * @category models
  */
 export interface HandlerContext {
-  readonly command: Command.Command<any, unknown, any, unknown, unknown>
+  readonly command: Command.Command.Any
   readonly commandPath: ReadonlyArray<string>
   readonly version: string
 }

package/src/unstable/cli/Param.ts

@@ -1506,7 +1506,7 @@ export const withFallbackConfig: {
       kind: error._tag === "MissingOption" ? "flag" : "argument"
     })
   const runConfig = (error: CliError.MissingOption | CliError.MissingArgument, args: ParsedArgs) =>
-    Config.option(config).asEffect().pipe(
+    Config.option(config).pipe(
       Effect.mapError((configError) => toInvalidValue(error, configError)),
       Effect.flatMap(Option.match({
         onNone: () => Effect.fail(error),

package/src/unstable/cli/Prompt.ts

@@ -6,13 +6,12 @@ import type { NoSuchElementError } from "../../Cause.ts"
 import type * as Cause from "../../Cause.ts"
 import * as Data from "../../Data.ts"
 import * as Effect from "../../Effect.ts"
+import * as Effectable from "../../Effectable.ts"
 import * as FileSystem from "../../FileSystem.ts"
 import { dual, pipe } from "../../Function.ts"
-import { YieldableProto } from "../../internal/core.ts"
 import * as EffectNumber from "../../Number.ts"
 import * as Option from "../../Option.ts"
 import * as Path from "../../Path.ts"
-import * as Pipeable from "../../Pipeable.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Queue from "../../Queue.ts"
 import * as Redacted from "../../Redacted.ts"
@@ -27,9 +26,7 @@ const TypeId = "~effect/cli/Prompt"
  * @since 4.0.0
  * @category models
  */
-export interface Prompt<Output>
-  extends Pipeable.Pipeable, Effect.Yieldable<Prompt<Output>, Output, Terminal.QuitError, Environment>
-{
+export interface Prompt<Output> extends Effect.Effect<Output, Terminal.QuitError, Environment> {
   readonly [TypeId]: {
     readonly _Output: Covariant<Output>
   }
@@ -1060,15 +1057,14 @@ export const toggle = (options: ToggleOptions): Prompt<boolean> => {
 }
 
 const proto = {
-  ...YieldableProto,
+  ...Effectable.Prototype<Prompt<any>>({
+    label: "Prompt",
+    evaluate() {
+      return run(this)
+    }
+  }),
   [TypeId]: {
     _Output: (_: never) => _
-  },
-  asEffect(): Effect.Effect<unknown, Terminal.QuitError, Environment> {
-    return run(this as any)
-  },
-  pipe() {
-    return Pipeable.pipeArguments(this, arguments)
   }
 }
 
@@ -1882,7 +1878,7 @@ const resolveCurrentPath = (
   }
   if (Option.isSome(options.startingPath)) {
     const startingPath = options.startingPath.value
-    return Effect.flatMap(FileSystem.FileSystem.asEffect(), (fs) =>
+    return Effect.flatMap(FileSystem.FileSystem, (fs) =>
       // Ensure the user provided starting path exists
       Effect.orDie(fs.exists(startingPath)).pipe(
         Effect.flatMap((exists) =>

package/src/unstable/cli/internal/command.ts

@@ -8,9 +8,8 @@
 import * as Arr from "../../../Array.ts"
 import * as Context from "../../../Context.ts"
 import * as Effect from "../../../Effect.ts"
-import { YieldableProto } from "../../../internal/core.ts"
+import * as Effectable from "../../../Effectable.ts"
 import * as Option from "../../../Option.ts"
-import { pipeArguments } from "../../../Pipeable.ts"
 import * as Predicate from "../../../Predicate.ts"
 import * as CliError from "../CliError.ts"
 import type * as GlobalFlag from "../GlobalFlag.ts"
@@ -73,14 +72,13 @@ export const toImpl = <Name extends string, Input, E, R, ContextInput = {}>(
 /* Proto                                                                      */
 /* ========================================================================== */
 
-export const Proto = {
-  ...YieldableProto,
-  pipe() {
-    return pipeArguments(this, arguments)
-  },
-  asEffect(this: Command<any, any, any, any, any>) {
-    return toImpl(this).service.asEffect()
-  }
+export const Proto: Effect.Effect<any, never, any> = {
+  ...Effectable.Prototype<Command.Any>({
+    label: "Command",
+    evaluate() {
+      return toImpl(this).service
+    }
+  })
 }
 
 /* ========================================================================== */
@@ -287,9 +285,9 @@ const parseParams: (parsedArgs: Param.ParsedArgs, params: ReadonlyArray<Param.An
 /**
  * Checks for duplicate flag names between parent and child commands.
  */
-export const checkForDuplicateFlags = <Name extends string, Input, ContextInput>(
-  parent: Command<Name, Input, ContextInput, unknown, unknown>,
-  subcommands: ReadonlyArray<Command<any, unknown, any, unknown, unknown>>,
+export const checkForDuplicateFlags = <Name extends string, Input, ContextInput, E, R>(
+  parent: Command<Name, Input, ContextInput, E, R>,
+  subcommands: ReadonlyArray<Command.Any>,
   options?: {
     readonly contextConfig?: ConfigInternal | undefined
   } | undefined
@@ -309,7 +307,7 @@ export const checkForDuplicateFlags = <Name extends string, Input, ContextInput>
   extractNames((options?.contextConfig ?? parentImpl.contextConfig).flags)
 
   for (const subcommand of subcommands) {
-    const subImpl = toImpl(subcommand)
+    const subImpl = toImpl(subcommand as any)
     for (const option of subImpl.config.flags) {
       const singles = Param.extractSingleParams(option)
       for (const single of singles) {

package/src/unstable/cluster/ClusterWorkflowEngine.ts

@@ -502,7 +502,7 @@ export const make = Effect.gen(function*() {
     ),
 
     deferredResult: (deferred) =>
-      WorkflowEngine.WorkflowInstance.asEffect().pipe(
+      WorkflowEngine.WorkflowInstance.pipe(
         Effect.flatMap((instance) =>
           requestReply({
             workflow: instance.workflow,

package/src/unstable/cluster/Entity.ts

@@ -221,10 +221,10 @@ const Proto = {
     return fromRpcGroup(this.type, this.protocol.annotateRpcsMerge(annotations))
   },
   getShardId(this: Entity<string, any>, entityId: EntityId) {
-    return Effect.map(shardingTag.asEffect(), (sharding) => sharding.getShardId(entityId, this.getShardGroup(entityId)))
+    return Effect.map(shardingTag, (sharding) => sharding.getShardId(entityId, this.getShardGroup(entityId)))
   },
   get client() {
-    return shardingTag.asEffect().pipe(
+    return shardingTag.pipe(
       Effect.flatMap((sharding) => sharding.makeClient(this as any))
     )
   },
@@ -253,7 +253,7 @@ const Proto = {
     | Rpc.Middleware<Rpcs>
     | Sharding
   > {
-    return shardingTag.asEffect().pipe(
+    return shardingTag.pipe(
       Effect.flatMap((sharding) =>
         sharding.registerEntity(
           this,

package/src/unstable/cluster/MessageStorage.ts

@@ -929,7 +929,7 @@ export const layerMemory: Layer.Layer<
   MessageStorage | MemoryDriver,
   never,
   ShardingConfig
-> = Layer.effect(MessageStorage, Effect.map(MemoryDriver.asEffect(), (_) => _.storage)).pipe(
+> = Layer.effect(MessageStorage, Effect.map(MemoryDriver, (_) => _.storage)).pipe(
   Layer.provideMerge(MemoryDriver.layer)
 )
 

package/src/unstable/cluster/ShardingConfig.ts

@@ -263,7 +263,7 @@ export const config: Config.Config<ShardingConfig["Service"]> = Config.all({
  * @since 4.0.0
  * @category Config
  */
-export const configFromEnv = config.asEffect().pipe(
+export const configFromEnv = config.pipe(
   Effect.provideService(
     ConfigProvider.ConfigProvider,
     ConfigProvider.fromEnv().pipe(

package/src/unstable/eventlog/SqlEventLogServerUnencrypted.ts

@@ -192,7 +192,7 @@ export const makeStorage = (options?: {
           VALUES (1, ${created})
         `.pipe(
           Effect.catchIf(
-            (error: SqlError.SqlError) => error.reason._tag === "ConstraintError",
+            isConstraintConflict,
             () => Effect.void
           ),
           Effect.andThen(selectRemoteId),
@@ -504,3 +504,6 @@ const decodeSessionAuthBindings = (
 ): Effect.Effect<ReadonlyArray<SessionAuthBindingSql>, Schema.SchemaError> => decodeSessionAuthBindingRows(rows)
 
 const withTracerDisabled = Effect.withTracerEnabled(false)
+
+const isConstraintConflict = (error: SqlError.SqlError): boolean =>
+  error.reason._tag === "ConstraintError" || error.reason._tag === "UniqueViolation"