@xano/sdk 1.0.0

package/dist/completion-ZQLO6PB6.js

@@ -0,0 +1,738 @@
+import {
+  GLOBAL_FLAGS,
+  argValues,
+  flagKey,
+  flagRefFor,
+  flagSpec,
+  flagValues,
+  getCommand,
+  liveCommandNames,
+  liveSubcommandNames,
+  takesProfileFlag,
+  visibleFlags
+} from "./chunk-PTHVMXZI.js";
+import "./chunk-UTI5G6OJ.js";
+import "./chunk-2EZ3ZJZZ.js";
+import "./chunk-5ZSO4T2G.js";
+import "./chunk-TFFGOFVZ.js";
+import "./chunk-36JUQZVQ.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/emit/completion.ts
+var COMPLETION_SHELLS = ["bash", "zsh", "fish"];
+var UNSUPPORTED_SHELLS = /* @__PURE__ */ new Set([
+  "pwsh",
+  "powershell",
+  "cmd",
+  "sh",
+  "dash",
+  "ksh",
+  "tcsh",
+  "csh",
+  "nu",
+  "nushell",
+  "elvish",
+  "xonsh"
+]);
+function isCompletionShell(s) {
+  return COMPLETION_SHELLS.includes(s);
+}
+function flagTokens(ref) {
+  const spec = flagSpec(ref);
+  return spec.match(/-{1,2}[a-z][a-z-]*/g) ?? [];
+}
+function takesNextWord(ref) {
+  const rest = flagSpec(ref).replace(/-{1,2}[a-z][a-z-]*,?/g, "").trim();
+  return rest !== "" && !rest.startsWith("=") && !rest.startsWith("[");
+}
+function valueFlagTokens() {
+  const refs = [...GLOBAL_FLAGS];
+  for (const name of liveCommandNames()) {
+    const spec = getCommand(name);
+    refs.push(...visibleFlags(spec) ?? []);
+    for (const verb of liveSubcommandNames(name)) refs.push(...visibleFlags(spec.subcommands[verb]) ?? []);
+  }
+  const valued = /* @__PURE__ */ new Set();
+  const switches = /* @__PURE__ */ new Set();
+  for (const ref of refs) for (const token of flagTokens(ref)) (takesNextWord(ref) ? valued : switches).add(token);
+  return [...valued].filter((t) => !switches.has(t)).sort();
+}
+function valueKind(ref) {
+  if (!takesNextWord(ref) || flagValues(ref) !== void 0) return void 0;
+  const key = flagKey(ref);
+  if (key === "profile" || key === "to-profile") return "profile";
+  const spec = flagSpec(ref);
+  if (/<dir>/.test(spec) || key.endsWith("-dir")) return "dir";
+  if (/<(path|file|p)>/.test(spec)) return "file";
+  return "free";
+}
+function inlineValueKind(ref) {
+  if (takesNextWord(ref) || flagValues(ref) !== void 0) return void 0;
+  const rest = flagSpec(ref).replace(/-{1,2}[a-z][a-z-]*,?/g, "").trim();
+  const placeholder = /^\[?=<([^>]+)>/.exec(rest)?.[1];
+  if (placeholder === void 0) return void 0;
+  const parts = placeholder.split("|");
+  if (parts.includes("dir")) return "dir";
+  if (parts.some((p) => p === "path" || p === "file")) return "file";
+  return "free";
+}
+function tokensFor(flags) {
+  return (flags ?? []).flatMap(flagTokens);
+}
+function wantsPaths(args) {
+  return (args ?? []).some((a) => a.path === true);
+}
+function firstArgValues(args) {
+  const first = args?.[0];
+  return first === void 0 ? [] : [...argValues(first) ?? []];
+}
+function valuedFlags(flags) {
+  const out = [];
+  for (const ref of flags ?? []) {
+    const values = flagValues(ref);
+    if (values === void 0) continue;
+    for (const token of flagTokens(ref)) out.push([token, [...values]]);
+  }
+  return out;
+}
+function describe(text) {
+  return text.replace(/`/g, "").replace(/\s+/g, " ").trim();
+}
+function sq(text) {
+  return `'${text.replace(/'/g, `'\\''`)}'`;
+}
+function inlineKindedFlags(flags) {
+  return (flags ?? []).flatMap((ref) => {
+    const kind = inlineValueKind(ref);
+    return kind === void 0 ? [] : flagTokens(ref).filter((t) => t.startsWith("--")).map((t) => [t, kind]);
+  });
+}
+function kindedFlags(flags, command, verb) {
+  const globals = GLOBAL_FLAGS.filter((key) => key !== "profile" || takesProfileFlag(command, verb));
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const ref of [...flags ?? [], ...globals]) {
+    const kind = valueKind(ref);
+    if (kind === void 0) continue;
+    for (const token of flagTokens(ref)) {
+      if (seen.has(token)) continue;
+      seen.add(token);
+      out.push([token, kind]);
+    }
+  }
+  return out;
+}
+function globalTokens(command, verb) {
+  return GLOBAL_FLAGS.filter((key) => key !== "profile" || takesProfileFlag(command, verb)).filter((key) => key !== "version" || flagRefFor(command, verb, "engine-version") === void 0).filter((key) => key !== "version" || !(command === "env" && verb === "set")).flatMap((key) => flagTokens(key));
+}
+function withGlobals(own, command, verb) {
+  return [.../* @__PURE__ */ new Set([...own, ...globalTokens(command, verb)])];
+}
+function leadingGlobals() {
+  return GLOBAL_FLAGS.flatMap((key) => flagTokens(key)).join(" ");
+}
+var PROFILE_NAME_VERBS = ["use", "show", "delete", "set-default"];
+var PROFILE_NAMES_JS = [
+  'const fs=require("fs"),os=require("os"),p=require("path");',
+  'const names=(f)=>{try{const j=JSON.parse(fs.readFileSync(f,"utf8"));',
+  'const o=j&&typeof j.profiles==="object"&&j.profiles?j.profiles:null;',
+  "return o?Object.keys(o).filter((n)=>/^[A-Za-z0-9._-]+$/.test(n)):[];}catch{return [];}};",
+  "const a=process.argv.slice(1);let cfg,local=false,cmd;",
+  "for(let i=0;i<a.length;i++){const w=a[i];",
+  // bash splits `--config=/alt.json` at the `=` (COMP_WORDBREAKS): `--config`, `=`, `/alt.json`.
+  'if(w==="--config"){cfg=a[++i];if(cfg==="=")cfg=a[++i];}else if(w.startsWith("--config="))cfg=w.slice(9);',
+  'else if(w==="--local")local=true;else if(w==="-p"||w==="--profile"){i++;if(a[i]==="=")i++;}',
+  'else if(!w.startsWith("-")&&cmd===undefined)cmd=w;}',
+  // A leading `~` the shell left unexpanded (quoted, or after `--config=`) is the home directory.
+  'const tl=(f)=>f&&(f==="~"||f.startsWith("~/"))?p.join(os.homedir(),f.slice(1)):f;',
+  "cfg=tl(cfg||process.env.XANO_CONFIG);",
+  "const localFile=()=>{const home=p.resolve(os.homedir()),start=process.cwd();let d=start;for(;;){",
+  'if(["xano.profile.json","package.json",".git"].some((m)=>fs.existsSync(p.join(d,m))))return p.join(d,".xano","auth.json");',
+  'const up=p.dirname(d);if(up===d||d===home)return p.join(start,".xano","auth.json");d=up;}};',
+  'const shared=tl(process.env.XANO_GLOBAL_CONFIG)||p.join(os.homedir(),".xanosdk","auth.json");',
+  "let file;if(cfg)file=cfg;else if(local)file=localFile();",
+  'else if(cmd==="login"||cmd==="logout")file=shared;',
+  "else{const l=localFile();file=names(l).length?l:shared;}",
+  'const n=names(file);if(n.length)console.log(n.join(" "));'
+].join("");
+var ENGINE_NAME_VERBS = ["stop", "token"];
+var ENGINE_RECORDS = { homeEnv: "XANOSDK_LOCAL_ENGINE_HOME", file: "engines.json" };
+var ENGINE_NAMES_JS = [
+  'const fs=require("fs"),os=require("os"),p=require("path");',
+  `const home=process.env.${ENGINE_RECORDS.homeEnv}||p.join(os.homedir(),".xanosdk","local-engine");`,
+  `try{const j=JSON.parse(fs.readFileSync(p.join(home,${JSON.stringify(ENGINE_RECORDS.file)}),"utf8"));`,
+  'const e=j&&typeof j.engines==="object"&&j.engines?Object.values(j.engines):[];',
+  'const n=[...new Set(e.map((r)=>r&&r.name).filter((x)=>typeof x==="string"&&/^[A-Za-z0-9._-]+$/.test(x)))];',
+  'if(n.length)console.log(n.join(" "));}catch{}'
+].join("");
+function scopes() {
+  const out = [];
+  for (const name of liveCommandNames()) {
+    const spec = getCommand(name);
+    out.push({
+      key: name,
+      flags: withGlobals(tokensFor(visibleFlags(spec)), name, void 0),
+      paths: wantsPaths(spec.args),
+      values: firstArgValues(spec.args),
+      valued: valuedFlags(visibleFlags(spec)),
+      kinds: kindedFlags(visibleFlags(spec), name, void 0),
+      inlineKinds: inlineKindedFlags(visibleFlags(spec))
+    });
+    for (const verb of liveSubcommandNames(name)) {
+      const sub = spec.subcommands[verb];
+      out.push({
+        key: `${name} ${verb}`,
+        flags: withGlobals(tokensFor(visibleFlags(sub)), name, verb),
+        paths: wantsPaths(sub.args),
+        values: firstArgValues(sub.args),
+        valued: valuedFlags(visibleFlags(sub)),
+        kinds: kindedFlags(visibleFlags(sub), name, verb),
+        inlineKinds: inlineKindedFlags(visibleFlags(sub))
+      });
+    }
+  }
+  return out;
+}
+function commandRows() {
+  return liveCommandNames().map((n) => [n, describe(getCommand(n).summary)]);
+}
+function subcommandRows(command) {
+  const spec = getCommand(command);
+  return liveSubcommandNames(command).map((v) => [v, describe(spec.subcommands[v].summary)]);
+}
+function renderBash() {
+  const commands = liveCommandNames().join(" ");
+  const subLines = liveCommandNames().filter((c) => liveSubcommandNames(c).length > 0).map((c) => `    ${c}) echo ${sq(liveSubcommandNames(c).join(" "))} ;;`);
+  const flagLines = scopes().filter((s) => s.flags.length > 0).map((s) => `    ${sq(s.key)}) echo ${sq(s.flags.join(" "))} ;;`);
+  const pathLines = scopes().filter((s) => s.paths).map((s) => sq(s.key)).join("|");
+  const valueLines = scopes().filter((s) => s.values.length > 0).map((s) => `    ${sq(s.key)}) echo ${sq(s.values.join(" "))} ;;`);
+  const flagValueLines = scopes().flatMap((s) => s.valued.map(([token, values]) => [`${s.key} ${token}`, values])).map(([k, values]) => `    ${sq(k)}) echo ${sq(values.join(" "))} ;;`);
+  const flagKindLines = scopes().flatMap(
+    (s) => s.kinds.map(([token, kind]) => `    ${sq(`${s.key} ${token}`)}) echo ${kind} ;;`)
+  );
+  const inlineKindLines = scopes().flatMap(
+    (s) => s.inlineKinds.map(([token, kind]) => `    ${sq(`${s.key} ${token}`)}) echo ${kind} ;;`)
+  );
+  return `# xanosdk completion for bash. Regenerate after upgrading:
+#   xanosdk completion bash > ~/.xanosdk-completion.bash
+#   echo 'source ~/.xanosdk-completion.bash' >> ~/.bashrc
+
+_xanosdk_subcommands() {
+  case "$1" in
+${subLines.join("\n")}
+  esac
+}
+
+_xanosdk_flags() {
+  case "$1" in
+${flagLines.join("\n")}
+  esac
+}
+
+_xanosdk_argvalues() {
+  case "$1" in
+${valueLines.join("\n")}
+  esac
+}
+
+_xanosdk_flagvalues() {
+  case "$1" in
+${flagValueLines.join("\n")}
+  esac
+}
+
+# What the argument of a value flag is when it has no closed set: file, dir, profile, or free.
+_xanosdk_flagkind() {
+  case "$1" in
+${flagKindLines.join("\n")}
+  esac
+}
+
+# The same, for a flag whose value is written only after \`=\` (\`--lock=<path>\`).
+_xanosdk_inlinekind() {
+  case "$1" in
+${inlineKindLines.join("\n")}
+  esac
+}
+
+# Stored profile names (keys only \u2014 never a token), from the file this line reads.
+_xanosdk_profiles() {
+  command -v node >/dev/null 2>&1 || return
+  node -e ${sq(PROFILE_NAMES_JS)} -- "\${COMP_WORDS[@]:1:COMP_CWORD-1}" 2>/dev/null
+}
+
+# Local engine names, from the engine records on this machine \u2014 nothing is started.
+_xanosdk_engines() {
+  command -v node >/dev/null 2>&1 || return
+  node -e ${sq(ENGINE_NAMES_JS)} 2>/dev/null
+}
+
+_xanosdk() {
+  local cur cmd sub scope o=1
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  COMPREPLY=()
+
+  # Global flags typed before the command (\`xanosdk --json status\`) are
+  # skipped, value and all: the command is the first word after them.
+  while [ "$o" -lt "$COMP_CWORD" ]; do
+    case "\${COMP_WORDS[o]}" in
+      --json|--no-refresh|--profile=*) o=$((o + 1)) ;;
+      -p|--profile)
+        if [ "\${COMP_WORDS[o+1]}" = "=" ]; then o=$((o + 3)); else o=$((o + 2)); fi ;;
+      *) break ;;
+    esac
+  done
+  # Completing the value of a leading -p/--profile.
+  if [ "$COMP_CWORD" -lt "$o" ]; then
+    COMPREPLY=( $(compgen -W "$(_xanosdk_profiles)" -- "$cur") )
+    return
+  fi
+  cmd="\${COMP_WORDS[o]}"
+  sub="\${COMP_WORDS[o+1]}"
+
+  # The first word after any leading global flags is the command; a dash there
+  # is another global flag.
+  if [ "$COMP_CWORD" -eq "$o" ]; then
+    case "$cur" in
+      -*) COMPREPLY=( $(compgen -W ${sq(leadingGlobals())} -- "$cur") ) ;;
+      *) COMPREPLY=( $(compgen -W ${sq(commands)} -- "$cur") ) ;;
+    esac
+    return
+  fi
+
+  # \`help <command> [verb]\`: a command path, completed as one.
+  if [ "$cmd" = help ]; then
+    case "$cur" in
+      -*) ;;
+      *)
+        if [ "$COMP_CWORD" -eq $((o + 1)) ]; then
+          COMPREPLY=( $(compgen -W ${sq(commands)} -- "$cur") )
+        elif [ "$COMP_CWORD" -eq $((o + 2)) ]; then
+          COMPREPLY=( $(compgen -W "$(_xanosdk_subcommands "$sub")" -- "$cur") )
+        fi
+        return
+        ;;
+    esac
+  fi
+
+  # The word after a noun command is its verb.
+  local subs
+  subs="$(_xanosdk_subcommands "$cmd")"
+  if [ "$COMP_CWORD" -eq $((o + 1)) ] && [ -n "$subs" ]; then
+    COMPREPLY=( $(compgen -W "$subs" -- "$cur") )
+    return
+  fi
+
+  scope="$cmd"
+  if [ -n "$subs" ]; then scope="$cmd $sub"; fi
+
+  # A dash starts a flag; anything else is a positional.
+  case "$cur" in
+    -*)
+      COMPREPLY=( $(compgen -W "$(_xanosdk_flags "$scope")" -- "$cur") )
+      return
+      ;;
+  esac
+
+  # Directly after a flag that takes a value, that value, never the
+  # positional of the command.
+  local prev values kind eq=0
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  # bash splits \`--profile=prod\` at the \`=\` (COMP_WORDBREAKS): the flag is the
+  # word before it, and a bare \`=\` under the cursor is an empty value.
+  if [ "$cur" = "=" ]; then
+    cur=""
+    eq=1
+  elif [ "$prev" = "=" ] && [ "$COMP_CWORD" -ge 2 ]; then
+    prev="\${COMP_WORDS[COMP_CWORD-2]}"
+    eq=1
+  fi
+  case "$prev" in
+    -p|--profile)
+      COMPREPLY=( $(compgen -W "$(_xanosdk_profiles)" -- "$cur") )
+      return
+      ;;
+  esac
+  values="$(_xanosdk_flagvalues "$scope $prev")"
+  if [ -n "$values" ]; then
+    COMPREPLY=( $(compgen -W "$values" -- "$cur") )
+    return
+  fi
+  kind="$(_xanosdk_flagkind "$scope $prev")"
+  # After \`--flag=\` the word is the value of that flag, never a positional.
+  if [ -z "$kind" ] && [ "$eq" = 1 ] && [[ "$prev" == --* ]]; then
+    kind="$(_xanosdk_inlinekind "$scope $prev")"
+    [ -n "$kind" ] || kind=free
+  fi
+  case "$kind" in
+    profile)
+      COMPREPLY=( $(compgen -W "$(_xanosdk_profiles)" -- "$cur") )
+      return
+      ;;
+    file|dir)
+      compopt -o filenames 2>/dev/null
+      local IFS=$'\\n'
+      if [ "$kind" = dir ]; then COMPREPLY=( $(compgen -d -- "$cur") ); else COMPREPLY=( $(compgen -f -- "$cur") ); fi
+      return
+      ;;
+    # A free-form value (a name, a number, a URL): nothing to offer, not even files.
+    free)
+      compopt +o default 2>/dev/null
+      return
+      ;;
+  esac
+  # A profile name: the one \`profile use|show|delete|set-default\` takes.
+  case "$scope" in
+    ${PROFILE_NAME_VERBS.map((v) => sq(`profile ${v}`)).join("|")})
+      COMPREPLY=( $(compgen -W "$(_xanosdk_profiles)" -- "$cur") )
+      return
+      ;;
+    # The engine name \`local-engine stop|token\` takes.
+    ${ENGINE_NAME_VERBS.map((v) => sq(`local-engine ${v}`)).join("|")})
+      COMPREPLY=( $(compgen -W "$(_xanosdk_engines)" -- "$cur") )
+      return
+      ;;
+  esac
+
+  # A positional can take both a closed set and a file (deploy <source>: a
+  # backend kind or a bundle), so the set is offered and file names are
+  # added after it rather than instead of it.
+  values="$(_xanosdk_argvalues "$scope")"
+  if [ -n "$values" ]; then
+    COMPREPLY=( $(compgen -W "$values" -- "$cur") )
+  fi
+
+  case "$scope" in
+    ${pathLines || "''"}) COMPREPLY+=( $(compgen -f -- "$cur") ) ;;
+  esac
+}
+
+complete -o default -F _xanosdk xanosdk
+`;
+}
+function renderZsh() {
+  const commandBlock = commandRows().map(([n, d]) => `    ${sq(`${n}:${d}`)}`).join("\n");
+  const familyBlocks = liveCommandNames().filter((c) => liveSubcommandNames(c).length > 0).map((c) => {
+    const rows = subcommandRows(c).map(([v, d]) => `        ${sq(`${v}:${d}`)}`).join("\n");
+    return `      ${c})
+        _xanosdk_verbs=(
+${rows}
+        )
+        ;;`;
+  }).join("\n");
+  const flagBlocks = scopes().filter((s) => s.flags.length > 0).map((s) => `      ${sq(s.key)}) _xanosdk_flags=(${s.flags.map(sq).join(" ")}) ;;`).join("\n");
+  const pathBlock = scopes().filter((s) => s.paths).map((s) => sq(s.key)).join("|");
+  const valueBlocks = scopes().filter((s) => s.values.length > 0).map((s) => `      ${sq(s.key)}) compadd ${s.values.map(sq).join(" ")}${s.paths ? "" : "; return"} ;;`).join("\n");
+  const flagValueBlocks = scopes().flatMap((s) => s.valued.map(([token, values]) => [`${s.key} ${token}`, values])).map(([k, values]) => `      ${sq(k)}) compadd ${values.map(sq).join(" ")}; return ;;`).join("\n");
+  const zshKind = {
+    file: "_files; return",
+    dir: "_files -/; return",
+    profile: "_xanosdk_profile_names; return",
+    // A free-form value (a name, a number, a URL): nothing to offer.
+    free: "return"
+  };
+  const flagKindBlocks = scopes().flatMap((s) => s.kinds.map(([token, kind]) => `      ${sq(`${s.key} ${token}`)}) ${zshKind[kind]} ;;`)).join("\n");
+  const inlineKindBlocks = scopes().flatMap((s) => s.inlineKinds.map(([token, kind]) => `      ${sq(`${s.key} ${token}`)}) ${zshKind[kind]} ;;`)).join("\n");
+  return `#compdef xanosdk
+# xanosdk completion for zsh. Regenerate after upgrading:
+#   xanosdk completion zsh > "\${fpath[1]}/_xanosdk"
+#   # \u2026then restart your shell, or: autoload -U compinit && compinit
+
+# Stored profile names (keys only \u2014 never a token), from the file this line reads.
+_xanosdk_profile_names() {
+  (( $+commands[node] )) && compadd -- \${=$(node -e ${sq(PROFILE_NAMES_JS)} -- "\${(@)words[2,CURRENT-1]}" 2>/dev/null)}
+}
+
+_xanosdk() {
+  local -a _xanosdk_commands _xanosdk_verbs _xanosdk_flags
+  local cmd sub scope
+  _xanosdk_commands=(
+${commandBlock}
+  )
+
+  # Global flags typed before the command (\`xanosdk --json status\`) are
+  # skipped, value and all: the command is the first word after them.
+  local o=2
+  while (( o < CURRENT )); do
+    case "\${words[o]}" in
+      --json|--no-refresh|--profile=*) (( o += 1 )) ;;
+      -p|--profile) (( o += 2 )) ;;
+      *) break ;;
+    esac
+  done
+  # Completing the value of a leading -p/--profile.
+  if (( CURRENT < o )); then
+    _xanosdk_profile_names
+    return
+  fi
+
+  if (( CURRENT == o )); then
+    if [[ "\${words[CURRENT]}" == -* ]]; then
+      compadd -- ${leadingGlobals().split(" ").map(sq).join(" ")}
+    else
+      _describe -t commands 'xanosdk command' _xanosdk_commands
+    fi
+    return
+  fi
+
+  cmd="\${words[o]}"
+  case "$cmd" in
+${familyBlocks}
+  esac
+
+  # \`help <command> [verb]\`: a command path, completed as one.
+  if [[ "$cmd" == help && "\${words[CURRENT]}" != -* ]]; then
+    if (( CURRENT == o + 1 )); then
+      _describe -t commands 'xanosdk command' _xanosdk_commands
+    elif (( CURRENT == o + 2 )); then
+      cmd="\${words[o + 1]}"
+      case "$cmd" in
+${familyBlocks}
+      esac
+      (( \${#_xanosdk_verbs} )) && _describe -t subcommands "xanosdk $cmd subcommand" _xanosdk_verbs
+    fi
+    return
+  fi
+
+  if (( CURRENT == o + 1 )) && (( \${#_xanosdk_verbs} )); then
+    _describe -t subcommands "xanosdk $cmd subcommand" _xanosdk_verbs
+    return
+  fi
+
+  scope="$cmd"
+  if (( \${#_xanosdk_verbs} )); then
+    sub="\${words[o + 1]}"
+    scope="$cmd $sub"
+  fi
+
+  case "$scope" in
+${flagBlocks}
+  esac
+
+  # \`--flag=<value>\`: zsh keeps it one word, so the flag is what precedes its
+  # \`=\`, and the value completes after it as it would after \`--flag \`.
+  if [[ "\${words[CURRENT]}" == --*=* ]]; then
+    local eqflag="\${words[CURRENT]%%=*}"
+    compset -P "\${eqflag}="
+    case "$eqflag" in
+      --profile) _xanosdk_profile_names; return ;;
+    esac
+    case "$scope $eqflag" in
+${flagValueBlocks}
+${flagKindBlocks}
+${inlineKindBlocks}
+    esac
+    return
+  fi
+
+  if [[ "\${words[CURRENT]}" == -* ]]; then
+    compadd -a _xanosdk_flags
+    return
+  fi
+
+  # Directly after a flag that takes a value, that value, never the
+  # positional of the command.
+  case "\${words[CURRENT-1]}" in
+    -p|--profile) _xanosdk_profile_names; return ;;
+  esac
+  case "$scope \${words[CURRENT-1]}" in
+${flagValueBlocks}
+${flagKindBlocks}
+  esac
+
+  # A profile name: the one \`profile use|show|delete|set-default\` takes.
+  case "$scope" in
+    ${PROFILE_NAME_VERBS.map((v) => sq(`profile ${v}`)).join("|")})
+      _xanosdk_profile_names
+      return
+      ;;
+  esac
+  # The engine name \`local-engine stop|token\` takes, from the engine records on this machine.
+  case "$scope" in
+    ${ENGINE_NAME_VERBS.map((v) => sq(`local-engine ${v}`)).join("|")})
+      (( $+commands[node] )) && compadd -- \${=$(node -e ${sq(ENGINE_NAMES_JS)} 2>/dev/null)}
+      return
+      ;;
+  esac
+
+  case "$scope" in
+${valueBlocks}
+  esac
+
+  case "$scope" in
+    ${pathBlock || "'__none__'"}) _files ;;
+  esac
+}
+
+_xanosdk "$@"
+`;
+}
+function renderFish() {
+  const families = liveCommandNames().filter((c) => subcommandRows(c).length > 0);
+  const valueFlags = new Set(valueFlagTokens());
+  const lines = [
+    "# xanosdk completion for fish. Regenerate after upgrading:",
+    "#   xanosdk completion fish > ~/.config/fish/completions/xanosdk.fish",
+    "",
+    // Without this, fish offers files at every position.
+    "complete -c xanosdk -f",
+    "",
+    "# The command, and for a command with verbs the verb, typed so far. A flag",
+    "# is skipped, and so is the value of one that takes the next word",
+    "# (`-p prof status` is `status`, not `prof`).",
+    "function __xanosdk_scope",
+    "    set -l typed (commandline -opc)",
+    "    set -e typed[1]",
+    "    set -l words",
+    "    set -l skip 0",
+    "    for w in $typed",
+    "        if test $skip -eq 1",
+    "            set skip 0",
+    "            continue",
+    "        end",
+    "        switch $w",
+    `            case ${[...valueFlags].map(sq).join(" ")}`,
+    "                set skip 1",
+    "            case '-*'",
+    "            case '*'",
+    "                set -a words $w",
+    "        end",
+    "    end",
+    "    test (count $words) -ge 1; or return",
+    `    if contains -- $words[1] ${families.map(sq).join(" ")}; and test (count $words) -ge 2`,
+    '        echo "$words[1] $words[2]"',
+    "    else",
+    "        echo $words[1]",
+    "    end",
+    "end",
+    "",
+    "function __xanosdk_scope_is",
+    "    set -l scope (__xanosdk_scope)",
+    '    test "$scope" = "$argv[1]"',
+    "end",
+    "",
+    "# No command typed yet \u2014 flags and their values aside.",
+    "function __xanosdk_no_command",
+    "    set -l scope (__xanosdk_scope)",
+    '    test -z "$scope"',
+    "end",
+    "",
+    "# `help` followed by exactly the words in $argv (flags aside) \u2014 the help",
+    "# target typed so far, so the next word completes as a command or a verb.",
+    "function __xanosdk_help_on",
+    "    set -l typed (commandline -opc)",
+    "    set -e typed[1]",
+    "    set -l words",
+    "    for w in $typed",
+    "        switch $w",
+    "            case '-*'",
+    "            case '*'",
+    "                set -a words $w",
+    "        end",
+    "    end",
+    '    test "$words[1]" = help; or return 1',
+    "    set -e words[1]",
+    '    test "$words" = "$argv"',
+    "end",
+    "",
+    "# Stored profile names (keys only \u2014 never a token), from the file this line reads.",
+    "function __xanosdk_profiles",
+    "    set -l words (commandline -opc)",
+    "    command -q node; or return",
+    `    node -e ${sq(PROFILE_NAMES_JS)} -- $words[2..-1] 2>/dev/null | string split ' '`,
+    "end",
+    "",
+    "# Local engine names, from the engine records on this machine \u2014 nothing is started.",
+    "function __xanosdk_engines",
+    "    command -q node; or return",
+    `    node -e ${sq(ENGINE_NAMES_JS)} 2>/dev/null | string split ' '`,
+    "end",
+    "",
+    "# Directories for a directory flag's value. fish puts back a `--flag=` or `-f`",
+    "# it read off the token, so only the value is completed \u2014 and `-f=`'s `=` is",
+    "# part of what fish reads as the value.",
+    "function __xanosdk_dirs",
+    "    set -l tok (commandline -ct)",
+    "    set -l lead ''",
+    "    if string match -qr -- '^--[^=]*=' $tok",
+    "        set tok (string replace -r -- '^--[^=]*=' '' $tok)",
+    "    else if string match -qr -- '^-[A-Za-z]=' $tok",
+    "        set lead '='",
+    "        set tok (string sub -s 4 -- $tok)",
+    "    end",
+    '    for d in (__fish_complete_directories "$tok")',
+    "        printf '%s%s\\n' $lead $d",
+    "    end",
+    "end",
+    ""
+  ];
+  for (const [name, desc] of commandRows()) {
+    lines.push(`complete -c xanosdk -n __xanosdk_no_command -a ${sq(name)} -d ${sq(desc)}`);
+  }
+  for (const token of leadingGlobals().split(" ")) lines.push(fishFlagLine("__xanosdk_no_command", token, valueFlags));
+  for (const [name, desc] of commandRows()) {
+    lines.push(`complete -c xanosdk -n '__xanosdk_help_on' -a ${sq(name)} -d ${sq(desc)}`);
+  }
+  for (const command of families) {
+    for (const [verb, desc] of subcommandRows(command)) {
+      lines.push(`complete -c xanosdk -n ${sq(`__xanosdk_help_on ${command}`)} -a ${sq(verb)} -d ${sq(desc)}`);
+    }
+  }
+  for (const command of families) {
+    lines.push("");
+    const condition = `__xanosdk_scope_is ${sq(command)}`;
+    for (const [verb, desc] of subcommandRows(command)) {
+      lines.push(`complete -c xanosdk -n ${sq(condition)} -a ${sq(verb)} -d ${sq(desc)}`);
+    }
+  }
+  lines.push("");
+  for (const scope of scopes()) {
+    if (scope.flags.length === 0 && !scope.paths && scope.values.length === 0) continue;
+    const condition = `__xanosdk_scope_is ${sq(scope.key)}`;
+    const values = new Map(scope.valued);
+    const kinds = new Map(scope.kinds);
+    for (const token of scope.flags) lines.push(fishFlagLine(condition, token, valueFlags, values.get(token), kinds.get(token)));
+    if (scope.values.length > 0) {
+      lines.push(`complete -c xanosdk -n ${sq(condition)} -a ${sq(scope.values.join(" "))}`);
+    }
+    if (PROFILE_NAME_VERBS.some((v) => scope.key === `profile ${v}`)) {
+      lines.push(`complete -c xanosdk -n ${sq(condition)} -a '(__xanosdk_profiles)'`);
+    }
+    if (ENGINE_NAME_VERBS.some((v) => scope.key === `local-engine ${v}`)) {
+      lines.push(`complete -c xanosdk -n ${sq(condition)} -a '(__xanosdk_engines)'`);
+    }
+    if (scope.paths) lines.push(`complete -c xanosdk -n ${sq(condition)} -F`);
+  }
+  return lines.join("\n") + "\n";
+}
+function fishFlagLine(condition, token, valueFlags, set, kind) {
+  const bare = token.replace(/^-+/, "");
+  const which = token.startsWith("--") ? "-l" : "-s";
+  const cond = /^[a-z_]+$/.test(condition) ? condition : sq(condition);
+  const suffix = set !== void 0 ? ` -x -a ${sq(set.join(" "))}` : kind === "profile" || token === "-p" || token === "--profile" ? " -x -a '(__xanosdk_profiles)'" : kind === "file" ? " -r -F" : kind === "dir" ? " -x -a '(__xanosdk_dirs)'" : valueFlags.has(token) || kind === "free" ? " -x" : "";
+  return `complete -c xanosdk -n ${cond} ${which} ${sq(bare)}${suffix}`;
+}
+function renderCompletion(shell) {
+  switch (shell) {
+    case "bash":
+      return renderBash();
+    case "zsh":
+      return renderZsh();
+    case "fish":
+      return renderFish();
+  }
+}
+function runCompletionCommand(shell) {
+  process.stdout.write(renderCompletion(shell));
+}
+export {
+  COMPLETION_SHELLS,
+  ENGINE_RECORDS,
+  UNSUPPORTED_SHELLS,
+  inlineValueKind,
+  isCompletionShell,
+  renderCompletion,
+  runCompletionCommand,
+  valueKind
+};
+//# sourceMappingURL=completion-ZQLO6PB6.js.map