effect 4.0.0-beta.43 → 4.0.0-beta.44

package/src/unstable/cli/Flag.ts

@@ -11,7 +11,6 @@ import type * as Schema from "../../Schema.ts"
 import type * as CliError from "./CliError.ts"
 import * as Param from "./Param.ts"
 import type * as Primitive from "./Primitive.ts"
-import type * as Prompt from "./Prompt.ts"
 
 // -------------------------------------------------------------------------------------
 // models
@@ -775,7 +774,7 @@ export const withFallbackPrompt: {
    * @since 4.0.0
    * @category combinators
    */
-  <B>(prompt: Prompt.Prompt<B>): <A>(self: Flag<A>) => Flag<A | B>
+  <B>(prompt: Param.FallbackPrompt<B>): <A>(self: Flag<A>) => Flag<A | B>
   /**
    * Adds a fallback prompt that is shown when a required flag is missing.
    *
@@ -791,8 +790,8 @@ export const withFallbackPrompt: {
    * @since 4.0.0
    * @category combinators
    */
-  <A, B>(self: Flag<A>, prompt: Prompt.Prompt<B>): Flag<A | B>
-} = dual(2, <A, B>(self: Flag<A>, prompt: Prompt.Prompt<B>) => Param.withFallbackPrompt(self, prompt))
+  <A, B>(self: Flag<A>, prompt: Param.FallbackPrompt<B>): Flag<A | B>
+} = dual(2, <A, B>(self: Flag<A>, prompt: Param.FallbackPrompt<B>) => Param.withFallbackPrompt(self, prompt))
 
 /**
  * Transforms the parsed value of a flag using a mapping function.

package/src/unstable/cli/GlobalFlag.ts

@@ -3,10 +3,10 @@
  */
 
 import * as Console from "../../Console.ts"
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import type { LogLevel as LogLevelType } from "../../LogLevel.ts"
 import * as Option from "../../Option.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as CliOutput from "./CliOutput.ts"
 import type * as Command from "./Command.ts"
 import * as Completions_ from "./Completions.ts"
