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

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

@@ -50,7 +50,7 @@ export const parseArgs = (
   lexResult: LexResult,
   command: Command.Any,
   commandPath: ReadonlyArray<string> = []
-): Effect.Effect<ParsedTokens, CliError.CliError, Param.Environment> =>
+): Effect.Effect<ParsedTokens, never, Param.Environment> =>
   Effect.gen(function*() {
     const { tokens, trailingOperands: afterEndOfOptions } = lexResult
     const newCommandPath = [...commandPath, command.name]
@@ -161,7 +161,7 @@ type ParseMode =
 type ParseState = {
   readonly flags: FlagAccumulator
   readonly arguments: Array<string>
-  readonly errors: Array<CliError.CliError>
+  readonly errors: Array<CliError.NonShowHelpErrors>
   mode: ParseMode
 }
 
@@ -179,7 +179,7 @@ type LeafResult = {
   readonly _tag: "Leaf"
   readonly flags: Readonly<FlagMap>
   readonly arguments: ReadonlyArray<string>
-  readonly errors: ReadonlyArray<CliError.CliError>
+  readonly errors: ReadonlyArray<CliError.NonShowHelpErrors>
 }
 
 /**
@@ -190,7 +190,7 @@ type SubcommandResult = {
   readonly flags: Readonly<FlagMap>
   readonly sub: Command<string, unknown, unknown, unknown, unknown>
   readonly childTokens: ReadonlyArray<Token>
-  readonly errors: ReadonlyArray<CliError.CliError>
+  readonly errors: ReadonlyArray<CliError.NonShowHelpErrors>
 }
 
 type LevelResult = LeafResult | SubcommandResult
@@ -317,11 +317,70 @@ const createFlagAccumulator = (params: ReadonlyArray<FlagParam>): FlagAccumulato
 /* ========================================================================== */
 
 type FlagToken = Extract<Token, { _tag: "LongOption" | "ShortOption" }>
+type ResolvedFlag = {
+  readonly param: FlagParam
+  readonly negated: boolean
+}
+type ConsumedFlagValue =
+  | {
+    readonly _tag: "Value"
+    readonly value: string | undefined
+  }
+  | {
+    readonly _tag: "Error"
+    readonly error: CliError.InvalidValue
+  }
 
 const isFlagToken = (t: Token): t is FlagToken => t._tag === "LongOption" || t._tag === "ShortOption"
 
 const getFlagName = (t: FlagToken): string => t._tag === "LongOption" ? t.name : t.flag
 
+const resolveFlag = (
+  token: FlagToken,
+  registry: FlagRegistry
+): ResolvedFlag | undefined => {
+  const tokenName = getFlagName(token)
+  const direct = registry.index.get(tokenName)
+  if (direct && direct.name === tokenName) {
+    return {
+      param: direct,
+      negated: false
+    }
+  }
+
+  if (token._tag === "LongOption" && token.name.startsWith("no-")) {
+    const canonicalName = token.name.slice(3)
+    const param = registry.index.get(canonicalName)
+    if (param && param.name === canonicalName && Primitive.isBoolean(param.primitiveType)) {
+      return {
+        param,
+        negated: true
+      }
+    }
+  }
+
+  if (direct) {
+    return {
+      param: direct,
+      negated: false
+    }
+  }
+
+  return undefined
+}
+
+const invalidNegatedFlagValue = (
+  token: FlagToken,
+  spec: FlagParam,
+  value: string
+): CliError.InvalidValue =>
+  new CliError.InvalidValue({
+    option: spec.name,
+    value,
+    expected: `omit the value and use ${token.raw} by itself to set --${spec.name} to false`,
+    kind: "flag"
+  })
+
 /**
  * Checks if a token is a boolean literal value.
  * Recognizes: true/false, yes/no, on/off, 1/0
@@ -346,28 +405,64 @@ const asBooleanLiteral = (token: Token | undefined): string | undefined =>
 const consumeFlagValue = (
   cursor: TokenCursor,
   token: FlagToken,
-  spec: FlagParam
-): string | undefined => {
+  spec: FlagParam,
+  negated = false
+): ConsumedFlagValue => {
   // Inline value has highest priority
+  if (negated) {
+    if (token.value !== undefined) {
+      return {
+        _tag: "Error",
+        error: invalidNegatedFlagValue(token, spec, token.value)
+      }
+    }
+
+    const literal = asBooleanLiteral(cursor.peek())
+    if (literal !== undefined) {
+      cursor.take()
+      return {
+        _tag: "Error",
+        error: invalidNegatedFlagValue(token, spec, literal)
+      }
+    }
+
+    return {
+      _tag: "Value",
+      value: "false"
+    }
+  }
+
   if (token.value !== undefined) {
-    return token.value
+    return {
+      _tag: "Value",
+      value: token.value
+    }
   }
 
   // Boolean flags: check for explicit literal or default to "true"
   if (Primitive.isBoolean(spec.primitiveType)) {
     const literal = asBooleanLiteral(cursor.peek())
     if (literal !== undefined) cursor.take()
-    return literal ?? "true"
+    return {
+      _tag: "Value",
+      value: literal ?? "true"
+    }
   }
 
   // Non-boolean: try to consume next Value token
   const next = cursor.peek()
   if (next?._tag === "Value") {
     cursor.take()
-    return next.value
+    return {
+      _tag: "Value",
+      value: next.value
+    }
   }
 
-  return undefined
+  return {
+    _tag: "Value",
+    value: undefined
+  }
 }
 
 /**
@@ -379,9 +474,10 @@ const consumeFlagValue = (
 export const consumeKnownFlags = (
   tokens: ReadonlyArray<Token>,
   registry: FlagRegistry
-): { flagMap: FlagMap; remainder: ReadonlyArray<Token> } => {
+): { flagMap: FlagMap; remainder: ReadonlyArray<Token>; errors: ReadonlyArray<CliError.InvalidValue> } => {
   const flagMap = createEmptyFlagMap(registry.params)
   const remainder: Array<Token> = []
+  const errors: Array<CliError.InvalidValue> = []
   const cursor = makeCursor(tokens)
 
   for (let t = cursor.take(); t; t = cursor.take()) {
@@ -390,19 +486,23 @@ export const consumeKnownFlags = (
       continue
     }
 
-    const param = registry.index.get(getFlagName(t))
-    if (!param) {
+    const resolved = resolveFlag(t, registry)
+    if (!resolved) {
       remainder.push(t)
       continue
     }
 
-    const value = consumeFlagValue(cursor, t, param)
-    if (value !== undefined) {
-      flagMap[param.name].push(value)
+    const consumed = consumeFlagValue(cursor, t, resolved.param, resolved.negated)
+    if (consumed._tag === "Error") {
+      errors.push(consumed.error)
+      continue
+    }
+    if (consumed.value !== undefined) {
+      flagMap[resolved.param.name].push(consumed.value)
     }
   }
 
-  return { flagMap, remainder }
+  return { flagMap, remainder, errors }
 }
 
 /* ========================================================================== */
@@ -419,6 +519,9 @@ const createUnrecognizedFlagError = (
 
   for (const p of params) {
     validNames.push(p.name)
+    if (Primitive.isBoolean(p.primitiveType)) {
+      validNames.push(`no-${p.name}`)
+    }
     for (const alias of p.aliases) {
       validNames.push(alias)
     }
@@ -498,6 +601,7 @@ const resolveFirstValue = (
     // npm-style: inherited parent flags can appear after subcommand name
     const tail = consumeKnownFlags(cursor.rest(), inheritedFlagRegistry)
     state.flags.merge(tail.flagMap)
+    state.errors.push(...tail.errors)
 
     return {
       _tag: "Subcommand",
@@ -542,15 +646,20 @@ const processFlag = (
   state: ParseState
 ): void => {
   const { commandPath, flagRegistry } = context
-  const name = getFlagName(token)
-  const spec = flagRegistry.index.get(name)
+  const resolved = resolveFlag(token, flagRegistry)
 
-  if (!spec) {
+  if (!resolved) {
     state.errors.push(createUnrecognizedFlagError(token, flagRegistry.params, commandPath))
     return
   }
 
-  state.flags.add(spec.name, consumeFlagValue(cursor, token, spec))
+  const consumed = consumeFlagValue(cursor, token, resolved.param, resolved.negated)
+  if (consumed._tag === "Error") {
+    state.errors.push(consumed.error)
+    return
+  }
+
+  state.flags.add(resolved.param.name, consumed.value)
 }
 
 /**

package/src/unstable/cluster/ClusterSchema.ts

@@ -1,8 +1,8 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import { constFalse, constTrue, identity } from "../../Function.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type * as Rpc from "../rpc/Rpc.ts"
 import type { EntityId } from "./EntityId.ts"
 import type { Request } from "./Envelope.ts"
@@ -11,7 +11,7 @@ import type { Request } from "./Envelope.ts"
  * @since 4.0.0
  * @category Annotations
  */
-export const Persisted = ServiceMap.Reference<boolean>("effect/cluster/ClusterSchema/Persisted", {
+export const Persisted = Context.Reference<boolean>("effect/cluster/ClusterSchema/Persisted", {
   defaultValue: constFalse
 })
 
@@ -22,7 +22,7 @@ export const Persisted = ServiceMap.Reference<boolean>("effect/cluster/ClusterSc
  * @since 4.0.0
  * @category Annotations
  */
-export const WithTransaction = ServiceMap.Reference<boolean>(
+export const WithTransaction = Context.Reference<boolean>(
   "effect/cluster/ClusterSchema/WithTransaction",
   { defaultValue: constFalse }
 )
@@ -31,7 +31,7 @@ export const WithTransaction = ServiceMap.Reference<boolean>(
  * @since 4.0.0
  * @category Annotations
  */
-export const Uninterruptible = ServiceMap.Reference<boolean | "client" | "server">(
+export const Uninterruptible = Context.Reference<boolean | "client" | "server">(
   "effect/cluster/ClusterSchema/Uninterruptible",
   { defaultValue: constFalse }
 )
@@ -40,8 +40,8 @@ export const Uninterruptible = ServiceMap.Reference<boolean | "client" | "server
  * @since 4.0.0
  * @category Annotations
  */
-export const isUninterruptibleForServer = (context: ServiceMap.ServiceMap<never>): boolean => {
-  const value = ServiceMap.get(context, Uninterruptible)
+export const isUninterruptibleForServer = (context: Context.Context<never>): boolean => {
+  const value = Context.get(context, Uninterruptible)
   return value === true || value === "server"
 }
 
@@ -49,8 +49,8 @@ export const isUninterruptibleForServer = (context: ServiceMap.ServiceMap<never>
  * @since 4.0.0
  * @category Annotations
  */
-export const isUninterruptibleForClient = (context: ServiceMap.ServiceMap<never>): boolean => {
-  const value = ServiceMap.get(context, Uninterruptible)
+export const isUninterruptibleForClient = (context: Context.Context<never>): boolean => {
+  const value = Context.get(context, Uninterruptible)
   return value === true || value === "client"
 }
 
@@ -58,7 +58,7 @@ export const isUninterruptibleForClient = (context: ServiceMap.ServiceMap<never>
  * @since 4.0.0
  * @category Annotations
  */
-export const ShardGroup = ServiceMap.Reference<(entityId: EntityId) => string>(
+export const ShardGroup = Context.Reference<(entityId: EntityId) => string>(
   "effect/cluster/ClusterSchema/ShardGroup",
   { defaultValue: () => (_) => "default" }
 )
@@ -67,7 +67,7 @@ export const ShardGroup = ServiceMap.Reference<(entityId: EntityId) => string>(
  * @since 4.0.0
  * @category Annotations
  */
-export const ClientTracingEnabled = ServiceMap.Reference<boolean>("effect/cluster/ClusterSchema/ClientTracingEnabled", {
+export const ClientTracingEnabled = Context.Reference<boolean>("effect/cluster/ClusterSchema/ClientTracingEnabled", {
   defaultValue: constTrue
 })
 
@@ -78,8 +78,8 @@ export const ClientTracingEnabled = ServiceMap.Reference<boolean>("effect/cluste
  * @since 4.0.0
  * @category Annotations
  */
-export const Dynamic = ServiceMap.Reference<
-  (annotations: ServiceMap.ServiceMap<never>, request: Request<Rpc.AnyWithProps>) => ServiceMap.ServiceMap<never>
+export const Dynamic = Context.Reference<
+  (annotations: Context.Context<never>, request: Request<Rpc.AnyWithProps>) => Context.Context<never>
 >(
   "effect/cluster/ClusterSchema/Dynamic",
   { defaultValue: () => identity }

package/src/unstable/cluster/ClusterWorkflowEngine.ts

@@ -1,12 +1,12 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import * as DateTime from "../../DateTime.ts"
 import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
 import * as Fiber from "../../Fiber.ts"
-import { constFalse } from "../../Function.ts"
 import * as Latch from "../../Latch.ts"
 import * as Layer from "../../Layer.ts"
 import * as Option from "../../Option.ts"
@@ -16,7 +16,6 @@ import type * as Record from "../../Record.ts"
 import * as Schedule from "../../Schedule.ts"
 import * as Schema from "../../Schema.ts"
 import type * as Scope from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Rpc from "../rpc/Rpc.ts"
 import { ClientAbort } from "../rpc/RpcSchema.ts"
 import * as Activity from "../workflow/Activity.ts"
@@ -110,7 +109,7 @@ export const make = Effect.gen(function*() {
 
   const activities = new Map<string, {
     readonly activity: Activity.Any
-    readonly services: ServiceMap.ServiceMap<any>
+    readonly context: Context.Context<any>
   }>()
   const interruptedActivities = new Set<string>()
   const activityLatches = new Map<string, Latch.Latch>()
@@ -138,7 +137,7 @@ export const make = Effect.gen(function*() {
     readonly entityType: string
     readonly executionId: string
   }) => {
-    const shardGroup = ServiceMap.get(options.workflow.annotations, ClusterSchema.ShardGroup)(
+    const shardGroup = Context.get(options.workflow.annotations, ClusterSchema.ShardGroup)(
       options.executionId as EntityId.EntityId
     )
     const entityId = EntityId.make(options.executionId)
@@ -211,7 +210,7 @@ export const make = Effect.gen(function*() {
     readonly workflow: Workflow.Any
     readonly executionId: string
   }) {
-    const shardGroup = ServiceMap.get(options.workflow.annotations, ClusterSchema.ShardGroup)(
+    const shardGroup = Context.get(options.workflow.annotations, ClusterSchema.ShardGroup)(
       options.executionId as EntityId.EntityId
     )
     const entityId = EntityId.make(options.executionId)
@@ -319,9 +318,9 @@ export const make = Effect.gen(function*() {
                 if (payload[payloadParentKey]) {
                   parent = payload[payloadParentKey]
                 }
-                return execute(workflow.payloadSchema.makeUnsafe(payload) as object, executionId).pipe(
+                return execute(workflow.payloadSchema.make(payload) as object, executionId).pipe(
                   Effect.onExit((exit) => {
-                    const suspendOnFailure = ServiceMap.get(workflow.annotations, Workflow.SuspendOnFailure)
+                    const suspendOnFailure = Context.get(workflow.annotations, Workflow.SuspendOnFailure)
                     if (!instance.suspended && !(suspendOnFailure && exit._tag === "Failure")) {
                       return parent ? ensureSuccess(sendResumeParent(parent)) : Effect.void
                     }
@@ -358,11 +357,11 @@ export const make = Effect.gen(function*() {
                     yield* latch.await
                     entry = activities.get(activityId)
                   }
-                  const contextMap = new Map(entry.services.mapUnsafe)
+                  const contextMap = new Map(entry.context.mapUnsafe)
                   contextMap.set(Activity.CurrentAttempt.key, payload.attempt)
                   contextMap.set(WorkflowEngine.WorkflowInstance.key, instance)
                   return yield* entry.activity.executeEncoded.pipe(
-                    Effect.provideServices(ServiceMap.makeUnsafe(contextMap))
+                    Effect.provideContext(Context.makeUnsafe(contextMap))
                   )
                 }).pipe(
                   Workflow.intoResult,
@@ -463,14 +462,14 @@ export const make = Effect.gen(function*() {
 
     activityExecute: Effect.fnUntraced(
       function*(activity, attempt) {
-        const services = yield* Effect.services<WorkflowEngine.WorkflowInstance>()
-        const instance = ServiceMap.get(services, WorkflowEngine.WorkflowInstance)
+        const services = yield* Effect.context<WorkflowEngine.WorkflowInstance>()
+        const instance = Context.get(services, WorkflowEngine.WorkflowInstance)
         yield* Effect.annotateCurrentSpan("executionId", instance.executionId)
         const activityId = `${instance.executionId}/${activity.name}`
         const client = (yield* RcMap.get(clientsPartial, instance.workflow.name))(instance.executionId)
         while (true) {
           if (!activities.has(activityId)) {
-            activities.set(activityId, { activity, services })
+            activities.set(activityId, { activity, context: services })
             const latch = activityLatches.get(activityId)
             if (latch) {
               yield* latch.release
@@ -481,7 +480,7 @@ export const make = Effect.gen(function*() {
             client.activity({
               name: activity.name,
               attempt,
-              withTransaction: ServiceMap.get(activity.annotations, ClusterSchema.WithTransaction)
+              withTransaction: Context.get(activity.annotations, ClusterSchema.WithTransaction)
             })
           )
           // If the activity has suspended and did not execute, we need to resume
@@ -582,7 +581,7 @@ const ActivityRpc = Rpc.make("activity", {
     name: Schema.String,
     attempt: Schema.Number,
     withTransaction: Schema.Boolean.pipe(
-      Schema.withDecodingDefault(constFalse)
+      Schema.withDecodingDefault(Effect.succeed(false))
     )
   },
   primaryKey: ({ attempt, name }) => activityPrimaryKey(name, attempt),
@@ -596,7 +595,7 @@ const ActivityRpc = Rpc.make("activity", {
     ClusterSchema.Dynamic,
     (annotations, request) =>
       (request.payload as any).withTransaction
-        ? ServiceMap.add(annotations, ClusterSchema.WithTransaction, true)
+        ? Context.add(annotations, ClusterSchema.WithTransaction, true)
         : annotations
   )
 

package/src/unstable/cluster/Entity.ts

@@ -3,6 +3,7 @@
  */
 import * as Arr from "../../Array.ts"
 import type * as Cause from "../../Cause.ts"
+import * as Context from "../../Context.ts"
 import * as Data from "../../Data.ts"
 import type * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
@@ -17,7 +18,6 @@ import * as Predicate from "../../Predicate.ts"
 import * as Queue from "../../Queue.ts"
 import type * as Schedule from "../../Schedule.ts"
 import { Scope } from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
 import * as Headers from "../http/Headers.ts"
 import * as Rpc from "../rpc/Rpc.ts"
@@ -76,22 +76,22 @@ export interface Entity<
   /**
    * Annotate the entity with a value.
    */
-  annotate<I, S>(key: ServiceMap.Key<I, S>, value: S): Entity<Type, Rpcs>
+  annotate<I, S>(key: Context.Key<I, S>, value: S): Entity<Type, Rpcs>
 
   /**
    * Annotate the Rpc's above this point with a value.
    */
-  annotateRpcs<I, S>(key: ServiceMap.Key<I, S>, value: S): Entity<Type, Rpcs>
+  annotateRpcs<I, S>(key: Context.Key<I, S>, value: S): Entity<Type, Rpcs>
 
   /**
    * Annotate the entity with the given annotations.
    */
-  annotateMerge<S>(annotation: ServiceMap.ServiceMap<S>): Entity<Type, Rpcs>
+  annotateMerge<S>(annotation: Context.Context<S>): Entity<Type, Rpcs>
 
   /**
    * Annotate the Rpc's above this point with a context object.
    */
-  annotateRpcsMerge<S>(context: ServiceMap.ServiceMap<S>): Entity<Type, Rpcs>
+  annotateRpcsMerge<S>(context: Context.Context<S>): Entity<Type, Rpcs>
 
   /**
    * Create a client for this entity.
@@ -208,16 +208,16 @@ const Proto = {
   [Equal.symbol](this: Entity<string, any>, that: Equal.Equal): boolean {
     return isEntity(that) && this.type === that.type
   },
-  annotate<I, S>(this: Entity<string, any>, key: ServiceMap.Key<I, S>, value: S) {
+  annotate<I, S>(this: Entity<string, any>, key: Context.Key<I, S>, value: S) {
     return fromRpcGroup(this.type, this.protocol.annotate(key, value))
   },
-  annotateRpcs<I, S>(this: Entity<string, any>, key: ServiceMap.Key<I, S>, value: S) {
+  annotateRpcs<I, S>(this: Entity<string, any>, key: Context.Key<I, S>, value: S) {
     return fromRpcGroup(this.type, this.protocol.annotateRpcs(key, value))
   },
-  annotateMerge<S>(this: Entity<string, any>, annotations: ServiceMap.ServiceMap<S>) {
+  annotateMerge<S>(this: Entity<string, any>, annotations: Context.Context<S>) {
     return fromRpcGroup(this.type, this.protocol.annotateMerge(annotations))
   },
-  annotateRpcsMerge<S>(this: Entity<string, any>, annotations: ServiceMap.ServiceMap<S>) {
+  annotateRpcsMerge<S>(this: Entity<string, any>, annotations: Context.Context<S>) {
     return fromRpcGroup(this.type, this.protocol.annotateRpcsMerge(annotations))
   },
   getShardId(this: Entity<string, any>, entityId: EntityId) {
@@ -377,9 +377,9 @@ export const fromRpcGroup = <const Type extends string, Rpcs extends Rpc.Any>(
   protocol: RpcGroup.RpcGroup<Rpcs>
 ): Entity<Type, Rpcs> => {
   const self = Object.create(Proto)
-  self.type = EntityType.makeUnsafe(type)
+  self.type = EntityType.make(type)
   self.protocol = protocol
-  self.getShardGroup = ServiceMap.get(protocol.annotations, ShardGroup)
+  self.getShardGroup = Context.get(protocol.annotations, ShardGroup)
   return self
 }
 
@@ -408,7 +408,7 @@ export const make = <const Type extends string, Rpcs extends ReadonlyArray<Rpc.A
  * @since 4.0.0
  * @category context
  */
-export class CurrentAddress extends ServiceMap.Service<
+export class CurrentAddress extends Context.Service<
   CurrentAddress,
   EntityAddress
 >()("effect/cluster/Entity/EntityAddress") {}
@@ -419,7 +419,7 @@ export class CurrentAddress extends ServiceMap.Service<
  * @since 4.0.0
  * @category context
  */
-export class CurrentRunnerAddress extends ServiceMap.Service<
+export class CurrentRunnerAddress extends Context.Service<
   CurrentRunnerAddress,
   RunnerAddress
 >()("effect/cluster/Entity/RunnerAddress") {}
@@ -491,7 +491,7 @@ export class Request<Rpc extends Rpc.Any> extends Data.Class<
   }
 }
 
-const shardingTag = ServiceMap.Service<Sharding, Sharding["Service"]>("effect/cluster/Sharding")
+const shardingTag = Context.Service<Sharding, Sharding["Service"]>("effect/cluster/Sharding")
 
 /**
  * @since 4.0.0
@@ -517,12 +517,12 @@ export const makeTestClient: <Type extends string, Rpcs extends Rpc.Any, LA, LE,
   const snowflakeGen = yield* Snowflake.makeGenerator
   const runnerAddress = new RunnerAddress({ host: "localhost", port: 3000 })
   const entityMap = new Map<string, {
-    readonly services: ServiceMap.ServiceMap<
+    readonly context: Context.Context<
       Rpc.ServicesClient<Rpcs> | Rpc.ServicesServer<Rpcs> | Rpc.Middleware<Rpcs> | LR
     >
     readonly concurrency: number | "unbounded"
     readonly build: Effect.Effect<
-      ServiceMap.ServiceMap<Rpc.ToHandler<Rpcs>>,
+      Context.Context<Rpc.ToHandler<Rpcs>>,
       never,
       Scope | CurrentAddress
     >
@@ -530,15 +530,15 @@ export const makeTestClient: <Type extends string, Rpcs extends Rpc.Any, LA, LE,
   const sharding = shardingTag.of({
     ...({} as Sharding["Service"]),
     registerEntity: (entity, handlers, options) =>
-      Effect.servicesWith((services) => {
+      Effect.contextWith((context) => {
         entityMap.set(entity.type, {
-          services: services as any,
+          context: context as any,
           concurrency: options?.concurrency ?? 1,
           build: entity.protocol.toHandlers(handlers as any).pipe(
-            Effect.provideServices(ServiceMap.mutate(services, (services) =>
-              services.pipe(
-                ServiceMap.add(CurrentRunnerAddress, runnerAddress),
-                ServiceMap.omit(Scope)
+            Effect.provideContext(Context.mutate(context, (context) =>
+              context.pipe(
+                Context.add(CurrentRunnerAddress, runnerAddress),
+                Context.omit(Scope)
               )))
           ) as any
         })
@@ -619,9 +619,9 @@ export const keepAlive: (
   olatch.value.closeUnsafe()
   yield* Effect.orDie(sharding.sendOutgoing(
     new Message.OutgoingRequest({
-      annotations: ServiceMap.empty(),
+      annotations: KeepAliveRpc.annotations,
       rpc: KeepAliveRpc,
-      services: ServiceMap.empty() as any,
+      context: Context.empty() as any,
       envelope: Envelope.makeRequest({
         requestId,
         address,
@@ -656,6 +656,6 @@ export const KeepAliveRpc = Rpc.make("Cluster/Entity/keepAlive")
  * @since 4.0.0
  * @category Keep alive
  */
-export class KeepAliveLatch extends ServiceMap.Service<KeepAliveLatch, Latch.Latch>()(
+export class KeepAliveLatch extends Context.Service<KeepAliveLatch, Latch.Latch>()(
   "effect/cluster/Entity/KeepAliveLatch"
 ) {}

package/src/unstable/cluster/EntityProxy.ts

@@ -60,11 +60,11 @@ export const toRpcGroup = <Type extends string, Rpcs extends Rpc.Any>(
       entityId: Schema.String,
       payload: parentRpc.payloadSchema
     })
-    const oldMake = payloadSchema.makeUnsafe
-    payloadSchema.makeUnsafe = (input: any, options?: Schema.MakeOptions) => {
+    const oldMake = payloadSchema.make
+    payloadSchema.make = (input: any, options?: Schema.MakeOptions) => {
       return oldMake({
         entityId: input.entityId,
-        payload: parentRpc.payloadSchema.makeUnsafe(input.payload, options)
+        payload: parentRpc.payloadSchema.make(input.payload, options)
       }, options)
     }
     const rpc = Rpc.make(`${entity.type}.${parentRpc._tag}`, {

package/src/unstable/cluster/EntityProxyServer.ts

@@ -1,9 +1,9 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Layer from "../../Layer.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type * as HttpApi from "../httpapi/HttpApi.ts"
 import * as HttpApiBuilder from "../httpapi/HttpApiBuilder.ts"
 import type * as HttpApiGroup from "../httpapi/HttpApiGroup.ts"
@@ -81,8 +81,8 @@ export const layerRpcHandlers = <
 >(
   entity: Entity.Entity<Type, Rpcs>
 ): Layer.Layer<RpcHandlers<Rpcs, Type>, never, Sharding | Rpc.ServicesServer<Rpcs>> =>
-  Layer.effectServices(Effect.gen(function*() {
-    const services = yield* Effect.services<never>()
+  Layer.effectContext(Effect.gen(function*() {
+    const services = yield* Effect.context<never>()
     const client = yield* entity.client
     const handlers = new Map<string, Rpc.Handler<string>>()
     for (const parentRpc_ of entity.protocol.requests.values()) {
@@ -101,7 +101,7 @@ export const layerRpcHandlers = <
           (client(entityId) as any)[parentRpc._tag](payload, { discard: true }) as any
       } as any)
     }
-    return ServiceMap.makeUnsafe(handlers)
+    return Context.makeUnsafe(handlers)
   }))
 
 /**