effect 4.0.0-beta.102 → 4.0.0-beta.104

package/src/unstable/cli/Prompt.ts

@@ -29,6 +29,11 @@ import type { Covariant } from "../../Types.ts"
 import * as Ansi from "./internal/ansi.ts"
 import type * as Primitive from "./Primitive.ts"
 
+declare const process: {
+  readonly platform: string
+  readonly cwd: () => string
+}
+
 const TypeId = "~effect/cli/Prompt"
 
 /**
@@ -651,28 +656,35 @@ export declare namespace All {
  *
  * **Example** (Collecting prompt results)
  *
- * ```ts
- * import { Effect } from "effect"
+ * ```ts import.meta.vitest
+ * import { Effect, FileSystem, Layer, Path, Terminal } from "effect"
  * import { Prompt } from "effect/unstable/cli"
  *
- * const username = Prompt.text({
- *   message: "Enter your username: "
+ * const terminal = Terminal.make({
+ *   columns: Effect.succeed(80),
+ *   rows: Effect.succeed(24),
+ *   readInput: Effect.succeed({} as never),
+ *   readLine: Effect.die("unused"),
+ *   display: () => Effect.void
  * })
+ * const services = Layer.mergeAll(
+ *   FileSystem.layerNoop({}),
+ *   Path.layer,
+ *   Layer.succeed(Terminal.Terminal, terminal)
+ * )
  *
- * const password = Prompt.password({
- *   message: "Enter your password: ",
- *   validate: (value) =>
- *     value.length === 0
- *       ? Effect.fail("Password cannot be empty")
- *       : Effect.succeed(value)
- * })
+ * const username = Prompt.succeed("alice")
+ * const password = Prompt.succeed("secret")
  *
  * const allWithTuple = Prompt.all([username, password])
  *
  * const allWithRecord = Prompt.all({ username, password })
+ *
+ * await Effect.runPromise(Effect.provide(allWithTuple, services)) // => ["alice", "secret"]
+ * await Effect.runPromise(Effect.provide(allWithRecord, services)) // => { username: "alice", password: "secret" }
  * ```
  *
- * @category collecting & elements
+ * @category combining
  * @since 4.0.0
  */
 export const all: <