@@ -51,7 +51,7 @@ export interface Action<A> {
  * @since 4.0.0
  * @category models
  */
-export interface Setting<Id extends string, A> extends ServiceMap.Service<Setting.Identifier<Id>, A> {
+export interface Setting<Id extends string, A> extends Context.Service<Setting.Identifier<Id>, A> {
   readonly _tag: "Setting"
   readonly id: Id
   readonly flag: Flag.Flag<A>
@@ -111,7 +111,7 @@ export const setting = <const Id extends string>(
   readonly flag: Flag.Flag<A>
 }): Setting<Id, A> => {
   settingIdCounter += 1
-  const ref = ServiceMap.Service<Setting.Identifier<Id>, A>(
+  const ref = Context.Service<Setting.Identifier<Id>, A>(
     `effect/unstable/cli/GlobalFlag/${id}/${settingIdCounter}`
   )
   return Object.assign(ref, {

package/src/unstable/cli/HelpDoc.ts

@@ -3,8 +3,8 @@
  */
 
 import type { NonEmptyReadonlyArray } from "../../Array.ts"
+import type * as Context from "../../Context.ts"
 import type * as Option from "../../Option.ts"
-import type * as ServiceMap from "../../ServiceMap.ts"
 
 /**
  * Structured representation of help documentation for a command.
@@ -13,13 +13,13 @@ import type * as ServiceMap from "../../ServiceMap.ts"
  *
  * @example
  * ```ts
- * import { Option as O, ServiceMap } from "effect"
+ * import { Option as O, Context } from "effect"
  * import type * as HelpDoc from "effect/unstable/cli/HelpDoc"
  *
  * const deployCommandHelp: HelpDoc.HelpDoc = {
  *   description: "Deploy your application to the cloud",
  *   usage: "myapp deploy [options] <target>",
- *   annotations: ServiceMap.empty(),
+ *   annotations: Context.empty(),
  *   flags: [
  *     {
  *       name: "verbose",
@@ -76,7 +76,7 @@ export interface HelpDoc {
   /**
    * Custom command annotations.
    */
-  readonly annotations: ServiceMap.ServiceMap<never>
+  readonly annotations: Context.Context<never>
 
   /**
    * List of positional arguments for this command
@@ -172,7 +172,7 @@ export interface FlagDoc {
  *
  * @example
  * ```ts
- * import { Option as O, ServiceMap } from "effect"
+ * import { Option as O, Context } from "effect"
  * import type { HelpDoc } from "effect/unstable/cli"
  *
  * const deploySubcommand: HelpDoc.SubcommandDoc = {
@@ -193,7 +193,7 @@ export interface FlagDoc {
  * const mainCommandHelp: HelpDoc.HelpDoc = {
  *   description: "Cloud deployment tool",
  *   usage: "myapp <command> [options]",
- *   annotations: ServiceMap.empty(),
+ *   annotations: Context.empty(),
  *   flags: [],
  *   subcommands: [{
  *     group: undefined,
@@ -251,7 +251,7 @@ export interface SubcommandGroupDoc {
  *
  * @example
  * ```ts
- * import { Option as O, ServiceMap } from "effect"
+ * import { Option as O, Context } from "effect"
  * import type { HelpDoc } from "effect/unstable/cli"
  *
  * const sourceArg: HelpDoc.ArgDoc = {
@@ -274,7 +274,7 @@ export interface SubcommandGroupDoc {
  * const copyCommandHelp: HelpDoc.HelpDoc = {
  *   description: "Copy files from source to destination",
  *   usage: "copy <source> [files...]",
- *   annotations: ServiceMap.empty(),
+ *   annotations: Context.empty(),
  *   flags: [],
  *   args: [sourceArg, filesArg]
  * }

package/src/unstable/cli/Param.ts

@@ -139,6 +139,17 @@ export interface ParsedArgs {
   readonly arguments: ReadonlyArray<string>
 }
 
+/**
+ * Represents a fallback prompt that can either be provided directly or
+ * computed effectfully when the parameter is missing.
+ *
+ * @since 4.0.0
+ * @category models
+ */
+export type FallbackPrompt<A> =
+  | Prompt.Prompt<A>
+  | Effect.Effect<Prompt.Prompt<A>, CliError.CliError, Environment>
+
 /**
  * @since 4.0.0
  * @category models
@@ -851,7 +862,7 @@ const FLAG_DASH_REGEXP = /^-+/
  *
  * const force = Param.boolean(Param.flagKind, "force").pipe(
  *   Param.withAlias("-f"),
- *   Param.withAlias("--no-prompt")
+ *   Param.withAlias("-F")
  * )
  *
  * // Also works on composed params:
@@ -882,7 +893,7 @@ export const withAlias: {
    *
    * const force = Param.boolean(Param.flagKind, "force").pipe(
    *   Param.withAlias("-f"),
-   *   Param.withAlias("--no-prompt")
+   *   Param.withAlias("-F")
    * )
    *
    * // Also works on composed params:
@@ -913,7 +924,7 @@ export const withAlias: {
    *
    * const force = Param.boolean(Param.flagKind, "force").pipe(
    *   Param.withAlias("-f"),
-   *   Param.withAlias("--no-prompt")
+   *   Param.withAlias("-F")
    * )
    *
    * // Also works on composed params:
@@ -1307,8 +1318,6 @@ export const mapTryCatch: {
  * ```ts
  * import * as Param from "effect/unstable/cli/Param"
  *
- * // @internal - this module is not exported publicly
- *
  * // Create an optional port option
  * // - When not provided: returns Option.none()
  * // - When provided: returns Option.some(parsedValue)
@@ -1321,15 +1330,29 @@ export const mapTryCatch: {
 export const optional = <Kind extends ParamKind, A>(
   param: Param<Kind, A>
 ): Param<Kind, Option.Option<A>> => {
-  const parse: Parse<Option.Option<A>> = (args) =>
-    param.parse(args).pipe(
-      Effect.map(
-        ([leftover, value]) => [leftover, Option.some(value)] as const
-      ),
+  const parse: Parse<Option.Option<A>> = Effect.fnUntraced(function*(args) {
+    const single = getUnderlyingSingleOrThrow(param)
+
+    // Handle boolean params that are explicitly marked as optional (i.e. the
+    // end user wants to return `Option.none()` instead of `false` when the
+    // flag (or its negated variant) are not present on the command line
+    if (
+      isFlagParam(single) &&
+      Primitive.isBoolean(single.primitiveType) &&
+      ![single.name, ...single.aliases].some((name) => (args.flags[name] ?? []).length > 0)
+    ) {
+      return [args.arguments, Option.none()] as const
+    }
+
+    return yield* param.parse(args).pipe(
+      Effect.map(([leftover, value]) => [leftover, Option.some(value)] as const),
       // Catch both MissingOption (for flags) and MissingArgument (for positional arguments)
-      Effect.catchTag("MissingOption", () => Effect.succeed([args.arguments, Option.none()] as const)),
-      Effect.catchTag("MissingArgument", () => Effect.succeed([args.arguments, Option.none()] as const))
+      Effect.catchTags({
+        MissingOption: () => Effect.succeed([args.arguments, Option.none()] as const),
+        MissingArgument: () => Effect.succeed([args.arguments, Option.none()] as const)
+      })
     )
+  })
   return Object.assign(Object.create(Proto), {
     _tag: "Optional",
     kind: param.kind,
@@ -1512,20 +1535,20 @@ export const withFallbackPrompt: {
    * @since 4.0.0
    * @category combinators
    */
-  <B>(prompt: Prompt.Prompt<B>): <Kind extends ParamKind, A>(self: Param<Kind, A>) => Param<Kind, A | B>
+  <B>(prompt: FallbackPrompt<B>): <Kind extends ParamKind, A>(self: Param<Kind, A>) => Param<Kind, A | B>
   /**
    * Adds a fallback prompt that is shown when a required parameter is missing.
    *
    * @since 4.0.0
    * @category combinators
    */
-  <Kind extends ParamKind, A, B>(self: Param<Kind, A>, prompt: Prompt.Prompt<B>): Param<Kind, A | B>
+  <Kind extends ParamKind, A, B>(self: Param<Kind, A>, prompt: FallbackPrompt<B>): Param<Kind, A | B>
 } = dual(2, <Kind extends ParamKind, A, B>(
   self: Param<Kind, A>,
-  prompt: Prompt.Prompt<B>
+  prompt: FallbackPrompt<B>
 ): Param<Kind, A | B> => {
   const runPrompt = (error: CliError.MissingOption | CliError.MissingArgument, args: ParsedArgs) =>
-    Prompt.run(prompt).pipe(
+    Effect.flatMap(Prompt.isPrompt(prompt) ? Effect.succeed(prompt) : prompt, Prompt.run).pipe(
       Effect.map((value) => [args.arguments, value as A | B] as const),
       Effect.catchTag("QuitError", () => Effect.fail(error))
     )

package/src/unstable/cli/Prompt.ts

@@ -2309,6 +2309,17 @@ const renderChoiceDescription = <A>(
 
 const metaOptionsCount = 2
 
+const renderMultiSelectTitle = (
+  title: string,
+  isHighlighted: boolean,
+  renderOptions?: RenderOptions | undefined
+) => {
+  if (renderOptions?.plain === true || !isHighlighted) {
+    return title
+  }
+  return Ansi.annotate(title, Ansi.combine(Ansi.underlined, Ansi.cyanBright))
+}
+
 const renderMultiSelectChoices = <A>(
   state: MultiSelectState,
   options: SelectOptionsReq<A> & MultiSelectOptionsReq,
@@ -2344,9 +2355,7 @@ const renderMultiSelectChoices = <A>(
     }
     if (index < metaOptions.length) {
       // Meta options
-      const title = isHighlighted && renderOptions?.plain !== true
-        ? Ansi.annotate(choice.title, Ansi.cyanBright)
-        : choice.title
+      const title = renderMultiSelectTitle(choice.title, isHighlighted, renderOptions)
       documents.push(prefix + " " + title)
     } else {
       // Regular choices
@@ -2356,9 +2365,7 @@ const renderMultiSelectChoices = <A>(
       const annotatedCheckbox = isHighlighted && renderOptions?.plain !== true
         ? Ansi.annotate(checkbox, Ansi.cyanBright)
         : checkbox
-      const title = isHighlighted && renderOptions?.plain !== true
-        ? Ansi.annotate(choice.title, Ansi.cyanBright)
-        : choice.title
+      const title = renderMultiSelectTitle(choice.title, isHighlighted, renderOptions)
       const description = renderChoiceDescription(choice as SelectChoice<A>, isHighlighted, renderOptions)
       documents.push(prefix + " " + annotatedCheckbox + " " + title + " " + description)
     }

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

@@ -6,12 +6,12 @@
  * Public API is in ../Command.ts
  */
 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 Option from "../../../Option.ts"
 import { pipeArguments } from "../../../Pipeable.ts"
 import * as Predicate from "../../../Predicate.ts"
-import * as ServiceMap from "../../../ServiceMap.ts"
 import * as CliError from "../CliError.ts"
 import type * as GlobalFlag from "../GlobalFlag.ts"
 import type { ArgDoc, ExampleDoc, FlagDoc, HelpDoc, SubcommandGroupDoc } from "../HelpDoc.ts"
@@ -39,8 +39,8 @@ export interface CommandInternal<Name extends string, Input, E, R, ContextInput>
 {
   readonly config: ConfigInternal
   readonly contextConfig: ConfigInternal
-  readonly service: ServiceMap.Key<CommandContext<Name>, ContextInput>
-  readonly annotations: ServiceMap.ServiceMap<never>
+  readonly service: Context.Key<CommandContext<Name>, ContextInput>
+  readonly annotations: Context.Context<never>
   readonly globalFlags: ReadonlyArray<GlobalFlag.GlobalFlag<any>>
   readonly parse: (input: ParsedTokens) => Effect.Effect<Input, CliError.CliError, Environment>
   readonly parseContext: (input: ParsedTokens) => Effect.Effect<ContextInput, CliError.CliError, Environment>
@@ -94,8 +94,8 @@ export const makeCommand = <const Name extends string, Input, E, R, ContextInput
   readonly name: Name
   readonly config: ConfigInternal
   readonly contextConfig?: ConfigInternal | undefined
-  readonly service?: ServiceMap.Key<CommandContext<Name>, ContextInput> | undefined
-  readonly annotations?: ServiceMap.ServiceMap<never> | undefined
+  readonly service?: Context.Key<CommandContext<Name>, ContextInput> | undefined
+  readonly annotations?: Context.Context<never> | undefined
   readonly globalFlags?: ReadonlyArray<GlobalFlag.GlobalFlag<any>> | undefined
   readonly description?: string | undefined
   readonly shortDescription?: string | undefined
@@ -112,8 +112,8 @@ export const makeCommand = <const Name extends string, Input, E, R, ContextInput
 }): Command<Name, Input, ContextInput, E, R> => {
   const config = options.config
   const contextConfig = options.contextConfig ?? emptyConfig
-  const service = options.service ?? ServiceMap.Service<CommandContext<Name>, ContextInput>(`${TypeId}/${options.name}`)
-  const annotations = options.annotations ?? ServiceMap.empty()
+  const service = options.service ?? Context.Service<CommandContext<Name>, ContextInput>(`${TypeId}/${options.name}`)
+  const annotations = options.annotations ?? Context.empty()
   const globalFlags = options.globalFlags ?? []
   const subcommands = options.subcommands ?? []
 

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 }