effect 4.0.0-beta.42 → 4.0.0-beta.44

package/src/unstable/cli/Command.ts

@@ -3,6 +3,7 @@
  */
 import type { NonEmptyArray, NonEmptyReadonlyArray } from "../../Array.ts"
 import * as Console from "../../Console.ts"
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import type * as FileSystem from "../../FileSystem.ts"
 import { dual } from "../../Function.ts"
@@ -13,7 +14,6 @@ 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 ServiceMap from "../../ServiceMap.ts"
 import * as Stdio from "../../Stdio.ts"
 import * as Terminal from "../../Terminal.ts"
 import type { NoInfer, Simplify } from "../../Types.ts"
@@ -125,7 +125,7 @@ export interface Command<Name extends string, Input, ContextInput = {}, E = neve
   /**
    * Custom annotations associated with this command.
    */
-  readonly annotations: ServiceMap.ServiceMap<never>
+  readonly annotations: Context.Context<never>
 }
 
 /**
@@ -359,7 +359,7 @@ export interface CommandContext<Name extends string> {
 export interface ParsedTokens {
   readonly flags: Record<string, ReadonlyArray<string>>
   readonly arguments: ReadonlyArray<string>
-  readonly errors?: ReadonlyArray<CliError.CliError>
+  readonly errors?: ReadonlyArray<CliError.NonShowHelpErrors>
   readonly subcommand: Option.Option<{
     readonly name: string
     readonly parsedInput: ParsedTokens
@@ -1091,7 +1091,7 @@ export const withSharedFlags: {
       annotations: impl.annotations,
       globalFlags: impl.globalFlags,
       examples: impl.examples,
-      service: impl.service as ServiceMap.Key<CommandContext<Name>, NextContextInput>,
+      service: impl.service as Context.Key<CommandContext<Name>, NextContextInput>,
       subcommands: impl.subcommands,
       parse,
       parseContext,
@@ -1339,7 +1339,7 @@ export const annotate: {
    * @since 4.0.0
    * @category combinators
    */