@@ -681,10 +693,13 @@ export const all: <
   if (arguments.length === 1) {
     if (isPrompt(arguments[0])) {
       return map(arguments[0], (x) => [x]) as any
-    } else if (Array.isArray(arguments[0])) {
-      return allTupled(arguments[0]) as any
+    } else if (Predicate.isIterable(arguments[0])) {
+      return allTupled(Arr.fromIterable(arguments[0] as Iterable<Prompt<any>>)) as any
     } else {
       const entries = Object.entries(arguments[0] as Readonly<{ [K: string]: Prompt<any> }>)
+      if (entries.length === 0) {
+        return succeed({}) as any
+      }
       let result = map(entries[0][1], (value) => ({ [entries[0][0]]: value }))
       if (entries.length === 1) {
         return result as any
@@ -1128,7 +1143,7 @@ export const password = (
  * The returned effect may fail with `Terminal.QuitError` if terminal input ends
  * or the prompt is quit.
  *
- * @category execution
+ * @category running
  * @since 4.0.0
  */
 export const run: <Output>(
@@ -1194,7 +1209,7 @@ export const select = <const A>(options: SelectOptions<A>): Prompt<A> => {
  *
  * **Example** (Filtering choices with autocomplete)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Prompt } from "effect/unstable/cli"
  *
  * const language = Prompt.autoComplete({
@@ -1205,6 +1220,8 @@ export const select = <const A>(options: SelectOptions<A>): Prompt<A> => {
  *     { title: "Kotlin", value: "kt" }
  *   ]
  * })
+ *
+ * Prompt.isPrompt(language) // => true
  * ```
  *
  * @category constructors
@@ -1260,7 +1277,7 @@ export const multiSelect = <const A>(
   const initialSelected = new Set<number>()
   for (let i = 0; i < opts.choices.length; i++) {
     const choice = opts.choices[i] as SelectChoice<A>
-    if (choice.selected === true) {
+    if (choice.selected === true && !choice.disabled) {
       initialSelected.add(i)
     }
   }
@@ -2043,6 +2060,9 @@ class Day extends DatePart {
   }
 
   private ordinalIndicator(day: number): string {
+    if (day >= 11 && day <= 13) {
+      return "th"
+    }
     switch (day % 10) {
       case 1:
         return "st"
@@ -2101,7 +2121,7 @@ class Year extends DatePart {
   override toString() {
     const year = `${this.date.getFullYear()}`.padStart(4, "0")
     return this.token.length === 2
-      ? year.substring(-2)
+      ? year.slice(-2)
       : year
   }
 }
@@ -2118,7 +2138,7 @@ class Meridiem extends DatePart {
   setValue(_value: string): void {}
 
   override toString() {
-    const meridiem = this.date.getHours() > 12 ? "pm" : "am"
+    const meridiem = this.date.getHours() >= 12 ? "pm" : "am"
     return /A/.test(this.token)
       ? meridiem.toUpperCase()
       : meridiem;
@@ -2605,9 +2625,9 @@ const renderMultiSelectChoices = <A>(
   renderOptions?: RenderOptions | undefined
 ) => {
   const choices = options.choices
-  const totalChoices = choices.length
-  const selectedCount = state.selectedIndices.size
-  const allSelected = selectedCount === totalChoices
+  const selectableCount = choices.filter((choice) => !choice.disabled).length
+  const selectedCount = Array.from(state.selectedIndices).filter((index) => !choices[index].disabled).length
+  const allSelected = selectedCount === selectableCount
 
   const selectAllText = allSelected
     ? options?.selectNone ?? "Select None"
@@ -2643,8 +2663,9 @@ const renderMultiSelectChoices = <A>(
       const annotatedCheckbox = isHighlighted && renderOptions?.plain !== true
         ? Ansi.annotate(checkbox, Ansi.cyanBright)
         : checkbox
-      const title = renderMultiSelectTitle(choice.title, isHighlighted, renderOptions)
-      const description = renderChoiceDescription(choice as SelectChoice<A>, isHighlighted, renderOptions)
+      const selectChoice = choice as SelectChoice<A>
+      const title = renderChoiceTitle(selectChoice, isHighlighted, renderOptions)
+      const description = renderChoiceDescription(selectChoice, isHighlighted, renderOptions)
       documents.push(prefix + " " + annotatedCheckbox + " " + title + " " + description)
     }
   }
@@ -2693,16 +2714,20 @@ const processSpace = <A>(
 ) => {
   const selectedIndices = new Set(state.selectedIndices)
   if (state.index === 0) {
-    if (state.selectedIndices.size === options.choices.length) {
+    const selectableCount = options.choices.filter((choice) => !choice.disabled).length
+    const selectedCount = Array.from(state.selectedIndices).filter((index) => !options.choices[index].disabled).length
+    if (selectedCount === selectableCount) {
       selectedIndices.clear()
     } else {
       for (let i = 0; i < options.choices.length; i++) {
-        selectedIndices.add(i)
+        if (!options.choices[i].disabled) {
+          selectedIndices.add(i)
+        }
       }
     }
   } else if (state.index === 1) {
     for (let i = 0; i < options.choices.length; i++) {
-      if (state.selectedIndices.has(i)) {
+      if (options.choices[i].disabled || state.selectedIndices.has(i)) {
         selectedIndices.delete(i)
       } else {
         selectedIndices.add(i)
@@ -2710,7 +2735,9 @@ const processSpace = <A>(
     }
   } else {
     const choiceIndex = state.index - metaOptionsCount
-    if (selectedIndices.has(choiceIndex)) {
+    if (options.choices[choiceIndex].disabled) {
+      return Effect.succeed(Action.Beep())
+    } else if (selectedIndices.has(choiceIndex)) {
       selectedIndices.delete(choiceIndex)
     } else {
       selectedIndices.add(choiceIndex)
@@ -2750,7 +2777,8 @@ const handleMultiSelectProcess = <A>(options: SelectOptionsReq<A> & MultiSelectO
       }
       case "enter":
       case "return": {
-        const selectedCount = state.selectedIndices.size
+        const selectedIndices = Array.from(state.selectedIndices).filter((index) => !options.choices[index].disabled)
+        const selectedCount = selectedIndices.length
         if (options.min !== undefined && selectedCount < options.min) {
           return Effect.succeed(
             Action.NextFrame({ state: { ...state, error: Option.some(`At least ${options.min} are required`) } })
@@ -2761,9 +2789,7 @@ const handleMultiSelectProcess = <A>(options: SelectOptionsReq<A> & MultiSelectO
             Action.NextFrame({ state: { ...state, error: Option.some(`At most ${options.max} choices are allowed`) } })
           )
         }
-        const selectedValues = Array.from(state.selectedIndices).sort(EffectNumber.Order).map((index) =>
-          options.choices[index].value
-        )
+        const selectedValues = selectedIndices.sort(EffectNumber.Order).map((index) => options.choices[index].value)
         return Effect.succeed(Action.Submit({ value: selectedValues }))
       }
       default: {
@@ -2919,10 +2945,14 @@ const defaultFloatProcessor = (input: string, state: NumberState) => {
     return Effect.succeed(Action.NextFrame({
       state: {
         ...state,
-        value: input === "." ? `${parsed}.` : `${parsed}`,
+        value: input === "."
+          ? `${parsed}.`
+          : state.value.includes(".") && /^\d$/.test(input)
+          ? state.value + input
+          : `${parsed}`,
         error: Option.none()
       }
-    }))
+    }));
   }
 }
 

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

@@ -79,9 +79,9 @@ export const combine = (...styles: Array<string>): Array<string> => styles
 /** @internal */
 export const cursorTo = (column: number, row?: number): string => {
   if (row === undefined) {
-    return `\x1b${Math.max(column + 1, 0)} G`
+    return `${ESC}${Math.max(column + 1, 0)}G`
   }
-  return `\x1b${row + 1}${SEP}${Math.max(column + 1, 0)} H`
+  return `${ESC}${row + 1}${SEP}${Math.max(column + 1, 0)}H`
 }
 
 /** @internal */

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

@@ -98,7 +98,7 @@ export const makeCommand = <const Name extends string, Input, E, R, ContextInput
   readonly description?: string | undefined
   readonly shortDescription?: string | undefined
   readonly alias?: string | undefined
-  readonly hidden?: boolean | undefined
+  readonly unlisted?: boolean | undefined
   readonly examples?: ReadonlyArray<Command.Example> | undefined
   readonly subcommands?: ReadonlyArray<SubcommandGroup> | undefined
   readonly parse?: ((input: ParsedTokens) => Effect.Effect<Input, CliError.CliError, Environment>) | undefined
@@ -139,7 +139,8 @@ export const makeCommand = <const Name extends string, Input, E, R, ContextInput
           name: single.name,
           type: single.typeName ?? Primitive.getTypeName(single.primitiveType),
           description: single.description,
-          required: !metadata.isOptional,
+          required: !metadata.isOptional &&
+            (!metadata.isVariadic || Option.exists(metadata.variadicMin, (min) => min > 0)),
           variadic: metadata.isVariadic
         })
       }
@@ -147,8 +148,8 @@ export const makeCommand = <const Name extends string, Input, E, R, ContextInput
 
     let usage = commandPath.length > 0 ? commandPath.join(" ") : options.name
     // Only render `<subcommand>` in usage when at least one visible subcommand
-    // exists; an all-hidden subcommand tree should look like a leaf command.
-    if (subcommands.some((group) => group.commands.some((c) => !c.hidden))) {
+    // exists; an all-unlisted subcommand tree should look like a leaf command.
+    if (subcommands.some((group) => group.commands.some((c) => !c.unlisted))) {
       usage += " <subcommand>"
     }
     usage += " [flags]"
@@ -159,21 +160,22 @@ export const makeCommand = <const Name extends string, Input, E, R, ContextInput
 
     for (const option of config.flags) {
       const singles = Param.extractSingleParams(option)
+      const metadata = Param.getParamMetadata(option)
       for (const single of singles) {
         // Hidden flags still parse on the command line but are omitted from
         // generated --help output.
         if (single.hidden) continue
-        flags.push(toFlagDoc(single))
+        flags.push(toFlagDoc(single, metadata))
       }
     }
 
     const subcommandDocs: Array<SubcommandGroupDoc> = []
 
     for (const group of subcommands) {
-      // Hidden subcommands still parse on the command line but are omitted
+      // Unlisted subcommands still parse on the command line but are omitted
       // from --help. Drop the whole group when nothing visible remains so we
       // don't render an empty heading.
-      const visible = group.commands.filter((c) => !c.hidden)
+      const visible = group.commands.filter((c) => !c.unlisted)
       if (visible.length === 0) continue
       subcommandDocs.push({
         group: group.group,
@@ -206,7 +208,7 @@ export const makeCommand = <const Name extends string, Input, E, R, ContextInput
     annotations,
     globalFlags,
     subcommands,
-    hidden: options.hidden ?? false,
+    unlisted: options.unlisted ?? false,
     config,
     contextConfig,
     service,
@@ -233,14 +235,17 @@ export const makeCommand = <const Name extends string, Input, E, R, ContextInput
 /**
  * Converts a single flag param into a FlagDoc for help display.
  */
-export const toFlagDoc = (single: Param.Single<typeof Param.flagKind, unknown>): FlagDoc => {
+export const toFlagDoc = (
+  single: Param.Single<typeof Param.flagKind, unknown>,
+  metadata: ReturnType<typeof Param.getParamMetadata>
+): FlagDoc => {
   const formattedAliases = single.aliases.map((alias) => alias.length === 1 ? `-${alias}` : `--${alias}`)
   return {
     name: single.name,
     aliases: formattedAliases,
     type: single.typeName ?? Primitive.getTypeName(single.primitiveType),
     description: appendChoiceKeys(single.description, Primitive.getChoiceKeys(single.primitiveType)),
-    required: single.primitiveType._tag !== "Boolean"
+    required: single.primitiveType._tag !== "Boolean" && !metadata.isOptional
   }
 }
 

package/src/unstable/cli/internal/completions/bash.ts

@@ -100,7 +100,8 @@ const generateFunction = (
 
   lines.push(`${funcName}()`)
   lines.push(`{`)
-  lines.push(`  local cur prev words cword`)
+  lines.push(`  local cur prev words cword i`)
+  lines.push(parentPath.length === 0 ? `  local _command_index=0` : `  local _command_index="$1"`)
   lines.push(`  _init_completion || return`)
   lines.push(``)
 
@@ -129,13 +130,23 @@ const generateFunction = (
   // Subcommand dispatch
   if (descriptor.subcommands.length > 0) {
     lines.push(`  # Subcommand dispatch`)
-    lines.push(`  local i cmd`)
-    lines.push(`  for ((i = 1; i < cword; i++)); do`)
+    lines.push(`  local cmd _skip_next=0`)
+    lines.push(`  for ((i = _command_index + 1; i < cword; i++)); do`)
+    lines.push(`    if (( _skip_next )); then`)
+    lines.push(`      _skip_next=0`)
+    lines.push(`      continue`)
+    lines.push(`    fi`)
     lines.push(`    case "\${words[i]}" in`)
+    for (const flag of descriptor.flags) {
+      if (flag.type._tag === "Boolean") continue
+      const forms = flagNamesForWordlist(flag)
+      lines.push(`      ${forms.join("|")}) _skip_next=1 ;;`)
+      lines.push(`      ${forms.map((form) => `${form}=*`).join("|")}) ;;`)
+    }
     for (const sub of descriptor.subcommands) {
       const subFuncName = `_${[...currentPath, sub.name].map(sanitizeFunctionName).join("_")}`
       lines.push(`      ${sub.name})`)
-      lines.push(`        ${subFuncName}`)
+      lines.push(`        ${subFuncName} "$i"`)
       lines.push(`        return`)
       lines.push(`        ;;`)
     }
@@ -159,13 +170,52 @@ const generateFunction = (
   }
 
   // Positional argument completion
-  const argsWithCompletions = descriptor.arguments.filter((a) => argCompletion(a.type) !== undefined)
+  const argsWithCompletions = descriptor.arguments.flatMap((argument, index) => {
+    const completion = argCompletion(argument.type)
+    return completion === undefined ? [] : [{ argument, completion, index }]
+  })
   if (argsWithCompletions.length > 0) {
     lines.push(`  # Positional argument completions`)
-    for (const arg of argsWithCompletions) {
-      const comp = argCompletion(arg.type)!
-      lines.push(`  ${comp}`)
-      lines.push(`  return`)
+    lines.push(`  local _position=0 _skip_next=0 _end_of_options=0`)
+    lines.push(`  for ((i = _command_index + 1; i < cword; i++)); do`)
+    lines.push(`    if (( _skip_next )); then`)
+    lines.push(`      _skip_next=0`)
+    lines.push(`      continue`)
+    lines.push(`    fi`)
+    lines.push(`    if (( _end_of_options )); then`)
+    lines.push(`      ((_position += 1))`)
+    lines.push(`      continue`)
+    lines.push(`    fi`)
+    lines.push(`    case "\${words[i]}" in`)
+    lines.push(`      --) _end_of_options=1 ;;`)
+    for (const flag of descriptor.flags) {
+      const forms = flagNamesForWordlist(flag)
+      if (flag.type._tag === "Boolean") {
+        lines.push(`      ${forms.join("|")}) ;;`)
+      } else {
+        lines.push(`      ${forms.join("|")}) _skip_next=1 ;;`)
+        lines.push(`      ${forms.map((form) => `${form}=*`).join("|")}) ;;`)
+      }
+    }
+    lines.push(`      -*) ;;`)
+    lines.push(`      *) ((_position += 1)) ;;`)
+    lines.push(`    esac`)
+    lines.push(`  done`)
+    lines.push(`  case "$_position" in`)
+    for (const { argument, completion, index } of argsWithCompletions) {
+      if (argument.variadic) continue
+      lines.push(`    ${index})`)
+      lines.push(`      ${completion}`)
+      lines.push(`      return`)
+      lines.push(`      ;;`)
+    }
+    lines.push(`  esac`)
+    const variadic = argsWithCompletions.find(({ argument }) => argument.variadic)
+    if (variadic !== undefined) {
+      lines.push(`  if (( _position >= ${variadic.index} )); then`)
+      lines.push(`    ${variadic.completion}`)
+      lines.push(`    return`)
+      lines.push(`  fi`)
     }
   } else if (descriptor.subcommands.length > 0) {
     const subNames = descriptor.subcommands.map((s) => s.name)

package/src/unstable/cli/internal/completions/descriptor.ts

@@ -30,15 +30,12 @@ const toFlagType = (single: Param.Single<"flag", unknown>): Completions.FlagType
       const keys = Primitive.getChoiceKeys(single.primitiveType)
       return { _tag: "Choice", values: keys ?? [] }
     }
-    case "Path": {
-      const typeName = single.typeName
-      const pathType: "file" | "directory" | "either" = typeName === "file"
-        ? "file"
-        : typeName === "directory"
-        ? "directory"
-        : "either"
-      return { _tag: "Path", pathType }
-    }
+    case "Path":
+      return { _tag: "Path", pathType: Primitive.getPathType(single.primitiveType) ?? "either" }
+    case "FileText":
+    case "FileParse":
+    case "FileSchema":
+      return { _tag: "Path", pathType: "file" }
     default:
       return { _tag: "String" }
   }
@@ -57,15 +54,12 @@ const toArgumentType = (single: Param.Single<"argument", unknown>): Completions.
       const keys = Primitive.getChoiceKeys(single.primitiveType)
       return { _tag: "Choice", values: keys ?? [] }
     }
-    case "Path": {
-      const typeName = single.typeName
-      const pathType: "file" | "directory" | "either" = typeName === "file"
-        ? "file"
-        : typeName === "directory"
-        ? "directory"
-        : "either"
-      return { _tag: "Path", pathType }
-    }
+    case "Path":
+      return { _tag: "Path", pathType: Primitive.getPathType(single.primitiveType) ?? "either" }
+    case "FileText":
+    case "FileParse":
+    case "FileSchema":
+      return { _tag: "Path", pathType: "file" }
     default:
       return { _tag: "String" }
   }
@@ -116,9 +110,9 @@ export const fromCommand = (cmd: Command.Any): Completions.CommandDescriptor =>
   const subcommands: Array<Completions.CommandDescriptor> = []
   for (const group of cmd.subcommands) {
     for (const subcommand of group.commands) {
-      // Omit hidden subcommands from completion scripts so tab-completion in
+      // Omit unlisted subcommands from completion scripts so tab-completion in
       // the shell does not advertise commands that are absent from --help.
-      if (subcommand.hidden) continue
+      if (subcommand.unlisted) continue
       subcommands.push(fromCommand(subcommand))
     }
   }

package/src/unstable/cli/internal/completions/fish.ts

@@ -18,7 +18,7 @@ const escapeFishString = (s: string): string => s.replace(/'/g, "\\'")
  * Build a Fish condition that checks the current subcommand context.
  *
  * For root-level completions with subcommands: `__fish_use_subcommand`
- * For nested commands: verify the parent subcommand is active AND none of its
+ * For nested commands: verify the full parent path is active AND none of its
  * child subcommands have been entered yet.
  */
 const subcommandCondition = (
@@ -31,14 +31,12 @@ const subcommandCondition = (
     }
     return ``
   }
-  const parent = parentPath[parentPath.length - 1]
+  const parentCondition = parentPath.map((parent) => `__fish_seen_subcommand_from ${parent}`).join("; and ")
   if (childSubcommandNames.length > 0) {
-    // Show only when parent is active but no child subcommand has been entered
-    return `__fish_seen_subcommand_from ${parent}; and not __fish_seen_subcommand_from ${
-      childSubcommandNames.join(" ")
-    }`
+    // Show only when the parent path is active but no child subcommand has been entered
+    return `${parentCondition}; and not __fish_seen_subcommand_from ${childSubcommandNames.join(" ")}`
   }
-  return `__fish_seen_subcommand_from ${parent}`
+  return parentCondition
 }
 
 /**

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

@@ -111,6 +111,7 @@ const getSharedFlagsForCommandPath = (
     const ancestorImpl = toImpl(ancestor)
     for (const flag of ancestorImpl.contextConfig.flags) {
       const singles = Param.extractSingleParams(flag)
+      const metadata = Param.getParamMetadata(flag)
       for (const single of singles) {
         if (seen.has(single.name)) {
           continue
@@ -122,7 +123,7 @@ const getSharedFlagsForCommandPath = (
           continue
         }
         seen.add(single.name)
-        sharedFlags.push(toFlagDoc(single))
+        sharedFlags.push(toFlagDoc(single, metadata))
       }
     }
   }
@@ -165,13 +166,14 @@ export const getHelpForCommandPath = <Name extends string, Input, E, R, ContextI
     const globalFlagDocs: Array<FlagDoc> = []
     for (const flag of flags) {
       const singles = Param.extractSingleParams(flag.flag)
+      const metadata = Param.getParamMetadata(flag.flag)
       for (const single of singles) {
         // Same rule as command-local flags: hidden globals are still parsed
         // and still trigger their handlers, they just don't appear under
         // "GLOBAL FLAGS" in --help.
         if (single.hidden) continue
         globalFlagDocs.push({
-          ...toFlagDoc(single),
+          ...toFlagDoc(single, metadata),
           required: false
         })
       }

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

@@ -47,8 +47,14 @@ const lexTokens = (args: ReadonlyArray<string>): ReadonlyArray<Token> => {
     if (!arg.startsWith("-")) {
       tokens.push({ _tag: "Value", value: arg })
     } else if (arg.startsWith("--")) {
-      const [name, value] = arg.slice(2).split("=", 2)
-      tokens.push({ _tag: "LongOption", name, raw: arg, value })
+      const equalIndex = arg.indexOf("=")
+      if (equalIndex !== -1) {
+        const name = arg.slice(2, equalIndex)
+        const value = arg.slice(equalIndex + 1)
+        tokens.push({ _tag: "LongOption", name, raw: arg, value })
+      } else {
+        tokens.push({ _tag: "LongOption", name: arg.slice(2), raw: arg })
+      }
     } else if (arg.length > 1) {
       const flags = arg.slice(1)
       const equalIndex = flags.indexOf("=")

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

@@ -84,7 +84,7 @@ export const parseArgs = (
       }
     }
 
-    const subLex: LexResult = { tokens: result.childTokens, trailingOperands: [] }
+    const subLex: LexResult = { tokens: result.childTokens, trailingOperands: afterEndOfOptions }
     const subParsed = yield* parseArgs(
       subLex,
       result.sub,
@@ -94,7 +94,7 @@ export const parseArgs = (
     const allErrors = [...result.errors, ...(subParsed.errors ?? [])]
     return {
       flags: result.flags,
-      arguments: afterEndOfOptions,
+      arguments: [],
       subcommand: Option.some({ name: result.sub.name, parsedInput: subParsed }),
       ...(allErrors.length > 0 && { errors: allErrors })
     }
@@ -826,12 +826,12 @@ const resolveFirstValue = (
   // Not a subcommand. Check if this looks like a typo.
   const expectsArgs = toImpl(command).config.arguments.length > 0
   if (!expectsArgs && subIndex.size > 0) {
-    // Exclude hidden subcommands so a typo cannot reveal a subcommand name
-    // that was intentionally kept out of --help. Hidden commands still
+    // Exclude unlisted subcommands so a typo cannot reveal a subcommand name
+    // that was intentionally kept out of --help. Unlisted commands still
     // resolve via subIndex when invoked by exact name.
     const visibleKeys: Array<string> = []
     for (const [key, sub] of subIndex) {
-      if (!sub.hidden) visibleKeys.push(key)
+      if (!sub.unlisted) visibleKeys.push(key)
     }
     const suggestions = suggest(value, visibleKeys)
     state.errors.push(

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

@@ -54,7 +54,7 @@ const promptCommand: (
 ) => Effect.Effect<void, CliError.CliError | Terminal.QuitError, Command.Environment> = Effect.fnUntraced(
   function*(command, commandLine, sectionName) {
     const impl = toImpl(command)
-    const visibleSubcommands = command.subcommands.flatMap((group) => group.commands.filter((child) => !child.hidden))
+    const visibleSubcommands = command.subcommands.flatMap((group) => group.commands.filter((child) => !child.unlisted))
     const config = visibleSubcommands.length === 0 ? impl.config : impl.contextConfig
 
     if (config.flags.length > 0) {
@@ -103,7 +103,7 @@ const promptCommand: (
 )
 
 const hasWizardSteps = (command: Command.Command.Any): boolean => {
-  const hasVisibleSubcommands = command.subcommands.some((group) => group.commands.some((child) => !child.hidden))
+  const hasVisibleSubcommands = command.subcommands.some((group) => group.commands.some((child) => !child.unlisted))
   return hasVisibleSubcommands || toImpl(command).config.orderedParams.length > 0
 }