-  <I, S>(service: ServiceMap.Key<I, S>, value: NoInfer<S>): <Name extends string, Input, E, R, ContextInput>(
+  <I, S>(service: Context.Key<I, S>, value: NoInfer<S>): <Name extends string, Input, E, R, ContextInput>(
     self: Command<Name, Input, ContextInput, E, R>
   ) => Command<Name, Input, ContextInput, E, R>
   /**
@@ -1350,50 +1350,50 @@ export const annotate: {
    */
   <Name extends string, Input, E, R, ContextInput, I, S>(
     self: Command<Name, Input, ContextInput, E, R>,
-    service: ServiceMap.Key<I, S>,
+    service: Context.Key<I, S>,
     value: NoInfer<S>
   ): Command<Name, Input, ContextInput, E, R>
 } = dual(3, <Name extends string, Input, E, R, ContextInput, I, S>(
   self: Command<Name, Input, ContextInput, E, R>,
-  service: ServiceMap.Key<I, S>,
+  service: Context.Key<I, S>,
   value: NoInfer<S>
 ) => {
   const impl = toImpl(self)
-  return makeCommand({ ...impl, annotations: ServiceMap.add(impl.annotations, service, value) })
+  return makeCommand({ ...impl, annotations: Context.add(impl.annotations, service, value) })
 })
 
 /**
- * Merges a ServiceMap of annotations into a command.
+ * Merges a Context of annotations into a command.
  *
  * @since 4.0.0
  * @category combinators
  */
 export const annotateMerge: {
   /**
-   * Merges a ServiceMap of annotations into a command.
+   * Merges a Context of annotations into a command.
    *
    * @since 4.0.0
    * @category combinators
    */
-  <I>(annotations: ServiceMap.ServiceMap<I>): <Name extends string, Input, E, R, ContextInput>(
+  <I>(annotations: Context.Context<I>): <Name extends string, Input, E, R, ContextInput>(
     self: Command<Name, Input, ContextInput, E, R>
   ) => Command<Name, Input, ContextInput, E, R>
   /**
-   * Merges a ServiceMap of annotations into a command.
+   * Merges a Context of annotations into a command.
    *
    * @since 4.0.0
    * @category combinators
    */
   <Name extends string, Input, E, R, ContextInput, I>(
     self: Command<Name, Input, ContextInput, E, R>,
-    annotations: ServiceMap.ServiceMap<I>
+    annotations: Context.Context<I>
   ): Command<Name, Input, ContextInput, E, R>
 } = dual(2, <Name extends string, Input, E, R, ContextInput, I>(
   self: Command<Name, Input, ContextInput, E, R>,
-  annotations: ServiceMap.ServiceMap<I>
+  annotations: Context.Context<I>
 ) => {
   const impl = toImpl(self)
-  return makeCommand({ ...impl, annotations: ServiceMap.merge(impl.annotations, annotations) })
+  return makeCommand({ ...impl, annotations: Context.merge(impl.annotations, annotations) })
 })
 
 /**
@@ -1634,7 +1634,7 @@ export const provideSync: {
    * @since 4.0.0
    * @category providing services
    */
-  <I, S, Input>(service: ServiceMap.Key<I, S>, implementation: S | ((input: Input) => S)): <const Name extends string, E, R, ContextInput>(
+  <I, S, Input>(service: Context.Key<I, S>, implementation: S | ((input: Input) => S)): <const Name extends string, E, R, ContextInput>(
     self: Command<Name, Input, ContextInput, E, R>
   ) => Command<Name, Input, ContextInput, E, Exclude<R, I>>
   /**
@@ -1646,12 +1646,12 @@ export const provideSync: {
    */
   <const Name extends string, Input, E, R, ContextInput, I, S>(
     self: Command<Name, Input, ContextInput, E, R>,
-    service: ServiceMap.Key<I, S>,
+    service: Context.Key<I, S>,
     implementation: S | ((input: Input) => S)
   ): Command<Name, Input, ContextInput, E, Exclude<R, I>>
 } = dual(3, <const Name extends string, Input, E, R, ContextInput, I, S>(
   self: Command<Name, Input, ContextInput, E, R>,
-  service: ServiceMap.Key<I, S>,
+  service: Context.Key<I, S>,
   implementation: S | ((input: Input) => S)
 ) =>
   mapHandler(self, (handler, input) =>
@@ -1677,7 +1677,7 @@ export const provideEffect: {
    * @category providing services
    */
   <I, S, Input, R2, E2>(
-    service: ServiceMap.Key<I, S>,
+    service: Context.Key<I, S>,
     effect: Effect.Effect<S, E2, R2> | ((input: Input) => Effect.Effect<S, E2, R2>)
   ): <const Name extends string, E, R, ContextInput>(
     self: Command<Name, Input, ContextInput, E, R>
@@ -1691,12 +1691,12 @@ export const provideEffect: {
    */
   <const Name extends string, Input, E, R, ContextInput, I, S, R2, E2>(
     self: Command<Name, Input, ContextInput, E, R>,
-    service: ServiceMap.Key<I, S>,
+    service: Context.Key<I, S>,
     effect: Effect.Effect<S, E2, R2> | ((input: Input) => Effect.Effect<S, E2, R2>)
   ): Command<Name, Input, ContextInput, E | E2, Exclude<R, I> | R2>
 } = dual(3, <const Name extends string, Input, E, R, ContextInput, I, S, R2, E2>(
   self: Command<Name, Input, ContextInput, E, R>,
-  service: ServiceMap.Key<I, S>,
+  service: Context.Key<I, S>,
   effect: Effect.Effect<S, E2, R2> | ((input: Input) => Effect.Effect<S, E2, R2>)
 ) =>
   mapHandler(
@@ -1751,9 +1751,9 @@ const getOutOfScopeGlobalFlagErrors = (
   activeFlags: ReadonlyArray<GlobalFlag.GlobalFlag<any>>,
   flagMap: Record<string, ReadonlyArray<string>>,
   commandPath: ReadonlyArray<string>
-): ReadonlyArray<CliError.CliError> => {
+): ReadonlyArray<CliError.UnrecognizedOption> => {
   const activeSet = new Set(activeFlags)
-  const errors: Array<CliError.CliError> = []
+  const errors: Array<CliError.UnrecognizedOption> = []
   const seen = new Set<string>()
 
   for (const flag of allFlags) {
@@ -1955,7 +1955,7 @@ export const runWith = <const Name extends string, Input, E, R, ContextInput>(
       // 2. Extract global flag tokens
       const allFlagParams = allFlags.flatMap((f) => Param.extractSingleParams(f.flag))
       const globalRegistry = Parser.createFlagRegistry(allFlagParams.filter(Param.isFlagParam))
-      const { flagMap, remainder } = Parser.consumeKnownFlags(tokens, globalRegistry)
+      const { flagMap, remainder, errors: globalFlagErrors } = Parser.consumeKnownFlags(tokens, globalRegistry)
       const emptyArgs: Param.ParsedArgs = { flags: flagMap, arguments: [] }
 
       // 3. Parse command arguments from remaining tokens
@@ -1966,9 +1966,12 @@ export const runWith = <const Name extends string, Input, E, R, ContextInput>(
 
       // 4. Reject globals that were passed outside the active command scope
       const outOfScopeErrors = getOutOfScopeGlobalFlagErrors(allFlags, activeFlags, flagMap, commandPath)
-      if (outOfScopeErrors.length > 0) {
+      if (outOfScopeErrors.length > 0 || globalFlagErrors.length > 0) {
         const parseErrors = parsedArgs.errors ?? []
-        return yield* new CliError.ShowHelp({ commandPath, errors: [...outOfScopeErrors, ...parseErrors] })
+        return yield* new CliError.ShowHelp({
+          commandPath,
+          errors: [...globalFlagErrors, ...outOfScopeErrors, ...parseErrors]
+        })
       }
 
       // 5. Process action flags — first present action wins, then exit
@@ -1991,7 +1994,10 @@ export const runWith = <const Name extends string, Input, E, R, ContextInput>(
       }
       const parseResult = yield* Effect.result(commandImpl.parse(parsedArgs))
       if (parseResult._tag === "Failure") {
-        return yield* new CliError.ShowHelp({ commandPath, errors: [parseResult.failure] })
+        return yield* new CliError.ShowHelp({
+          commandPath,
+          errors: [parseResult.failure as CliError.NonShowHelpErrors]
+        })
       }
 
       // 7. Provide setting values
@@ -2007,12 +2013,12 @@ export const runWith = <const Name extends string, Input, E, R, ContextInput>(
 
       // 8. Apply built-in setting behavior
       const services = Option.match(logLevel, {
-        onNone: () => ServiceMap.empty(),
-        onSome: (level) => ServiceMap.make(References.MinimumLogLevel, level)
+        onNone: () => Context.empty(),
+        onSome: (level) => Context.make(References.MinimumLogLevel, level)
       })
 
       // 9. Run command handler with composed context
-      yield* Effect.provideServices(program, services)
+      yield* Effect.provideContext(program, services)
     },
     Effect.catchFilter(
       (error) =>

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 ?? []