chore: make deps

.drone.yml

@@ -49,6 +49,31 @@ steps:
     depends_on:
       - make check
 
+  - name: fetch
+    image: docker:git
+    commands:
+      - git fetch --tags
+    depends_on:
+      - make check
+      - make test
+    when:
+      event: tag
+
+  - name: release
+    image: goreleaser/goreleaser:v2.5.1
+    environment:
+      GITEA_TOKEN:
+        from_secret: goreleaser_gitea_token
+    volumes:
+      - name: deps
+        path: /go
+    commands:
+      - goreleaser release
+    depends_on:
+      - fetch
+    when:
+      event: tag
+
   - name: publish image
     image: plugins/docker
     settings:

.goreleaser.yml

@@ -1,6 +1,4 @@
 ---
-version: 2
-
 gitea_urls:
   api: https://git.coopcloud.tech/api/v1
   download: https://git.coopcloud.tech/
@@ -28,9 +26,6 @@ builds:
       - 5
       - 6
       - 7
-    flags:
-      - -v
-      - -trimpath
     ldflags:
       - "-X 'main.Commit={{ .Commit }}'"
       - "-X 'main.Version={{ .Version }}'"

AUTHORS.md

@@ -10,17 +10,14 @@
 - cassowary
 - chasqui
 - codegod100
-- cyrnel
 - decentral1se
 - fauno
 - frando
 - iexos
-- jade
 - kawaiipunk
 - knoflook
 - mayel
 - moritz
-- namnatulco
 - p4u1
 - rix
 - roxxers

Makefile

@@ -5,7 +5,6 @@ GOPATH       := $(shell go env GOPATH)
 GOVERSION    := 1.24
 LDFLAGS      := "-X 'main.Commit=$(COMMIT)'"
 DIST_LDFLAGS := $(LDFLAGS)" -s -w"
-BFLAGS       := -v -trimpath
 GCFLAGS      := "all=-l -B"
 DOMAIN       := abra
 POFILES      := $(wildcard pkg/i18n/locales/*.po)
@@ -23,7 +22,7 @@ install:
 	@go install -gcflags=$(GCFLAGS) -ldflags=$(LDFLAGS) $(ABRA)
 
 build:
-	@go build $(BFLAGS) -gcflags=$(GCFLAGS) -ldflags=$(DIST_LDFLAGS) $(ABRA)
+	@go build -v -gcflags=$(GCFLAGS) -ldflags=$(DIST_LDFLAGS) $(ABRA)
 
 build-docker:
 	@docker run -it -v $(PWD):/abra golang:$(GOVERSION) \
@@ -86,6 +85,3 @@ build-mo:
 	for lang in $(POFILES); do \
 		msgfmt $$lang -o $$(echo $$lang | sed 's/.po/.mo/g') --statistics; \
 	done
-
-release:
-	@goreleaser release --clean

cli/app/deploy.go

@@ -10,7 +10,6 @@ import (
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/secret"
-	"coopcloud.tech/tagcmp"
 
 	appPkg "coopcloud.tech/abra/pkg/app"
 	"coopcloud.tech/abra/pkg/client"
@@ -108,15 +107,6 @@ checkout as-is. Recipe commit hashes are also supported as values for
 			log.Fatal(err)
 		}
 
-		isChaosCommit, err := app.Recipe.IsChaosCommit(toDeployVersion)
-		if err != nil {
-			log.Fatal(i18n.G("unable to determine if %s is a chaos commit: %s", toDeployVersion, err))
-		}
-
-		if !isChaosCommit && !tagcmp.IsParsable(toDeployVersion) {
-			log.Fatal(i18n.G("unable to parse deploy version: %s", toDeployVersion))
-		}
-
 		if !internal.Chaos {
 			isChaosCommit, err := app.Recipe.EnsureVersion(toDeployVersion)
 			if err != nil {
@@ -291,21 +281,13 @@ checkout as-is. Recipe commit hashes are also supported as values for
 }
 
 func getLatestVersionOrCommit(app appPkg.App) (string, error) {
-	recipeVersions, warnings, err := app.Recipe.GetRecipeVersions()
+	versions, err := app.Recipe.Tags()
 	if err != nil {
 		return "", err
 	}
 
-	for _, warning := range warnings {
-		log.Warn(warning)
-	}
-
-	if len(recipeVersions) > 0 && !internal.Chaos {
-		latest := recipeVersions[len(recipeVersions)-1]
-		for tag := range latest {
-			log.Debug(i18n.G("selected latest recipe version: %s (from %d available versions)", tag, len(recipeVersions)))
-			return tag, nil
-		}
+	if len(versions) > 0 && !internal.Chaos {
+		return versions[len(versions)-1], nil
 	}
 
 	head, err := app.Recipe.Head()

cli/app/list.go

@@ -113,10 +113,6 @@ Use "--status/-S" flag to query all servers for the live deployment status.`),
 				totalAppsCount++
 
 				if status {
-					if err := app.Recipe.Ensure(internal.GetEnsureContext()); err != nil {
-						log.Fatal(err)
-					}
-
 					status := i18n.G("unknown")
 					version := i18n.G("unknown")
 					chaos := i18n.G("unknown")
@@ -329,14 +325,6 @@ func init() {
 		i18n.G("show apps of a specific server"),
 	)
 
-	AppListCommand.Flags().BoolVarP(
-		&internal.Chaos,
-		i18n.G("chaos"),
-		i18n.G("C"),
-		false,
-		i18n.G("ignore uncommitted recipes changes"),
-	)
-
 	AppListCommand.RegisterFlagCompletionFunc(
 		i18n.G("server"),
 		func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

cli/app/new.go

@@ -72,10 +72,6 @@ var AppNewCommand = &cobra.Command{
 	Run: func(cmd *cobra.Command, args []string) {
 		recipe := internal.ValidateRecipe(args, cmd.Name())
 
-		if err := recipe.Ensure(internal.GetEnsureContext()); err != nil {
-			log.Fatal(err)
-		}
-
 		if len(args) == 2 && internal.Chaos {
 			log.Fatal(i18n.G("cannot use [version] and --chaos together"))
 		}
@@ -102,14 +98,10 @@ var AppNewCommand = &cobra.Command{
 			var recipeVersions recipePkg.RecipeVersions
 			if recipeVersion == "" {
 				var err error
-				var warnings []string
-				recipeVersions, warnings, err = recipe.GetRecipeVersions()
+				recipeVersions, _, err = recipe.GetRecipeVersions()
 				if err != nil {
 					log.Fatal(err)
 				}
-				for _, warning := range warnings {
-					log.Warn(warning)
-				}
 			}
 
 			if len(recipeVersions) > 0 {
@@ -118,8 +110,6 @@ var AppNewCommand = &cobra.Command{
 					recipeVersion = tag
 				}
 
-				log.Debug(i18n.G("selected recipe version: %s (from %d available versions)", recipeVersion, len(recipeVersions)))
-
 				if _, err := recipe.EnsureVersion(recipeVersion); err != nil {
 					log.Fatal(err)
 				}

cli/internal/deploy.go

@@ -127,7 +127,7 @@ func DeployOverview(
 	}
 
 	response := false
-	prompt := &survey.Confirm{Message: i18n.G("proceed?")}
+	prompt := &survey.Confirm{Message: "proceed?"}
 	if err := survey.AskOne(prompt, &response); err != nil {
 		return err
 	}

cli/recipe/release.go

@@ -14,7 +14,7 @@ import (
 	gitPkg "coopcloud.tech/abra/pkg/git"
 	"coopcloud.tech/abra/pkg/i18n"
 	"coopcloud.tech/abra/pkg/log"
-	recipePkg "coopcloud.tech/abra/pkg/recipe"
+	"coopcloud.tech/abra/pkg/recipe"
 	"coopcloud.tech/tagcmp"
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/distribution/reference"
@@ -23,9 +23,6 @@ import (
 	"github.com/spf13/cobra"
 )
 
-// Errors
-var errEmptyVersionsInCatalogue = errors.New(i18n.G("catalogue versions list is unexpectedly empty"))
-
 // translators: `abra recipe release` aliases. use a comma separated list of
 // aliases with no spaces in between
 var recipeReleaseAliases = i18n.G("rl")
@@ -53,7 +50,7 @@ recipe updates are properly communicated. I.e. developers of an app might
 publish a minor version but that might lead to changes in the recipe which are
 major and therefore require intervention while doing the upgrade work.
 
-This command will publish your new release to git.coopcloud.tech. This
+Publish your new release to git.coopcloud.tech with "--publish/-p". This
 requires that you have permission to git push to these repositories and have
 your SSH keys configured on your account. Enable ssh-agent and make sure to add
 your private key and enter your passphrase beforehand.
@@ -63,13 +60,12 @@ your private key and enter your passphrase beforehand.
 	Example: `  # publish release
   eval ` + "`ssh-agent`" + `
   ssh-add ~/.ssh/id_ed25519
-  abra recipe release gitea`,
+  abra recipe release gitea -p`,
 	Args: cobra.RangeArgs(1, 2),
 	ValidArgsFunction: func(
 		cmd *cobra.Command,
 		args []string,
-		toComplete string,
-	) ([]string, cobra.ShellCompDirective) {
+		toComplete string) ([]string, cobra.ShellCompDirective) {
 		switch l := len(args); l {
 		case 0:
 			return autocomplete.RecipeNameComplete()
@@ -97,6 +93,21 @@ your private key and enter your passphrase beforehand.
 			log.Fatal(i18n.G("main app service version for %s is empty?", recipe.Name))
 		}
 
+		var tagString string
+		if len(args) == 2 {
+			tagString = args[1]
+		}
+
+		if tagString != "" {
+			if _, err := tagcmp.Parse(tagString); err != nil {
+				log.Fatal(i18n.G("cannot parse %s, invalid tag specified?", tagString))
+			}
+		}
+
+		if (internal.Major || internal.Minor || internal.Patch) && tagString != "" {
+			log.Fatal(i18n.G("cannot specify tag and bump type at the same time"))
+		}
+
 		repo, err := git.PlainOpen(recipe.Dir)
 		if err != nil {
 			log.Fatal(err)
@@ -107,13 +118,16 @@ your private key and enter your passphrase beforehand.
 			log.Fatal(err)
 		}
 
-		isClean, err := gitPkg.IsClean(recipe.Dir)
-		if err != nil {
-			log.Fatal(err)
-		}
-
-		if !isClean {
-			log.Fatal(i18n.G("working directory not clean in %s, aborting", recipe.Dir))
+		if tagString != "" {
+			if err := createReleaseFromTag(recipe, tagString, mainAppVersion); err != nil {
+				if cleanErr := cleanTag(recipe, tagString); cleanErr != nil {
+					log.Fatal(cleanErr)
+				}
+				if cleanErr := cleanCommit(recipe, preCommitHead); cleanErr != nil {
+					log.Fatal(cleanErr)
+				}
+				log.Fatal(err)
+			}
 		}
 
 		tags, err := recipe.Tags()
@@ -121,195 +135,67 @@ your private key and enter your passphrase beforehand.
 			log.Fatal(err)
 		}
 
-		var tagString string
-		if len(args) == 2 {
-			tagString = args[1]
-		}
-
-		if (internal.Major || internal.Minor || internal.Patch) && tagString != "" {
-			log.Fatal(i18n.G("cannot specify tag and bump type at the same time"))
-		}
-
-		if len(tags) == 0 && tagString == "" {
-			log.Warn(i18n.G("no git tags found for %s", recipe.Name))
-			if internal.NoInput {
-				log.Fatal(i18n.G("unable to continue, input required for initial version"))
-			}
-			fmt.Println(i18n.G(`
-The following options are two types of initial semantic version that you can
-pick for %s that will be published in the recipe catalogue. This follows the
-semver convention (more on https://semver.org), here is a short cheatsheet
-
-    0.1.0: development release, still hacking. when you make a major upgrade
-           you increment the "y" part (i.e. 0.1.0 -> 0.2.0) and only move to
-           using the "x" part when things are stable.
-
-    1.0.0: public release, assumed to be working. you already have a stable
-           and reliable deployment of this app and feel relatively confident
-           about it.
-
-If you want people to be able alpha test your current config for %s but don't
-think it is quite reliable, go with 0.1.0 and people will know that things are
-likely to change.
-
-`, recipe.Name, recipe.Name))
-			var chosenVersion string
-			edPrompt := &survey.Select{
-				Message: i18n.G("which version do you want to begin with?"),
-				Options: []string{"0.1.0", "1.0.0"},
-			}
-
-			if err := survey.AskOne(edPrompt, &chosenVersion); err != nil {
-				log.Fatal(err)
-			}
-
-			tagString = fmt.Sprintf("%s+%s", chosenVersion, mainAppVersion)
-		}
-
-		if tagString == "" && (!internal.Major && !internal.Minor && !internal.Patch) {
-
-			catl, err := recipePkg.ReadRecipeCatalogue(false)
-			if err != nil {
-				log.Fatal(err)
-			}
-
-			changesTable, err := formatter.CreateTable()
-			if err != nil {
-				log.Fatal(err)
-			}
-
-			latestRelease := tags[len(tags)-1]
-			latestRecipeVersion, err := getLatestVersion(recipe, catl)
-			if err != nil && err != errEmptyVersionsInCatalogue {
-				log.Fatal(err)
-			}
-			changesTable.Headers(i18n.G("SERVICE"), latestRelease, i18n.G("PROPOSED CHANGES"))
-
-			allRecipeVersions := catl[recipe.Name].Versions
-			for _, recipeVersion := range allRecipeVersions {
-				if serviceVersions, ok := recipeVersion[latestRecipeVersion]; ok {
-					for serviceName := range serviceVersions {
-						serviceMeta := serviceVersions[serviceName]
-
-						existingImageTag := fmt.Sprintf("%s:%s", serviceMeta.Image, serviceMeta.Tag)
-						newImageTag := fmt.Sprintf("%s:%s", serviceMeta.Image, imagesTmp[serviceMeta.Image])
-
-						if existingImageTag == newImageTag {
-							continue
-						}
-
-						changesTable.Row([]string{serviceName, existingImageTag, newImageTag}...)
-					}
-				}
-			}
-
-			changeOverview := changesTable.Render()
-
-			if err := internal.PromptBumpType("", latestRelease, changeOverview); err != nil {
-				log.Fatal(err)
-			}
-		}
-
-		if tagString == "" {
-			var lastGitTag tagcmp.Tag
-			iter, err := repo.Tags()
-			if err != nil {
-				log.Fatal(err)
-			}
-
-			if err := iter.ForEach(func(ref *plumbing.Reference) error {
-				obj, err := repo.TagObject(ref.Hash())
-				if err != nil {
-					log.Fatal(i18n.G("tag at commit %s is unannotated or otherwise broken", ref.Hash()))
-					return err
-				}
-
-				tagcmpTag, err := tagcmp.Parse(obj.Name)
-				if err != nil {
-					return err
-				}
-
-				if (lastGitTag == tagcmp.Tag{}) {
-					lastGitTag = tagcmpTag
-				} else if tagcmpTag.IsGreaterThan(lastGitTag) {
-					lastGitTag = tagcmpTag
-				}
-
-				return nil
-			}); err != nil {
-				log.Fatal(err)
-			}
-
-			// bumpType is used to decide what part of the tag should be incremented
-			bumpType := btoi(internal.Major)*4 + btoi(internal.Minor)*2 + btoi(internal.Patch)
-			if bumpType != 0 {
-				// a bitwise check if the number is a power of 2
-				if (bumpType & (bumpType - 1)) != 0 {
-					log.Fatal(i18n.G("you can only use one version flag: --major, --minor or --patch"))
-				}
-			}
-
-			newTag := lastGitTag
-			if bumpType > 0 {
-				if internal.Patch {
-					now, err := strconv.Atoi(newTag.Patch)
-					if err != nil {
-						log.Fatal(err)
-					}
-
-					newTag.Patch = strconv.Itoa(now + 1)
-				} else if internal.Minor {
-					now, err := strconv.Atoi(newTag.Minor)
-					if err != nil {
-						log.Fatal(err)
-					}
-
-					newTag.Patch = "0"
-					newTag.Minor = strconv.Itoa(now + 1)
-				} else if internal.Major {
-					now, err := strconv.Atoi(newTag.Major)
-					if err != nil {
-						log.Fatal(err)
-					}
-
-					newTag.Patch = "0"
-					newTag.Minor = "0"
-					newTag.Major = strconv.Itoa(now + 1)
-				}
-			}
-
-			newTag.Metadata = mainAppVersion
-			log.Debug(i18n.G("choosing %s as new version for %s", newTag.String(), recipe.Name))
-			tagString = newTag.String()
-		}
-
-		if _, err := tagcmp.Parse(tagString); err != nil {
-			log.Fatal(i18n.G("invalid version %s specified", tagString))
+		labelVersion, err := getLabelVersion(recipe, false)
+		if err != nil {
+			log.Fatal(err)
 		}
 
 		for _, tag := range tags {
 			previousTagLeftHand := strings.Split(tag, "+")[0]
-			newTagStringLeftHand := strings.Split(tagString, "+")[0]
+			newTagStringLeftHand := strings.Split(labelVersion, "+")[0]
 			if previousTagLeftHand == newTagStringLeftHand {
 				log.Fatal(i18n.G("%s+... conflicts with a previous release: %s", newTagStringLeftHand, tag))
 			}
 		}
 
-		if err := createReleaseFromTag(recipe, tagString, mainAppVersion); err != nil {
-			if cleanErr := cleanTag(recipe, tagString); cleanErr != nil {
-				log.Fatal(i18n.G("unable to clean up tag after failed release attempt: %s", cleanErr))
-			}
-			if resetErr := resetCommit(recipe, preCommitHead); resetErr != nil {
-				log.Fatal(i18n.G("unable to reset commit after failed release attempt: %s", resetErr))
-			}
-			log.Error(err)
-			log.Fatal(i18n.G("release failed. any changes made have been reverted"))
+		if tagString == "" && (!internal.Major && !internal.Minor && !internal.Patch) {
+			tagString = labelVersion
 		}
+
+		isClean, err := gitPkg.IsClean(recipe.Dir)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		if !isClean {
+			log.Info(i18n.G("%s currently has these unstaged changes 👇", recipe.Name))
+			if err := gitPkg.DiffUnstaged(recipe.Dir); err != nil {
+				log.Fatal(err)
+			}
+		}
+
+		if len(tags) > 0 {
+			log.Warn(i18n.G("previous git tags detected, assuming new semver release"))
+
+			if err := createReleaseFromPreviousTag(tagString, mainAppVersion, recipe, tags); err != nil {
+				if cleanErr := cleanTag(recipe, tagString); cleanErr != nil {
+					log.Fatal(cleanErr)
+				}
+				if cleanErr := cleanCommit(recipe, preCommitHead); cleanErr != nil {
+					log.Fatal(cleanErr)
+				}
+				log.Fatal(err)
+			}
+		} else {
+			log.Warn(i18n.G("no tag specified and no previous tag available for %s, assuming initial release", recipe.Name))
+
+			if err := createReleaseFromTag(recipe, tagString, mainAppVersion); err != nil {
+				if cleanErr := cleanTag(recipe, tagString); cleanErr != nil {
+					log.Fatal(cleanErr)
+				}
+				if cleanErr := cleanCommit(recipe, preCommitHead); cleanErr != nil {
+					log.Fatal(cleanErr)
+				}
+				log.Fatal(err)
+			}
+		}
+
+		return
 	},
 }
 
 // GetImageVersions retrieves image versions for a recipe
-func GetImageVersions(recipe recipePkg.Recipe) (map[string]string, error) {
+func GetImageVersions(recipe recipe.Recipe) (map[string]string, error) {
 	services := make(map[string]string)
 
 	config, err := recipe.GetComposeConfig(nil)
@@ -353,7 +239,7 @@ func GetImageVersions(recipe recipePkg.Recipe) (map[string]string, error) {
 }
 
 // createReleaseFromTag creates a new release based on a supplied recipe version string
-func createReleaseFromTag(recipe recipePkg.Recipe, tagString, mainAppVersion string) error {
+func createReleaseFromTag(recipe recipe.Recipe, tagString, mainAppVersion string) error {
 	var err error
 
 	repo, err := git.PlainOpen(recipe.Dir)
@@ -361,14 +247,23 @@ func createReleaseFromTag(recipe recipePkg.Recipe, tagString, mainAppVersion str
 		return err
 	}
 
-	mainService := "app"
-	label := fmt.Sprintf("coop-cloud.${STACK_NAME}.version=%s", tagString)
-	if !internal.Dry {
-		if err := recipe.UpdateLabel("compose.y*ml", mainService, label); err != nil {
-			log.Fatal(err)
-		}
-	} else {
-		log.Info(i18n.G("dry run: not syncing label %s for recipe %s", tagString, recipe.Name))
+	tag, err := tagcmp.Parse(tagString)
+	if err != nil {
+		return err
+	}
+
+	if tag.MissingMinor {
+		tag.Minor = "0"
+		tag.MissingMinor = false
+	}
+
+	if tag.MissingPatch {
+		tag.Patch = "0"
+		tag.MissingPatch = false
+	}
+
+	if tagString == "" {
+		tagString = fmt.Sprintf("%s+%s", tag.String(), mainAppVersion)
 	}
 
 	if err := addReleaseNotes(recipe, tagString); err != nil {
@@ -407,7 +302,7 @@ func getTagCreateOptions(tag string) (git.CreateTagOptions, error) {
 
 // addReleaseNotes checks if the release/next release note exists and moves the
 // file to release/<tag>.
-func addReleaseNotes(recipe recipePkg.Recipe, tag string) error {
+func addReleaseNotes(recipe recipe.Recipe, tag string) error {
 	releaseDir := path.Join(recipe.Dir, "release")
 	if _, err := os.Stat(releaseDir); errors.Is(err, os.ErrNotExist) {
 		if err := os.Mkdir(releaseDir, 0755); err != nil {
@@ -492,7 +387,7 @@ func addReleaseNotes(recipe recipePkg.Recipe, tag string) error {
 	return nil
 }
 
-func commitRelease(recipe recipePkg.Recipe, tag string) error {
+func commitRelease(recipe recipe.Recipe, tag string) error {
 	if internal.Dry {
 		log.Debug(i18n.G("dry run: no changes committed"))
 		return nil
@@ -544,30 +439,140 @@ func tagRelease(tagString string, repo *git.Repository) error {
 	return nil
 }
 
-func pushRelease(recipe recipePkg.Recipe, tagString string) error {
+func pushRelease(recipe recipe.Recipe, tagString string) error {
 	if internal.Dry {
 		log.Info(i18n.G("dry run: no changes published"))
 		return nil
 	}
 
-	if os.Getenv("SSH_AUTH_SOCK") == "" {
-		return errors.New(i18n.G("ssh-agent not found. see \"abra recipe release --help\" and try again"))
+	if !publish && !internal.NoInput {
+		prompt := &survey.Confirm{
+			Message: i18n.G("publish new release?"),
+		}
+
+		if err := survey.AskOne(prompt, &publish); err != nil {
+			return err
+		}
 	}
 
-	if err := recipe.Push(internal.Dry); err != nil {
-		return err
-	}
+	if publish {
+		if os.Getenv("SSH_AUTH_SOCK") == "" {
+			return errors.New(i18n.G("ssh-agent not found. see \"abra recipe release --help\" and try again"))
+		}
 
-	url := fmt.Sprintf("%s/src/tag/%s", recipe.GitURL, tagString)
-	log.Info(i18n.G("new release published: %s", url))
+		if err := recipe.Push(internal.Dry); err != nil {
+			return err
+		}
+
+		url := fmt.Sprintf("%s/src/tag/%s", recipe.GitURL, tagString)
+		log.Info(i18n.G("new release published: %s", url))
+	} else {
+		log.Info(i18n.G("no -p/--publish passed, not publishing"))
+	}
 
 	return nil
 }
 
-// resetCommit hard resets to the state before release was started.
-// This will only remove changes made by the release process due to requiring
-// a clean working directory.
-func resetCommit(recipe recipePkg.Recipe, head *plumbing.Reference) error {
+func createReleaseFromPreviousTag(tagString, mainAppVersion string, recipe recipe.Recipe, tags []string) error {
+	repo, err := git.PlainOpen(recipe.Dir)
+	if err != nil {
+		return err
+	}
+
+	bumpType := btoi(internal.Major)*4 + btoi(internal.Minor)*2 + btoi(internal.Patch)
+	if bumpType != 0 {
+		if (bumpType & (bumpType - 1)) != 0 {
+			return errors.New(i18n.G("you can only use one of: --major, --minor, --patch"))
+		}
+	}
+
+	var lastGitTag tagcmp.Tag
+	for _, tag := range tags {
+		parsed, err := tagcmp.Parse(tag)
+		if err != nil {
+			return err
+		}
+
+		if (lastGitTag == tagcmp.Tag{}) {
+			lastGitTag = parsed
+		} else if parsed.IsGreaterThan(lastGitTag) {
+			lastGitTag = parsed
+		}
+	}
+
+	newTag := lastGitTag
+	if internal.Patch {
+		now, err := strconv.Atoi(newTag.Patch)
+		if err != nil {
+			return err
+		}
+
+		newTag.Patch = strconv.Itoa(now + 1)
+	} else if internal.Minor {
+		now, err := strconv.Atoi(newTag.Minor)
+		if err != nil {
+			return err
+		}
+
+		newTag.Patch = "0"
+		newTag.Minor = strconv.Itoa(now + 1)
+	} else if internal.Major {
+		now, err := strconv.Atoi(newTag.Major)
+		if err != nil {
+			return err
+		}
+
+		newTag.Patch = "0"
+		newTag.Minor = "0"
+		newTag.Major = strconv.Itoa(now + 1)
+	}
+
+	if internal.Major || internal.Minor || internal.Patch {
+		newTag.Metadata = mainAppVersion
+		tagString = newTag.String()
+	}
+
+	if lastGitTag.String() == tagString {
+		return errors.New(i18n.G("latest git tag (%s) and synced label (%s) are the same?", lastGitTag, tagString))
+	}
+
+	if !internal.NoInput {
+		prompt := &survey.Confirm{
+			Message: i18n.G("current: %s, new: %s, correct?", lastGitTag, tagString),
+		}
+
+		var ok bool
+		if err := survey.AskOne(prompt, &ok); err != nil {
+			return err
+		}
+
+		if !ok {
+			return errors.New(i18n.G("exiting as requested"))
+		}
+	}
+
+	if err := addReleaseNotes(recipe, tagString); err != nil {
+		return errors.New(i18n.G("failed to add release notes: %s", err.Error()))
+	}
+
+	if err := commitRelease(recipe, tagString); err != nil {
+		return errors.New(i18n.G("failed to commit changes: %s", err.Error()))
+	}
+
+	if err := tagRelease(tagString, repo); err != nil {
+		return errors.New(i18n.G("failed to tag release: %s", err.Error()))
+	}
+
+	if err := pushRelease(recipe, tagString); err != nil {
+		return errors.New(i18n.G("failed to publish new release: %s", err.Error()))
+	}
+
+	return nil
+}
+
+// cleanCommit soft removes the latest release commit. No change are lost the
+// the commit itself is removed. This is the equivalent of `git reset HEAD~1`.
+func cleanCommit(recipe recipe.Recipe, head *plumbing.Reference) error {
 	repo, err := git.PlainOpen(recipe.Dir)
 	if err != nil {
 		return errors.New(i18n.G("unable to open repo in %s: %s", recipe.Dir, err))
@@ -578,18 +583,18 @@ func resetCommit(recipe recipePkg.Recipe, head *plumbing.Reference) error {
 		return errors.New(i18n.G("unable to open work tree in %s: %s", recipe.Dir, err))
 	}
 
-	opts := &git.ResetOptions{Commit: head.Hash(), Mode: git.HardReset}
+	opts := &git.ResetOptions{Commit: head.Hash(), Mode: git.MixedReset}
 	if err := worktree.Reset(opts); err != nil {
-		return errors.New(i18n.G("unable to hard reset %s: %s", recipe.Dir, err))
+		return errors.New(i18n.G("unable to soft reset %s: %s", recipe.Dir, err))
 	}
 
-	log.Debug(i18n.G("reset commit to pre-release state"))
+	log.Debug(i18n.G("removed freshly created commit"))
 
 	return nil
 }
 
 // cleanTag removes a freshly created tag
-func cleanTag(recipe recipePkg.Recipe, tag string) error {
+func cleanTag(recipe recipe.Recipe, tag string) error {
 	repo, err := git.PlainOpen(recipe.Dir)
 	if err != nil {
 		return errors.New(i18n.G("unable to open repo in %s: %s", recipe.Dir, err))
@@ -606,17 +611,37 @@ func cleanTag(recipe recipePkg.Recipe, tag string) error {
 	return nil
 }
 
-func getLatestVersion(recipe recipePkg.Recipe, catl recipePkg.RecipeCatalogue) (string, error) {
-	versions, err := recipePkg.GetRecipeCatalogueVersions(recipe.Name, catl)
+func getLabelVersion(recipe recipe.Recipe, prompt bool) (string, error) {
+	initTag, err := recipe.GetVersionLabelLocal()
 	if err != nil {
 		return "", err
 	}
-	if len(versions) > 0 {
-		return versions[len(versions)-1], nil
+
+	if initTag == "" {
+		return "", errors.New(i18n.G("unable to read version for %s from synced label. Did you try running \"abra recipe sync %s\" already?", recipe.Name, recipe.Name))
 	}
-	return "", errEmptyVersionsInCatalogue
+
+	log.Warn(i18n.G("discovered %s as currently synced recipe label", initTag))
+
+	if prompt && !internal.NoInput {
+		var response bool
+		prompt := &survey.Confirm{Message: i18n.G("use %s as the new version?", initTag)}
+		if err := survey.AskOne(prompt, &response); err != nil {
+			return "", err
+		}
+
+		if !response {
+			return "", errors.New(i18n.G("please fix your synced label for %s and re-run this command", recipe.Name))
+		}
+	}
+
+	return initTag, nil
 }
 
+var (
+	publish bool
+)
+
 func init() {
 	RecipeReleaseCommand.Flags().BoolVarP(
 		&internal.Dry,
@@ -649,4 +674,12 @@ func init() {
 		false,
 		i18n.G("increase the patch part of the version"),
 	)
+
+	RecipeReleaseCommand.Flags().BoolVarP(
+		&publish,
+		i18n.G("publish"),
+		i18n.G("p"),
+		false,
+		i18n.G("publish changes to git.coopcloud.tech"),
+	)
 }

cli/recipe/release_test.go

@@ -1,33 +0,0 @@
-package recipe
-
-import (
-	"testing"
-
-	recipePkg "coopcloud.tech/abra/pkg/recipe"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestGetLatestVersionReturnsErrorWhenVersionsIsEmpty(t *testing.T) {
-	recipe := recipePkg.Recipe{}
-	catalogue := recipePkg.RecipeCatalogue{}
-	_, err := getLatestVersion(recipe, catalogue)
-	assert.Equal(t, err, errEmptyVersionsInCatalogue)
-}
-
-func TestGetLatestVersionReturnsLastVersion(t *testing.T) {
-	recipe := recipePkg.Recipe{
-		Name: "test",
-	}
-	versions := []map[string]map[string]recipePkg.ServiceMeta{
-		make(map[string]map[string]recipePkg.ServiceMeta),
-		make(map[string]map[string]recipePkg.ServiceMeta),
-	}
-	versions[0]["0.0.3"] = make(map[string]recipePkg.ServiceMeta)
-	versions[1]["0.0.2"] = make(map[string]recipePkg.ServiceMeta)
-	catalogue := make(recipePkg.RecipeCatalogue)
-	catalogue["test"] = recipePkg.RecipeMeta{
-		Versions: versions,
-	}
-	version, _ := getLatestVersion(recipe, catalogue)
-	assert.Equal(t, version, "0.0.3")
-}

cli/recipe/sync.go

@@ -0,0 +1,300 @@
+package recipe
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	"coopcloud.tech/abra/cli/internal"
+	"coopcloud.tech/abra/pkg/autocomplete"
+	"coopcloud.tech/abra/pkg/formatter"
+	gitPkg "coopcloud.tech/abra/pkg/git"
+	"coopcloud.tech/abra/pkg/i18n"
+	"coopcloud.tech/abra/pkg/log"
+	recipePkg "coopcloud.tech/abra/pkg/recipe"
+	"coopcloud.tech/tagcmp"
+	"github.com/AlecAivazis/survey/v2"
+	"github.com/go-git/go-git/v5"
+	"github.com/go-git/go-git/v5/plumbing"
+	"github.com/spf13/cobra"
+)
+
+// translators: `abra recipe reset` aliases. use a comma separated list of
+// aliases with no spaces in between
+var recipeSyncAliases = i18n.G("s")
+
+var RecipeSyncCommand = &cobra.Command{
+	// translators: `recipe sync` command
+	Use:     i18n.G("sync <recipe> [version] [flags]"),
+	Aliases: strings.Split(recipeSyncAliases, ","),
+	// translators: Short description for `recipe sync` command
+	Short: i18n.G("Sync recipe version label"),
+	Long: i18n.G(`Generate labels for the main recipe service.
+
+By convention, the service named "app" using the following format:
+
+    coop-cloud.${STACK_NAME}.version=<version>
+
+Where [version] can be specifed on the command-line or Abra can attempt to
+auto-generate it for you. The <recipe> configuration will be updated on the
+local file system.`),
+	Args: cobra.RangeArgs(1, 2),
+	ValidArgsFunction: func(
+		cmd *cobra.Command,
+		args []string,
+		toComplete string) ([]string, cobra.ShellCompDirective) {
+		switch l := len(args); l {
+		case 0:
+			return autocomplete.RecipeNameComplete()
+		case 1:
+			return autocomplete.RecipeVersionComplete(args[0])
+		default:
+			return nil, cobra.ShellCompDirectiveError
+		}
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		recipe := internal.ValidateRecipe(args, cmd.Name())
+
+		mainApp, err := internal.GetMainAppImage(recipe)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		imagesTmp, err := GetImageVersions(recipe)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		mainAppVersion := imagesTmp[mainApp]
+
+		tags, err := recipe.Tags()
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		var nextTag string
+		if len(args) == 2 {
+			nextTag = args[1]
+		}
+
+		if len(tags) == 0 && nextTag == "" {
+			log.Warn(i18n.G("no git tags found for %s", recipe.Name))
+			if internal.NoInput {
+				log.Fatal(i18n.G("unable to continue, input required for initial version"))
+			}
+			fmt.Println(i18n.G(`
+The following options are two types of initial semantic version that you can
+pick for %s that will be published in the recipe catalogue. This follows the
+semver convention (more on https://semver.org), here is a short cheatsheet
+
+    0.1.0: development release, still hacking. when you make a major upgrade
+           you increment the "y" part (i.e. 0.1.0 -> 0.2.0) and only move to
+           using the "x" part when things are stable.
+
+    1.0.0: public release, assumed to be working. you already have a stable
+           and reliable deployment of this app and feel relatively confident
+           about it.
+
+If you want people to be able alpha test your current config for %s but don't
+think it is quite reliable, go with 0.1.0 and people will know that things are
+likely to change.
+
+`, recipe.Name, recipe.Name))
+			var chosenVersion string
+			edPrompt := &survey.Select{
+				Message: i18n.G("which version do you want to begin with?"),
+				Options: []string{"0.1.0", "1.0.0"},
+			}
+
+			if err := survey.AskOne(edPrompt, &chosenVersion); err != nil {
+				log.Fatal(err)
+			}
+
+			nextTag = fmt.Sprintf("%s+%s", chosenVersion, mainAppVersion)
+		}
+
+		if nextTag == "" && (!internal.Major && !internal.Minor && !internal.Patch) {
+			var changeOverview string
+
+			catl, err := recipePkg.ReadRecipeCatalogue(false)
+			if err != nil {
+				log.Fatal(err)
+			}
+
+			versions, err := recipePkg.GetRecipeCatalogueVersions(recipe.Name, catl)
+			if err != nil {
+				log.Fatal(err)
+			}
+
+			changesTable, err := formatter.CreateTable()
+			if err != nil {
+				log.Fatal(err)
+			}
+
+			latestRelease := tags[len(tags)-1]
+			changesTable.Headers(i18n.G("SERVICE"), latestRelease, i18n.G("PROPOSED CHANGES"))
+
+			latestRecipeVersion := versions[len(versions)-1]
+			allRecipeVersions := catl[recipe.Name].Versions
+			for _, recipeVersion := range allRecipeVersions {
+				if serviceVersions, ok := recipeVersion[latestRecipeVersion]; ok {
+					for serviceName := range serviceVersions {
+						serviceMeta := serviceVersions[serviceName]
+
+						existingImageTag := fmt.Sprintf("%s:%s", serviceMeta.Image, serviceMeta.Tag)
+						newImageTag := fmt.Sprintf("%s:%s", serviceMeta.Image, imagesTmp[serviceMeta.Image])
+
+						if existingImageTag == newImageTag {
+							continue
+						}
+
+						changesTable.Row([]string{serviceName, existingImageTag, newImageTag}...)
+					}
+				}
+			}
+
+			changeOverview = changesTable.Render()
+
+			if err := internal.PromptBumpType("", latestRelease, changeOverview); err != nil {
+				log.Fatal(err)
+			}
+		}
+
+		if nextTag == "" {
+			repo, err := git.PlainOpen(recipe.Dir)
+			if err != nil {
+				log.Fatal(err)
+			}
+
+			var lastGitTag tagcmp.Tag
+			iter, err := repo.Tags()
+			if err != nil {
+				log.Fatal(err)
+			}
+
+			if err := iter.ForEach(func(ref *plumbing.Reference) error {
+				obj, err := repo.TagObject(ref.Hash())
+				if err != nil {
+					log.Fatal(i18n.G("tag at commit %s is unannotated or otherwise broken", ref.Hash()))
+					return err
+				}
+
+				tagcmpTag, err := tagcmp.Parse(obj.Name)
+				if err != nil {
+					return err
+				}
+
+				if (lastGitTag == tagcmp.Tag{}) {
+					lastGitTag = tagcmpTag
+				} else if tagcmpTag.IsGreaterThan(lastGitTag) {
+					lastGitTag = tagcmpTag
+				}
+
+				return nil
+			}); err != nil {
+				log.Fatal(err)
+			}
+
+			// bumpType is used to decide what part of the tag should be incremented
+			bumpType := btoi(internal.Major)*4 + btoi(internal.Minor)*2 + btoi(internal.Patch)
+			if bumpType != 0 {
+				// a bitwise check if the number is a power of 2
+				if (bumpType & (bumpType - 1)) != 0 {
+					log.Fatal(i18n.G("you can only use one version flag: --major, --minor or --patch"))
+				}
+			}
+
+			newTag := lastGitTag
+			if bumpType > 0 {
+				if internal.Patch {
+					now, err := strconv.Atoi(newTag.Patch)
+					if err != nil {
+						log.Fatal(err)
+					}
+
+					newTag.Patch = strconv.Itoa(now + 1)
+				} else if internal.Minor {
+					now, err := strconv.Atoi(newTag.Minor)
+					if err != nil {
+						log.Fatal(err)
+					}
+
+					newTag.Patch = "0"
+					newTag.Minor = strconv.Itoa(now + 1)
+				} else if internal.Major {
+					now, err := strconv.Atoi(newTag.Major)
+					if err != nil {
+						log.Fatal(err)
+					}
+
+					newTag.Patch = "0"
+					newTag.Minor = "0"
+					newTag.Major = strconv.Itoa(now + 1)
+				}
+			}
+
+			newTag.Metadata = mainAppVersion
+			log.Debug(i18n.G("choosing %s as new version for %s", newTag.String(), recipe.Name))
+			nextTag = newTag.String()
+		}
+
+		if _, err := tagcmp.Parse(nextTag); err != nil {
+			log.Fatal(i18n.G("invalid version %s specified", nextTag))
+		}
+
+		mainService := "app"
+		label := i18n.G("coop-cloud.${STACK_NAME}.version=%s", nextTag)
+		if !internal.Dry {
+			if err := recipe.UpdateLabel("compose.y*ml", mainService, label); err != nil {
+				log.Fatal(err)
+			}
+		} else {
+			log.Info(i18n.G("dry run: not syncing label %s for recipe %s", nextTag, recipe.Name))
+		}
+
+		isClean, err := gitPkg.IsClean(recipe.Dir)
+		if err != nil {
+			log.Fatal(err)
+		}
+		if !isClean {
+			log.Info(i18n.G("%s currently has these unstaged changes 👇", recipe.Name))
+			if err := gitPkg.DiffUnstaged(recipe.Dir); err != nil {
+				log.Fatal(err)
+			}
+		}
+	},
+}
+
+func init() {
+	RecipeSyncCommand.Flags().BoolVarP(
+		&internal.Dry,
+		i18n.G("dry-run"),
+		i18n.G("r"),
+		false,
+		i18n.G("report changes that would be made"),
+	)
+
+	RecipeSyncCommand.Flags().BoolVarP(
+		&internal.Major,
+		i18n.G("major"),
+		i18n.G("x"),
+		false,
+		i18n.G("increase the major part of the version"),
+	)
+
+	RecipeSyncCommand.Flags().BoolVarP(
+		&internal.Minor,
+		i18n.G("minor"),
+		i18n.G("y"),
+		false,
+		i18n.G("increase the minor part of the version"),
+	)
+
+	RecipeSyncCommand.Flags().BoolVarP(
+		&internal.Patch,
+		i18n.G("patch"),
+		i18n.G("z"),
+		false,
+		i18n.G("increase the patch part of the version"),
+	)
+}

cli/recipe/upgrade.go

@@ -57,13 +57,14 @@ is up to the end-user to decide.
 
 The command is interactive and will show a select input which allows you to
 make a seclection. Use the "?" key to see more help on navigating this
-interface.`),
+interface.
+
+You may invoke this command in "wizard" mode and be prompted for input.`),
 	Args: cobra.RangeArgs(0, 1),
 	ValidArgsFunction: func(
 		cmd *cobra.Command,
 		args []string,
-		toComplete string,
-	) ([]string, cobra.ShellCompDirective) {
+		toComplete string) ([]string, cobra.ShellCompDirective) {
 		return autocomplete.RecipeNameComplete()
 	},
 	Run: func(cmd *cobra.Command, args []string) {
@@ -336,37 +337,12 @@ interface.`),
 			if err := gitPkg.DiffUnstaged(recipe.Dir); err != nil {
 				log.Fatal(err)
 			}
-
-			if !internal.NoInput && !createCommit {
-				prompt := &survey.Confirm{
-					Message: i18n.G("commit changes?"),
-					Default: true,
-				}
-
-				if err := survey.AskOne(prompt, &createCommit); err != nil {
-					log.Fatal(err)
-				}
-			}
-
-			if createCommit {
-				msg := i18n.G("chore: update image tags")
-				if err := gitPkg.Commit(recipe.Dir, msg, internal.Dry); err != nil {
-					log.Fatal(err)
-				}
-				log.Info(i18n.G("committed changes as '%s'", msg))
-			}
-
-		} else {
-			if createCommit {
-				log.Warn(i18n.G("no changes, skip creating commit"))
-			}
 		}
 	},
 }
 
 var (
-	allTags      bool
-	createCommit bool
+	allTags bool
 )
 
 func init() {
@@ -409,12 +385,4 @@ func init() {
 		false,
 		i18n.G("list all tags, not just upgrades"),
 	)
-
-	RecipeUpgradeCommand.Flags().BoolVarP(
-		&createCommit,
-		i18n.G("commit"),
-		i18n.GC("c", "recipe upgrade"),
-		false,
-		i18n.G("commit changes"),
-	)
 }

cli/run.go

@@ -187,20 +187,28 @@ Config:
 
 	rootCmd.PersistentFlags().BoolVarP(
 		&internal.Debug,
-		i18n.G("debug"),
-		i18n.G("d"),
+		"debug",
+		"d",
 		false,
 		i18n.G("show debug messages"),
 	)
 
 	rootCmd.PersistentFlags().BoolVarP(
 		&internal.NoInput,
-		i18n.G("no-input"),
-		i18n.G("n"),
+		"no-input",
+		"n",
 		false,
 		i18n.G("toggle non-interactive mode"),
 	)
 
+	rootCmd.PersistentFlags().BoolVarP(
+		&internal.Offline,
+		"offline",
+		"o",
+		false,
+		i18n.G("prefer offline & filesystem access"),
+	)
+
 	rootCmd.PersistentFlags().BoolVarP(
 		&internal.Help,
 		i18n.G("help"),
@@ -209,14 +217,6 @@ Config:
 		i18n.G("help for abra"),
 	)
 
-	rootCmd.PersistentFlags().BoolVarP(
-		&internal.Offline,
-		i18n.G("offline"),
-		i18n.G("o"),
-		false,
-		i18n.G("prefer offline & filesystem access"),
-	)
-
 	rootCmd.Flags().BoolVarP(
 		&internal.Version,
 		i18n.G("version"),
@@ -245,6 +245,7 @@ Config:
 		recipe.RecipeNewCommand,
 		recipe.RecipeReleaseCommand,
 		recipe.RecipeResetCommand,
+		recipe.RecipeSyncCommand,
 		recipe.RecipeUpgradeCommand,
 		recipe.RecipeVersionCommand,
 	)

go.mod

@@ -1,8 +1,6 @@
 module coopcloud.tech/abra
 
-go 1.24.0
-
-toolchain go1.24.1
+go 1.24.2
 
 require (
 	coopcloud.tech/tagcmp v0.0.0-20250818180036-0ec1b205b5ca
@@ -12,17 +10,17 @@ require (
 	github.com/charmbracelet/lipgloss v1.1.0
 	github.com/charmbracelet/log v0.4.2
 	github.com/distribution/reference v0.6.0
-	github.com/docker/cli v28.4.0+incompatible
+	github.com/docker/cli v29.0.0+incompatible
 	github.com/docker/docker v28.5.2+incompatible
 	github.com/docker/go-units v0.5.0
-	github.com/go-git/go-git/v5 v5.16.2
+	github.com/go-git/go-git/v5 v5.16.3
 	github.com/google/go-cmp v0.7.0
 	github.com/leonelquinteros/gotext v1.7.2
 	github.com/moby/sys/signal v0.7.1
 	github.com/moby/term v0.5.2
 	github.com/pkg/errors v0.9.1
 	github.com/schollz/progressbar/v3 v3.18.0
-	golang.org/x/term v0.35.0
+	golang.org/x/term v0.36.0
 	gopkg.in/yaml.v3 v3.0.1
 	gotest.tools/v3 v3.5.2
 )
@@ -38,19 +36,21 @@ require (
 	github.com/cenkalti/backoff/v4 v4.3.0 // indirect
 	github.com/cenkalti/backoff/v5 v5.0.3 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
-	github.com/charmbracelet/colorprofile v0.3.2 // indirect
-	github.com/charmbracelet/x/ansi v0.10.2 // indirect
-	github.com/charmbracelet/x/cellbuf v0.0.13 // indirect
+	github.com/charmbracelet/colorprofile v0.3.3 // indirect
+	github.com/charmbracelet/x/ansi v0.11.0 // indirect
+	github.com/charmbracelet/x/cellbuf v0.0.14 // indirect
 	github.com/charmbracelet/x/exp/golden v0.0.0-20241011142426-46044092ad91 // indirect
-	github.com/charmbracelet/x/term v0.2.1 // indirect
-	github.com/clipperhouse/uax29/v2 v2.2.0 // indirect
+	github.com/charmbracelet/x/term v0.2.2 // indirect
+	github.com/clipperhouse/displaywidth v0.5.0 // indirect
+	github.com/clipperhouse/stringish v0.1.1 // indirect
+	github.com/clipperhouse/uax29/v2 v2.3.0 // indirect
 	github.com/cloudflare/circl v1.6.1 // indirect
 	github.com/containerd/errdefs v1.0.0 // indirect
 	github.com/containerd/errdefs/pkg v0.3.0 // indirect
 	github.com/containerd/log v0.1.0 // indirect
 	github.com/containerd/platforms v0.2.1 // indirect
 	github.com/cpuguy83/go-md2man/v2 v2.0.7 // indirect
-	github.com/cyphar/filepath-securejoin v0.5.0 // indirect
+	github.com/cyphar/filepath-securejoin v0.6.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/docker/distribution v2.8.3+incompatible // indirect
 	github.com/docker/go-connections v0.6.0 // indirect
@@ -62,19 +62,19 @@ require (
 	github.com/ghodss/yaml v1.0.0 // indirect
 	github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 // indirect
 	github.com/go-git/go-billy/v5 v5.6.2 // indirect
-	github.com/go-logfmt/logfmt v0.6.0 // indirect
+	github.com/go-logfmt/logfmt v0.6.1 // indirect
 	github.com/go-logr/logr v1.4.3 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
 	github.com/go-viper/mapstructure/v2 v2.4.0 // indirect
 	github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 // indirect
 	github.com/google/uuid v1.6.0 // indirect
-	github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.2 // indirect
+	github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.3 // indirect
 	github.com/hashicorp/go-cleanhttp v0.5.2 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect
 	github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 // indirect
 	github.com/kevinburke/ssh_config v1.4.0 // indirect
-	github.com/klauspost/compress v1.18.0 // indirect
+	github.com/klauspost/compress v1.18.1 // indirect
 	github.com/klauspost/cpuid/v2 v2.3.0 // indirect
 	github.com/lucasb-eyer/go-colorful v1.3.0 // indirect
 	github.com/mattn/go-colorable v0.1.14 // indirect
@@ -86,6 +86,8 @@ require (
 	github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db // indirect
 	github.com/moby/docker-image-spec v1.3.1 // indirect
 	github.com/moby/go-archive v0.1.0 // indirect
+	github.com/moby/moby/api v1.52.0 // indirect
+	github.com/moby/moby/client v0.1.0 // indirect
 	github.com/moby/sys/atomicwriter v0.1.0 // indirect
 	github.com/moby/sys/user v0.4.0 // indirect
 	github.com/moby/sys/userns v0.1.0 // indirect
@@ -100,12 +102,12 @@ require (
 	github.com/pjbgf/sha1cd v0.5.0 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/prometheus/client_model v0.6.2 // indirect
-	github.com/prometheus/common v0.66.1 // indirect
-	github.com/prometheus/procfs v0.17.0 // indirect
+	github.com/prometheus/common v0.67.2 // indirect
+	github.com/prometheus/procfs v0.19.2 // indirect
 	github.com/rivo/uniseg v0.4.7 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
 	github.com/sirupsen/logrus v1.9.3 // indirect
-	github.com/skeema/knownhosts v1.3.1 // indirect
+	github.com/skeema/knownhosts v1.3.2 // indirect
 	github.com/spf13/pflag v1.0.10 // indirect
 	github.com/xanzy/ssh-agent v0.3.3 // indirect
 	github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 // indirect
@@ -122,18 +124,17 @@ require (
 	go.opentelemetry.io/otel/sdk v1.38.0 // indirect
 	go.opentelemetry.io/otel/sdk/metric v1.38.0 // indirect
 	go.opentelemetry.io/otel/trace v1.38.0 // indirect
-	go.opentelemetry.io/proto/otlp v1.8.0 // indirect
+	go.opentelemetry.io/proto/otlp v1.9.0 // indirect
 	go.yaml.in/yaml/v2 v2.4.3 // indirect
-	go.yaml.in/yaml/v3 v3.0.4 // indirect
-	golang.org/x/crypto v0.42.0 // indirect
-	golang.org/x/exp v0.0.0-20250911091902-df9299821621 // indirect
-	golang.org/x/net v0.44.0 // indirect
-	golang.org/x/text v0.29.0 // indirect
-	golang.org/x/time v0.13.0 // indirect
-	google.golang.org/genproto/googleapis/api v0.0.0-20250929231259-57b25ae835d4 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20250929231259-57b25ae835d4 // indirect
-	google.golang.org/grpc v1.75.1 // indirect
-	google.golang.org/protobuf v1.36.9 // indirect
+	golang.org/x/crypto v0.43.0 // indirect
+	golang.org/x/exp v0.0.0-20251023183803-a4bb9ffd2546 // indirect
+	golang.org/x/net v0.46.0 // indirect
+	golang.org/x/text v0.30.0 // indirect
+	golang.org/x/time v0.14.0 // indirect
+	google.golang.org/genproto/googleapis/api v0.0.0-20251110190251-83f479183930 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20251110190251-83f479183930 // indirect
+	google.golang.org/grpc v1.76.0 // indirect
+	google.golang.org/protobuf v1.36.10 // indirect
 	gopkg.in/warnings.v0 v0.1.2 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 )
@@ -142,7 +143,7 @@ require (
 	github.com/containers/image v3.0.2+incompatible
 	github.com/containers/storage v1.38.2 // indirect
 	github.com/decentral1se/passgen v1.0.1
-	github.com/docker/docker-credential-helpers v0.9.3 // indirect
+	github.com/docker/docker-credential-helpers v0.9.4 // indirect
 	github.com/fvbommel/sortorder v1.1.0 // indirect
 	github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 // indirect
 	github.com/gorilla/mux v1.8.1 // indirect
@@ -156,9 +157,5 @@ require (
 	github.com/stretchr/testify v1.11.1
 	github.com/theupdateframework/notary v0.7.0 // indirect
 	github.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb // indirect
-	golang.org/x/sys v0.36.0
+	golang.org/x/sys v0.38.0
 )
-
-replace github.com/docker/cli v28.4.0+incompatible => git.coopcloud.tech/toolshed/docker-cli v28.5.3-0.20260202112816-30df2d0b3a00+incompatible
-
-replace github.com/spf13/cobra => github.com/decentral1se/cobra v1.10.2-i18n

go.sum

@@ -27,8 +27,6 @@ coopcloud.tech/tagcmp v0.0.0-20250818180036-0ec1b205b5ca/go.mod h1:ESVm0wQKcbcFi
 dario.cat/mergo v1.0.2 h1:85+piFYR1tMbRrLcDwR18y4UKJ3aH1Tbzi24VRW1TK8=
 dario.cat/mergo v1.0.2/go.mod h1:E/hbnu0NxMFBjpMIE34DRGLWqDy0g5FuKDhCb31ngxA=
 dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
-git.coopcloud.tech/toolshed/docker-cli v28.5.3-0.20260202112816-30df2d0b3a00+incompatible h1:YdW2uK5sHj545lGz/FrozPueINkQ7fUjlsNd8aYcqik=
-git.coopcloud.tech/toolshed/docker-cli v28.5.3-0.20260202112816-30df2d0b3a00+incompatible/go.mod h1:PY19bHY5R4DLmRuCrv4TR7etURn/+tSTFuam4FUTiD8=
 git.coopcloud.tech/toolshed/godotenv v1.5.2-0.20250103171850-4d0ca41daa5c h1:oeKnUB79PKYD8D0/unYuu7MRcWryQQWOns8+JL+acrs=
 git.coopcloud.tech/toolshed/godotenv v1.5.2-0.20250103171850-4d0ca41daa5c/go.mod h1:fQuhwrpg6qb9NlFXKYi/LysWu1wxjraS8sxyW12CUF0=
 github.com/AdaLogics/go-fuzz-headers v0.0.0-20240806141605-e8a1dd7889d6 h1:He8afgbRMd7mFxO99hRNu+6tazq8nFF9lIwo9JFroBk=
@@ -97,6 +95,7 @@ github.com/alexflint/go-filemutex v0.0.0-20171022225611-72bdc8eae2ae/go.mod h1:C
 github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be h1:9AeTilPcZAjCFIImctFaOjnTIavg87rW78vTPkQqLI8=
 github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be/go.mod h1:ySMOLuWl6zY27l47sB3qLNK6tF2fkHG55UZxx8oIVo4=
 github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY=
+github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8=
 github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio=
 github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs=
 github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a/go.mod h1:lB+ZfQJz7igIIfQNfa7Ml4HSf2uFQQRzpGGRXenZAgY=
@@ -130,6 +129,7 @@ github.com/cenkalti/backoff/v4 v4.3.0/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyY
 github.com/cenkalti/backoff/v5 v5.0.3 h1:ZN+IMa753KfX5hd8vVaMixjnqRZ3y8CuJKRKj1xcsSM=
 github.com/cenkalti/backoff/v5 v5.0.3/go.mod h1:rkhZdG3JZukswDf7f0cwqPNk4K0sa+F97BxZthm/crw=
 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
+github.com/cespare/xxhash v1.1.0 h1:a6HrQnmkObjyL+Gs60czilIUGqrzKutQD6XZog3p+ko=
 github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
 github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
@@ -138,18 +138,26 @@ github.com/charmbracelet/bubbletea v1.3.10 h1:otUDHWMMzQSB0Pkc87rm691KZ3SWa4KUlv
 github.com/charmbracelet/bubbletea v1.3.10/go.mod h1:ORQfo0fk8U+po9VaNvnV95UPWA1BitP1E0N6xJPlHr4=
 github.com/charmbracelet/colorprofile v0.3.2 h1:9J27WdztfJQVAQKX2WOlSSRB+5gaKqqITmrvb1uTIiI=
 github.com/charmbracelet/colorprofile v0.3.2/go.mod h1:mTD5XzNeWHj8oqHb+S1bssQb7vIHbepiebQ2kPKVKbI=
+github.com/charmbracelet/colorprofile v0.3.3 h1:DjJzJtLP6/NZ8p7Cgjno0CKGr7wwRJGxWUwh2IyhfAI=
+github.com/charmbracelet/colorprofile v0.3.3/go.mod h1:nB1FugsAbzq284eJcjfah2nhdSLppN2NqvfotkfRYP4=
 github.com/charmbracelet/lipgloss v1.1.0 h1:vYXsiLHVkK7fp74RkV7b2kq9+zDLoEU4MZoFqR/noCY=
 github.com/charmbracelet/lipgloss v1.1.0/go.mod h1:/6Q8FR2o+kj8rz4Dq0zQc3vYf7X+B0binUUBwA0aL30=
 github.com/charmbracelet/log v0.4.2 h1:hYt8Qj6a8yLnvR+h7MwsJv/XvmBJXiueUcI3cIxsyig=
 github.com/charmbracelet/log v0.4.2/go.mod h1:qifHGX/tc7eluv2R6pWIpyHDDrrb/AG71Pf2ysQu5nw=
 github.com/charmbracelet/x/ansi v0.10.2 h1:ith2ArZS0CJG30cIUfID1LXN7ZFXRCww6RUvAPA+Pzw=
 github.com/charmbracelet/x/ansi v0.10.2/go.mod h1:HbLdJjQH4UH4AqA2HpRWuWNluRE6zxJH/yteYEYCFa8=
+github.com/charmbracelet/x/ansi v0.11.0 h1:uuIVK7GIplwX6UBIz8S2TF8nkr7xRlygSsBRjSJqIvA=
+github.com/charmbracelet/x/ansi v0.11.0/go.mod h1:uQt8bOrq/xgXjlGcFMc8U2WYbnxyjrKhnvTQluvfCaE=
 github.com/charmbracelet/x/cellbuf v0.0.13 h1:/KBBKHuVRbq1lYx5BzEHBAFBP8VcQzJejZ/IA3iR28k=
 github.com/charmbracelet/x/cellbuf v0.0.13/go.mod h1:xe0nKWGd3eJgtqZRaN9RjMtK7xUYchjzPr7q6kcvCCs=
+github.com/charmbracelet/x/cellbuf v0.0.14 h1:iUEMryGyFTelKW3THW4+FfPgi4fkmKnnaLOXuc+/Kj4=
+github.com/charmbracelet/x/cellbuf v0.0.14/go.mod h1:P447lJl49ywBbil/KjCk2HexGh4tEY9LH0/1QrZZ9rA=
 github.com/charmbracelet/x/exp/golden v0.0.0-20241011142426-46044092ad91 h1:payRxjMjKgx2PaCWLZ4p3ro9y97+TVLZNaRZgJwSVDQ=
 github.com/charmbracelet/x/exp/golden v0.0.0-20241011142426-46044092ad91/go.mod h1:wDlXFlCrmJ8J+swcL/MnGUuYnqgQdW9rhSD61oNMb6U=
 github.com/charmbracelet/x/term v0.2.1 h1:AQeHeLZ1OqSXhrAWpYUtZyX1T3zVxfpZuEQMIQaGIAQ=
 github.com/charmbracelet/x/term v0.2.1/go.mod h1:oQ4enTYFV7QN4m0i9mzHrViD7TQKvNEEkHUMCmsxdUg=
+github.com/charmbracelet/x/term v0.2.2 h1:xVRT/S2ZcKdhhOuSP4t5cLi5o+JxklsoEObBSgfgZRk=
+github.com/charmbracelet/x/term v0.2.2/go.mod h1:kF8CY5RddLWrsgVwpw4kAa6TESp6EB5y3uxGLeCqzAI=
 github.com/checkpoint-restore/go-criu/v4 v4.1.0/go.mod h1:xUQBLp4RLc5zJtWY++yjOoMoB5lihDt7fai+75m+rGw=
 github.com/checkpoint-restore/go-criu/v5 v5.0.0/go.mod h1:cfwC0EG7HMUenopBsUf9d89JlCLQIfgVcNsNN0t6T2M=
 github.com/checkpoint-restore/go-criu/v5 v5.3.0/go.mod h1:E/eQpaFtUKGOOSEBZgmKAcn+zUUwWxqcaKZlF54wK8E=
@@ -165,8 +173,14 @@ github.com/cilium/ebpf v0.4.0/go.mod h1:4tRaxcgiL706VnOzHOdBlY8IEAIdxINsQBcU4xJJ
 github.com/cilium/ebpf v0.6.2/go.mod h1:4tRaxcgiL706VnOzHOdBlY8IEAIdxINsQBcU4xJJXRs=
 github.com/cilium/ebpf v0.7.0/go.mod h1:/oI2+1shJiTGAMgl6/RgJr36Eo1jzrRcAWbcXO2usCA=
 github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
+github.com/clipperhouse/displaywidth v0.5.0 h1:AIG5vQaSL2EKqzt0M9JMnvNxOCRTKUc4vUnLWGgP89I=
+github.com/clipperhouse/displaywidth v0.5.0/go.mod h1:R+kHuzaYWFkTm7xoMmK1lFydbci4X2CicfbGstSGg0o=
+github.com/clipperhouse/stringish v0.1.1 h1:+NSqMOr3GR6k1FdRhhnXrLfztGzuG+VuFDfatpWHKCs=
+github.com/clipperhouse/stringish v0.1.1/go.mod h1:v/WhFtE1q0ovMta2+m+UbpZ+2/HEXNWYXQgCt4hdOzA=
 github.com/clipperhouse/uax29/v2 v2.2.0 h1:ChwIKnQN3kcZteTXMgb1wztSgaU+ZemkgWdohwgs8tY=
 github.com/clipperhouse/uax29/v2 v2.2.0/go.mod h1:EFJ2TJMRUaplDxHKj1qAEhCtQPW2tJSwu5BF98AuoVM=
+github.com/clipperhouse/uax29/v2 v2.3.0 h1:SNdx9DVUqMoBuBoW3iLOj4FQv3dN5mDtuqwuhIGpJy4=
+github.com/clipperhouse/uax29/v2 v2.3.0/go.mod h1:Wn1g7MK6OoeDT0vL+Q0SQLDz/KpfsVRgg6W7ihQeh4g=
 github.com/cloudflare/cfssl v0.0.0-20180223231731-4e2dcbde5004/go.mod h1:yMWuSON2oQp+43nFtAV/uvKQIFpSPerB57DCt9t8sSA=
 github.com/cloudflare/circl v1.6.1 h1:zqIqSPIndyBh1bjLVVDHMPpVKqp8Su/V+6MeDzzQBQ0=
 github.com/cloudflare/circl v1.6.1/go.mod h1:uddAzsPgqdMAYatqJ0lsjX1oECcQLIlRpzZh3pJrofs=
@@ -272,6 +286,8 @@ github.com/containers/ocicrypt v1.1.0/go.mod h1:b8AOe0YR67uU8OqfVNcznfFpAzu3rdgU
 github.com/containers/ocicrypt v1.1.1/go.mod h1:Dm55fwWm1YZAjYRaJ94z2mfZikIyIN4B0oB3dj3jFxY=
 github.com/containers/storage v1.38.2 h1:8bAIxnVBGKzMw5EWCivVj24bztQT6IkDp4uHiyhnzwE=
 github.com/containers/storage v1.38.2/go.mod h1:INP0RPLHWBxx+pTsO5uiHlDUGHDFvWZPWprAbAlQWPQ=
+github.com/coreos/bbolt v1.3.2/go.mod h1:iRUV2dpdMOn7Bo10OQBFzIJO9kkE559Wcmn+qkEiiKk=
+github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE=
 github.com/coreos/go-iptables v0.4.5/go.mod h1:/mVI274lEDI2ns62jHCDnCyBF9Iwsmekav8Dbxlm1MU=
 github.com/coreos/go-iptables v0.5.0/go.mod h1:/mVI274lEDI2ns62jHCDnCyBF9Iwsmekav8Dbxlm1MU=
 github.com/coreos/go-oidc v2.1.0+incompatible/go.mod h1:CgnwVTmzoESiwO9qyAFEMiHoZ1nMCKZlZ9V6mm3/LKc=
@@ -299,6 +315,8 @@ github.com/cyphar/filepath-securejoin v0.2.2/go.mod h1:FpkQEhXnPnOthhzymB7CGsFk2
 github.com/cyphar/filepath-securejoin v0.2.3/go.mod h1:aPGpWjXOXUn2NCNjFvBE6aRxGGx79pTxQpKOJNYHHl4=
 github.com/cyphar/filepath-securejoin v0.5.0 h1:hIAhkRBMQ8nIeuVwcAoymp7MY4oherZdAxD+m0u9zaw=
 github.com/cyphar/filepath-securejoin v0.5.0/go.mod h1:Sdj7gXlvMcPZsbhwhQ33GguGLDGQL7h7bg04C/+u9jI=
+github.com/cyphar/filepath-securejoin v0.6.0 h1:BtGB77njd6SVO6VztOHfPxKitJvd/VPT+OFBFMOi1Is=
+github.com/cyphar/filepath-securejoin v0.6.0/go.mod h1:A8hd4EnAeyujCJRrICiOWqjS1AX0a9kM5XL+NwKoYSc=
 github.com/d2g/dhcp4 v0.0.0-20170904100407-a1d1b6c41b1c/go.mod h1:Ct2BUK8SB0YC1SMSibvLzxjeJLnrYEVLULFNiHY9YfQ=
 github.com/d2g/dhcp4client v1.0.0/go.mod h1:j0hNfjhrt2SxUOw55nL0ATM/z4Yt3t2Kd1mW34z5W5s=
 github.com/d2g/dhcp4server v0.0.0-20181031114812-7d4a0a7f59a5/go.mod h1:Eo87+Kg/IX2hfWJfwxMzLyuSZyxSoAug2nGa1G2QAi8=
@@ -306,29 +324,36 @@ github.com/d2g/hardwareaddr v0.0.0-20190221164911-e7d9fbe030e4/go.mod h1:bMl4RjI
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/decentral1se/cobra v1.10.2-i18n h1:XR+6AHHfnf4k5NM9f09oLMrEVwz3rkQIAIcqgL8R08g=
-github.com/decentral1se/cobra v1.10.2-i18n/go.mod h1:7C1pvHqHw5A4vrJfjNwvOdzYu0Gml16OCs2GRiTUUS4=
 github.com/decentral1se/passgen v1.0.1 h1:j2AxK/kHKxDHWZZfkJj8Wgae9+O+DYEqR5sjKthIYKA=
 github.com/decentral1se/passgen v1.0.1/go.mod h1:530V+lNoPhKtkrX2fIVsIfLhkl47CuiOM7HRgi7C+SU=
 github.com/denisenkom/go-mssqldb v0.0.0-20191128021309-1d7a30a10f73/go.mod h1:xbL0rPBG9cCiLr28tMa8zpbdarY27NDyej4t/EjAShU=
 github.com/denverdino/aliyungo v0.0.0-20190125010748-a747050bb1ba/go.mod h1:dV8lFg6daOBZbT6/BDGIz6Y3WFGn8juu6G+CQ6LHtl0=
 github.com/dgrijalva/jwt-go v0.0.0-20170104182250-a601269ab70c/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
 github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
+github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
 github.com/distribution/reference v0.6.0 h1:0IXCQ5g4/QMHHkarYzh5l+u8T3t73zM5QvfrDyIgxBk=
 github.com/distribution/reference v0.6.0/go.mod h1:BbU0aIcezP1/5jX/8MP0YiH4SdvB5Y4f/wlDRiLyi3E=
 github.com/dnaeon/go-vcr v1.0.1/go.mod h1:aBB1+wY4s93YsC3HHjMBMrwTj2R9FHDzUr9KyGc8n1E=
 github.com/docker/cli v0.0.0-20191017083524-a8ff7f821017/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8=
+github.com/docker/cli v28.4.0+incompatible h1:RBcf3Kjw2pMtwui5V0DIMdyeab8glEw5QY0UUU4C9kY=
+github.com/docker/cli v28.4.0+incompatible/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8=
+github.com/docker/cli v29.0.0+incompatible h1:KgsN2RUFMNM8wChxryicn4p46BdQWpXOA1XLGBGPGAw=
+github.com/docker/cli v29.0.0+incompatible/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8=
 github.com/docker/distribution v0.0.0-20190905152932-14b96e55d84c/go.mod h1:0+TTO4EOBfRPhZXAeF1Vu+W3hHZ8eLp8PgKVZlcvtFY=
 github.com/docker/distribution v2.7.1-0.20190205005809-0d3efadf0154+incompatible/go.mod h1:J2gT2udsDAN96Uj4KfcMRqY0/ypR+oyYUYmja8H+y+w=
 github.com/docker/distribution v2.7.1+incompatible/go.mod h1:J2gT2udsDAN96Uj4KfcMRqY0/ypR+oyYUYmja8H+y+w=
 github.com/docker/distribution v2.8.3+incompatible h1:AtKxIZ36LoNK51+Z6RpzLpddBirtxJnzDrHLEKxTAYk=
 github.com/docker/distribution v2.8.3+incompatible/go.mod h1:J2gT2udsDAN96Uj4KfcMRqY0/ypR+oyYUYmja8H+y+w=
 github.com/docker/docker v1.4.2-0.20190924003213-a8608b5b67c7/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
+github.com/docker/docker v28.4.0+incompatible h1:KVC7bz5zJY/4AZe/78BIvCnPsLaC9T/zh72xnlrTTOk=
+github.com/docker/docker v28.4.0+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
 github.com/docker/docker v28.5.2+incompatible h1:DBX0Y0zAjZbSrm1uzOkdr1onVghKaftjlSWt4AFexzM=
 github.com/docker/docker v28.5.2+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
 github.com/docker/docker-credential-helpers v0.6.3/go.mod h1:WRaJzqw3CTB9bk10avuGsjVBZsD05qeibJ1/TYlvc0Y=
 github.com/docker/docker-credential-helpers v0.9.3 h1:gAm/VtF9wgqJMoxzT3Gj5p4AqIjCBS4wrsOh9yRqcz8=
 github.com/docker/docker-credential-helpers v0.9.3/go.mod h1:x+4Gbw9aGmChi3qTLZj8Dfn0TD20M/fuWy0E5+WDeCo=
+github.com/docker/docker-credential-helpers v0.9.4 h1:76ItO69/AP/V4yT9V4uuuItG0B1N8hvt0T0c0NN/DzI=
+github.com/docker/docker-credential-helpers v0.9.4/go.mod h1:v1S+hepowrQXITkEfw6o4+BMbGot02wiKpzWhGUZK6c=
 github.com/docker/go v1.5.1-1.0.20160303222718-d30aec9fd63c h1:lzqkGL9b3znc+ZUgi7FlLnqjQhcXxkNM/quxIjBVMD0=
 github.com/docker/go v1.5.1-1.0.20160303222718-d30aec9fd63c/go.mod h1:CADgU4DSXK5QUlFslkQu2yW2TKzFZcXq/leZfM0UH5Q=
 github.com/docker/go-connections v0.4.0/go.mod h1:Gbd7IOopHjR8Iph03tsViu4nIes5XhDvyHbTtUxmeec=
@@ -393,6 +418,8 @@ github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399 h1:eMj
 github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399/go.mod h1:1OCfN199q1Jm3HZlxleg+Dw/mwps2Wbk9frAWm+4FII=
 github.com/go-git/go-git/v5 v5.16.2 h1:fT6ZIOjE5iEnkzKyxTHK1W4HGAsPhqEqiSAssSO77hM=
 github.com/go-git/go-git/v5 v5.16.2/go.mod h1:4Ge4alE/5gPs30F2H1esi2gPd69R0C39lolkucHBOp8=
+github.com/go-git/go-git/v5 v5.16.3 h1:Z8BtvxZ09bYm/yYNgPKCzgWtaRqDTgIKRgIRHBfU6Z8=
+github.com/go-git/go-git/v5 v5.16.3/go.mod h1:4Ge4alE/5gPs30F2H1esi2gPd69R0C39lolkucHBOp8=
 github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
 github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
 github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
@@ -403,6 +430,8 @@ github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9
 github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
 github.com/go-logfmt/logfmt v0.6.0 h1:wGYYu3uicYdqXVgoYbvnkrPVXkuLM1p1ifugDMEdRi4=
 github.com/go-logfmt/logfmt v0.6.0/go.mod h1:WYhtIu8zTZfxdn5+rREduYbwxfcBr/Vr6KEVveWlfTs=
+github.com/go-logfmt/logfmt v0.6.1 h1:4hvbpePJKnIzH1B+8OR/JPbTx37NktoI9LE2QZBBkvE=
+github.com/go-logfmt/logfmt v0.6.1/go.mod h1:EV2pOAQoZaT1ZXZbqDl5hrymndi4SY9ED9/z6CO0XAk=
 github.com/go-logr/logr v0.1.0/go.mod h1:ixOQHD9gLJUVQQ2ZOR7zLEifBX6tGkNJF4QyIY7sIas=
 github.com/go-logr/logr v0.2.0/go.mod h1:z6/tIYblkpsD+a4lm/fGIIU9mZ+XfAiaFtq7xTgseGU=
 github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
@@ -443,6 +472,7 @@ github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69
 github.com/golang-sql/civil v0.0.0-20190719163853-cb61b32ac6fe/go.mod h1:8vg3r2VgvsThLBIFL93Qb5yWzgyZWhEmBwUJWevAkK0=
 github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
 github.com/golang/groupcache v0.0.0-20160516000752-02826c3e7903/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20190129154638-5b532d6fd5ef/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
 github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
 github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
 github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
@@ -518,14 +548,20 @@ github.com/gorilla/mux v1.7.3/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2z
 github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY=
 github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ=
 github.com/gorilla/websocket v0.0.0-20170926233335-4201258b820c/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
+github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
 github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/gregjones/httpcache v0.0.0-20180305231024-9cad4c3443a7/go.mod h1:FecbI9+v66THATjSRHfNgh1IVFe/9kFxbXtjV0ctIMA=
+github.com/grpc-ecosystem/go-grpc-middleware v1.0.0/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs=
 github.com/grpc-ecosystem/go-grpc-middleware v1.0.1-0.20190118093823-f849b5445de4/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs=
 github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk=
+github.com/grpc-ecosystem/grpc-gateway v1.9.0/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
 github.com/grpc-ecosystem/grpc-gateway v1.9.5/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
+github.com/grpc-ecosystem/grpc-gateway v1.16.0 h1:gmcG1KaJ57LophUzW0Hy8NmPhnMZb4M0+kPpLofRdBo=
 github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw=
 github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.2 h1:8Tjv8EJ+pM1xP8mK6egEbD1OgnVTyacbefKhmbLhIhU=
 github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.2/go.mod h1:pkJQ2tZHJ0aFOVEEot6oZmaVEZcRme73eIFmhiVuRWs=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.3 h1:NmZ1PKzSTQbuGHw9DGPFomqkkLWMC+vZCkfs+FHv1Vg=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.3/go.mod h1:zQrxl1YP88HQlA6i9c63DSVPFklWpGX4OWAc9bFuaH4=
 github.com/hailocab/go-hostpool v0.0.0-20160125115350-e80d13ce29ed/go.mod h1:tMWxXQ9wFIaZeTI9F+hmhFiGpFmhOHzyShyFUhRm0H4=
 github.com/hashicorp/errwrap v0.0.0-20141028054710-7554cd9344ce/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
 github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
@@ -540,6 +576,7 @@ github.com/hashicorp/go-retryablehttp v0.7.8 h1:ylXZWnqa7Lhqpk0L1P1LzDtGcCR0rPVU
 github.com/hashicorp/go-retryablehttp v0.7.8/go.mod h1:rjiScheydd+CxvumBsIrFKlx3iS0jrZ7LvzFGFmuKbw=
 github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
 github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
+github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
 github.com/hinshun/vt10x v0.0.0-20220119200601-820417d04eec h1:qv2VnGeEQHchGaZ/u7lxST/RaJw+cv273q79D81Xbog=
 github.com/hinshun/vt10x v0.0.0-20220119200601-820417d04eec/go.mod h1:Q48J4R4DvxnHolD5P8pOtXigYlRuPLGl6moFx3ulM68=
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
@@ -584,6 +621,8 @@ github.com/klauspost/compress v1.11.13/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdY
 github.com/klauspost/compress v1.14.2/go.mod h1:/3/Vjq9QcHkK5uEr5lBEmyoZ1iFhe47etQ6QUkpK6sk=
 github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
 github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
+github.com/klauspost/compress v1.18.1 h1:bcSGx7UbpBqMChDtsF28Lw6v/G94LPrrbMbdC3JH2co=
+github.com/klauspost/compress v1.18.1/go.mod h1:ZQFFVG+MdnR0P+l6wpXgIL4NTtwiKIdBnrBd8Nrxr+0=
 github.com/klauspost/cpuid/v2 v2.3.0 h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzhA9Y=
 github.com/klauspost/cpuid/v2 v2.3.0/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
 github.com/klauspost/pgzip v1.2.5/go.mod h1:Ch1tH69qFZu15pkjo5kYi6mth2Zzwzt50oCQKQE9RUs=
@@ -610,6 +649,7 @@ github.com/linuxkit/virtsock v0.0.0-20201010232012-f8cee7dfc7a3/go.mod h1:3r6x7q
 github.com/lucasb-eyer/go-colorful v1.3.0 h1:2/yBRLdWBZKrf7gB40FoiKfAWYQ0lqNcbuQwVHXptag=
 github.com/lucasb-eyer/go-colorful v1.3.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
 github.com/magiconair/properties v1.5.3/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
+github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
 github.com/mailru/easyjson v0.0.0-20160728113105-d5b7844b561a/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
 github.com/mailru/easyjson v0.0.0-20190614124828-94de47d64c63/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
 github.com/mailru/easyjson v0.0.0-20190626092158-b2ccc519800e/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
@@ -645,6 +685,7 @@ github.com/miekg/pkcs11 v1.1.1/go.mod h1:XsNlhZGX73bx86s2hdc/FuaLm2CPZJemRLMA+WT
 github.com/mistifyio/go-zfs v2.1.2-0.20190413222219-f784269be439+incompatible/go.mod h1:8AuVvqP/mXw1px98n46wfvcGfQ4ci2FwoAjKYxuo3Z4=
 github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db h1:62I3jR2EmQ4l5rM/4FEfDWcRD+abF5XlKShorW5LRoQ=
 github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db/go.mod h1:l0dey0ia/Uv7NcFFVbCLtqEBQbrT4OCwCSKTEv6enCw=
+github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
 github.com/mitchellh/mapstructure v0.0.0-20150613213606-2caf8efc9366/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
 github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
 github.com/mitchellh/osext v0.0.0-20151018003038-5e2d6d41470f/go.mod h1:OkQIRizQZAeMln+1tSwduZz7+Af5oFlKirV/MSYes2A=
@@ -653,6 +694,10 @@ github.com/moby/docker-image-spec v1.3.1/go.mod h1:eKmb5VW8vQEh/BAr2yvVNvuiJuY6U
 github.com/moby/go-archive v0.1.0 h1:Kk/5rdW/g+H8NHdJW2gsXyZ7UnzvJNOy6VKJqueWdcQ=
 github.com/moby/go-archive v0.1.0/go.mod h1:G9B+YoujNohJmrIYFBpSd54GTUB4lt9S+xVQvsJyFuo=
 github.com/moby/locker v1.0.1/go.mod h1:S7SDdo5zpBK84bzzVlKr2V0hz+7x9hWbYC/kq7oQppc=
+github.com/moby/moby/api v1.52.0 h1:00BtlJY4MXkkt84WhUZPRqt5TvPbgig2FZvTbe3igYg=
+github.com/moby/moby/api v1.52.0/go.mod h1:8mb+ReTlisw4pS6BRzCMts5M49W5M7bKt1cJy/YbAqc=
+github.com/moby/moby/client v0.1.0 h1:nt+hn6O9cyJQqq5UWnFGqsZRTS/JirUqzPjEl0Bdc/8=
+github.com/moby/moby/client v0.1.0/go.mod h1:O+/tw5d4a1Ha/ZA/tPxIZJapJRUS6LNZ1wiVRxYHyUE=
 github.com/moby/patternmatcher v0.6.0 h1:GmP9lR19aU5GqSSFko+5pRqHi+Ohk1O69aFiKkVGiPk=
 github.com/moby/patternmatcher v0.6.0/go.mod h1:hDPoyOpDY7OrrMDLaYoY3hf52gNCR/YOUYxkhApJIxc=
 github.com/moby/sys/atomicwriter v0.1.0 h1:kw5D/EqkBwsBFi0ss9v1VG3wIkVhzGvLklJ+w3A14Sw=
@@ -696,6 +741,7 @@ github.com/mxk/go-flowrate v0.0.0-20140419014527-cca7078d478f/go.mod h1:ZdcZmHo+
 github.com/ncw/swift v1.0.47/go.mod h1:23YIA4yWVnGwv2dQlN4bB7egfYX6YLn0Yo/S6zZO/ZM=
 github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
 github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
+github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U=
 github.com/olekukonko/tablewriter v0.0.0-20170122224234-a0225b3f23b5/go.mod h1:vsDQFd/mU46D+Z4whnwzcISnGGzXWMclvtLoiIKAKIo=
 github.com/onsi/ginkgo v0.0.0-20151202141238-7f8ab55aaf3b/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 github.com/onsi/ginkgo v0.0.0-20170829012221-11459a886d9c/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
@@ -748,6 +794,7 @@ github.com/opencontainers/selinux v1.8.0/go.mod h1:RScLhm78qiWa2gbVCcGkC7tCGdgk3
 github.com/opencontainers/selinux v1.8.2/go.mod h1:MUIHuUEvKB1wtJjQdOyYRgOnLD2xAPP8dBsCoU0KuF8=
 github.com/opencontainers/selinux v1.10.0/go.mod h1:2i0OySw99QjzBBQByd1Gr9gSjvuho1lHsJxIJ3gGbJI=
 github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o=
+github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
 github.com/pelletier/go-toml v1.8.1/go.mod h1:T2/BmBdy8dvIRq1a/8aqjN41wvWlN4lrapLU/GW4pbc=
 github.com/peterbourgon/diskv v2.0.1+incompatible/go.mod h1:uqqh8zWWbv1HBMNONnaR/tNboyR3/BZd58JJSHlUSCU=
 github.com/pjbgf/sha1cd v0.5.0 h1:a+UkboSi1znleCDUNT3M5YxjOnN1fz2FhN48FlwCxs0=
@@ -763,6 +810,7 @@ github.com/pquerna/cachecontrol v0.0.0-20171018203845-0dec1b30a021/go.mod h1:prY
 github.com/prometheus/client_golang v0.0.0-20180209125602-c332b6f63c06/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
 github.com/prometheus/client_golang v0.9.0-pre1.0.20180209125602-c332b6f63c06/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
 github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
+github.com/prometheus/client_golang v0.9.3/go.mod h1:/TN21ttK/J9q6uSwhBd54HahCDft0ttaMvbicHlPoso=
 github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
 github.com/prometheus/client_golang v1.1.0/go.mod h1:I1FGZT9+L76gKKOs5djB6ezCbFQP1xR9D75/vuwEF3g=
 github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M=
@@ -776,13 +824,18 @@ github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6T
 github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk=
 github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE=
 github.com/prometheus/common v0.0.0-20180110214958-89604d197083/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
+github.com/prometheus/common v0.0.0-20181113130724-41aa239b4cce/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
+github.com/prometheus/common v0.4.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
 github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
 github.com/prometheus/common v0.6.0/go.mod h1:eBmuwkDJBwy6iBfxCBob6t6dR6ENT/y+J+Zk0j9GMYc=
 github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo=
 github.com/prometheus/common v0.66.1 h1:h5E0h5/Y8niHc5DlaLlWLArTQI7tMrsfQjHV+d9ZoGs=
 github.com/prometheus/common v0.66.1/go.mod h1:gcaUsgf3KfRSwHY4dIMXLPV0K/Wg1oZ8+SbZk/HH/dA=
+github.com/prometheus/common v0.67.2 h1:PcBAckGFTIHt2+L3I33uNRTlKTplNzFctXcWhPyAEN8=
+github.com/prometheus/common v0.67.2/go.mod h1:63W3KZb1JOKgcjlIr64WW/LvFGAqKPj0atm+knVGEko=
 github.com/prometheus/procfs v0.0.0-20180125133057-cb4147076ac7/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
 github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
+github.com/prometheus/procfs v0.0.0-20190507164030-5867b95ac084/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
 github.com/prometheus/procfs v0.0.0-20190522114515-bc1a522cf7b1/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
 github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
 github.com/prometheus/procfs v0.0.3/go.mod h1:4A/X28fw3Fc593LaREMrKMqOKvUAntwMDaekg4FpcdQ=
@@ -793,6 +846,9 @@ github.com/prometheus/procfs v0.2.0/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4O
 github.com/prometheus/procfs v0.6.0/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
 github.com/prometheus/procfs v0.17.0 h1:FuLQ+05u4ZI+SS/w9+BWEM2TXiHKsUQ9TADiRH7DuK0=
 github.com/prometheus/procfs v0.17.0/go.mod h1:oPQLaDAMRbA+u8H5Pbfq+dl3VDAvHxMUOVhe0wYB2zw=
+github.com/prometheus/procfs v0.19.2 h1:zUMhqEW66Ex7OXIiDkll3tl9a1ZdilUOd/F6ZXw4Vws=
+github.com/prometheus/procfs v0.19.2/go.mod h1:M0aotyiemPhBCM0z5w87kL22CxfcH05ZpYlu+b4J7mw=
+github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU=
 github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
 github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg=
@@ -800,6 +856,8 @@ github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6L
 github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
 github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
 github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
+github.com/russross/blackfriday v1.6.0 h1:KqfZb0pUVN2lYqZUYRddxF4OR8ZMURnJIG5Y3VRLtww=
+github.com/russross/blackfriday v1.6.0/go.mod h1:ti0ldHuxg49ri4ksnFxlkCfN+hvslNlmVHqNRXXJNAY=
 github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
@@ -825,13 +883,24 @@ github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ
 github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
 github.com/skeema/knownhosts v1.3.1 h1:X2osQ+RAjK76shCbvhHHHVl3ZlgDm8apHEHFqRjnBY8=
 github.com/skeema/knownhosts v1.3.1/go.mod h1:r7KTdC8l4uxWRyK2TpQZ/1o5HaSzh06ePQNxPwTcfiY=
+github.com/skeema/knownhosts v1.3.2 h1:EDL9mgf4NzwMXCTfaxSD/o/a5fxDw/xL9nkU28JjdBg=
+github.com/skeema/knownhosts v1.3.2/go.mod h1:bEg3iQAuw+jyiw+484wwFJoKSLwcfd7fqRy+N0QTiow=
 github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
 github.com/smartystreets/goconvey v0.0.0-20190330032615-68dc04aab96a/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
 github.com/soheilhy/cmux v0.1.4/go.mod h1:IM3LyeVVIOuxMH7sFAkER9+bJ4dT7Ms6E4xg4kGIyLM=
 github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
+github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
 github.com/spf13/afero v1.2.2/go.mod h1:9ZxEEn6pIJ8Rxe320qSDBk6AsU0r9pR7Q4OcevTdifk=
 github.com/spf13/cast v0.0.0-20150508191742-4d07383ffe94/go.mod h1:r2rcYCSwa1IExKTDiTfzaxqT2FNHs8hODu4LnUfgKEg=
+github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
+github.com/spf13/cobra v0.0.1/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ=
+github.com/spf13/cobra v0.0.2-0.20171109065643-2da4a54c5cee/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ=
+github.com/spf13/cobra v0.0.3/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ=
+github.com/spf13/cobra v1.0.0/go.mod h1:/6GTrnGXV9HjY+aR4k0oJ5tcvakLuG6EuKReYlHNrgE=
+github.com/spf13/cobra v1.10.1 h1:lJeBwCfmrnXthfAupyUTzJ/J4Nc1RsHC/mSRU2dll/s=
+github.com/spf13/cobra v1.10.1/go.mod h1:7SmJGaTHFVBY0jW4NXGluQoLvhqFQM+6XSKD+P4XaB0=
 github.com/spf13/jwalterweatherman v0.0.0-20141219030609-3d60171a6431/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
+github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
 github.com/spf13/pflag v0.0.0-20170130214245-9ff6c6923cff/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
 github.com/spf13/pflag v1.0.0/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
 github.com/spf13/pflag v1.0.1-0.20171106142849-4c012f6dcd95/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
@@ -842,6 +911,7 @@ github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An
 github.com/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk=
 github.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/spf13/viper v0.0.0-20150530192845-be5ff3e4840c/go.mod h1:A8kyI5cUJhb8N+3pkfONlcEcZbueH6nhAm0Fq7SrnBM=
+github.com/spf13/viper v1.4.0/go.mod h1:PTJ7Z/lr49W6bUbkmS1V3by4uWynFiR9p7+dSq/yZzE=
 github.com/stefanberger/go-pkcs11uri v0.0.0-20201008174630-78d3cae3a980/go.mod h1:AO3tvPzVZ/ayst6UlUKUv6rcPQInYe3IknH3jYhAKu8=
 github.com/stretchr/objx v0.0.0-20180129172003-8a3f7159479f/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
@@ -866,6 +936,7 @@ github.com/theupdateframework/notary v0.7.0 h1:QyagRZ7wlSpjT5N2qQAh/pN+DVqgekv4D
 github.com/theupdateframework/notary v0.7.0/go.mod h1:c9DRxcmhHmVLDay4/2fUYdISnHqbFDGRSlXPO0AhYWw=
 github.com/tmc/grpc-websocket-proxy v0.0.0-20170815181823-89b8d40f7ca8/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
 github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
+github.com/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGrc=
 github.com/ulikunitz/xz v0.5.10/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
 github.com/urfave/cli v0.0.0-20171014202726-7bc6a0acffa5/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijbERA=
 github.com/urfave/cli v1.20.0/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijbERA=
@@ -894,6 +965,7 @@ github.com/xeipuuv/gojsonschema v1.2.0/go.mod h1:anYRn/JVcOK2ZgGU+IjEV4nwlhoK5sQ
 github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=
 github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=
 github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=
+github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q=
 github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
@@ -901,6 +973,7 @@ github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5t
 github.com/yvasiyarov/go-metrics v0.0.0-20140926110328-57bccd1ccd43/go.mod h1:aX5oPXxHm3bOH+xeAttToC8pqch2ScQN/JoXYupl6xs=
 github.com/yvasiyarov/gorelic v0.0.0-20141212073537-a9bba5b9ab50/go.mod h1:NUSPSUX/bi6SeDMUh6brw0nXpxHnc96TguQh0+r/ssA=
 github.com/yvasiyarov/newrelic_platform_go v0.0.0-20140908184405-b21fdbd4370f/go.mod h1:GlGEuHIJweS1mbCqG+7vt2nvWLzLLnRHbXz5JKd/Qbg=
+go.etcd.io/bbolt v1.3.2/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU=
 go.etcd.io/bbolt v1.3.3/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU=
 go.etcd.io/bbolt v1.3.5/go.mod h1:G5EMThwa9y8QZGBClrRx5EY+Yw9kAhnjy3bSjsnlVTQ=
 go.etcd.io/bbolt v1.3.6/go.mod h1:qXsaaIqmgQH0T+OPdb99Bf+PKfBBQVAdyD6TY9G8XM4=
@@ -935,6 +1008,8 @@ go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42s
 go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI=
 go.opentelemetry.io/proto/otlp v1.8.0 h1:fRAZQDcAFHySxpJ1TwlA1cJ4tvcrw7nXl9xWWC8N5CE=
 go.opentelemetry.io/proto/otlp v1.8.0/go.mod h1:tIeYOeNBU4cvmPqpaji1P+KbB4Oloai8wN4rWzRrFF0=
+go.opentelemetry.io/proto/otlp v1.9.0 h1:l706jCMITVouPOqEnii2fIAuO3IVGBRPV5ICjceRb/A=
+go.opentelemetry.io/proto/otlp v1.9.0/go.mod h1:xE+Cx5E/eEHw+ISFkwPLwCZefwVjY+pqKg1qcK03+/4=
 go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
 go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
@@ -943,8 +1018,6 @@ go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/
 go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
 go.yaml.in/yaml/v2 v2.4.3 h1:6gvOSjQoTB3vt1l+CU+tSyi/HOjfOjRLJ4YwYZGwRO0=
 go.yaml.in/yaml/v2 v2.4.3/go.mod h1:zSxWcmIDjOzPXpjlTTbAsKokqkDNAVtZO0WOMiT90s8=
-go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
-go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
 golang.org/x/crypto v0.0.0-20171113213409-9f005a07e0d3/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20181009213950-7c1a557ab941/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
@@ -965,6 +1038,8 @@ golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5y
 golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
 golang.org/x/crypto v0.42.0 h1:chiH31gIWm57EkTXpwnqf8qeuMUi0yekh6mT2AvFlqI=
 golang.org/x/crypto v0.42.0/go.mod h1:4+rDnOTJhQCx2q7/j6rAN5XDw8kPjeaXEUR2eL94ix8=
+golang.org/x/crypto v0.43.0 h1:dduJYIi3A3KOfdGOHX8AVZ/jGiyPa3IbBozJ5kNuE04=
+golang.org/x/crypto v0.43.0/go.mod h1:BFbav4mRNlXJL4wNeejLpWxB7wMbc79PdRGhWKncxR0=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
@@ -977,6 +1052,8 @@ golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EH
 golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU=
 golang.org/x/exp v0.0.0-20250911091902-df9299821621 h1:2id6c1/gto0kaHYyrixvknJ8tUK/Qs5IsmBtrc+FtgU=
 golang.org/x/exp v0.0.0-20250911091902-df9299821621/go.mod h1:TwQYMMnGpvZyc+JpB/UAuTNIsVJifOlSkrZkhcvpVUk=
+golang.org/x/exp v0.0.0-20251023183803-a4bb9ffd2546 h1:mgKeJMpvi0yx/sU5GsxQ7p6s2wtOnGAHZWCHUM4KGzY=
+golang.org/x/exp v0.0.0-20251023183803-a4bb9ffd2546/go.mod h1:j/pmGrbnkbPtQfxEe5D0VQhZC6qKbfKifgD0oM7sR70=
 golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
 golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
 golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
@@ -1042,6 +1119,8 @@ golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qx
 golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
 golang.org/x/net v0.44.0 h1:evd8IRDyfNBMBTTY5XRF1vaZlD+EmWx6x8PkhR04H/I=
 golang.org/x/net v0.44.0/go.mod h1:ECOoLqd5U3Lhyeyo/QDCEVQ4sNgYsqvCZ722XogGieY=
+golang.org/x/net v0.46.0 h1:giFlY12I07fugqwPuWJi68oOnpfqFnJIJzaIIm2JVV4=
+golang.org/x/net v0.46.0/go.mod h1:Q9BGdFy1y4nkUwiLvT5qtyhAnEHgnQ/zd8PfU6nc210=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
@@ -1139,11 +1218,15 @@ golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.36.0 h1:KVRy2GtZBrk1cBYA7MKu5bEZFxQk4NIDV6RLVcC8o0k=
 golang.org/x/sys v0.36.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/sys v0.38.0 h1:3yZWxaJjBmCWXqhN1qh02AkOnCQ1poK6oF+a7xWL6Gc=
+golang.org/x/sys v0.38.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
 golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/term v0.35.0 h1:bZBVKBudEyhRcajGcNc3jIfWPqV4y/Kt2XcoigOWtDQ=
 golang.org/x/term v0.35.0/go.mod h1:TPGtkTLesOwf2DE8CgVYiZinHAOuy5AYUYT1lENIZnA=
+golang.org/x/term v0.36.0 h1:zMPR+aF8gfksFprF/Nc/rd1wRS1EI6nDBGyWAvDzx2Q=
+golang.org/x/term v0.36.0/go.mod h1:Qu394IJq6V6dCBRgwqshf3mPF85AqzYEzofzRdZkWss=
 golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
@@ -1155,6 +1238,8 @@ golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 golang.org/x/text v0.29.0 h1:1neNs90w9YzJ9BocxfsQNHKuAT4pkghyXc4nhZ6sJvk=
 golang.org/x/text v0.29.0/go.mod h1:7MhJOA9CD2qZyOKYazxdYMF85OwPdEr9jTtBpO7ydH4=
+golang.org/x/text v0.30.0 h1:yznKA/E9zq54KzlzBEAWn1NXSQ8DIp/NYMy88xJjl4k=
+golang.org/x/text v0.30.0/go.mod h1:yDdHFIX9t+tORqspjENWgzaCVXgk0yYnYuSZ8UzzBVM=
 golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
@@ -1163,6 +1248,8 @@ golang.org/x/time v0.0.0-20200416051211-89c76fbcd5d1/go.mod h1:tRJNPiyCQ0inRvYxb
 golang.org/x/time v0.0.0-20200630173020-3af7569d3a1e/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.13.0 h1:eUlYslOIt32DgYD6utsuUeHs4d7AsEYLuIAdg7FlYgI=
 golang.org/x/time v0.13.0/go.mod h1:eL/Oa2bBBK0TkX57Fyni+NgnyQQN4LitPmob2Hjnqw4=
+golang.org/x/time v0.14.0 h1:MRx4UaLrDotUKUdCIqzPC48t1Y9hANFKIRpNx+Te8PI=
+golang.org/x/time v0.14.0/go.mod h1:eL/Oa2bBBK0TkX57Fyni+NgnyQQN4LitPmob2Hjnqw4=
 golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20181011042414-1f849cf54d09/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
@@ -1260,8 +1347,12 @@ google.golang.org/genproto v0.0.0-20200527145253-8367513e4ece/go.mod h1:jDfRM7Fc
 google.golang.org/genproto v0.0.0-20201110150050-8816d57aaa9a/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
 google.golang.org/genproto/googleapis/api v0.0.0-20250929231259-57b25ae835d4 h1:8XJ4pajGwOlasW+L13MnEGA8W4115jJySQtVfS2/IBU=
 google.golang.org/genproto/googleapis/api v0.0.0-20250929231259-57b25ae835d4/go.mod h1:NnuHhy+bxcg30o7FnVAZbXsPHUDQ9qKWAQKCD7VxFtk=
+google.golang.org/genproto/googleapis/api v0.0.0-20251110190251-83f479183930 h1:8BWFtrvJRbplrKV5VHlIm4YM726eeBPPAL2QDNWhRrU=
+google.golang.org/genproto/googleapis/api v0.0.0-20251110190251-83f479183930/go.mod h1:G5IanEx8/PgI9w6CFcYQf7jMtHQhZruvfM1i3qOqk5U=
 google.golang.org/genproto/googleapis/rpc v0.0.0-20250929231259-57b25ae835d4 h1:i8QOKZfYg6AbGVZzUAY3LrNWCKF8O6zFisU9Wl9RER4=
 google.golang.org/genproto/googleapis/rpc v0.0.0-20250929231259-57b25ae835d4/go.mod h1:HSkG/KdJWusxU1F6CNrwNDjBMgisKxGnc5dAZfT0mjQ=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20251110190251-83f479183930 h1:tK4fkUnnRhig9TsTp4otV1FxwBFYgbKUq1RY0V6KZ4U=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20251110190251-83f479183930/go.mod h1:7i2o+ce6H/6BluujYR+kqX3GKH+dChPTQU19wjRPiGk=
 google.golang.org/grpc v0.0.0-20160317175043-d3ddb4469d5a/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw=
 google.golang.org/grpc v1.0.5/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw=
 google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
@@ -1283,6 +1374,8 @@ google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAG
 google.golang.org/grpc v1.40.0/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34=
 google.golang.org/grpc v1.75.1 h1:/ODCNEuf9VghjgO3rqLcfg8fiOP0nSluljWFlDxELLI=
 google.golang.org/grpc v1.75.1/go.mod h1:JtPAzKiq4v1xcAB2hydNlWI2RnF85XXcV0mhKXr2ecQ=
+google.golang.org/grpc v1.76.0 h1:UnVkv1+uMLYXoIz6o7chp59WfQUYA2ex/BXQ9rHZu7A=
+google.golang.org/grpc v1.76.0/go.mod h1:Ju12QI8M6iQJtbcsV+awF5a4hfJMLi4X0JLo94ULZ6c=
 google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
 google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
 google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
@@ -1298,6 +1391,8 @@ google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQ
 google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
 google.golang.org/protobuf v1.36.9 h1:w2gp2mA27hUeUzj9Ex9FBjsBm40zfaDtEWow293U7Iw=
 google.golang.org/protobuf v1.36.9/go.mod h1:fuxRtAxBytpl4zzqUh6/eyUujkJdNiuEkXntxiD/uRU=
+google.golang.org/protobuf v1.36.10 h1:AYd7cD/uASjIL6Q9LiTjz8JLcrh/88q5UObnmY3aOOE=
+google.golang.org/protobuf v1.36.10/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
 gopkg.in/airbrake/gobrake.v2 v2.0.9/go.mod h1:/h5ZAUhDkGaJfjzjKLSjv6zCL6O0LLBxU4K+aSYdM/U=
 gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
 gopkg.in/cenkalti/backoff.v2 v2.2.1/go.mod h1:S0QdOvT2AlerfSBkp0O+dk+bbIMaNbEmVk876gPCthU=
@@ -1335,6 +1430,7 @@ gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gotest.tools v2.2.0+incompatible h1:VsBPFP1AI068pPrMxtb/S8Zkgf9xEmTLJjfM+P5UIEo=
 gotest.tools v2.2.0+incompatible/go.mod h1:DsYFclhRJ6vuDpmuTbkuFWG+y2sxOXAzmJt81HFBacw=
 gotest.tools/v3 v3.0.2/go.mod h1:3SzNCllyD9/Y+b5r9JIKQ474KzkZyqLqEfYqMsX94Bk=
 gotest.tools/v3 v3.0.3/go.mod h1:Z7Lb0S5l+klDB31fvDQX8ss/FlKDxtlFlw3Oa8Ymbl8=

pkg/client/client.go

@@ -8,6 +8,7 @@ import (
 	"os"
 	"path"
 	"strings"
+	"time"
 
 	"coopcloud.tech/abra/pkg/config"
 	contextPkg "coopcloud.tech/abra/pkg/context"
@@ -83,7 +84,8 @@ func New(serverName string, opts ...Opt) (*client.Client, error) {
 
 		httpClient := &http.Client{
 			Transport: &http.Transport{
-				DialContext: helper.Dialer,
+				DialContext:     helper.Dialer,
+				IdleConnTimeout: 30 * time.Second,
 			},
 		}
 

pkg/deploy/utils.go

@@ -165,13 +165,7 @@ func GetImagesForStack(cl *dockerClient.Client, app appPkg.App) (map[string]stri
 			}
 
 			imageBaseName := reference.Path(imageParsed)
-			namedTag, ok := imageParsed.(reference.NamedTagged)
-			if !ok {
-				// This is an image without a tag
-				images[imageBaseName] = ""
-				continue
-			}
-			imageTag := namedTag.Tag()
+			imageTag := imageParsed.(reference.NamedTagged).Tag()
 
 			existingImageVersion, ok := images[imageBaseName]
 			if !ok {
@@ -288,13 +282,7 @@ func GatherImagesForDeploy(cl *dockerClient.Client, app appPkg.App, compose *com
 		}
 
 		imageBaseName := reference.Path(imageParsed)
-		namedTag, ok := imageParsed.(reference.NamedTagged)
-		if !ok {
-			// This is an image without a tag
-			newImages[imageBaseName] = ""
-			continue
-		}
-		imageTag := namedTag.Tag()
+		imageTag := imageParsed.(reference.NamedTagged).Tag()
 
 		existingImageVersion, ok := newImages[imageBaseName]
 		if !ok {

pkg/git/commit.go

@@ -35,7 +35,7 @@ func Commit(repoPath, commitMessage string, dryRun bool) error {
 
 	if !dryRun {
 		// NOTE(d1): `All: true` does not include untracked files
-		_, err := commitWorktree.Commit(commitMessage, &git.CommitOptions{All: true})
+		_, err = commitWorktree.Commit(commitMessage, &git.CommitOptions{All: true})
 		if err != nil {
 			return err
 		}

pkg/i18n/i18n.go

@@ -23,14 +23,6 @@ var (
 	GC            = Mo.GetC
 )
 
-func GetLocaleStr() string {
-	locale := os.Getenv("LANG")
-	if lastUnderscore := strings.LastIndex(locale, "_"); lastUnderscore != -1 {
-		locale = locale[0:lastUnderscore]
-	}
-	return locale
-}
-
 func LoadLocale() (string, *gotext.Mo) {
 	entries, err := assetFS.ReadDir("locales")
 	if err != nil {
@@ -46,7 +38,11 @@ func LoadLocale() (string, *gotext.Mo) {
 		}
 	}
 
-	locale := GetLocaleStr()
+	locale := os.Getenv("LANG")
+	if lastUnderscore := strings.LastIndex(locale, "_"); lastUnderscore != -1 {
+		locale = locale[0:lastUnderscore]
+	}
+
 	if locale != "" {
 		if slices.Contains(linguas, locale) {
 			Locale = locale

pkg/lint/recipe.go

@@ -142,7 +142,7 @@ var LintRules = map[string][]LintRule{
 			Function:     LintAppService,
 		},
 		{
-			Ref:          "R016",
+			Ref:          "R015",
 			Level:        i18n.G("error"),
 			Description:  i18n.G("deploy labels stanza present"),
 			HowToResolve: i18n.G("include \"deploy: labels: ...\" stanza"),
@@ -258,7 +258,7 @@ func LintAppService(recipe recipe.Recipe) (bool, error) {
 func LintTraefikEnabledSkipCondition(r recipe.Recipe) (bool, error) {
 	sampleEnv, err := r.SampleEnv()
 	if err != nil {
-		return false, errors.New(i18n.G(".env.sample for %s couldn't be read: %s", r.Name, err))
+		return false, errors.New(i18n.G("unable to discover .env.sample for %s", r.Name))
 	}
 
 	if _, ok := sampleEnv["DOMAIN"]; !ok {

pkg/recipe/files.go

@@ -15,7 +15,7 @@ import (
 func (r Recipe) SampleEnv() (map[string]string, error) {
 	sampleEnv, err := envfile.ReadEnv(r.SampleEnvPath)
 	if err != nil {
-		return sampleEnv, errors.New(i18n.G(".env.sample for %s couldn't be read: %s", r.Name, err))
+		return sampleEnv, errors.New(i18n.G("unable to discover .env.sample for %s", r.Name))
 	}
 	return sampleEnv, nil
 }

pkg/recipe/git.go

@@ -32,12 +32,6 @@ func (r Recipe) Ensure(ctx EnsureContext) error {
 		return err
 	}
 
-	// NOTE(d1): if we cannot parse the .env.sample then there is a
-	//           fundamental problem which requires solving right now
-	if _, err := r.SampleEnv(); err != nil {
-		return err
-	}
-
 	if ctx.Chaos {
 		return nil
 	}
@@ -409,18 +403,15 @@ func (r Recipe) GetRecipeVersions() (RecipeVersions, []string, error) {
 			Branch: plumbing.ReferenceName(ref.Name()),
 		}
 		if err := worktree.Checkout(checkOutOpts); err != nil {
-			log.Debug(i18n.G("failed to check out %s in %s: %s", tag, r.Dir, err))
-			warnMsg = append(warnMsg, i18n.G("skipping tag %s: checkout failed: %s", tag, err))
-			return nil
+			log.Debug(i18n.G("failed to check out %s in %s", tag, r.Dir))
+			return err
 		}
 
 		log.Debug(i18n.G("git checkout: %s in %s", ref.Name(), r.Dir))
 
 		config, err := r.GetComposeConfig(nil)
 		if err != nil {
-			log.Debug(i18n.G("failed to get compose config for %s: %s", tag, err))
-			warnMsg = append(warnMsg, i18n.G("skipping tag %s: invalid compose config: %s", tag, err))
-			return nil
+			return err
 		}
 
 		versionMeta := make(map[string]ServiceMeta)
@@ -428,9 +419,7 @@ func (r Recipe) GetRecipeVersions() (RecipeVersions, []string, error) {
 
 			img, err := reference.ParseNormalizedNamed(service.Image)
 			if err != nil {
-				log.Debug(i18n.G("failed to parse image for %s in %s: %s", service.Name, tag, err))
-				warnMsg = append(warnMsg, i18n.G("skipping tag %s: invalid image reference in service %s: %s", tag, service.Name, err))
-				return nil
+				return err
 			}
 
 			path := reference.Path(img)
@@ -456,7 +445,6 @@ func (r Recipe) GetRecipeVersions() (RecipeVersions, []string, error) {
 
 		return nil
 	}); err != nil {
-		log.Warn(i18n.G("GetRecipeVersions encountered error for %s: %s (collected %d versions)", r.Name, err, len(versions)))
 		return versions, warnMsg, nil
 	}
 

pkg/secret/secret.go

@@ -5,8 +5,6 @@ package secret
 
 import (
 	"context"
-	"crypto/rand"
-	"encoding/base64"
 	"errors"
 	"fmt"
 	"slices"
@@ -41,14 +39,6 @@ type Secret struct {
 	// variable. For Example:
 	//   SECRET_FOO=v1 # charset=default,special
 	Charset string
-	// Encoding comes from the encoding modifier at the secret version environment
-	// variable. For Example:
-	//   SECRET_FOO=v1 # encoding=base64
-	Encoding string
-	// Prefix comes from the prefix modifier at the secret version environment
-	// variable. For Example:
-	//   SECRET_FOO=v1 # prefix=base64:
-	Prefix string
 	// Whether or not to skip generation of the secret or not
 	// For example: SECRET_FOO=v1 # generate=false
 	SkipGenerate bool
@@ -97,17 +87,6 @@ func GeneratePassphrase() (string, error) {
 	return passphrases[0], nil
 }
 
-// generateRandomBytes generates random bytes as a string
-func generateRandomBytes(length int) (string, error) {
-	randomBytes := make([]byte, length)
-	if _, err := rand.Read(randomBytes); err != nil {
-		return "", errors.New(i18n.G("failed to generate random bytes: %w", err))
-	}
-
-	// Return as string for consistent handling with other secret types
-	return string(randomBytes), nil
-}
-
 // ReadSecretsConfig reads secret names/versions from the recipe config. The
 // function generalises appEnv/composeFiles because some times you have an app
 // and some times you don't (as the caller). We need to be able to handle the
@@ -198,8 +177,6 @@ func ReadSecretsConfig(appEnvPath string, composeFiles []string, stackName strin
 			}
 
 			value.Charset = resolveCharset(modifierValues["charset"])
-			value.Encoding = resolveEncoding(value.Charset, modifierValues["encoding"], secretId)
-			value.Prefix = modifierValues["prefix"]
 			break
 		}
 		secretValues[secretId] = value
@@ -208,45 +185,11 @@ func ReadSecretsConfig(appEnvPath string, composeFiles []string, stackName strin
 	return secretValues, nil
 }
 
-// encodeSecret applies encoding to the generated secret value
-func encodeSecret(value, encoding string) string {
-	switch strings.ToLower(encoding) {
-	case "base64":
-		return base64.StdEncoding.EncodeToString([]byte(value))
-	default:
-		return value // No encoding applied
-	}
-}
-
-// applyPrefix adds a prefix to the secret value
-func applyPrefix(value, prefix string) string {
-	if prefix != "" {
-		return prefix + value
-	}
-	return value
-}
-
-// resolveEncoding validates and resolves the encoding for a given charset and secretId
-func resolveEncoding(charset, encoding, secretId string) string {
-	if charset == "bytes" {
-		if encoding == "" {
-			return "base64"
-		} else if encoding != "base64" {
-			log.Warnf(i18n.G("charset=bytes only supports encoding=base64, got encoding=%s for secret %s, defaulting to base64", encoding, secretId))
-			return "base64"
-		}
-	}
-
-	return encoding
-}
-
 // resolveCharset sets the passgen Alphabet required for a secret
 func resolveCharset(input string) string {
 	switch strings.ToLower(input) {
 	case "hex":
 		return passgen.AlphabetNumericAmbiguous + "abcdef"
-	case "bytes":
-		return "bytes"
 	case "special":
 		return passgen.AlphabetSpecial
 	case "safespecial":
@@ -281,23 +224,12 @@ func GenerateSecrets(cl *dockerClient.Client, secrets map[string]Secret, server
 			log.Debug(i18n.G("attempting to generate and store %s on %s", secret.RemoteName, server))
 
 			if secret.Length > 0 {
-				var password string
-				var err error
-
-				if secret.Charset == "bytes" {
-					password, err = generateRandomBytes(secret.Length)
-				} else {
-					password, err = GeneratePassword(uint(secret.Length), secret.Charset)
-				}
-
+				password, err := GeneratePassword(uint(secret.Length), secret.Charset)
 				if err != nil {
 					ch <- err
 					return
 				}
 
-				password = encodeSecret(password, secret.Encoding)
-				password = applyPrefix(password, secret.Prefix)
-
 				if err := client.StoreSecret(cl, secret.RemoteName, password); err != nil {
 					if strings.Contains(err.Error(), "AlreadyExists") {
 						log.Warnf(i18n.G("%s already exists", secret.RemoteName))
@@ -318,9 +250,6 @@ func GenerateSecrets(cl *dockerClient.Client, secrets map[string]Secret, server
 					return
 				}
 
-				passphrase = encodeSecret(passphrase, secret.Encoding)
-				passphrase = applyPrefix(passphrase, secret.Prefix)
-
 				if err := client.StoreSecret(cl, secret.RemoteName, passphrase); err != nil {
 					if strings.Contains(err.Error(), "AlreadyExists") {
 						log.Warnf(i18n.G("%s already exists", secret.RemoteName))

pkg/secret/secret_test.go

@@ -18,80 +18,42 @@ func TestReadSecretsConfig(t *testing.T) {
 	assert.Equal(t, "v2", secretsFromConfig["test_pass_one"].Version)
 	assert.Equal(t, 0, secretsFromConfig["test_pass_one"].Length)
 	assert.Equal(t, "abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789", secretsFromConfig["test_pass_one"].Charset)
-	assert.Equal(t, "", secretsFromConfig["test_pass_one"].Encoding)
-	assert.Equal(t, "", secretsFromConfig["test_pass_one"].Prefix)
 
 	// Has a length modifier
 	assert.Equal(t, "test_example_com_test_pass_two_v1", secretsFromConfig["test_pass_two"].RemoteName)
 	assert.Equal(t, "v1", secretsFromConfig["test_pass_two"].Version)
 	assert.Equal(t, 10, secretsFromConfig["test_pass_two"].Length)
 	assert.Equal(t, "abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789", secretsFromConfig["test_pass_two"].Charset)
-	assert.Equal(t, "", secretsFromConfig["test_pass_two"].Encoding)
-	assert.Equal(t, "", secretsFromConfig["test_pass_two"].Prefix)
 
 	// Secret name does not include the secret id
 	assert.Equal(t, "test_example_com_pass_three_v2", secretsFromConfig["test_pass_three"].RemoteName)
 	assert.Equal(t, "v2", secretsFromConfig["test_pass_three"].Version)
 	assert.Equal(t, 0, secretsFromConfig["test_pass_three"].Length)
 	assert.Equal(t, "abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789", secretsFromConfig["test_pass_three"].Charset)
-	assert.Equal(t, "", secretsFromConfig["test_pass_three"].Encoding)
-	assert.Equal(t, "", secretsFromConfig["test_pass_three"].Prefix)
 
 	// Has a length modifier and a charset=default,safespecial modifier
 	assert.Equal(t, "test_example_com_test_pass_four_v1", secretsFromConfig["test_pass_four"].RemoteName)
 	assert.Equal(t, "v1", secretsFromConfig["test_pass_four"].Version)
 	assert.Equal(t, 12, secretsFromConfig["test_pass_four"].Length)
 	assert.Equal(t, "abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789!@#%^&*_-+=", secretsFromConfig["test_pass_four"].Charset)
-	assert.Equal(t, "", secretsFromConfig["test_pass_four"].Encoding)
-	assert.Equal(t, "", secretsFromConfig["test_pass_four"].Prefix)
 
 	// Has a length modifier and a charset=default,special modifier
 	assert.Equal(t, "test_example_com_test_pass_five_v1", secretsFromConfig["test_pass_five"].RemoteName)
 	assert.Equal(t, "v1", secretsFromConfig["test_pass_five"].Version)
 	assert.Equal(t, 12, secretsFromConfig["test_pass_five"].Length)
 	assert.Equal(t, "abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789!@#$%^&*_-+=", secretsFromConfig["test_pass_five"].Charset)
-	assert.Equal(t, "", secretsFromConfig["test_pass_five"].Encoding)
-	assert.Equal(t, "", secretsFromConfig["test_pass_five"].Prefix)
 
 	// Has only a charset=default,special modifier, which gets setted but ignored in the generation
 	assert.Equal(t, "test_example_com_test_pass_six_v1", secretsFromConfig["test_pass_six"].RemoteName)
 	assert.Equal(t, "v1", secretsFromConfig["test_pass_six"].Version)
 	assert.Equal(t, 0, secretsFromConfig["test_pass_six"].Length)
 	assert.Equal(t, "abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789!@#$%^&*_-+=", secretsFromConfig["test_pass_six"].Charset)
-	assert.Equal(t, "", secretsFromConfig["test_pass_six"].Encoding)
-	assert.Equal(t, "", secretsFromConfig["test_pass_six"].Prefix)
 
 	// Has a length modifier and a charset=hex modifier
 	assert.Equal(t, "test_example_com_test_pass_seven_v1", secretsFromConfig["test_pass_seven"].RemoteName)
 	assert.Equal(t, "v1", secretsFromConfig["test_pass_seven"].Version)
 	assert.Equal(t, 32, secretsFromConfig["test_pass_seven"].Length)
 	assert.Equal(t, "0123456789abcdef", secretsFromConfig["test_pass_seven"].Charset)
-	assert.Equal(t, "", secretsFromConfig["test_pass_seven"].Encoding)
-	assert.Equal(t, "", secretsFromConfig["test_pass_seven"].Prefix)
-
-	// Has a length modifier and an encoding=base64 modifier
-	assert.Equal(t, "test_example_com_test_pass_eight_v1", secretsFromConfig["test_pass_eight"].RemoteName)
-	assert.Equal(t, "v1", secretsFromConfig["test_pass_eight"].Version)
-	assert.Equal(t, 12, secretsFromConfig["test_pass_eight"].Length)
-	assert.Equal(t, "abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789", secretsFromConfig["test_pass_eight"].Charset)
-	assert.Equal(t, "base64", secretsFromConfig["test_pass_eight"].Encoding)
-	assert.Equal(t, "", secretsFromConfig["test_pass_eight"].Prefix)
-
-	// Has a length modifier and a prefix=base64: modifier
-	assert.Equal(t, "test_example_com_test_pass_nine_v1", secretsFromConfig["test_pass_nine"].RemoteName)
-	assert.Equal(t, "v1", secretsFromConfig["test_pass_nine"].Version)
-	assert.Equal(t, 16, secretsFromConfig["test_pass_nine"].Length)
-	assert.Equal(t, "abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789", secretsFromConfig["test_pass_nine"].Charset)
-	assert.Equal(t, "", secretsFromConfig["test_pass_nine"].Encoding)
-	assert.Equal(t, "base64:", secretsFromConfig["test_pass_nine"].Prefix)
-
-	// Has all modifiers: length, charset=bytes, and prefix=base64: (Laravel-style)
-	assert.Equal(t, "test_example_com_test_pass_ten_v1", secretsFromConfig["test_pass_ten"].RemoteName)
-	assert.Equal(t, "v1", secretsFromConfig["test_pass_ten"].Version)
-	assert.Equal(t, 32, secretsFromConfig["test_pass_ten"].Length)
-	assert.Equal(t, "bytes", secretsFromConfig["test_pass_ten"].Charset)
-	assert.Equal(t, "base64", secretsFromConfig["test_pass_ten"].Encoding) // Defaults to base64 for bytes
-	assert.Equal(t, "base64:", secretsFromConfig["test_pass_ten"].Prefix)
 }
 
 func TestReadSecretsConfigWithLongDomain(t *testing.T) {
@@ -102,48 +64,3 @@ func TestReadSecretsConfigWithLongDomain(t *testing.T) {
 	}
 	assert.Contains(t, err.Error(), "is > 64 chars")
 }
-
-func TestEncodeSecret(t *testing.T) {
-	// base64 encoding
-	input := "testpassword123"
-	encoded := encodeSecret(input, "base64")
-	expected := "dGVzdHBhc3N3b3JkMTIz"
-	assert.Equal(t, expected, encoded)
-
-	// no encoding (default)
-	noEncoding := encodeSecret(input, "")
-	assert.Equal(t, input, noEncoding)
-
-	// unknown encoding (should return original)
-	unknownEncoding := encodeSecret(input, "unknown")
-	assert.Equal(t, input, unknownEncoding)
-}
-
-func TestApplyPrefix(t *testing.T) {
-	input := "testvalue"
-
-	// with prefix
-	prefixed := applyPrefix(input, "base64:")
-	assert.Equal(t, "base64:testvalue", prefixed)
-
-	// with empty prefix
-	noPrefixed := applyPrefix(input, "")
-	assert.Equal(t, input, noPrefixed)
-}
-
-func TestGenerateRandomBytes(t *testing.T) {
-	// random bytes generation with 32 bytes
-	key, err := generateRandomBytes(32)
-	assert.NoError(t, err)
-	assert.Equal(t, 32, len([]byte(key))) // Check raw byte length
-
-	// random bytes generation with 16 bytes
-	key16, err := generateRandomBytes(16)
-	assert.NoError(t, err)
-	assert.Equal(t, 16, len([]byte(key16))) // Check raw byte length
-
-	// that keys are different (randomness)
-	key2, err := generateRandomBytes(32)
-	assert.NoError(t, err)
-	assert.NotEqual(t, key, key2)
-}

pkg/secret/testdir/.env.sample

@@ -5,6 +5,3 @@ SECRET_TEST_PASS_FOUR_VERSION=v1 # length=12 charset=default,safespecial
 SECRET_TEST_PASS_FIVE_VERSION=v1 # length=12 charset=default,special
 SECRET_TEST_PASS_SIX_VERSION=v1 # charset=default,special
 SECRET_TEST_PASS_SEVEN_VERSION=v1 # length=32 charset=hex
-SECRET_TEST_PASS_EIGHT_VERSION=v1 # length=12 encoding=base64
-SECRET_TEST_PASS_NINE_VERSION=v1 # length=16 prefix=base64:
-SECRET_TEST_PASS_TEN_VERSION=v1 # length=32 charset=bytes prefix=base64:

pkg/secret/testdir/compose.yaml

@@ -12,9 +12,6 @@ services:
       - test_pass_five
       - test_pass_six
       - test_pass_seven
-      - test_pass_eight
-      - test_pass_nine
-      - test_pass_ten
 
 secrets:
   test_pass_one:
@@ -38,12 +35,3 @@ secrets:
   test_pass_seven:
     external: true
     name: ${STACK_NAME}_test_pass_seven_${SECRET_TEST_PASS_SEVEN_VERSION}
-  test_pass_eight:
-    external: true
-    name: ${STACK_NAME}_test_pass_eight_${SECRET_TEST_PASS_EIGHT_VERSION}
-  test_pass_nine:
-    external: true
-    name: ${STACK_NAME}_test_pass_nine_${SECRET_TEST_PASS_NINE_VERSION}
-  test_pass_ten:
-    external: true
-    name: ${STACK_NAME}_test_pass_ten_${SECRET_TEST_PASS_TEN_VERSION}

pkg/upstream/stack/loader.go

@@ -138,7 +138,7 @@ func loadConfigFile(filename string) (*composetypes.ConfigFile, error) {
 
 	config, err := loader.ParseYAML(bytes)
 	if err != nil {
-		return nil, fmt.Errorf("%s: %s", filename, err)
+		return nil, err
 	}
 
 	return &composetypes.ConfigFile{

pkg/upstream/stack/stack.go

@@ -19,7 +19,7 @@ import (
 	"coopcloud.tech/abra/pkg/ui"
 	"coopcloud.tech/abra/pkg/upstream/convert"
 	"github.com/docker/cli/cli/command"
-	"github.com/docker/cli/cli/command/stack/formatter"
+	"github.com/docker/cli/cli/command/formatter"
 	composetypes "github.com/docker/cli/cli/compose/types"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/container"

scripts/installer/installer

@@ -1,8 +1,8 @@
 #!/usr/bin/env bash
 
-ABRA_VERSION="0.13.0-beta"
+ABRA_VERSION="0.12.0-beta"
 ABRA_RELEASE_URL="https://git.coopcloud.tech/api/v1/repos/toolshed/abra/releases/tags/$ABRA_VERSION"
-RC_VERSION="0.13.0-beta"
+RC_VERSION="0.12.0-beta"
 RC_VERSION_URL="https://git.coopcloud.tech/api/v1/repos/toolshed/abra/releases/tags/$RC_VERSION"
 
 for arg in "$@"; do
@@ -89,7 +89,7 @@ function install_abra_release {
   if [ $? -ne 0 ]; then
       echo "$(tput setaf 3)WARNING: $HOME/.local/bin/ is not in \$PATH! If you want to run abra by just typing "abra" you should add it to your \$PATH! To do that run this once and restart your terminal:$(tput sgr0)"
       p=$HOME/.local/bin
-      com='echo PATH="$PATH:'"$p"'"'
+      com="echo PATH=\$PATH:$p"
       if [[ $SHELL =~ "bash" ]]; then
           echo "$com >> $HOME/.bashrc"
       elif [[ $SHELL =~ "fizsh" ]]; then

tests/integration/app_check.bats

@@ -106,7 +106,7 @@ teardown(){
 
   run $ABRA app check "$TEST_APP_DOMAIN" --chaos
   assert_failure
-  assert_output --partial 'no such file or directory'
+  assert_output --partial 'unable to discover .env.sample'
 }
 
 @test "error if missing env var" {

tests/integration/app_deploy.bats

@@ -23,24 +23,12 @@ teardown(){
   _reset_recipe
   _undeploy_app
   _undeploy_app2 "gitea.$TEST_SERVER"
-  _undeploy_app2 "zammad.$TEST_SERVER"
 
   _reset_app
   _reset_tags
 
   run rm -rf "$ABRA_DIR/recipes/$TEST_RECIPE/foo"
   assert_not_exists "$ABRA_DIR/recipes/$TEST_RECIPE/foo"
-
-  if [[ -d "$ABRA_DIR/recipes/foo" ]]; then
-    run rm -rf "$ABRA_DIR/recipes/foo"
-    assert_not_exists "$ABRA_DIR/recipes/foo"
-  fi
-
-  # NOTE(d1): give some extra space for the pure chaos that we are unleashing
-  #           on the CI machine with these deploy tests. the hope is to prevent
-  #           lock-ups and network failures which are common in flaky swarm
-  #           mode
-  sleep 1
 }
 
 @test "validate app argument" {
@@ -87,10 +75,8 @@ teardown(){
   assert_success
 }
 
+# bats test_tags=slow
 @test "bail if recipe lint errors and no --chaos" {
-  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" checkout main
-  assert_success
-
   # Break the recipe
   run sed -i '/traefik.enable=.*/d' "$ABRA_DIR/recipes/$TEST_RECIPE/compose.yml"
   assert_success
@@ -102,8 +88,8 @@ teardown(){
   assert_success
 
   # Make a broken release
+  run $ABRA recipe sync --patch "$TEST_RECIPE"
   run $ABRA recipe release --patch -n "$TEST_RECIPE"
-  assert_success
 
   # Make sure we deploy latest
   _wipe_env_version
@@ -616,89 +602,3 @@ teardown(){
   refute_output --partial "WITH_COMMENT=foo"
   assert_output --partial "WITH_COMMENT=bar"
 }
-
-# bats test_tags=slow
-@test "deploy with udp and tcp on same port" {
-  run sed -i 's/TYPE=abra-test-recipe:.*/TYPE=git.coopcloud.tech\/p4u1\/abra-test-recipe:030e8a1cb1a0f17281847b3e55d829220ad32c50/g' \
-    "$ABRA_DIR/servers/$TEST_SERVER/$TEST_APP_DOMAIN.env"
-  assert_success
-
-  run bash -c "printf '\nCOMPOSE_FILE=\"\$COMPOSE_FILE:compose.udp-and-tcp.yml\"' >> $ABRA_DIR/servers/$TEST_SERVER/$TEST_APP_DOMAIN.env"
-  assert_success
-
-  run $ABRA app deploy "$TEST_APP_DOMAIN" --no-input
-  assert_success
-
-  run docker service inspect  --format '{{ range .Endpoint.Ports }}{{ .Protocol }}={{ .PublishedPort }}{{ end }}' \
-    "${TEST_APP_DOMAIN//./_}_app"
-  assert_success
-  assert_output --partial "tcp=1312"
-  assert_output --partial "udp=1312"
-}
-
-# bats test_tags=slow
-@test "does not crash when docker image has no tag" {
-  run sed -i 's/TYPE=abra-test-recipe:.*/TYPE=git.coopcloud.tech\/p4u1\/abra-test-recipe:b29422d5a344ea45df271443182f775ea82b4da8/g' \
-    "$ABRA_DIR/servers/$TEST_SERVER/$TEST_APP_DOMAIN.env"
-  assert_success
-
-  run bash -c "printf '\nCOMPOSE_FILE=\"\$COMPOSE_FILE:compose.no-image-tag.yml\"' >> $ABRA_DIR/servers/$TEST_SERVER/$TEST_APP_DOMAIN.env"
-  assert_success
-
-  run $ABRA app deploy "$TEST_APP_DOMAIN" --no-input
-  assert_success
-}
-
-
-@test "does not use old recipe version when recipe is broken" {
-  run $ABRA app new zammad \
-    --no-input \
-    --server "$TEST_SERVER" \
-    --domain "zammad.$TEST_SERVER" \
-    --secrets
-  assert_success
-  assert_exists "$ABRA_DIR/servers/$TEST_SERVER/zammad.$TEST_SERVER.env"
-
-  # NOTE(d1): --no-converge-checks because the zammad recipe is a beast and we
-  #           mostly only care about the correct version being used
-  run $ABRA app deploy "zammad.$TEST_SERVER" \
-    --no-input --no-converge-checks
-  assert_success
-  refute_output --partial "1.0.0+6.3.1-95"
-}
-
-# bats test_tags=slow
-@test "unable to deploy borked tag" {
-  _remove_tags
-
-  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" tag \
-    -a "2.4.8_1" -m "feat: completely borked tag"
-  assert_success
-
-  run $ABRA app deploy "$TEST_APP_DOMAIN" "2.4.8_1" \
-    --no-input --no-converge-checks --debug
-  assert_failure
-  assert_output --partial "unable to parse"
-}
-
-# bats test_tags=slow
-@test "app deploy with borked sample env gives useful error" {
-  run $ABRA recipe new foo --no-input
-  assert_success
-
-  run $ABRA app new foo \
-    --no-input \
-    --server "$TEST_SERVER" \
-    --domain "foo.$TEST_SERVER" \
-    --chaos
-  assert_success
-  assert_exists "$ABRA_DIR/servers/$TEST_SERVER/foo.$TEST_SERVER.env"
-
-  run bash -c "printf '\nEVIL-VAR=EVIL' >> $ABRA_DIR/recipes/foo/.env.sample"
-  assert_success
-
-  run $ABRA app deploy "foo.$TEST_SERVER" \
-    --no-input --no-converge-checks --chaos
-  assert_failure
-  assert_output --partial "unexpected character"
-}

tests/integration/app_list.bats

@@ -67,16 +67,6 @@ teardown(){
   assert_output --partial "$TEST_SERVER"
   assert_output --partial "$TEST_APP_DOMAIN"
   assert_output --partial "deployed"
-  assert_output --partial "latest"
-
-  _remove_tags
-
-  run $ABRA app ls --status
-  assert_success
-  assert_output --partial "$TEST_SERVER"
-  assert_output --partial "$TEST_APP_DOMAIN"
-  assert_output --partial "deployed"
-  assert_output --partial "latest"
 }
 
 @test "filter by server" {
@@ -161,7 +151,7 @@ teardown(){
     --no-input --no-converge-checks --chaos
   assert_success
 
-  run $ABRA app ls --status --chaos
+  run $ABRA app ls --status
   assert_success
   assert_output --partial "+U"
 
@@ -190,16 +180,13 @@ teardown(){
 
 # bats test_tags=slow
 @test "list ignores borked tags" {
-  run $ABRA app deploy "$TEST_APP_DOMAIN" \
-    --no-input --no-converge-checks
+  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" tag \
+    -a "2.4.8_1" -m "feat: completely borked tag"
   assert_success
 
-  # NOTE(d1): always upgradable tag which is also borked
-  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" tag \
-    -a "100.100.100_1_2_3" -m "feat: completely borked tag"
-  assert_success
+  _deploy_app
 
   run $ABRA app ls --status --debug
   assert_success
-  assert_output --partial "unable to parse"
+  assert_output --partial "unable to parse 2.4.8_1"
 }

tests/integration/app_new.bats

@@ -63,30 +63,6 @@ teardown(){
   assert_success
 }
 
-@test "ensure recipe is up-to-date" {
-  run bash -c 'git -C "$ABRA_DIR/recipes/$TEST_RECIPE" tag -l'
-  assert_success
-  assert_output --partial '0.3.5+1.21.0'
-
-  run bash -c 'git -C "$ABRA_DIR/recipes/$TEST_RECIPE" tag -d 0.3.5+1.21.0'
-  assert_success
-
-  run bash -c 'git -C "$ABRA_DIR/recipes/$TEST_RECIPE" tag -l'
-  assert_success
-  refute_output --partial '0.3.5+1.21.0'
-
-  run $ABRA app new "$TEST_RECIPE" \
-    --no-input \
-    --server "$TEST_SERVER" \
-    --domain "$TEST_APP_DOMAIN"
-  assert_success
-  assert_exists "$ABRA_DIR/servers/$TEST_SERVER/$TEST_APP_DOMAIN.env"
-
-  run grep -q "TYPE=$TEST_RECIPE:0.3.5+1.21.0" \
-    "$ABRA_DIR/servers/$TEST_SERVER/$TEST_APP_DOMAIN.env"
-  assert_success
-}
-
 @test "create new app with version commit" {
   tagHash=$(_get_tag_hash "0.3.0+1.21.0")
 

tests/integration/helpers/common.bash

@@ -13,6 +13,7 @@ _common_setup() {
   load "$PWD/tests/integration/helpers/docker"
 
   export ABRA="$PWD/abra"
+  export KADABRA="$PWD/kadabra"
 
   export TEST_APP_NAME="$(basename "${BATS_TEST_FILENAME//./_}")"
   export TEST_APP_DOMAIN="$TEST_APP_NAME.$TEST_SERVER"
@@ -20,20 +21,4 @@ _common_setup() {
   export TEST_RECIPE="abra-test-recipe"
 
   _ensure_swarm
-  _ensure_ssh_agent
-}
-
-
-_ensure_ssh_agent() {
-  if ! command -v ssh-agent >/dev/null 2>&1
-  then
-    echo "ssh-agent is missing, please install it"
-    exit 1
-  fi
-
-  export SSH_AUTH_SOCK="$HOME/.ssh/ssh_auth_sock"
-  if [ ! -S ~/.ssh/ssh_auth_sock ]; then
-    eval `ssh-agent`
-    ln -sf "$SSH_AUTH_SOCK" ~/.ssh/ssh_auth_sock
-  fi
 }

tests/integration/helpers/git.bash

@@ -17,12 +17,7 @@ _remove_tags(){
 
   run bash -c 'git -C "$ABRA_DIR/recipes/$TEST_RECIPE" tag -l | wc -l'
   assert_success
-  # If this was done without the --regexp I get this error:
-  # -- output differs --
-  # expected : 0
-  # actual   :        0
-  # --
-  assert_output --regexp '[[:space:]]*0'
+  assert_output '0'
 }
 
 _reset_tags() {

tests/integration/helpers/recipe.bash

@@ -5,22 +5,11 @@ _latest_release(){
 }
 
 _fetch_recipe() {
-  # clone first to a bare repo which will serve as origin-ssh
-  # this enables simulating git push in recipe release
   if [[ ! -d "$ABRA_DIR/recipes/$TEST_RECIPE" ]]; then
-    run mkdir -p "$ABRA_DIR/origin-recipes"
-    assert_success
-
-    run git clone "https://git.coopcloud.tech/toolshed/$TEST_RECIPE" "$ABRA_DIR/origin-recipes/$TEST_RECIPE.git" --bare
-    assert_success
-
     run mkdir -p "$ABRA_DIR/recipes"
     assert_success
 
-    run git clone "$ABRA_DIR/origin-recipes/$TEST_RECIPE.git" "$ABRA_DIR/recipes/$TEST_RECIPE"
-    assert_success
-
-    run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" remote add origin-ssh "$ABRA_DIR/origin-recipes/$TEST_RECIPE.git"
+    run git clone "https://git.coopcloud.tech/toolshed/$TEST_RECIPE" "$ABRA_DIR/recipes/$TEST_RECIPE"
     assert_success
   fi
 }
@@ -30,10 +19,6 @@ _reset_recipe(){
   assert_success
   assert_not_exists "$ABRA_DIR/recipes/$TEST_RECIPE"
 
-  run rm -rf "$ABRA_DIR/origin-recipes/$TEST_RECIPE.git"
-  assert_success
-  assert_not_exists "$ABRA_DIR/origin-recipes/$TEST_RECIPE.git"
-
   _fetch_recipe
 }
 

tests/integration/recipe_release.bats

@@ -1,18 +1,18 @@
 #!/usr/bin/env bash
 
-setup_file() {
+setup_file(){
   load "$PWD/tests/integration/helpers/common"
   _common_setup
   _add_server
   _new_app
 }
 
-teardown_file() {
+teardown_file(){
   _rm_server
   _reset_recipe
 }
 
-setup() {
+setup(){
   load "$PWD/tests/integration/helpers/common"
   _common_setup
   _set_git_author
@@ -21,14 +21,6 @@ setup() {
 teardown() {
   _reset_recipe
   _reset_tags
-  if [[ -d "$ABRA_DIR/recipes/foobar" ]]; then
-    run rm -rf "$ABRA_DIR/recipes/foobar"
-    assert_success
-  fi
-  if [[ -d "$ABRA_DIR/origin-recipes/foobar.git" ]]; then
-    run rm -rf "$ABRA_DIR/origin-recipes/foobar.git"
-    assert_success
-  fi
 }
 
 @test "validate recipe argument" {
@@ -40,10 +32,10 @@ teardown() {
 }
 
 @test "release patch bump" {
-  run $ABRA recipe upgrade "$TEST_RECIPE" --no-input --patch --commit
+  run $ABRA recipe upgrade "$TEST_RECIPE" --no-input --patch
   assert_success
 
-  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" show
+  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" diff
   assert_success
   assert_output --partial 'image: nginx:1.21.6'
 
@@ -53,9 +45,17 @@ teardown() {
     -a "0.3.0+1.21.0" -m "fake: 0.3.0+1.21.0"
   assert_success
 
+  run $ABRA recipe sync "$TEST_RECIPE" --no-input --patch
+  assert_success
+  assert_output --partial 'synced label'
+
+  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" diff
+  assert_success
+  assert_output --partial 'coop-cloud.${STACK_NAME}.version=0.3.1+1.21.6'
+
   run $ABRA recipe release "$TEST_RECIPE" --no-input --patch
   assert_success
-  assert_output --partial 'INFO new release published:'
+  assert_output --partial 'no -p/--publish passed, not publishing'
 
   run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" tag --list
   assert_success
@@ -63,10 +63,10 @@ teardown() {
 }
 
 @test "release minor bump" {
-  run $ABRA recipe upgrade "$TEST_RECIPE" --no-input --minor --commit
+  run $ABRA recipe upgrade "$TEST_RECIPE" --no-input --minor
   assert_success
 
-  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" show
+  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" diff
   assert_success
   assert_output --regexp 'image: nginx:1.2.*'
 
@@ -76,57 +76,58 @@ teardown() {
     -a "0.3.0+1.21.0" -m "fake: 0.3.0+1.21.0"
   assert_success
 
+  run $ABRA recipe sync "$TEST_RECIPE" --no-input --minor
+  assert_success
+  assert_output --partial 'synced label'
+
+  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" diff
+  assert_success
+  assert_output --regexp 'coop-cloud\.\$\{STACK_NAME\}\.version=0\.4\.0\+1\.2.*'
+
   run $ABRA recipe release "$TEST_RECIPE" --no-input --minor
   assert_success
-  assert_output --partial 'INFO new release published:'
+  assert_output --partial 'no -p/--publish passed, not publishing'
 
   run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" tag --list
   assert_success
   assert_output --regexp '0\.4\.0\+1\.2.*'
 }
 
-@test "release with unstaged changes" {
-  run bash -c 'echo "# unstaged changes" >> "$ABRA_DIR/recipes/$TEST_RECIPE/compose.yml"'
+@test "unknown files not committed" {
+  run $ABRA recipe upgrade "$TEST_RECIPE" --no-input --patch
   assert_success
 
-  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" diff --quiet
-  assert_failure
+  run bash -c 'echo "unstaged changes" >> "$ABRA_DIR/recipes/$TEST_RECIPE/foo"'
+  assert_success
+  assert_exists "$ABRA_DIR/recipes/$TEST_RECIPE/foo"
+
+  run $ABRA recipe sync "$TEST_RECIPE" --no-input --patch
+  assert_success
 
   run $ABRA recipe release "$TEST_RECIPE" --no-input --patch
-  assert_failure
-  assert_output --partial "working directory not clean"
-}
-
-@test "release with staged changes" {
-  run bash -c 'echo "# staged changes" >> "$ABRA_DIR/recipes/$TEST_RECIPE/compose.yml"'
   assert_success
+  assert_output --partial 'no -p/--publish passed, not publishing'
 
-  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" add compose.yml
-  assert_success
-
-  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" diff --quiet --cached
+  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" rm foo
   assert_failure
-
-  run $ABRA recipe release "$TEST_RECIPE" --no-input --patch
-  assert_failure
-  assert_output --partial "working directory not clean"
+  assert_output --partial "fatal: pathspec 'foo' did not match any files"
 }
 
 @test "release with next release note" {
   _mkfile "$ABRA_DIR/recipes/$TEST_RECIPE/release/next" "those are some release notes for the next release"
 
-  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" checkout main
-  assert_success
-
   run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" add release/next
   assert_success
 
   run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" commit -m "added some release notes"
   assert_success
 
-  run $ABRA recipe release "$TEST_RECIPE" --no-input --minor
+  run $ABRA recipe sync "$TEST_RECIPE" --no-input --patch
   assert_success
-  assert_output --partial 'new release published:'
+
+  run $ABRA recipe release  "$TEST_RECIPE" --no-input  --minor
+  assert_success
+  assert_output --partial 'no -p/--publish passed, not publishing'
 
   assert_not_exists "$ABRA_DIR/recipes/$TEST_RECIPE/release/next"
   assert_exists "$ABRA_DIR/recipes/$TEST_RECIPE/release/0.4.0+1.21.0"
@@ -145,125 +146,14 @@ teardown() {
   assert_success
   assert_output --regexp 'nginx:1.29.1'
 
-  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" commit -am "updated nginx"
+  run sed -i "s/0.2.0+1.21.0/0.2.0+1.29.1/g" "$ABRA_DIR/recipes/$TEST_RECIPE/compose.yml"
   assert_success
 
-  run $ABRA recipe release "$TEST_RECIPE" --no-input "0.2.0+1.29.1"
+  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" diff
+  assert_success
+  assert_output --regexp 'coop-cloud\.\$\{STACK_NAME\}\.version=0\.2\.0\+1\.29\.1'
+
+  run $ABRA recipe release "$TEST_RECIPE" --no-input --minor
   assert_failure
   assert_output --partial '0.2.0+... conflicts with a previous release: 0.2.0+1.21.0'
 }
-
-@test "error if recipe release --no-input and no initial version" {
-  _remove_tags
-
-  run $ABRA recipe release "$TEST_RECIPE" --no-input --patch
-  assert_failure
-  assert_output --partial 'unable to continue'
-  assert_output --partial 'initial version'
-}
-
-@test "recipe release without input fails with prompt" {
-  run $ABRA recipe new foobar
-  assert_success
-  assert_exists "$ABRA_DIR/recipes/foobar"
-
-  run $ABRA recipe release foobar --no-input --patch
-  assert_failure
-  assert_output --partial "input required for initial version"
-}
-
-@test "release new recipe: fail without input" {
-  run $ABRA recipe new foobar
-  assert_success
-  assert_exists "$ABRA_DIR/recipes/foobar"
-
-  run bash -c "$ABRA recipe release foobar --no-input"
-  assert_failure
-  assert_output --partial 'unable to continue, input required for initial version'
-}
-
-# note: piping 0.1.0 from stdin is not testable right now because release notes also wants input
-# survey lib used for prompts breaks multi-line stdin for multi-prompt
-@test "release new recipe: development release" {
-  run $ABRA recipe new foobar
-  assert_success
-  assert_exists "$ABRA_DIR/recipes/foobar"
-
-  # fake origin
-  git clone "$ABRA_DIR/recipes/foobar" "$ABRA_DIR/origin-recipes/foobar.git" --bare
-  assert_success
-
-  run git -C "$ABRA_DIR/recipes/foobar" remote add origin-ssh "$ABRA_DIR/origin-recipes/foobar.git"
-  assert_success
-
-  run bash -c "$ABRA recipe release foobar 0.1.0+1.2.0 --no-input"
-  assert_success
-  assert_output --regexp 'coop-cloud\.\$\{STACK_NAME\}\.version=0\.1\.0\+1\.2.*'
-}
-
-@test "release newly created recipe with no version label" {
-  run $ABRA recipe new foobar
-  assert_success
-  assert_exists "$ABRA_DIR/recipes/foobar"
-
-  run sed -i 's/- "coop-cloud.${STACK_NAME}.version="/#- "coop-cloud.${STACK_NAME}.version="/g' \
-    "$ABRA_DIR/recipes/foobar/compose.yml"
-  assert_success
-
-  run git -C "$ABRA_DIR/recipes/foobar" commit -am "updated nginx"
-  assert_success
-
-  run bash -c "echo 0.1.0 | $ABRA recipe release foobar --patch"
-  assert_failure
-  assert_output --partial "automagic insertion not supported yet"
-}
-
-@test "push during release fails" {
-  tagHash=$(_get_tag_hash "0.2.0+1.21.0")
-  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" checkout "$tagHash"
-  assert_success
-
-  run $ABRA recipe upgrade "$TEST_RECIPE" --no-input --patch --commit
-  assert_success
-
-  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" show
-  assert_success
-  assert_output --partial 'image: nginx:1.21.6'
-
-  wantHash="$(_get_current_hash)"
-
-  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" remote set-url origin-ssh "$ABRA_DIR/does/not/exist"
-  assert_success
-
-  run $ABRA recipe release "$TEST_RECIPE" --no-input --patch
-  assert_failure
-  assert_output --partial 'failed to publish new release:'
-  assert_output --partial 'any changes made have been reverted'
-
-  assert_equal "$wantHash" "$(_get_current_hash)"
-
-  assert_equal "$(_git_status)" ""
-}
-
-@test "release, fail, release: works" {
-  tagHash=$(_get_tag_hash "0.2.0+1.21.0")
-  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" checkout "$tagHash"
-  assert_success
-
-  run $ABRA recipe upgrade "$TEST_RECIPE" --no-input --patch --commit
-  assert_success
-
-  # NOTE(d1): fake broken remote so the release fails
-  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" remote set-url origin-ssh "$ABRA_DIR/does/not/exist"
-  assert_success
-
-  run $ABRA recipe release "$TEST_RECIPE" --no-input --patch
-  assert_failure
-
-  # NOTE(d1): correct remote so release can proceed
-  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" remote set-url origin-ssh "$ABRA_DIR/origin-recipes/$TEST_RECIPE.git"
-  assert_success
-
-  run $ABRA recipe release "$TEST_RECIPE" --no-input --patch
-  assert_success
-}

tests/integration/recipe_sync.bats

@@ -0,0 +1,200 @@
+#!/usr/bin/env bash
+
+setup_file(){
+  load "$PWD/tests/integration/helpers/common"
+  _common_setup
+  _add_server
+  _new_app
+}
+
+teardown_file(){
+  _rm_server
+}
+
+setup(){
+  load "$PWD/tests/integration/helpers/common"
+  _common_setup
+}
+
+teardown(){
+  _reset_recipe
+  _reset_tags
+  if [[ -d "$ABRA_DIR/recipes/foobar" ]]; then
+    run rm -rf "$ABRA_DIR/recipes/foobar"
+    assert_success
+  fi
+}
+
+@test "validate recipe argument" {
+  run $ABRA recipe sync --no-input
+  assert_failure
+
+  run $ABRA recipe sync DOESNTEXIST --no-input
+  assert_failure
+}
+
+@test "allow unstaged changes" {
+  run echo "unstaged changes" >> "$ABRA_DIR/recipes/$TEST_RECIPE/foo"
+  assert_success
+
+  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" status
+  assert_success
+  assert_output --partial 'foo'
+
+  run $ABRA recipe sync "$TEST_RECIPE" --no-input --patch
+  assert_success
+
+  assert_exists "$ABRA_DIR/recipes/$TEST_RECIPE/foo"
+  assert_equal "$(_git_status)" "M compose.yml ?? foo"
+
+  run rm -rf "$ABRA_DIR/recipes/$TEST_RECIPE/foo"
+  assert_success
+  assert_not_exists "$ABRA_DIR/recipes/$TEST_RECIPE/foo"
+}
+
+@test "detect unstaged label changes" {
+  run $ABRA recipe fetch "$TEST_RECIPE"
+  assert_success
+
+  run $ABRA recipe sync "$TEST_RECIPE" --patch
+  assert_success
+
+  run $ABRA recipe sync "$TEST_RECIPE" --patch
+  assert_success
+  assert_output --partial 'is already set, nothing to do?'
+}
+
+@test "sync patch label bump" {
+  run $ABRA recipe upgrade "$TEST_RECIPE" --no-input --patch
+  assert_success
+
+  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" diff
+  assert_success
+  assert_output --partial 'image: nginx:1.21.6'
+
+  # NOTE(d1): ensure the latest tag is the one we expect
+  _remove_tags
+  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" tag \
+    -a "0.3.0+1.21.0" -m "fake: 0.3.0+1.21.0"
+  assert_success
+
+  run $ABRA recipe sync "$TEST_RECIPE" --no-input --patch
+  assert_success
+
+  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" diff
+  assert_success
+  assert_output --regexp 'coop-cloud\.\$\{STACK_NAME\}\.version=0\.3\.1\+1\.2.*'
+}
+
+@test "sync minor label bump" {
+  run $ABRA recipe upgrade "$TEST_RECIPE" --no-input --minor
+  assert_success
+
+  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" diff
+  assert_success
+  assert_output --regexp 'image: nginx:1.2.*'
+
+  # NOTE(d1): ensure the latest tag is the one we expect
+  _remove_tags
+  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" tag \
+    -a "0.3.0+1.21.0" -m "fake: 0.3.0+1.21.0"
+  assert_success
+
+  run $ABRA recipe sync "$TEST_RECIPE" --no-input --minor
+  assert_success
+
+  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" diff
+  assert_success
+  assert_output --regexp 'coop-cloud\.\$\{STACK_NAME\}\.version=0\.4\.0\+1\.2.*'
+}
+
+@test "error if --no-input and no initial version" {
+  _remove_tags
+
+  run $ABRA recipe sync "$TEST_RECIPE" --no-input --patch
+  assert_failure
+  assert_output --partial 'unable to continue'
+  assert_output --partial 'initial version'
+}
+
+@test "output label sync only once" {
+  run $ABRA recipe upgrade "$TEST_RECIPE" --no-input --minor
+  assert_success
+
+  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" diff
+  assert_success
+  assert_output --regexp 'image: nginx:1.2.*'
+
+  run $ABRA recipe sync "$TEST_RECIPE" --no-input --minor
+  assert_success
+  assert_line --index 0 --partial 'synced label'
+  refute_line --index 1 --partial 'synced label'
+}
+
+@test "sync with no tags or previous release" {
+  _remove_tags
+
+  run $ABRA recipe upgrade "$TEST_RECIPE" --no-input --patch
+  assert_success
+
+  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" diff
+  assert_success
+  assert_output --partial 'image: nginx:1.21.6'
+
+  # NOTE(d1): ensure the latest tag is the one we expect
+  _remove_tags
+  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" tag \
+    -a "0.3.0+1.21.0" -m "fake: 0.3.0+1.21.0"
+  assert_success
+
+  run $ABRA recipe sync "$TEST_RECIPE" --no-input --patch
+  assert_success
+
+  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" diff
+  assert_success
+  assert_output --regexp 'coop-cloud\.\$\{STACK_NAME\}\.version=0\.3\.1\+1\.2.*'
+}
+
+@test "sync recipe without input fails with prompt" {
+  run $ABRA recipe new foobar
+  assert_success
+  assert_exists "$ABRA_DIR/recipes/foobar"
+
+  run $ABRA recipe sync foobar --no-input --patch
+  assert_failure
+  assert_output --partial "input required for initial version"
+}
+
+@test "sync new recipe: development release" {
+  run $ABRA recipe new foobar
+  assert_success
+  assert_exists "$ABRA_DIR/recipes/foobar"
+
+  run bash -c "echo 0.1.0 | $ABRA recipe sync foobar --patch"
+  assert_success
+  assert_output --regexp 'coop-cloud\.\$\{STACK_NAME\}\.version=0\.1\.0\+1\.2.*'
+}
+
+@test "sync new recipe: public release" {
+  run $ABRA recipe new foobar
+  assert_success
+  assert_exists "$ABRA_DIR/recipes/foobar"
+
+  run bash -c "echo 1.0.0 | $ABRA recipe sync foobar --patch"
+  assert_success
+  assert_output --regexp 'coop-cloud\.\$\{STACK_NAME\}\.version=1\.0\.0\+1\.2.*'
+}
+
+@test "sync newly created recipe with no version label" {
+  run $ABRA recipe new foobar
+  assert_success
+  assert_exists "$ABRA_DIR/recipes/foobar"
+
+  run sed -i 's/- "coop-cloud.${STACK_NAME}.version="/#- "coop-cloud.${STACK_NAME}.version="/g' \
+    "$ABRA_DIR/recipes/foobar/compose.yml"
+  assert_success
+
+  run bash -c "echo 0.1.0 | $ABRA recipe sync foobar --patch"
+  assert_failure
+  assert_output --partial "automagic insertion not supported yet"
+}

tests/integration/recipe_upgrade.bats

@@ -106,37 +106,3 @@ teardown(){
   assert_success
   assert_output --regexp 'image: nginx:1.2.*'
 }
-
-@test "upgrade and commit" {
-  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" rev-list --count HEAD
-  assert_success
-  expected_count="$((output + 1))"
-
-  run $ABRA recipe upgrade "$TEST_RECIPE" --no-input --minor --commit
-  assert_success
-  assert_output --partial 'committed changes as'
-
-  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" diff --quiet
-  assert_success
-
-  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" rev-list --count HEAD
-  assert_success
-  assert_output "$expected_count"
-}
-
-@test "upgrade nothing, skip commit" {
-  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" rev-list --count HEAD
-  assert_success
-  expected_count="$output"
-
-  run $ABRA recipe upgrade "$TEST_RECIPE" --no-input --commit
-  assert_success
-  assert_output --partial "no changes, skip creating commit"
-
-  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" diff --quiet
-  assert_success
-
-  run git -C "$ABRA_DIR/recipes/$TEST_RECIPE" rev-list --count HEAD
-  assert_success
-  assert_output "$expected_count"
-}

vendor/github.com/charmbracelet/colorprofile/env.go

@@ -153,29 +153,24 @@ func envColorProfile(env environ) (p Profile) {
 		p = ANSI
 	}
 
-	parts := strings.Split(term, "-")
-	switch parts[0] {
-	case "alacritty",
-		"contour",
-		"foot",
-		"ghostty",
-		"kitty",
-		"rio",
-		"st",
-		"wezterm":
+	switch {
+	case strings.Contains(term, "alacritty"),
+		strings.Contains(term, "contour"),
+		strings.Contains(term, "foot"),
+		strings.Contains(term, "ghostty"),
+		strings.Contains(term, "kitty"),
+		strings.Contains(term, "rio"),
+		strings.Contains(term, "st"),
+		strings.Contains(term, "wezterm"):
 		return TrueColor
-	case "xterm":
-		if len(parts) > 1 {
-			switch parts[1] {
-			case "ghostty", "kitty":
-				// These terminals can be defined as xterm-TERMNAME
-				return TrueColor
-			}
-		}
-	case "tmux", "screen":
+	case strings.HasPrefix(term, "tmux"), strings.HasPrefix(term, "screen"):
 		if p < ANSI256 {
 			p = ANSI256
 		}
+	case strings.HasPrefix(term, "xterm"):
+		if p < ANSI {
+			p = ANSI
+		}
 	}
 
 	if isCloudShell, _ := strconv.ParseBool(env.get("GOOGLE_CLOUD_SHELL")); isCloudShell {

vendor/github.com/charmbracelet/x/ansi/mode.go

@@ -108,7 +108,7 @@ func DECRST(modes ...Mode) string {
 
 func setMode(reset bool, modes ...Mode) (s string) {
 	if len(modes) == 0 {
-		return //nolint:nakedret
+		return s
 	}
 
 	cmd := "h"
@@ -142,7 +142,7 @@ func setMode(reset bool, modes ...Mode) (s string) {
 	if len(dec) > 0 {
 		s += seq + "?" + strings.Join(dec, ";") + cmd
 	}
-	return //nolint:nakedret
+	return s
 }
 
 // RequestMode (DECRQM) returns a sequence to request a mode from the terminal.
@@ -228,12 +228,12 @@ func (m DECMode) Mode() int {
 //
 // See: https://vt100.net/docs/vt510-rm/KAM.html
 const (
-	KeyboardActionMode = ANSIMode(2)
-	KAM                = KeyboardActionMode
+	ModeKeyboardAction = ANSIMode(2)
+	KAM                = ModeKeyboardAction
 
-	SetKeyboardActionMode     = "\x1b[2h"
-	ResetKeyboardActionMode   = "\x1b[2l"
-	RequestKeyboardActionMode = "\x1b[2$p"
+	SetModeKeyboardAction     = "\x1b[2h"
+	ResetModeKeyboardAction   = "\x1b[2l"
+	RequestModeKeyboardAction = "\x1b[2$p"
 )
 
 // Insert/Replace Mode (IRM) is a mode that determines whether characters are
@@ -245,12 +245,12 @@ const (
 //
 // See: https://vt100.net/docs/vt510-rm/IRM.html
 const (
-	InsertReplaceMode = ANSIMode(4)
-	IRM               = InsertReplaceMode
+	ModeInsertReplace = ANSIMode(4)
+	IRM               = ModeInsertReplace
 
-	SetInsertReplaceMode     = "\x1b[4h"
-	ResetInsertReplaceMode   = "\x1b[4l"
-	RequestInsertReplaceMode = "\x1b[4$p"
+	SetModeInsertReplace     = "\x1b[4h"
+	ResetModeInsertReplace   = "\x1b[4l"
+	RequestModeInsertReplace = "\x1b[4$p"
 )
 
 // BiDirectional Support Mode (BDSM) is a mode that determines whether the
@@ -260,12 +260,12 @@ const (
 //
 // See ECMA-48 7.2.1.
 const (
-	BiDirectionalSupportMode = ANSIMode(8)
-	BDSM                     = BiDirectionalSupportMode
+	ModeBiDirectionalSupport = ANSIMode(8)
+	BDSM                     = ModeBiDirectionalSupport
 
-	SetBiDirectionalSupportMode     = "\x1b[8h"
-	ResetBiDirectionalSupportMode   = "\x1b[8l"
-	RequestBiDirectionalSupportMode = "\x1b[8$p"
+	SetModeBiDirectionalSupport     = "\x1b[8h"
+	ResetModeBiDirectionalSupport   = "\x1b[8l"
+	RequestModeBiDirectionalSupport = "\x1b[8$p"
 )
 
 // Send Receive Mode (SRM) or Local Echo Mode is a mode that determines whether
@@ -274,17 +274,17 @@ const (
 //
 // See: https://vt100.net/docs/vt510-rm/SRM.html
 const (
-	SendReceiveMode = ANSIMode(12)
-	LocalEchoMode   = SendReceiveMode
-	SRM             = SendReceiveMode
+	ModeSendReceive = ANSIMode(12)
+	ModeLocalEcho   = ModeSendReceive
+	SRM             = ModeSendReceive
 
-	SetSendReceiveMode     = "\x1b[12h"
-	ResetSendReceiveMode   = "\x1b[12l"
-	RequestSendReceiveMode = "\x1b[12$p"
+	SetModeSendReceive     = "\x1b[12h"
+	ResetModeSendReceive   = "\x1b[12l"
+	RequestModeSendReceive = "\x1b[12$p"
 
-	SetLocalEchoMode     = "\x1b[12h"
-	ResetLocalEchoMode   = "\x1b[12l"
-	RequestLocalEchoMode = "\x1b[12$p"
+	SetModeLocalEcho     = "\x1b[12h"
+	ResetModeLocalEcho   = "\x1b[12l"
+	RequestModeLocalEcho = "\x1b[12$p"
 )
 
 // Line Feed/New Line Mode (LNM) is a mode that determines whether the terminal
@@ -299,12 +299,12 @@ const (
 //
 // See: https://vt100.net/docs/vt510-rm/LNM.html
 const (
-	LineFeedNewLineMode = ANSIMode(20)
-	LNM                 = LineFeedNewLineMode
+	ModeLineFeedNewLine = ANSIMode(20)
+	LNM                 = ModeLineFeedNewLine
 
-	SetLineFeedNewLineMode     = "\x1b[20h"
-	ResetLineFeedNewLineMode   = "\x1b[20l"
-	RequestLineFeedNewLineMode = "\x1b[20$p"
+	SetModeLineFeedNewLine     = "\x1b[20h"
+	ResetModeLineFeedNewLine   = "\x1b[20l"
+	RequestModeLineFeedNewLine = "\x1b[20$p"
 )
 
 // Cursor Keys Mode (DECCKM) is a mode that determines whether the cursor keys
@@ -312,18 +312,12 @@ const (
 //
 // See: https://vt100.net/docs/vt510-rm/DECCKM.html
 const (
-	CursorKeysMode = DECMode(1)
-	DECCKM         = CursorKeysMode
+	ModeCursorKeys = DECMode(1)
+	DECCKM         = ModeCursorKeys
 
-	SetCursorKeysMode     = "\x1b[?1h"
-	ResetCursorKeysMode   = "\x1b[?1l"
-	RequestCursorKeysMode = "\x1b[?1$p"
-)
-
-// Deprecated: use [SetCursorKeysMode] and [ResetCursorKeysMode] instead.
-const (
-	EnableCursorKeys  = "\x1b[?1h" //nolint:revive // grouped constants
-	DisableCursorKeys = "\x1b[?1l"
+	SetModeCursorKeys     = "\x1b[?1h"
+	ResetModeCursorKeys   = "\x1b[?1l"
+	RequestModeCursorKeys = "\x1b[?1$p"
 )
 
 // Origin Mode (DECOM) is a mode that determines whether the cursor moves to the
@@ -331,12 +325,12 @@ const (
 //
 // See: https://vt100.net/docs/vt510-rm/DECOM.html
 const (
-	OriginMode = DECMode(6)
-	DECOM      = OriginMode
+	ModeOrigin = DECMode(6)
+	DECOM      = ModeOrigin
 
-	SetOriginMode     = "\x1b[?6h"
-	ResetOriginMode   = "\x1b[?6l"
-	RequestOriginMode = "\x1b[?6$p"
+	SetModeOrigin     = "\x1b[?6h"
+	ResetModeOrigin   = "\x1b[?6l"
+	RequestModeOrigin = "\x1b[?6$p"
 )
 
 // Auto Wrap Mode (DECAWM) is a mode that determines whether the cursor wraps
@@ -344,12 +338,12 @@ const (
 //
 // See: https://vt100.net/docs/vt510-rm/DECAWM.html
 const (
-	AutoWrapMode = DECMode(7)
-	DECAWM       = AutoWrapMode
+	ModeAutoWrap = DECMode(7)
+	DECAWM       = ModeAutoWrap
 
-	SetAutoWrapMode     = "\x1b[?7h"
-	ResetAutoWrapMode   = "\x1b[?7l"
-	RequestAutoWrapMode = "\x1b[?7$p"
+	SetModeAutoWrap     = "\x1b[?7h"
+	ResetModeAutoWrap   = "\x1b[?7l"
+	RequestModeAutoWrap = "\x1b[?7$p"
 )
 
 // X10 Mouse Mode is a mode that determines whether the mouse reports on button
@@ -364,39 +358,29 @@ const (
 //
 // See: https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h2-Mouse-Tracking
 const (
-	X10MouseMode = DECMode(9)
+	ModeMouseX10 = DECMode(9)
 
-	SetX10MouseMode     = "\x1b[?9h"
-	ResetX10MouseMode   = "\x1b[?9l"
-	RequestX10MouseMode = "\x1b[?9$p"
+	SetModeMouseX10     = "\x1b[?9h"
+	ResetModeMouseX10   = "\x1b[?9l"
+	RequestModeMouseX10 = "\x1b[?9$p"
 )
 
 // Text Cursor Enable Mode (DECTCEM) is a mode that shows/hides the cursor.
 //
 // See: https://vt100.net/docs/vt510-rm/DECTCEM.html
 const (
-	TextCursorEnableMode = DECMode(25)
-	DECTCEM              = TextCursorEnableMode
+	ModeTextCursorEnable = DECMode(25)
+	DECTCEM              = ModeTextCursorEnable
 
-	SetTextCursorEnableMode     = "\x1b[?25h"
-	ResetTextCursorEnableMode   = "\x1b[?25l"
-	RequestTextCursorEnableMode = "\x1b[?25$p"
+	SetModeTextCursorEnable     = "\x1b[?25h"
+	ResetModeTextCursorEnable   = "\x1b[?25l"
+	RequestModeTextCursorEnable = "\x1b[?25$p"
 )
 
-// These are aliases for [SetTextCursorEnableMode] and [ResetTextCursorEnableMode].
+// These are aliases for [SetModeTextCursorEnable] and [ResetModeTextCursorEnable].
 const (
-	ShowCursor = SetTextCursorEnableMode
-	HideCursor = ResetTextCursorEnableMode
-)
-
-// Text Cursor Enable Mode (DECTCEM) is a mode that shows/hides the cursor.
-//
-// See: https://vt100.net/docs/vt510-rm/DECTCEM.html
-//
-// Deprecated: use [SetTextCursorEnableMode] and [ResetTextCursorEnableMode] instead.
-const (
-	CursorEnableMode        = DECMode(25)
-	RequestCursorVisibility = "\x1b[?25$p"
+	ShowCursor = SetModeTextCursorEnable
+	HideCursor = ResetModeTextCursorEnable
 )
 
 // Numeric Keypad Mode (DECNKM) is a mode that determines whether the keypad
@@ -406,12 +390,12 @@ const (
 //
 // See: https://vt100.net/docs/vt510-rm/DECNKM.html
 const (
-	NumericKeypadMode = DECMode(66)
-	DECNKM            = NumericKeypadMode
+	ModeNumericKeypad = DECMode(66)
+	DECNKM            = ModeNumericKeypad
 
-	SetNumericKeypadMode     = "\x1b[?66h"
-	ResetNumericKeypadMode   = "\x1b[?66l"
-	RequestNumericKeypadMode = "\x1b[?66$p"
+	SetModeNumericKeypad     = "\x1b[?66h"
+	ResetModeNumericKeypad   = "\x1b[?66l"
+	RequestModeNumericKeypad = "\x1b[?66$p"
 )
 
 // Backarrow Key Mode (DECBKM) is a mode that determines whether the backspace
@@ -419,12 +403,12 @@ const (
 //
 // See: https://vt100.net/docs/vt510-rm/DECBKM.html
 const (
-	BackarrowKeyMode = DECMode(67)
-	DECBKM           = BackarrowKeyMode
+	ModeBackarrowKey = DECMode(67)
+	DECBKM           = ModeBackarrowKey
 
-	SetBackarrowKeyMode     = "\x1b[?67h"
-	ResetBackarrowKeyMode   = "\x1b[?67l"
-	RequestBackarrowKeyMode = "\x1b[?67$p"
+	SetModeBackarrowKey     = "\x1b[?67h"
+	ResetModeBackarrowKey   = "\x1b[?67l"
+	RequestModeBackarrowKey = "\x1b[?67$p"
 )
 
 // Left Right Margin Mode (DECLRMM) is a mode that determines whether the left
@@ -432,47 +416,33 @@ const (
 //
 // See: https://vt100.net/docs/vt510-rm/DECLRMM.html
 const (
-	LeftRightMarginMode = DECMode(69)
-	DECLRMM             = LeftRightMarginMode
+	ModeLeftRightMargin = DECMode(69)
+	DECLRMM             = ModeLeftRightMargin
 
-	SetLeftRightMarginMode     = "\x1b[?69h"
-	ResetLeftRightMarginMode   = "\x1b[?69l"
-	RequestLeftRightMarginMode = "\x1b[?69$p"
+	SetModeLeftRightMargin     = "\x1b[?69h"
+	ResetModeLeftRightMargin   = "\x1b[?69l"
+	RequestModeLeftRightMargin = "\x1b[?69$p"
 )
 
 // Normal Mouse Mode is a mode that determines whether the mouse reports on
 // button presses and releases. It will also report modifier keys, wheel
 // events, and extra buttons.
 //
-// It uses the same encoding as [X10MouseMode] with a few differences:
+// It uses the same encoding as [ModeMouseX10] with a few differences:
 //
 // See: https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h2-Mouse-Tracking
 const (
-	NormalMouseMode = DECMode(1000)
+	ModeMouseNormal = DECMode(1000)
 
-	SetNormalMouseMode     = "\x1b[?1000h"
-	ResetNormalMouseMode   = "\x1b[?1000l"
-	RequestNormalMouseMode = "\x1b[?1000$p"
-)
-
-// VT Mouse Tracking is a mode that determines whether the mouse reports on
-// button press and release.
-//
-// See: https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h2-Mouse-Tracking
-//
-// Deprecated: use [NormalMouseMode] instead.
-const (
-	MouseMode = DECMode(1000)
-
-	EnableMouse  = "\x1b[?1000h"
-	DisableMouse = "\x1b[?1000l"
-	RequestMouse = "\x1b[?1000$p"
+	SetModeMouseNormal     = "\x1b[?1000h"
+	ResetModeMouseNormal   = "\x1b[?1000l"
+	RequestModeMouseNormal = "\x1b[?1000$p"
 )
 
 // Highlight Mouse Tracking is a mode that determines whether the mouse reports
 // on button presses, releases, and highlighted cells.
 //
-// It uses the same encoding as [NormalMouseMode] with a few differences:
+// It uses the same encoding as [ModeMouseNormal] with a few differences:
 //
 // On highlight events, the terminal responds with the following encoding:
 //
@@ -481,11 +451,11 @@ const (
 //
 // Where the parameters are startx, starty, endx, endy, mousex, and mousey.
 const (
-	HighlightMouseMode = DECMode(1001)
+	ModeMouseHighlight = DECMode(1001)
 
-	SetHighlightMouseMode     = "\x1b[?1001h"
-	ResetHighlightMouseMode   = "\x1b[?1001l"
-	RequestHighlightMouseMode = "\x1b[?1001$p"
+	SetModeMouseHighlight     = "\x1b[?1001h"
+	ResetModeMouseHighlight   = "\x1b[?1001l"
+	RequestModeMouseHighlight = "\x1b[?1001$p"
 )
 
 // VT Hilite Mouse Tracking is a mode that determines whether the mouse reports on
@@ -493,65 +463,29 @@ const (
 //
 // See: https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h2-Mouse-Tracking
 //
-// Deprecated: use [HighlightMouseMode] instead.
-const (
-	MouseHiliteMode = DECMode(1001)
 
-	EnableMouseHilite  = "\x1b[?1001h"
-	DisableMouseHilite = "\x1b[?1001l"
-	RequestMouseHilite = "\x1b[?1001$p"
-)
-
-// Button Event Mouse Tracking is essentially the same as [NormalMouseMode],
+// Button Event Mouse Tracking is essentially the same as [ModeMouseNormal],
 // but it also reports button-motion events when a button is pressed.
 //
 // See: https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h2-Mouse-Tracking
 const (
-	ButtonEventMouseMode = DECMode(1002)
+	ModeMouseButtonEvent = DECMode(1002)
 
-	SetButtonEventMouseMode     = "\x1b[?1002h"
-	ResetButtonEventMouseMode   = "\x1b[?1002l"
-	RequestButtonEventMouseMode = "\x1b[?1002$p"
+	SetModeMouseButtonEvent     = "\x1b[?1002h"
+	ResetModeMouseButtonEvent   = "\x1b[?1002l"
+	RequestModeMouseButtonEvent = "\x1b[?1002$p"
 )
 
-// Cell Motion Mouse Tracking is a mode that determines whether the mouse
-// reports on button press, release, and motion events.
-//
-// See: https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h2-Mouse-Tracking
-//
-// Deprecated: use [ButtonEventMouseMode] instead.
-const (
-	MouseCellMotionMode = DECMode(1002)
-
-	EnableMouseCellMotion  = "\x1b[?1002h"
-	DisableMouseCellMotion = "\x1b[?1002l"
-	RequestMouseCellMotion = "\x1b[?1002$p"
-)
-
-// Any Event Mouse Tracking is the same as [ButtonEventMouseMode], except that
+// Any Event Mouse Tracking is the same as [ModeMouseButtonEvent], except that
 // all motion events are reported even if no mouse buttons are pressed.
 //
 // See: https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h2-Mouse-Tracking
 const (
-	AnyEventMouseMode = DECMode(1003)
+	ModeMouseAnyEvent = DECMode(1003)
 
-	SetAnyEventMouseMode     = "\x1b[?1003h"
-	ResetAnyEventMouseMode   = "\x1b[?1003l"
-	RequestAnyEventMouseMode = "\x1b[?1003$p"
-)
-
-// All Mouse Tracking is a mode that determines whether the mouse reports on
-// button press, release, motion, and highlight events.
-//
-// See: https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h2-Mouse-Tracking
-//
-// Deprecated: use [AnyEventMouseMode] instead.
-const (
-	MouseAllMotionMode = DECMode(1003)
-
-	EnableMouseAllMotion  = "\x1b[?1003h"
-	DisableMouseAllMotion = "\x1b[?1003l"
-	RequestMouseAllMotion = "\x1b[?1003$p"
+	SetModeMouseAnyEvent     = "\x1b[?1003h"
+	ResetModeMouseAnyEvent   = "\x1b[?1003l"
+	RequestModeMouseAnyEvent = "\x1b[?1003$p"
 )
 
 // Focus Event Mode is a mode that determines whether the terminal reports focus
@@ -564,22 +498,11 @@ const (
 //
 // See: https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h2-Focus-Tracking
 const (
-	FocusEventMode = DECMode(1004)
+	ModeFocusEvent = DECMode(1004)
 
-	SetFocusEventMode     = "\x1b[?1004h"
-	ResetFocusEventMode   = "\x1b[?1004l"
-	RequestFocusEventMode = "\x1b[?1004$p"
-)
-
-// Deprecated: use [SetFocusEventMode], [ResetFocusEventMode], and
-// [RequestFocusEventMode] instead.
-// Focus reporting mode constants.
-const (
-	ReportFocusMode = DECMode(1004) //nolint:revive // grouped constants
-
-	EnableReportFocus  = "\x1b[?1004h"
-	DisableReportFocus = "\x1b[?1004l"
-	RequestReportFocus = "\x1b[?1004$p"
+	SetModeFocusEvent     = "\x1b[?1004h"
+	ResetModeFocusEvent   = "\x1b[?1004l"
+	RequestModeFocusEvent = "\x1b[?1004$p"
 )
 
 // SGR Extended Mouse Mode is a mode that changes the mouse tracking encoding
@@ -589,24 +512,15 @@ const (
 //
 //	CSI < Cb ; Cx ; Cy M
 //
-// Where Cb is the same as [NormalMouseMode], and Cx and Cy are the x and y.
+// Where Cb is the same as [ModeMouseNormal], and Cx and Cy are the x and y.
 //
 // See: https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h2-Mouse-Tracking
 const (
-	SgrExtMouseMode = DECMode(1006)
+	ModeMouseExtSgr = DECMode(1006)
 
-	SetSgrExtMouseMode     = "\x1b[?1006h"
-	ResetSgrExtMouseMode   = "\x1b[?1006l"
-	RequestSgrExtMouseMode = "\x1b[?1006$p"
-)
-
-// Deprecated: use [SgrExtMouseMode] [SetSgrExtMouseMode],
-// [ResetSgrExtMouseMode], and [RequestSgrExtMouseMode] instead.
-const (
-	MouseSgrExtMode    = DECMode(1006) //nolint:revive // grouped constants
-	EnableMouseSgrExt  = "\x1b[?1006h"
-	DisableMouseSgrExt = "\x1b[?1006l"
-	RequestMouseSgrExt = "\x1b[?1006$p"
+	SetModeMouseExtSgr     = "\x1b[?1006h"
+	ResetModeMouseExtSgr   = "\x1b[?1006l"
+	RequestModeMouseExtSgr = "\x1b[?1006$p"
 )
 
 // UTF-8 Extended Mouse Mode is a mode that changes the mouse tracking encoding
@@ -614,11 +528,11 @@ const (
 //
 // See: https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h2-Mouse-Tracking
 const (
-	Utf8ExtMouseMode = DECMode(1005)
+	ModeMouseExtUtf8 = DECMode(1005)
 
-	SetUtf8ExtMouseMode     = "\x1b[?1005h"
-	ResetUtf8ExtMouseMode   = "\x1b[?1005l"
-	RequestUtf8ExtMouseMode = "\x1b[?1005$p"
+	SetModeMouseExtUtf8     = "\x1b[?1005h"
+	ResetModeMouseExtUtf8   = "\x1b[?1005l"
+	RequestModeMouseExtUtf8 = "\x1b[?1005$p"
 )
 
 // URXVT Extended Mouse Mode is a mode that changes the mouse tracking encoding
@@ -626,25 +540,25 @@ const (
 //
 // See: https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h2-Mouse-Tracking
 const (
-	UrxvtExtMouseMode = DECMode(1015)
+	ModeMouseExtUrxvt = DECMode(1015)
 
-	SetUrxvtExtMouseMode     = "\x1b[?1015h"
-	ResetUrxvtExtMouseMode   = "\x1b[?1015l"
-	RequestUrxvtExtMouseMode = "\x1b[?1015$p"
+	SetModeMouseExtUrxvt     = "\x1b[?1015h"
+	ResetModeMouseExtUrxvt   = "\x1b[?1015l"
+	RequestModeMouseExtUrxvt = "\x1b[?1015$p"
 )
 
 // SGR Pixel Extended Mouse Mode is a mode that changes the mouse tracking
 // encoding to use SGR parameters with pixel coordinates.
 //
-// This is similar to [SgrExtMouseMode], but also reports pixel coordinates.
+// This is similar to [ModeMouseExtSgr], but also reports pixel coordinates.
 //
 // See: https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h2-Mouse-Tracking
 const (
-	SgrPixelExtMouseMode = DECMode(1016)
+	ModeMouseExtSgrPixel = DECMode(1016)
 
-	SetSgrPixelExtMouseMode     = "\x1b[?1016h"
-	ResetSgrPixelExtMouseMode   = "\x1b[?1016l"
-	RequestSgrPixelExtMouseMode = "\x1b[?1016$p"
+	SetModeMouseExtSgrPixel     = "\x1b[?1016h"
+	ResetModeMouseExtSgrPixel   = "\x1b[?1016l"
+	RequestModeMouseExtSgrPixel = "\x1b[?1016$p"
 )
 
 // Alternate Screen Mode is a mode that determines whether the alternate screen
@@ -653,11 +567,11 @@ const (
 //
 // See: https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h2-The-Alternate-Screen-Buffer
 const (
-	AltScreenMode = DECMode(1047)
+	ModeAltScreen = DECMode(1047)
 
-	SetAltScreenMode     = "\x1b[?1047h"
-	ResetAltScreenMode   = "\x1b[?1047l"
-	RequestAltScreenMode = "\x1b[?1047$p"
+	SetModeAltScreen     = "\x1b[?1047h"
+	ResetModeAltScreen   = "\x1b[?1047l"
+	RequestModeAltScreen = "\x1b[?1047$p"
 )
 
 // Save Cursor Mode is a mode that saves the cursor position.
@@ -665,42 +579,24 @@ const (
 //
 // See: https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h2-The-Alternate-Screen-Buffer
 const (
-	SaveCursorMode = DECMode(1048)
+	ModeSaveCursor = DECMode(1048)
 
-	SetSaveCursorMode     = "\x1b[?1048h"
-	ResetSaveCursorMode   = "\x1b[?1048l"
-	RequestSaveCursorMode = "\x1b[?1048$p"
+	SetModeSaveCursor     = "\x1b[?1048h"
+	ResetModeSaveCursor   = "\x1b[?1048l"
+	RequestModeSaveCursor = "\x1b[?1048$p"
 )
 
 // Alternate Screen Save Cursor Mode is a mode that saves the cursor position as in
-// [SaveCursorMode], switches to the alternate screen buffer as in [AltScreenMode],
+// [ModeSaveCursor], switches to the alternate screen buffer as in [ModeAltScreen],
 // and clears the screen on switch.
 //
 // See: https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h2-The-Alternate-Screen-Buffer
 const (
-	AltScreenSaveCursorMode = DECMode(1049)
+	ModeAltScreenSaveCursor = DECMode(1049)
 
-	SetAltScreenSaveCursorMode     = "\x1b[?1049h"
-	ResetAltScreenSaveCursorMode   = "\x1b[?1049l"
-	RequestAltScreenSaveCursorMode = "\x1b[?1049$p"
-)
-
-// Alternate Screen Buffer is a mode that determines whether the alternate screen
-// buffer is active.
-//
-// See: https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h2-The-Alternate-Screen-Buffer
-//
-// Deprecated: use [AltScreenSaveCursorMode] instead.
-const (
-	AltScreenBufferMode = DECMode(1049)
-
-	SetAltScreenBufferMode     = "\x1b[?1049h"
-	ResetAltScreenBufferMode   = "\x1b[?1049l"
-	RequestAltScreenBufferMode = "\x1b[?1049$p"
-
-	EnableAltScreenBuffer  = "\x1b[?1049h"
-	DisableAltScreenBuffer = "\x1b[?1049l"
-	RequestAltScreenBuffer = "\x1b[?1049$p"
+	SetModeAltScreenSaveCursor     = "\x1b[?1049h"
+	ResetModeAltScreenSaveCursor   = "\x1b[?1049l"
+	RequestModeAltScreenSaveCursor = "\x1b[?1049$p"
 )
 
 // Bracketed Paste Mode is a mode that determines whether pasted text is
@@ -709,19 +605,11 @@ const (
 // See: https://cirw.in/blog/bracketed-paste
 // See: https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h2-Bracketed-Paste-Mode
 const (
-	BracketedPasteMode = DECMode(2004)
+	ModeBracketedPaste = DECMode(2004)
 
-	SetBracketedPasteMode     = "\x1b[?2004h"
-	ResetBracketedPasteMode   = "\x1b[?2004l"
-	RequestBracketedPasteMode = "\x1b[?2004$p"
-)
-
-// Deprecated: use [SetBracketedPasteMode], [ResetBracketedPasteMode], and
-// [RequestBracketedPasteMode] instead.
-const (
-	EnableBracketedPaste  = "\x1b[?2004h" //nolint:revive // grouped constants
-	DisableBracketedPaste = "\x1b[?2004l"
-	RequestBracketedPaste = "\x1b[?2004$p"
+	SetModeBracketedPaste     = "\x1b[?2004h"
+	ResetModeBracketedPaste   = "\x1b[?2004l"
+	RequestModeBracketedPaste = "\x1b[?2004$p"
 )
 
 // Synchronized Output Mode is a mode that determines whether output is
@@ -729,23 +617,11 @@ const (
 //
 // See: https://gist.github.com/christianparpart/d8a62cc1ab659194337d73e399004036
 const (
-	SynchronizedOutputMode = DECMode(2026)
+	ModeSynchronizedOutput = DECMode(2026)
 
-	SetSynchronizedOutputMode     = "\x1b[?2026h"
-	ResetSynchronizedOutputMode   = "\x1b[?2026l"
-	RequestSynchronizedOutputMode = "\x1b[?2026$p"
-)
-
-// Synchronized Output Mode. See [SynchronizedOutputMode].
-//
-// Deprecated: use [SynchronizedOutputMode], [SetSynchronizedOutputMode], and
-// [ResetSynchronizedOutputMode], and [RequestSynchronizedOutputMode] instead.
-const (
-	SyncdOutputMode = DECMode(2026)
-
-	EnableSyncdOutput  = "\x1b[?2026h"
-	DisableSyncdOutput = "\x1b[?2026l"
-	RequestSyncdOutput = "\x1b[?2026$p"
+	SetModeSynchronizedOutput     = "\x1b[?2026h"
+	ResetModeSynchronizedOutput   = "\x1b[?2026l"
+	RequestModeSynchronizedOutput = "\x1b[?2026$p"
 )
 
 // Unicode Core Mode is a mode that determines whether the terminal should use
@@ -754,41 +630,16 @@ const (
 //
 // See: https://github.com/contour-terminal/terminal-unicode-core
 const (
-	UnicodeCoreMode = DECMode(2027)
+	ModeUnicodeCore = DECMode(2027)
 
-	SetUnicodeCoreMode     = "\x1b[?2027h"
-	ResetUnicodeCoreMode   = "\x1b[?2027l"
-	RequestUnicodeCoreMode = "\x1b[?2027$p"
+	SetModeUnicodeCore     = "\x1b[?2027h"
+	ResetModeUnicodeCore   = "\x1b[?2027l"
+	RequestModeUnicodeCore = "\x1b[?2027$p"
 )
 
-// Grapheme Clustering Mode is a mode that determines whether the terminal
-// should look for grapheme clusters instead of single runes in the rendered
-// text. This makes the terminal properly render combining characters such as
-// emojis.
 //
-// See: https://github.com/contour-terminal/terminal-unicode-core
-//
-// Deprecated: use [GraphemeClusteringMode], [SetUnicodeCoreMode],
-// [ResetUnicodeCoreMode], and [RequestUnicodeCoreMode] instead.
-const (
-	GraphemeClusteringMode = DECMode(2027)
 
-	SetGraphemeClusteringMode     = "\x1b[?2027h"
-	ResetGraphemeClusteringMode   = "\x1b[?2027l"
-	RequestGraphemeClusteringMode = "\x1b[?2027$p"
-)
-
-// Grapheme Clustering Mode. See [GraphemeClusteringMode].
-//
-// Deprecated: use [SetUnicodeCoreMode], [ResetUnicodeCoreMode], and
-// [RequestUnicodeCoreMode] instead.
-const (
-	EnableGraphemeClustering  = "\x1b[?2027h"
-	DisableGraphemeClustering = "\x1b[?2027l"
-	RequestGraphemeClustering = "\x1b[?2027$p"
-)
-
-// LightDarkMode is a mode that enables reporting the operating system's color
+// ModeLightDark is a mode that enables reporting the operating system's color
 // scheme (light or dark) preference. It reports the color scheme as a [DSR]
 // and [LightDarkReport] escape sequences encoded as follows:
 //
@@ -802,14 +653,14 @@ const (
 //
 // See: https://contour-terminal.org/vt-extensions/color-palette-update-notifications/
 const (
-	LightDarkMode = DECMode(2031)
+	ModeLightDark = DECMode(2031)
 
-	SetLightDarkMode     = "\x1b[?2031h"
-	ResetLightDarkMode   = "\x1b[?2031l"
-	RequestLightDarkMode = "\x1b[?2031$p"
+	SetModeLightDark     = "\x1b[?2031h"
+	ResetModeLightDark   = "\x1b[?2031l"
+	RequestModeLightDark = "\x1b[?2031$p"
 )
 
-// InBandResizeMode is a mode that reports terminal resize events as escape
+// ModeInBandResize is a mode that reports terminal resize events as escape
 // sequences. This is useful for systems that do not support [SIGWINCH] like
 // Windows.
 //
@@ -819,11 +670,11 @@ const (
 //
 // See: https://gist.github.com/rockorager/e695fb2924d36b2bcf1fff4a3704bd83
 const (
-	InBandResizeMode = DECMode(2048)
+	ModeInBandResize = DECMode(2048)
 
-	SetInBandResizeMode     = "\x1b[?2048h"
-	ResetInBandResizeMode   = "\x1b[?2048l"
-	RequestInBandResizeMode = "\x1b[?2048$p"
+	SetModeInBandResize     = "\x1b[?2048h"
+	ResetModeInBandResize   = "\x1b[?2048l"
+	RequestModeInBandResize = "\x1b[?2048$p"
 )
 
 // Win32Input is a mode that determines whether input is processed by the
@@ -831,17 +682,9 @@ const (
 //
 // See: https://github.com/microsoft/terminal/blob/main/doc/specs/%234999%20-%20Improved%20keyboard%20handling%20in%20Conpty.md
 const (
-	Win32InputMode = DECMode(9001)
+	ModeWin32Input = DECMode(9001)
 
-	SetWin32InputMode     = "\x1b[?9001h"
-	ResetWin32InputMode   = "\x1b[?9001l"
-	RequestWin32InputMode = "\x1b[?9001$p"
-)
-
-// Deprecated: use [SetWin32InputMode], [ResetWin32InputMode], and
-// [RequestWin32InputMode] instead.
-const (
-	EnableWin32Input  = "\x1b[?9001h" //nolint:revive // grouped constants
-	DisableWin32Input = "\x1b[?9001l"
-	RequestWin32Input = "\x1b[?9001$p"
+	SetModeWin32Input     = "\x1b[?9001h"
+	ResetModeWin32Input   = "\x1b[?9001l"
+	RequestModeWin32Input = "\x1b[?9001$p"
 )

vendor/github.com/charmbracelet/x/ansi/mode_deprecated.go

@@ -0,0 +1,495 @@
+package ansi
+
+// Keyboard Action Mode (KAM) controls locking of the keyboard.
+//
+// Deprecated: use [ModeKeyboardAction] instead.
+const (
+	KeyboardActionMode = ANSIMode(2)
+
+	SetKeyboardActionMode     = "\x1b[2h"
+	ResetKeyboardActionMode   = "\x1b[2l"
+	RequestKeyboardActionMode = "\x1b[2$p"
+)
+
+// Insert/Replace Mode (IRM) determines whether characters are inserted or replaced.
+//
+// Deprecated: use [ModeInsertReplace] instead.
+const (
+	InsertReplaceMode = ANSIMode(4)
+
+	SetInsertReplaceMode     = "\x1b[4h"
+	ResetInsertReplaceMode   = "\x1b[4l"
+	RequestInsertReplaceMode = "\x1b[4$p"
+)
+
+// BiDirectional Support Mode (BDSM) determines whether the terminal supports bidirectional text.
+//
+// Deprecated: use [ModeBiDirectionalSupport] instead.
+const (
+	BiDirectionalSupportMode = ANSIMode(8)
+
+	SetBiDirectionalSupportMode     = "\x1b[8h"
+	ResetBiDirectionalSupportMode   = "\x1b[8l"
+	RequestBiDirectionalSupportMode = "\x1b[8$p"
+)
+
+// Send Receive Mode (SRM) or Local Echo Mode determines whether the terminal echoes characters.
+//
+// Deprecated: use [ModeSendReceive] instead.
+const (
+	SendReceiveMode = ANSIMode(12)
+	LocalEchoMode   = SendReceiveMode
+
+	SetSendReceiveMode     = "\x1b[12h"
+	ResetSendReceiveMode   = "\x1b[12l"
+	RequestSendReceiveMode = "\x1b[12$p"
+
+	SetLocalEchoMode     = "\x1b[12h"
+	ResetLocalEchoMode   = "\x1b[12l"
+	RequestLocalEchoMode = "\x1b[12$p"
+)
+
+// Line Feed/New Line Mode (LNM) determines whether the terminal interprets line feed as new line.
+//
+// Deprecated: use [ModeLineFeedNewLine] instead.
+const (
+	LineFeedNewLineMode = ANSIMode(20)
+
+	SetLineFeedNewLineMode     = "\x1b[20h"
+	ResetLineFeedNewLineMode   = "\x1b[20l"
+	RequestLineFeedNewLineMode = "\x1b[20$p"
+)
+
+// Cursor Keys Mode (DECCKM) determines whether cursor keys send ANSI or application sequences.
+//
+// Deprecated: use [ModeCursorKeys] instead.
+const (
+	CursorKeysMode = DECMode(1)
+
+	SetCursorKeysMode     = "\x1b[?1h"
+	ResetCursorKeysMode   = "\x1b[?1l"
+	RequestCursorKeysMode = "\x1b[?1$p"
+)
+
+// Cursor Keys mode.
+//
+// Deprecated: use [SetModeCursorKeys] and [ResetModeCursorKeys] instead.
+const (
+	EnableCursorKeys  = "\x1b[?1h"
+	DisableCursorKeys = "\x1b[?1l"
+)
+
+// Origin Mode (DECOM) determines whether the cursor moves to home or margin position.
+//
+// Deprecated: use [ModeOrigin] instead.
+const (
+	OriginMode = DECMode(6)
+
+	SetOriginMode     = "\x1b[?6h"
+	ResetOriginMode   = "\x1b[?6l"
+	RequestOriginMode = "\x1b[?6$p"
+)
+
+// Auto Wrap Mode (DECAWM) determines whether the cursor wraps to the next line.
+//
+// Deprecated: use [ModeAutoWrap] instead.
+const (
+	AutoWrapMode = DECMode(7)
+
+	SetAutoWrapMode     = "\x1b[?7h"
+	ResetAutoWrapMode   = "\x1b[?7l"
+	RequestAutoWrapMode = "\x1b[?7$p"
+)
+
+// X10 Mouse Mode determines whether the mouse reports on button presses.
+//
+// Deprecated: use [ModeMouseX10] instead.
+const (
+	X10MouseMode = DECMode(9)
+
+	SetX10MouseMode     = "\x1b[?9h"
+	ResetX10MouseMode   = "\x1b[?9l"
+	RequestX10MouseMode = "\x1b[?9$p"
+)
+
+// Text Cursor Enable Mode (DECTCEM) shows/hides the cursor.
+//
+// Deprecated: use [ModeTextCursorEnable] instead.
+const (
+	TextCursorEnableMode = DECMode(25)
+
+	SetTextCursorEnableMode     = "\x1b[?25h"
+	ResetTextCursorEnableMode   = "\x1b[?25l"
+	RequestTextCursorEnableMode = "\x1b[?25$p"
+)
+
+// Text Cursor Enable mode.
+//
+// Deprecated: use [SetModeTextCursorEnable] and [ResetModeTextCursorEnable] instead.
+const (
+	CursorEnableMode        = DECMode(25)
+	RequestCursorVisibility = "\x1b[?25$p"
+)
+
+// Numeric Keypad Mode (DECNKM) determines whether the keypad sends application or numeric sequences.
+//
+// Deprecated: use [ModeNumericKeypad] instead.
+const (
+	NumericKeypadMode = DECMode(66)
+
+	SetNumericKeypadMode     = "\x1b[?66h"
+	ResetNumericKeypadMode   = "\x1b[?66l"
+	RequestNumericKeypadMode = "\x1b[?66$p"
+)
+
+// Backarrow Key Mode (DECBKM) determines whether the backspace key sends backspace or delete.
+//
+// Deprecated: use [ModeBackarrowKey] instead.
+const (
+	BackarrowKeyMode = DECMode(67)
+
+	SetBackarrowKeyMode     = "\x1b[?67h"
+	ResetBackarrowKeyMode   = "\x1b[?67l"
+	RequestBackarrowKeyMode = "\x1b[?67$p"
+)
+
+// Left Right Margin Mode (DECLRMM) determines whether left and right margins can be set.
+//
+// Deprecated: use [ModeLeftRightMargin] instead.
+const (
+	LeftRightMarginMode = DECMode(69)
+
+	SetLeftRightMarginMode     = "\x1b[?69h"
+	ResetLeftRightMarginMode   = "\x1b[?69l"
+	RequestLeftRightMarginMode = "\x1b[?69$p"
+)
+
+// Normal Mouse Mode determines whether the mouse reports on button presses and releases.
+//
+// Deprecated: use [ModeMouseNormal] instead.
+const (
+	NormalMouseMode = DECMode(1000)
+
+	SetNormalMouseMode     = "\x1b[?1000h"
+	ResetNormalMouseMode   = "\x1b[?1000l"
+	RequestNormalMouseMode = "\x1b[?1000$p"
+)
+
+// VT Mouse Tracking mode.
+//
+// Deprecated: use [ModeMouseNormal] instead.
+const (
+	MouseMode = DECMode(1000)
+
+	EnableMouse  = "\x1b[?1000h"
+	DisableMouse = "\x1b[?1000l"
+	RequestMouse = "\x1b[?1000$p"
+)
+
+// Highlight Mouse Tracking determines whether the mouse reports on button presses and highlighted cells.
+//
+// Deprecated: use [ModeMouseHighlight] instead.
+const (
+	HighlightMouseMode = DECMode(1001)
+
+	SetHighlightMouseMode     = "\x1b[?1001h"
+	ResetHighlightMouseMode   = "\x1b[?1001l"
+	RequestHighlightMouseMode = "\x1b[?1001$p"
+)
+
+// VT Hilite Mouse Tracking mode.
+//
+// Deprecated: use [ModeMouseHighlight] instead.
+const (
+	MouseHiliteMode = DECMode(1001)
+
+	EnableMouseHilite  = "\x1b[?1001h"
+	DisableMouseHilite = "\x1b[?1001l"
+	RequestMouseHilite = "\x1b[?1001$p"
+)
+
+// Button Event Mouse Tracking reports button-motion events when a button is pressed.
+//
+// Deprecated: use [ModeMouseButtonEvent] instead.
+const (
+	ButtonEventMouseMode = DECMode(1002)
+
+	SetButtonEventMouseMode     = "\x1b[?1002h"
+	ResetButtonEventMouseMode   = "\x1b[?1002l"
+	RequestButtonEventMouseMode = "\x1b[?1002$p"
+)
+
+// Cell Motion Mouse Tracking mode.
+//
+// Deprecated: use [ModeMouseButtonEvent] instead.
+const (
+	MouseCellMotionMode = DECMode(1002)
+
+	EnableMouseCellMotion  = "\x1b[?1002h"
+	DisableMouseCellMotion = "\x1b[?1002l"
+	RequestMouseCellMotion = "\x1b[?1002$p"
+)
+
+// Any Event Mouse Tracking reports all motion events.
+//
+// Deprecated: use [ModeMouseAnyEvent] instead.
+const (
+	AnyEventMouseMode = DECMode(1003)
+
+	SetAnyEventMouseMode     = "\x1b[?1003h"
+	ResetAnyEventMouseMode   = "\x1b[?1003l"
+	RequestAnyEventMouseMode = "\x1b[?1003$p"
+)
+
+// All Mouse Tracking mode.
+//
+// Deprecated: use [ModeMouseAnyEvent] instead.
+const (
+	MouseAllMotionMode = DECMode(1003)
+
+	EnableMouseAllMotion  = "\x1b[?1003h"
+	DisableMouseAllMotion = "\x1b[?1003l"
+	RequestMouseAllMotion = "\x1b[?1003$p"
+)
+
+// Focus Event Mode determines whether the terminal reports focus and blur events.
+//
+// Deprecated: use [ModeFocusEvent] instead.
+const (
+	FocusEventMode = DECMode(1004)
+
+	SetFocusEventMode     = "\x1b[?1004h"
+	ResetFocusEventMode   = "\x1b[?1004l"
+	RequestFocusEventMode = "\x1b[?1004$p"
+)
+
+// Focus reporting mode.
+//
+// Deprecated: use [SetModeFocusEvent], [ResetModeFocusEvent], and
+// [RequestModeFocusEvent] instead.
+const (
+	ReportFocusMode = DECMode(1004)
+
+	EnableReportFocus  = "\x1b[?1004h"
+	DisableReportFocus = "\x1b[?1004l"
+	RequestReportFocus = "\x1b[?1004$p"
+)
+
+// UTF-8 Extended Mouse Mode changes the mouse tracking encoding to use UTF-8 parameters.
+//
+// Deprecated: use [ModeMouseExtUtf8] instead.
+const (
+	Utf8ExtMouseMode = DECMode(1005)
+
+	SetUtf8ExtMouseMode     = "\x1b[?1005h"
+	ResetUtf8ExtMouseMode   = "\x1b[?1005l"
+	RequestUtf8ExtMouseMode = "\x1b[?1005$p"
+)
+
+// SGR Extended Mouse Mode changes the mouse tracking encoding to use SGR parameters.
+//
+// Deprecated: use [ModeMouseExtSgr] instead.
+const (
+	SgrExtMouseMode = DECMode(1006)
+
+	SetSgrExtMouseMode     = "\x1b[?1006h"
+	ResetSgrExtMouseMode   = "\x1b[?1006l"
+	RequestSgrExtMouseMode = "\x1b[?1006$p"
+)
+
+// Mouse SGR Extended mode.
+//
+// Deprecated: use [ModeMouseExtSgr], [SetModeMouseExtSgr],
+// [ResetModeMouseExtSgr], and [RequestModeMouseExtSgr] instead.
+const (
+	MouseSgrExtMode    = DECMode(1006)
+	EnableMouseSgrExt  = "\x1b[?1006h"
+	DisableMouseSgrExt = "\x1b[?1006l"
+	RequestMouseSgrExt = "\x1b[?1006$p"
+)
+
+// URXVT Extended Mouse Mode changes the mouse tracking encoding to use an alternate encoding.
+//
+// Deprecated: use [ModeMouseUrxvtExt] instead.
+const (
+	UrxvtExtMouseMode = DECMode(1015)
+
+	SetUrxvtExtMouseMode     = "\x1b[?1015h"
+	ResetUrxvtExtMouseMode   = "\x1b[?1015l"
+	RequestUrxvtExtMouseMode = "\x1b[?1015$p"
+)
+
+// SGR Pixel Extended Mouse Mode changes the mouse tracking encoding to use SGR parameters with pixel coordinates.
+//
+// Deprecated: use [ModeMouseExtSgrPixel] instead.
+const (
+	SgrPixelExtMouseMode = DECMode(1016)
+
+	SetSgrPixelExtMouseMode     = "\x1b[?1016h"
+	ResetSgrPixelExtMouseMode   = "\x1b[?1016l"
+	RequestSgrPixelExtMouseMode = "\x1b[?1016$p"
+)
+
+// Alternate Screen Mode determines whether the alternate screen buffer is active.
+//
+// Deprecated: use [ModeAltScreen] instead.
+const (
+	AltScreenMode = DECMode(1047)
+
+	SetAltScreenMode     = "\x1b[?1047h"
+	ResetAltScreenMode   = "\x1b[?1047l"
+	RequestAltScreenMode = "\x1b[?1047$p"
+)
+
+// Save Cursor Mode saves the cursor position.
+//
+// Deprecated: use [ModeSaveCursor] instead.
+const (
+	SaveCursorMode = DECMode(1048)
+
+	SetSaveCursorMode     = "\x1b[?1048h"
+	ResetSaveCursorMode   = "\x1b[?1048l"
+	RequestSaveCursorMode = "\x1b[?1048$p"
+)
+
+// Alternate Screen Save Cursor Mode saves the cursor position and switches to alternate screen.
+//
+// Deprecated: use [ModeAltScreenSaveCursor] instead.
+const (
+	AltScreenSaveCursorMode = DECMode(1049)
+
+	SetAltScreenSaveCursorMode     = "\x1b[?1049h"
+	ResetAltScreenSaveCursorMode   = "\x1b[?1049l"
+	RequestAltScreenSaveCursorMode = "\x1b[?1049$p"
+)
+
+// Alternate Screen Buffer mode.
+//
+// Deprecated: use [ModeAltScreenSaveCursor] instead.
+const (
+	AltScreenBufferMode = DECMode(1049)
+
+	SetAltScreenBufferMode     = "\x1b[?1049h"
+	ResetAltScreenBufferMode   = "\x1b[?1049l"
+	RequestAltScreenBufferMode = "\x1b[?1049$p"
+
+	EnableAltScreenBuffer  = "\x1b[?1049h"
+	DisableAltScreenBuffer = "\x1b[?1049l"
+	RequestAltScreenBuffer = "\x1b[?1049$p"
+)
+
+// Bracketed Paste Mode determines whether pasted text is bracketed with escape sequences.
+//
+// Deprecated: use [ModeBracketedPaste] instead.
+const (
+	BracketedPasteMode = DECMode(2004)
+
+	SetBracketedPasteMode     = "\x1b[?2004h"
+	ResetBracketedPasteMode   = "\x1b[?2004l"
+	RequestBracketedPasteMode = "\x1b[?2004$p"
+)
+
+// Deprecated: use [SetModeBracketedPaste], [ResetModeBracketedPaste], and
+// [RequestModeBracketedPaste] instead.
+const (
+	EnableBracketedPaste  = "\x1b[?2004h" //nolint:revive
+	DisableBracketedPaste = "\x1b[?2004l"
+	RequestBracketedPaste = "\x1b[?2004$p"
+)
+
+// Synchronized Output Mode determines whether output is synchronized with the terminal.
+//
+// Deprecated: use [ModeSynchronizedOutput] instead.
+const (
+	SynchronizedOutputMode = DECMode(2026)
+
+	SetSynchronizedOutputMode     = "\x1b[?2026h"
+	ResetSynchronizedOutputMode   = "\x1b[?2026l"
+	RequestSynchronizedOutputMode = "\x1b[?2026$p"
+)
+
+// Synchronized output mode.
+//
+// Deprecated: use [ModeSynchronizedOutput], [SetModeSynchronizedOutput],
+// [ResetModeSynchronizedOutput], and [RequestModeSynchronizedOutput] instead.
+const (
+	SyncdOutputMode = DECMode(2026)
+
+	EnableSyncdOutput  = "\x1b[?2026h"
+	DisableSyncdOutput = "\x1b[?2026l"
+	RequestSyncdOutput = "\x1b[?2026$p"
+)
+
+// Unicode Core Mode determines whether the terminal uses Unicode grapheme clustering.
+//
+// Deprecated: use [ModeUnicodeCore] instead.
+const (
+	UnicodeCoreMode = DECMode(2027)
+
+	SetUnicodeCoreMode     = "\x1b[?2027h"
+	ResetUnicodeCoreMode   = "\x1b[?2027l"
+	RequestUnicodeCoreMode = "\x1b[?2027$p"
+)
+
+// Grapheme Clustering Mode determines whether the terminal looks for grapheme clusters.
+//
+// Deprecated: use [ModeUnicodeCore], [SetModeUnicodeCore],
+// [ResetModeUnicodeCore], and [RequestModeUnicodeCore] instead.
+const (
+	GraphemeClusteringMode = DECMode(2027)
+
+	SetGraphemeClusteringMode     = "\x1b[?2027h"
+	ResetGraphemeClusteringMode   = "\x1b[?2027l"
+	RequestGraphemeClusteringMode = "\x1b[?2027$p"
+)
+
+// Unicode Core mode.
+//
+// Deprecated: use [SetModeUnicodeCore], [ResetModeUnicodeCore], and
+// [RequestModeUnicodeCore] instead.
+const (
+	EnableGraphemeClustering  = "\x1b[?2027h"
+	DisableGraphemeClustering = "\x1b[?2027l"
+	RequestGraphemeClustering = "\x1b[?2027$p"
+)
+
+// Light Dark Mode enables reporting the operating system's color scheme preference.
+//
+// Deprecated: use [ModeLightDark] instead.
+const (
+	LightDarkMode = DECMode(2031)
+
+	SetLightDarkMode     = "\x1b[?2031h"
+	ResetLightDarkMode   = "\x1b[?2031l"
+	RequestLightDarkMode = "\x1b[?2031$p"
+)
+
+// In Band Resize Mode reports terminal resize events as escape sequences.
+//
+// Deprecated: use [ModeInBandResize] instead.
+const (
+	InBandResizeMode = DECMode(2048)
+
+	SetInBandResizeMode     = "\x1b[?2048h"
+	ResetInBandResizeMode   = "\x1b[?2048l"
+	RequestInBandResizeMode = "\x1b[?2048$p"
+)
+
+// Win32Input determines whether input is processed by the Win32 console and Conpty.
+//
+// Deprecated: use [ModeWin32Input] instead.
+const (
+	Win32InputMode = DECMode(9001)
+
+	SetWin32InputMode     = "\x1b[?9001h"
+	ResetWin32InputMode   = "\x1b[?9001l"
+	RequestWin32InputMode = "\x1b[?9001$p"
+)
+
+// Deprecated: use [SetModeWin32Input], [ResetModeWin32Input], and
+// [RequestModeWin32Input] instead.
+const (
+	EnableWin32Input  = "\x1b[?9001h" //nolint:revive
+	DisableWin32Input = "\x1b[?9001l"
+	RequestWin32Input = "\x1b[?9001$p"
+)

vendor/github.com/charmbracelet/x/ansi/mouse.go

@@ -134,7 +134,7 @@ func EncodeMouseButton(b MouseButton, motion, shift, alt, ctrl bool) (m byte) {
 		m |= bitMotion
 	}
 
-	return //nolint:nakedret
+	return m
 }
 
 // x10Offset is the offset for X10 mouse events.

vendor/github.com/charmbracelet/x/ansi/notification.go

@@ -1,5 +1,10 @@
 package ansi
 
+import (
+	"fmt"
+	"strings"
+)
+
 // Notify sends a desktop notification using iTerm's OSC 9.
 //
 //	OSC 9 ; Mc ST
@@ -11,3 +16,17 @@ package ansi
 func Notify(s string) string {
 	return "\x1b]9;" + s + "\x07"
 }
+
+// DesktopNotification sends a desktop notification based on the extensible OSC
+// 99 escape code.
+//
+//	OSC 99 ; <metadata> ; <payload> ST
+//	OSC 99 ; <metadata> ; <payload> BEL
+//
+// Where <metadata> is a colon-separated list of key-value pairs, and
+// <payload> is the notification body.
+//
+// See: https://sw.kovidgoyal.net/kitty/desktop-notifications/
+func DesktopNotification(payload string, metadata ...string) string {
+	return fmt.Sprintf("\x1b]99;%s;%s\x07", strings.Join(metadata, ":"), payload)
+}

vendor/github.com/charmbracelet/x/ansi/parser_decode.go

@@ -4,8 +4,9 @@ import (
 	"unicode/utf8"
 
 	"github.com/charmbracelet/x/ansi/parser"
+	"github.com/clipperhouse/displaywidth"
+	"github.com/clipperhouse/uax29/v2/graphemes"
 	"github.com/mattn/go-runewidth"
-	"github.com/rivo/uniseg"
 )
 
 // State represents the state of the ANSI escape sequence parser used by
@@ -176,10 +177,7 @@ func decodeSequence[T string | []byte](m Method, b T, state State, p *Parser) (s
 			}
 
 			if utf8.RuneStart(c) {
-				seq, _, width, _ = FirstGraphemeCluster(b, -1)
-				if m == WcWidth {
-					width = runewidth.StringWidth(string(seq))
-				}
+				seq, width = FirstGraphemeCluster(b, m)
 				i += len(seq)
 				return b[:i], width, i, NormalState
 			}
@@ -434,17 +432,22 @@ func HasEscPrefix[T string | []byte](b T) bool {
 	return len(b) > 0 && b[0] == ESC
 }
 
-// FirstGraphemeCluster returns the first grapheme cluster in the given string or byte slice.
-// This is a syntactic sugar function that wraps
-// uniseg.FirstGraphemeClusterInString and uniseg.FirstGraphemeCluster.
-func FirstGraphemeCluster[T string | []byte](b T, state int) (T, T, int, int) {
+// FirstGraphemeCluster returns the first grapheme cluster in the given string
+// or byte slice, and its monospace display width.
+func FirstGraphemeCluster[T string | []byte](b T, m Method) (T, int) {
 	switch b := any(b).(type) {
 	case string:
-		cluster, rest, width, newState := uniseg.FirstGraphemeClusterInString(b, state)
-		return T(cluster), T(rest), width, newState
+		cluster := graphemes.FromString(b).First()
+		if m == WcWidth {
+			return T(cluster), runewidth.StringWidth(cluster)
+		}
+		return T(cluster), displaywidth.String(cluster)
 	case []byte:
-		cluster, rest, width, newState := uniseg.FirstGraphemeCluster(b, state)
-		return T(cluster), T(rest), width, newState
+		cluster := graphemes.FromBytes(b).First()
+		if m == WcWidth {
+			return T(cluster), runewidth.StringWidth(string(cluster))
+		}
+		return T(cluster), displaywidth.Bytes(cluster)
 	}
 	panic("unreachable")
 }
@@ -490,7 +493,7 @@ func Command(prefix, inter, final byte) (c int) {
 	c = int(final)
 	c |= int(prefix) << parser.PrefixShift
 	c |= int(inter) << parser.IntermedShift
-	return
+	return c
 }
 
 // Param represents a sequence parameter. Sequence parameters with
@@ -520,5 +523,5 @@ func Parameter(p int, hasMore bool) (s int) {
 	if hasMore {
 		s |= parser.HasMoreFlag
 	}
-	return
+	return s
 }

vendor/github.com/charmbracelet/x/ansi/sgr.go

@@ -21,59 +21,59 @@ func SGR(ps ...Attr) string {
 }
 
 var attrStrings = map[int]string{
-	ResetAttr:                        resetAttr,
-	BoldAttr:                         boldAttr,
-	FaintAttr:                        faintAttr,
-	ItalicAttr:                       italicAttr,
-	UnderlineAttr:                    underlineAttr,
-	SlowBlinkAttr:                    slowBlinkAttr,
-	RapidBlinkAttr:                   rapidBlinkAttr,
-	ReverseAttr:                      reverseAttr,
-	ConcealAttr:                      concealAttr,
-	StrikethroughAttr:                strikethroughAttr,
-	NormalIntensityAttr:              normalIntensityAttr,
-	NoItalicAttr:                     noItalicAttr,
-	NoUnderlineAttr:                  noUnderlineAttr,
-	NoBlinkAttr:                      noBlinkAttr,
-	NoReverseAttr:                    noReverseAttr,
-	NoConcealAttr:                    noConcealAttr,
-	NoStrikethroughAttr:              noStrikethroughAttr,
-	BlackForegroundColorAttr:         blackForegroundColorAttr,
-	RedForegroundColorAttr:           redForegroundColorAttr,
-	GreenForegroundColorAttr:         greenForegroundColorAttr,
-	YellowForegroundColorAttr:        yellowForegroundColorAttr,
-	BlueForegroundColorAttr:          blueForegroundColorAttr,
-	MagentaForegroundColorAttr:       magentaForegroundColorAttr,
-	CyanForegroundColorAttr:          cyanForegroundColorAttr,
-	WhiteForegroundColorAttr:         whiteForegroundColorAttr,
-	ExtendedForegroundColorAttr:      extendedForegroundColorAttr,
-	DefaultForegroundColorAttr:       defaultForegroundColorAttr,
-	BlackBackgroundColorAttr:         blackBackgroundColorAttr,
-	RedBackgroundColorAttr:           redBackgroundColorAttr,
-	GreenBackgroundColorAttr:         greenBackgroundColorAttr,
-	YellowBackgroundColorAttr:        yellowBackgroundColorAttr,
-	BlueBackgroundColorAttr:          blueBackgroundColorAttr,
-	MagentaBackgroundColorAttr:       magentaBackgroundColorAttr,
-	CyanBackgroundColorAttr:          cyanBackgroundColorAttr,
-	WhiteBackgroundColorAttr:         whiteBackgroundColorAttr,
-	ExtendedBackgroundColorAttr:      extendedBackgroundColorAttr,
-	DefaultBackgroundColorAttr:       defaultBackgroundColorAttr,
-	ExtendedUnderlineColorAttr:       extendedUnderlineColorAttr,
-	DefaultUnderlineColorAttr:        defaultUnderlineColorAttr,
-	BrightBlackForegroundColorAttr:   brightBlackForegroundColorAttr,
-	BrightRedForegroundColorAttr:     brightRedForegroundColorAttr,
-	BrightGreenForegroundColorAttr:   brightGreenForegroundColorAttr,
-	BrightYellowForegroundColorAttr:  brightYellowForegroundColorAttr,
-	BrightBlueForegroundColorAttr:    brightBlueForegroundColorAttr,
-	BrightMagentaForegroundColorAttr: brightMagentaForegroundColorAttr,
-	BrightCyanForegroundColorAttr:    brightCyanForegroundColorAttr,
-	BrightWhiteForegroundColorAttr:   brightWhiteForegroundColorAttr,
-	BrightBlackBackgroundColorAttr:   brightBlackBackgroundColorAttr,
-	BrightRedBackgroundColorAttr:     brightRedBackgroundColorAttr,
-	BrightGreenBackgroundColorAttr:   brightGreenBackgroundColorAttr,
-	BrightYellowBackgroundColorAttr:  brightYellowBackgroundColorAttr,
-	BrightBlueBackgroundColorAttr:    brightBlueBackgroundColorAttr,
-	BrightMagentaBackgroundColorAttr: brightMagentaBackgroundColorAttr,
-	BrightCyanBackgroundColorAttr:    brightCyanBackgroundColorAttr,
-	BrightWhiteBackgroundColorAttr:   brightWhiteBackgroundColorAttr,
+	AttrReset:                        attrReset,
+	AttrBold:                         attrBold,
+	AttrFaint:                        attrFaint,
+	AttrItalic:                       attrItalic,
+	AttrUnderline:                    attrUnderline,
+	AttrBlink:                        attrBlink,
+	AttrRapidBlink:                   attrRapidBlink,
+	AttrReverse:                      attrReverse,
+	AttrConceal:                      attrConceal,
+	AttrStrikethrough:                attrStrikethrough,
+	AttrNormalIntensity:              attrNormalIntensity,
+	AttrNoItalic:                     attrNoItalic,
+	AttrNoUnderline:                  attrNoUnderline,
+	AttrNoBlink:                      attrNoBlink,
+	AttrNoReverse:                    attrNoReverse,
+	AttrNoConceal:                    attrNoConceal,
+	AttrNoStrikethrough:              attrNoStrikethrough,
+	AttrBlackForegroundColor:         attrBlackForegroundColor,
+	AttrRedForegroundColor:           attrRedForegroundColor,
+	AttrGreenForegroundColor:         attrGreenForegroundColor,
+	AttrYellowForegroundColor:        attrYellowForegroundColor,
+	AttrBlueForegroundColor:          attrBlueForegroundColor,
+	AttrMagentaForegroundColor:       attrMagentaForegroundColor,
+	AttrCyanForegroundColor:          attrCyanForegroundColor,
+	AttrWhiteForegroundColor:         attrWhiteForegroundColor,
+	AttrExtendedForegroundColor:      attrExtendedForegroundColor,
+	AttrDefaultForegroundColor:       attrDefaultForegroundColor,
+	AttrBlackBackgroundColor:         attrBlackBackgroundColor,
+	AttrRedBackgroundColor:           attrRedBackgroundColor,
+	AttrGreenBackgroundColor:         attrGreenBackgroundColor,
+	AttrYellowBackgroundColor:        attrYellowBackgroundColor,
+	AttrBlueBackgroundColor:          attrBlueBackgroundColor,
+	AttrMagentaBackgroundColor:       attrMagentaBackgroundColor,
+	AttrCyanBackgroundColor:          attrCyanBackgroundColor,
+	AttrWhiteBackgroundColor:         attrWhiteBackgroundColor,
+	AttrExtendedBackgroundColor:      attrExtendedBackgroundColor,
+	AttrDefaultBackgroundColor:       attrDefaultBackgroundColor,
+	AttrExtendedUnderlineColor:       attrExtendedUnderlineColor,
+	AttrDefaultUnderlineColor:        attrDefaultUnderlineColor,
+	AttrBrightBlackForegroundColor:   attrBrightBlackForegroundColor,
+	AttrBrightRedForegroundColor:     attrBrightRedForegroundColor,
+	AttrBrightGreenForegroundColor:   attrBrightGreenForegroundColor,
+	AttrBrightYellowForegroundColor:  attrBrightYellowForegroundColor,
+	AttrBrightBlueForegroundColor:    attrBrightBlueForegroundColor,
+	AttrBrightMagentaForegroundColor: attrBrightMagentaForegroundColor,
+	AttrBrightCyanForegroundColor:    attrBrightCyanForegroundColor,
+	AttrBrightWhiteForegroundColor:   attrBrightWhiteForegroundColor,
+	AttrBrightBlackBackgroundColor:   attrBrightBlackBackgroundColor,
+	AttrBrightRedBackgroundColor:     attrBrightRedBackgroundColor,
+	AttrBrightGreenBackgroundColor:   attrBrightGreenBackgroundColor,
+	AttrBrightYellowBackgroundColor:  attrBrightYellowBackgroundColor,
+	AttrBrightBlueBackgroundColor:    attrBrightBlueBackgroundColor,
+	AttrBrightMagentaBackgroundColor: attrBrightMagentaBackgroundColor,
+	AttrBrightCyanBackgroundColor:    attrBrightCyanBackgroundColor,
+	AttrBrightWhiteBackgroundColor:   attrBrightWhiteBackgroundColor,
 }

vendor/github.com/charmbracelet/x/ansi/style.go

@@ -17,7 +17,9 @@ type Attr = int
 // Style represents an ANSI SGR (Select Graphic Rendition) style.
 type Style []string
 
-// NewStyle returns a new style with the given attributes.
+// NewStyle returns a new style with the given attributes. Attributes are SGR
+// (Select Graphic Rendition) codes that control text formatting like bold,
+// italic, colors, etc.
 func NewStyle(attrs ...Attr) Style {
 	if len(attrs) == 0 {
 		return Style{}
@@ -46,7 +48,8 @@ func (s Style) String() string {
 	return "\x1b[" + strings.Join(s, ";") + "m"
 }
 
-// Styled returns a styled string with the given style applied.
+// Styled returns a styled string with the given style applied. The style is
+// applied at the beginning and reset at the end of the string.
 func (s Style) Styled(str string) string {
 	if len(s) == 0 {
 		return str
@@ -54,161 +57,211 @@ func (s Style) Styled(str string) string {
 	return s.String() + str + ResetStyle
 }
 
-// Reset appends the reset style attribute to the style.
+// Reset appends the reset style attribute to the style. This resets all
+// formatting attributes to their defaults.
 func (s Style) Reset() Style {
-	return append(s, resetAttr)
+	return append(s, attrReset)
 }
 
-// Bold appends the bold style attribute to the style.
+// Bold appends the bold or normal intensity style attribute to the style.
+// You can use [Style.Normal] to reset to normal intensity.
 func (s Style) Bold() Style {
-	return append(s, boldAttr)
+	return append(s, attrBold)
 }
 
-// Faint appends the faint style attribute to the style.
+// Faint appends the faint or normal intensity style attribute to the style.
+// You can use [Style.Normal] to reset to normal intensity.
 func (s Style) Faint() Style {
-	return append(s, faintAttr)
+	return append(s, attrFaint)
 }
 
-// Italic appends the italic style attribute to the style.
-func (s Style) Italic() Style {
-	return append(s, italicAttr)
+// Italic appends the italic or no italic style attribute to the style.
+// When v is true, text is rendered in italic. When false, italic is disabled.
+func (s Style) Italic(v bool) Style {
+	if v {
+		return append(s, attrItalic)
+	}
+	return append(s, attrNoItalic)
 }
 
-// Underline appends the underline style attribute to the style.
-func (s Style) Underline() Style {
-	return append(s, underlineAttr)
+// Underline appends the underline or no underline style attribute to the style.
+// When v is true, text is underlined. When false, underline is disabled.
+func (s Style) Underline(v bool) Style {
+	if v {
+		return append(s, attrUnderline)
+	}
+	return append(s, attrNoUnderline)
 }
 
 // UnderlineStyle appends the underline style attribute to the style.
+// Supports various underline styles including single, double, curly, dotted,
+// and dashed.
 func (s Style) UnderlineStyle(u UnderlineStyle) Style {
 	switch u {
-	case NoUnderlineStyle:
-		return s.NoUnderline()
-	case SingleUnderlineStyle:
-		return s.Underline()
-	case DoubleUnderlineStyle:
-		return append(s, doubleUnderlineStyle)
-	case CurlyUnderlineStyle:
-		return append(s, curlyUnderlineStyle)
-	case DottedUnderlineStyle:
-		return append(s, dottedUnderlineStyle)
-	case DashedUnderlineStyle:
-		return append(s, dashedUnderlineStyle)
+	case UnderlineStyleNone:
+		return s.Underline(false)
+	case UnderlineStyleSingle:
+		return s.Underline(true)
+	case UnderlineStyleDouble:
+		return append(s, underlineStyleDouble)
+	case UnderlineStyleCurly:
+		return append(s, underlineStyleCurly)
+	case UnderlineStyleDotted:
+		return append(s, underlineStyleDotted)
+	case UnderlineStyleDashed:
+		return append(s, underlineStyleDashed)
 	}
 	return s
 }
 
-// DoubleUnderline appends the double underline style attribute to the style.
-// This is a convenience method for UnderlineStyle(DoubleUnderlineStyle).
-func (s Style) DoubleUnderline() Style {
-	return s.UnderlineStyle(DoubleUnderlineStyle)
+// Blink appends the slow blink or no blink style attribute to the style.
+// When v is true, text blinks slowly (less than 150 per minute). When false,
+// blinking is disabled.
+func (s Style) Blink(v bool) Style {
+	if v {
+		return append(s, attrBlink)
+	}
+	return append(s, attrNoBlink)
 }
 
-// CurlyUnderline appends the curly underline style attribute to the style.
-// This is a convenience method for UnderlineStyle(CurlyUnderlineStyle).
-func (s Style) CurlyUnderline() Style {
-	return s.UnderlineStyle(CurlyUnderlineStyle)
+// RapidBlink appends the rapid blink or no blink style attribute to the style.
+// When v is true, text blinks rapidly (150+ per minute). When false, blinking
+// is disabled.
+//
+// Note that this is not widely supported in terminal emulators.
+func (s Style) RapidBlink(v bool) Style {
+	if v {
+		return append(s, attrRapidBlink)
+	}
+	return append(s, attrNoBlink)
 }
 
-// DottedUnderline appends the dotted underline style attribute to the style.
-// This is a convenience method for UnderlineStyle(DottedUnderlineStyle).
-func (s Style) DottedUnderline() Style {
-	return s.UnderlineStyle(DottedUnderlineStyle)
+// Reverse appends the reverse or no reverse style attribute to the style.
+// When v is true, foreground and background colors are swapped. When false,
+// reverse video is disabled.
+func (s Style) Reverse(v bool) Style {
+	if v {
+		return append(s, attrReverse)
+	}
+	return append(s, attrNoReverse)
 }
 
-// DashedUnderline appends the dashed underline style attribute to the style.
-// This is a convenience method for UnderlineStyle(DashedUnderlineStyle).
-func (s Style) DashedUnderline() Style {
-	return s.UnderlineStyle(DashedUnderlineStyle)
+// Conceal appends the conceal or no conceal style attribute to the style.
+// When v is true, text is hidden/concealed. When false, concealment is
+// disabled.
+func (s Style) Conceal(v bool) Style {
+	if v {
+		return append(s, attrConceal)
+	}
+	return append(s, attrNoConceal)
 }
 
-// SlowBlink appends the slow blink style attribute to the style.
-func (s Style) SlowBlink() Style {
-	return append(s, slowBlinkAttr)
+// Strikethrough appends the strikethrough or no strikethrough style attribute
+// to the style. When v is true, text is rendered with a horizontal line through
+// it. When false, strikethrough is disabled.
+func (s Style) Strikethrough(v bool) Style {
+	if v {
+		return append(s, attrStrikethrough)
+	}
+	return append(s, attrNoStrikethrough)
 }
 
-// RapidBlink appends the rapid blink style attribute to the style.
-func (s Style) RapidBlink() Style {
-	return append(s, rapidBlinkAttr)
-}
-
-// Reverse appends the reverse style attribute to the style.
-func (s Style) Reverse() Style {
-	return append(s, reverseAttr)
-}
-
-// Conceal appends the conceal style attribute to the style.
-func (s Style) Conceal() Style {
-	return append(s, concealAttr)
-}
-
-// Strikethrough appends the strikethrough style attribute to the style.
-func (s Style) Strikethrough() Style {
-	return append(s, strikethroughAttr)
-}
-
-// NormalIntensity appends the normal intensity style attribute to the style.
-func (s Style) NormalIntensity() Style {
-	return append(s, normalIntensityAttr)
+// Normal appends the normal intensity style attribute to the style. This
+// resets [Style.Bold] and [Style.Faint] attributes.
+func (s Style) Normal() Style {
+	return append(s, attrNormalIntensity)
 }
 
 // NoItalic appends the no italic style attribute to the style.
+//
+// Deprecated: use [Style.Italic](false) instead.
 func (s Style) NoItalic() Style {
-	return append(s, noItalicAttr)
+	return append(s, attrNoItalic)
 }
 
 // NoUnderline appends the no underline style attribute to the style.
+//
+// Deprecated: use [Style.Underline](false) instead.
 func (s Style) NoUnderline() Style {
-	return append(s, noUnderlineAttr)
+	return append(s, attrNoUnderline)
 }
 
 // NoBlink appends the no blink style attribute to the style.
+//
+// Deprecated: use [Style.Blink](false) or [Style.RapidBlink](false) instead.
 func (s Style) NoBlink() Style {
-	return append(s, noBlinkAttr)
+	return append(s, attrNoBlink)
 }
 
 // NoReverse appends the no reverse style attribute to the style.
+//
+// Deprecated: use [Style.Reverse](false) instead.
 func (s Style) NoReverse() Style {
-	return append(s, noReverseAttr)
+	return append(s, attrNoReverse)
 }
 
 // NoConceal appends the no conceal style attribute to the style.
+//
+// Deprecated: use [Style.Conceal](false) instead.
 func (s Style) NoConceal() Style {
-	return append(s, noConcealAttr)
+	return append(s, attrNoConceal)
 }
 
 // NoStrikethrough appends the no strikethrough style attribute to the style.
+//
+// Deprecated: use [Style.Strikethrough](false) instead.
 func (s Style) NoStrikethrough() Style {
-	return append(s, noStrikethroughAttr)
+	return append(s, attrNoStrikethrough)
 }
 
 // DefaultForegroundColor appends the default foreground color style attribute to the style.
+//
+// Deprecated: use [Style.ForegroundColor](nil) instead.
 func (s Style) DefaultForegroundColor() Style {
-	return append(s, defaultForegroundColorAttr)
+	return append(s, attrDefaultForegroundColor)
 }
 
 // DefaultBackgroundColor appends the default background color style attribute to the style.
+//
+// Deprecated: use [Style.BackgroundColor](nil) instead.
 func (s Style) DefaultBackgroundColor() Style {
-	return append(s, defaultBackgroundColorAttr)
+	return append(s, attrDefaultBackgroundColor)
 }
 
 // DefaultUnderlineColor appends the default underline color style attribute to the style.
+//
+// Deprecated: use [Style.UnderlineColor](nil) instead.
 func (s Style) DefaultUnderlineColor() Style {
-	return append(s, defaultUnderlineColorAttr)
+	return append(s, attrDefaultUnderlineColor)
 }
 
 // ForegroundColor appends the foreground color style attribute to the style.
+// If c is nil, the default foreground color is used. Supports [BasicColor],
+// [IndexedColor] (256-color), and [color.Color] (24-bit RGB).
 func (s Style) ForegroundColor(c Color) Style {
+	if c == nil {
+		return append(s, attrDefaultForegroundColor)
+	}
 	return append(s, foregroundColorString(c))
 }
 
 // BackgroundColor appends the background color style attribute to the style.
+// If c is nil, the default background color is used. Supports [BasicColor],
+// [IndexedColor] (256-color), and [color.Color] (24-bit RGB).
 func (s Style) BackgroundColor(c Color) Style {
+	if c == nil {
+		return append(s, attrDefaultBackgroundColor)
+	}
 	return append(s, backgroundColorString(c))
 }
 
 // UnderlineColor appends the underline color style attribute to the style.
+// If c is nil, the default underline color is used. Supports [BasicColor],
+// [IndexedColor] (256-color), and [color.Color] (24-bit RGB).
 func (s Style) UnderlineColor(c Color) Style {
+	if c == nil {
+		return append(s, attrDefaultUnderlineColor)
+	}
 	return append(s, underlineColorString(c))
 }
 
@@ -217,146 +270,216 @@ func (s Style) UnderlineColor(c Color) Style {
 type UnderlineStyle = byte
 
 const (
-	doubleUnderlineStyle = "4:2"
-	curlyUnderlineStyle  = "4:3"
-	dottedUnderlineStyle = "4:4"
-	dashedUnderlineStyle = "4:5"
+	underlineStyleDouble = "4:2"
+	underlineStyleCurly  = "4:3"
+	underlineStyleDotted = "4:4"
+	underlineStyleDashed = "4:5"
 )
 
+// Underline styles constants.
+const (
+	UnderlineStyleNone UnderlineStyle = iota
+	UnderlineStyleSingle
+	UnderlineStyleDouble
+	UnderlineStyleCurly
+	UnderlineStyleDotted
+	UnderlineStyleDashed
+)
+
+// Underline styles constants.
+//
+// Deprecated: use [UnderlineStyleNone], [UnderlineStyleSingle], etc. instead.
 const (
-	// NoUnderlineStyle is the default underline style.
 	NoUnderlineStyle UnderlineStyle = iota
-	// SingleUnderlineStyle is a single underline style.
 	SingleUnderlineStyle
-	// DoubleUnderlineStyle is a double underline style.
 	DoubleUnderlineStyle
-	// CurlyUnderlineStyle is a curly underline style.
 	CurlyUnderlineStyle
-	// DottedUnderlineStyle is a dotted underline style.
 	DottedUnderlineStyle
-	// DashedUnderlineStyle is a dashed underline style.
 	DashedUnderlineStyle
 )
 
 // SGR (Select Graphic Rendition) style attributes.
 // See: https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_(Select_Graphic_Rendition)_parameters
 const (
-	ResetAttr                        Attr = 0
-	BoldAttr                         Attr = 1
-	FaintAttr                        Attr = 2
-	ItalicAttr                       Attr = 3
-	UnderlineAttr                    Attr = 4
-	SlowBlinkAttr                    Attr = 5
-	RapidBlinkAttr                   Attr = 6
-	ReverseAttr                      Attr = 7
-	ConcealAttr                      Attr = 8
-	StrikethroughAttr                Attr = 9
-	NormalIntensityAttr              Attr = 22
-	NoItalicAttr                     Attr = 23
-	NoUnderlineAttr                  Attr = 24
-	NoBlinkAttr                      Attr = 25
-	NoReverseAttr                    Attr = 27
-	NoConcealAttr                    Attr = 28
-	NoStrikethroughAttr              Attr = 29
-	BlackForegroundColorAttr         Attr = 30
-	RedForegroundColorAttr           Attr = 31
-	GreenForegroundColorAttr         Attr = 32
-	YellowForegroundColorAttr        Attr = 33
-	BlueForegroundColorAttr          Attr = 34
-	MagentaForegroundColorAttr       Attr = 35
-	CyanForegroundColorAttr          Attr = 36
-	WhiteForegroundColorAttr         Attr = 37
-	ExtendedForegroundColorAttr      Attr = 38
-	DefaultForegroundColorAttr       Attr = 39
-	BlackBackgroundColorAttr         Attr = 40
-	RedBackgroundColorAttr           Attr = 41
-	GreenBackgroundColorAttr         Attr = 42
-	YellowBackgroundColorAttr        Attr = 43
-	BlueBackgroundColorAttr          Attr = 44
-	MagentaBackgroundColorAttr       Attr = 45
-	CyanBackgroundColorAttr          Attr = 46
-	WhiteBackgroundColorAttr         Attr = 47
-	ExtendedBackgroundColorAttr      Attr = 48
-	DefaultBackgroundColorAttr       Attr = 49
-	ExtendedUnderlineColorAttr       Attr = 58
-	DefaultUnderlineColorAttr        Attr = 59
-	BrightBlackForegroundColorAttr   Attr = 90
-	BrightRedForegroundColorAttr     Attr = 91
-	BrightGreenForegroundColorAttr   Attr = 92
-	BrightYellowForegroundColorAttr  Attr = 93
-	BrightBlueForegroundColorAttr    Attr = 94
-	BrightMagentaForegroundColorAttr Attr = 95
-	BrightCyanForegroundColorAttr    Attr = 96
-	BrightWhiteForegroundColorAttr   Attr = 97
-	BrightBlackBackgroundColorAttr   Attr = 100
-	BrightRedBackgroundColorAttr     Attr = 101
-	BrightGreenBackgroundColorAttr   Attr = 102
-	BrightYellowBackgroundColorAttr  Attr = 103
-	BrightBlueBackgroundColorAttr    Attr = 104
-	BrightMagentaBackgroundColorAttr Attr = 105
-	BrightCyanBackgroundColorAttr    Attr = 106
-	BrightWhiteBackgroundColorAttr   Attr = 107
+	AttrReset                        Attr = 0
+	AttrBold                         Attr = 1
+	AttrFaint                        Attr = 2
+	AttrItalic                       Attr = 3
+	AttrUnderline                    Attr = 4
+	AttrBlink                        Attr = 5
+	AttrRapidBlink                   Attr = 6
+	AttrReverse                      Attr = 7
+	AttrConceal                      Attr = 8
+	AttrStrikethrough                Attr = 9
+	AttrNormalIntensity              Attr = 22
+	AttrNoItalic                     Attr = 23
+	AttrNoUnderline                  Attr = 24
+	AttrNoBlink                      Attr = 25
+	AttrNoReverse                    Attr = 27
+	AttrNoConceal                    Attr = 28
+	AttrNoStrikethrough              Attr = 29
+	AttrBlackForegroundColor         Attr = 30
+	AttrRedForegroundColor           Attr = 31
+	AttrGreenForegroundColor         Attr = 32
+	AttrYellowForegroundColor        Attr = 33
+	AttrBlueForegroundColor          Attr = 34
+	AttrMagentaForegroundColor       Attr = 35
+	AttrCyanForegroundColor          Attr = 36
+	AttrWhiteForegroundColor         Attr = 37
+	AttrExtendedForegroundColor      Attr = 38
+	AttrDefaultForegroundColor       Attr = 39
+	AttrBlackBackgroundColor         Attr = 40
+	AttrRedBackgroundColor           Attr = 41
+	AttrGreenBackgroundColor         Attr = 42
+	AttrYellowBackgroundColor        Attr = 43
+	AttrBlueBackgroundColor          Attr = 44
+	AttrMagentaBackgroundColor       Attr = 45
+	AttrCyanBackgroundColor          Attr = 46
+	AttrWhiteBackgroundColor         Attr = 47
+	AttrExtendedBackgroundColor      Attr = 48
+	AttrDefaultBackgroundColor       Attr = 49
+	AttrExtendedUnderlineColor       Attr = 58
+	AttrDefaultUnderlineColor        Attr = 59
+	AttrBrightBlackForegroundColor   Attr = 90
+	AttrBrightRedForegroundColor     Attr = 91
+	AttrBrightGreenForegroundColor   Attr = 92
+	AttrBrightYellowForegroundColor  Attr = 93
+	AttrBrightBlueForegroundColor    Attr = 94
+	AttrBrightMagentaForegroundColor Attr = 95
+	AttrBrightCyanForegroundColor    Attr = 96
+	AttrBrightWhiteForegroundColor   Attr = 97
+	AttrBrightBlackBackgroundColor   Attr = 100
+	AttrBrightRedBackgroundColor     Attr = 101
+	AttrBrightGreenBackgroundColor   Attr = 102
+	AttrBrightYellowBackgroundColor  Attr = 103
+	AttrBrightBlueBackgroundColor    Attr = 104
+	AttrBrightMagentaBackgroundColor Attr = 105
+	AttrBrightCyanBackgroundColor    Attr = 106
+	AttrBrightWhiteBackgroundColor   Attr = 107
 
-	RGBColorIntroducerAttr      Attr = 2
-	ExtendedColorIntroducerAttr Attr = 5
+	AttrRGBColorIntroducer      Attr = 2
+	AttrExtendedColorIntroducer Attr = 5
+)
+
+// SGR (Select Graphic Rendition) style attributes.
+//
+// Deprecated: use Attr* constants instead.
+const (
+	ResetAttr                        = AttrReset
+	BoldAttr                         = AttrBold
+	FaintAttr                        = AttrFaint
+	ItalicAttr                       = AttrItalic
+	UnderlineAttr                    = AttrUnderline
+	SlowBlinkAttr                    = AttrBlink
+	RapidBlinkAttr                   = AttrRapidBlink
+	ReverseAttr                      = AttrReverse
+	ConcealAttr                      = AttrConceal
+	StrikethroughAttr                = AttrStrikethrough
+	NormalIntensityAttr              = AttrNormalIntensity
+	NoItalicAttr                     = AttrNoItalic
+	NoUnderlineAttr                  = AttrNoUnderline
+	NoBlinkAttr                      = AttrNoBlink
+	NoReverseAttr                    = AttrNoReverse
+	NoConcealAttr                    = AttrNoConceal
+	NoStrikethroughAttr              = AttrNoStrikethrough
+	BlackForegroundColorAttr         = AttrBlackForegroundColor
+	RedForegroundColorAttr           = AttrRedForegroundColor
+	GreenForegroundColorAttr         = AttrGreenForegroundColor
+	YellowForegroundColorAttr        = AttrYellowForegroundColor
+	BlueForegroundColorAttr          = AttrBlueForegroundColor
+	MagentaForegroundColorAttr       = AttrMagentaForegroundColor
+	CyanForegroundColorAttr          = AttrCyanForegroundColor
+	WhiteForegroundColorAttr         = AttrWhiteForegroundColor
+	ExtendedForegroundColorAttr      = AttrExtendedForegroundColor
+	DefaultForegroundColorAttr       = AttrDefaultForegroundColor
+	BlackBackgroundColorAttr         = AttrBlackBackgroundColor
+	RedBackgroundColorAttr           = AttrRedBackgroundColor
+	GreenBackgroundColorAttr         = AttrGreenBackgroundColor
+	YellowBackgroundColorAttr        = AttrYellowBackgroundColor
+	BlueBackgroundColorAttr          = AttrBlueBackgroundColor
+	MagentaBackgroundColorAttr       = AttrMagentaBackgroundColor
+	CyanBackgroundColorAttr          = AttrCyanBackgroundColor
+	WhiteBackgroundColorAttr         = AttrWhiteBackgroundColor
+	ExtendedBackgroundColorAttr      = AttrExtendedBackgroundColor
+	DefaultBackgroundColorAttr       = AttrDefaultBackgroundColor
+	ExtendedUnderlineColorAttr       = AttrExtendedUnderlineColor
+	DefaultUnderlineColorAttr        = AttrDefaultUnderlineColor
+	BrightBlackForegroundColorAttr   = AttrBrightBlackForegroundColor
+	BrightRedForegroundColorAttr     = AttrBrightRedForegroundColor
+	BrightGreenForegroundColorAttr   = AttrBrightGreenForegroundColor
+	BrightYellowForegroundColorAttr  = AttrBrightYellowForegroundColor
+	BrightBlueForegroundColorAttr    = AttrBrightBlueForegroundColor
+	BrightMagentaForegroundColorAttr = AttrBrightMagentaForegroundColor
+	BrightCyanForegroundColorAttr    = AttrBrightCyanForegroundColor
+	BrightWhiteForegroundColorAttr   = AttrBrightWhiteForegroundColor
+	BrightBlackBackgroundColorAttr   = AttrBrightBlackBackgroundColor
+	BrightRedBackgroundColorAttr     = AttrBrightRedBackgroundColor
+	BrightGreenBackgroundColorAttr   = AttrBrightGreenBackgroundColor
+	BrightYellowBackgroundColorAttr  = AttrBrightYellowBackgroundColor
+	BrightBlueBackgroundColorAttr    = AttrBrightBlueBackgroundColor
+	BrightMagentaBackgroundColorAttr = AttrBrightMagentaBackgroundColor
+	BrightCyanBackgroundColorAttr    = AttrBrightCyanBackgroundColor
+	BrightWhiteBackgroundColorAttr   = AttrBrightWhiteBackgroundColor
+	RGBColorIntroducerAttr           = AttrRGBColorIntroducer
+	ExtendedColorIntroducerAttr      = AttrExtendedColorIntroducer
 )
 
 const (
-	resetAttr                        = "0"
-	boldAttr                         = "1"
-	faintAttr                        = "2"
-	italicAttr                       = "3"
-	underlineAttr                    = "4"
-	slowBlinkAttr                    = "5"
-	rapidBlinkAttr                   = "6"
-	reverseAttr                      = "7"
-	concealAttr                      = "8"
-	strikethroughAttr                = "9"
-	normalIntensityAttr              = "22"
-	noItalicAttr                     = "23"
-	noUnderlineAttr                  = "24"
-	noBlinkAttr                      = "25"
-	noReverseAttr                    = "27"
-	noConcealAttr                    = "28"
-	noStrikethroughAttr              = "29"
-	blackForegroundColorAttr         = "30"
-	redForegroundColorAttr           = "31"
-	greenForegroundColorAttr         = "32"
-	yellowForegroundColorAttr        = "33"
-	blueForegroundColorAttr          = "34"
-	magentaForegroundColorAttr       = "35"
-	cyanForegroundColorAttr          = "36"
-	whiteForegroundColorAttr         = "37"
-	extendedForegroundColorAttr      = "38"
-	defaultForegroundColorAttr       = "39"
-	blackBackgroundColorAttr         = "40"
-	redBackgroundColorAttr           = "41"
-	greenBackgroundColorAttr         = "42"
-	yellowBackgroundColorAttr        = "43"
-	blueBackgroundColorAttr          = "44"
-	magentaBackgroundColorAttr       = "45"
-	cyanBackgroundColorAttr          = "46"
-	whiteBackgroundColorAttr         = "47"
-	extendedBackgroundColorAttr      = "48"
-	defaultBackgroundColorAttr       = "49"
-	extendedUnderlineColorAttr       = "58"
-	defaultUnderlineColorAttr        = "59"
-	brightBlackForegroundColorAttr   = "90"
-	brightRedForegroundColorAttr     = "91"
-	brightGreenForegroundColorAttr   = "92"
-	brightYellowForegroundColorAttr  = "93"
-	brightBlueForegroundColorAttr    = "94"
-	brightMagentaForegroundColorAttr = "95"
-	brightCyanForegroundColorAttr    = "96"
-	brightWhiteForegroundColorAttr   = "97"
-	brightBlackBackgroundColorAttr   = "100"
-	brightRedBackgroundColorAttr     = "101"
-	brightGreenBackgroundColorAttr   = "102"
-	brightYellowBackgroundColorAttr  = "103"
-	brightBlueBackgroundColorAttr    = "104"
-	brightMagentaBackgroundColorAttr = "105"
-	brightCyanBackgroundColorAttr    = "106"
-	brightWhiteBackgroundColorAttr   = "107"
+	attrReset                        = "0"
+	attrBold                         = "1"
+	attrFaint                        = "2"
+	attrItalic                       = "3"
+	attrUnderline                    = "4"
+	attrBlink                        = "5"
+	attrRapidBlink                   = "6"
+	attrReverse                      = "7"
+	attrConceal                      = "8"
+	attrStrikethrough                = "9"
+	attrNormalIntensity              = "22"
+	attrNoItalic                     = "23"
+	attrNoUnderline                  = "24"
+	attrNoBlink                      = "25"
+	attrNoReverse                    = "27"
+	attrNoConceal                    = "28"
+	attrNoStrikethrough              = "29"
+	attrBlackForegroundColor         = "30"
+	attrRedForegroundColor           = "31"
+	attrGreenForegroundColor         = "32"
+	attrYellowForegroundColor        = "33"
+	attrBlueForegroundColor          = "34"
+	attrMagentaForegroundColor       = "35"
+	attrCyanForegroundColor          = "36"
+	attrWhiteForegroundColor         = "37"
+	attrExtendedForegroundColor      = "38"
+	attrDefaultForegroundColor       = "39"
+	attrBlackBackgroundColor         = "40"
+	attrRedBackgroundColor           = "41"
+	attrGreenBackgroundColor         = "42"
+	attrYellowBackgroundColor        = "43"
+	attrBlueBackgroundColor          = "44"
+	attrMagentaBackgroundColor       = "45"
+	attrCyanBackgroundColor          = "46"
+	attrWhiteBackgroundColor         = "47"
+	attrExtendedBackgroundColor      = "48"
+	attrDefaultBackgroundColor       = "49"
+	attrExtendedUnderlineColor       = "58"
+	attrDefaultUnderlineColor        = "59"
+	attrBrightBlackForegroundColor   = "90"
+	attrBrightRedForegroundColor     = "91"
+	attrBrightGreenForegroundColor   = "92"
+	attrBrightYellowForegroundColor  = "93"
+	attrBrightBlueForegroundColor    = "94"
+	attrBrightMagentaForegroundColor = "95"
+	attrBrightCyanForegroundColor    = "96"
+	attrBrightWhiteForegroundColor   = "97"
+	attrBrightBlackBackgroundColor   = "100"
+	attrBrightRedBackgroundColor     = "101"
+	attrBrightGreenBackgroundColor   = "102"
+	attrBrightYellowBackgroundColor  = "103"
+	attrBrightBlueBackgroundColor    = "104"
+	attrBrightMagentaBackgroundColor = "105"
+	attrBrightCyanBackgroundColor    = "106"
+	attrBrightWhiteBackgroundColor   = "107"
 )
 
 // foregroundColorString returns the style SGR attribute for the given
@@ -369,37 +492,37 @@ func foregroundColorString(c Color) string {
 		// "3<n>" or "9<n>" where n is the color number from 0 to 7
 		switch c {
 		case Black:
-			return blackForegroundColorAttr
+			return attrBlackForegroundColor
 		case Red:
-			return redForegroundColorAttr
+			return attrRedForegroundColor
 		case Green:
-			return greenForegroundColorAttr
+			return attrGreenForegroundColor
 		case Yellow:
-			return yellowForegroundColorAttr
+			return attrYellowForegroundColor
 		case Blue:
-			return blueForegroundColorAttr
+			return attrBlueForegroundColor
 		case Magenta:
-			return magentaForegroundColorAttr
+			return attrMagentaForegroundColor
 		case Cyan:
-			return cyanForegroundColorAttr
+			return attrCyanForegroundColor
 		case White:
-			return whiteForegroundColorAttr
+			return attrWhiteForegroundColor
 		case BrightBlack:
-			return brightBlackForegroundColorAttr
+			return attrBrightBlackForegroundColor
 		case BrightRed:
-			return brightRedForegroundColorAttr
+			return attrBrightRedForegroundColor
 		case BrightGreen:
-			return brightGreenForegroundColorAttr
+			return attrBrightGreenForegroundColor
 		case BrightYellow:
-			return brightYellowForegroundColorAttr
+			return attrBrightYellowForegroundColor
 		case BrightBlue:
-			return brightBlueForegroundColorAttr
+			return attrBrightBlueForegroundColor
 		case BrightMagenta:
-			return brightMagentaForegroundColorAttr
+			return attrBrightMagentaForegroundColor
 		case BrightCyan:
-			return brightCyanForegroundColorAttr
+			return attrBrightCyanForegroundColor
 		case BrightWhite:
-			return brightWhiteForegroundColorAttr
+			return attrBrightWhiteForegroundColor
 		}
 	case ExtendedColor:
 		// 256-color ANSI foreground
@@ -414,7 +537,7 @@ func foregroundColorString(c Color) string {
 			strconv.FormatUint(uint64(shift(g)), 10) + ";" +
 			strconv.FormatUint(uint64(shift(b)), 10)
 	}
-	return defaultForegroundColorAttr
+	return attrDefaultForegroundColor
 }
 
 // backgroundColorString returns the style SGR attribute for the given
@@ -427,37 +550,37 @@ func backgroundColorString(c Color) string {
 		// "4<n>" or "10<n>" where n is the color number from 0 to 7
 		switch c {
 		case Black:
-			return blackBackgroundColorAttr
+			return attrBlackBackgroundColor
 		case Red:
-			return redBackgroundColorAttr
+			return attrRedBackgroundColor
 		case Green:
-			return greenBackgroundColorAttr
+			return attrGreenBackgroundColor
 		case Yellow:
-			return yellowBackgroundColorAttr
+			return attrYellowBackgroundColor
 		case Blue:
-			return blueBackgroundColorAttr
+			return attrBlueBackgroundColor
 		case Magenta:
-			return magentaBackgroundColorAttr
+			return attrMagentaBackgroundColor
 		case Cyan:
-			return cyanBackgroundColorAttr
+			return attrCyanBackgroundColor
 		case White:
-			return whiteBackgroundColorAttr
+			return attrWhiteBackgroundColor
 		case BrightBlack:
-			return brightBlackBackgroundColorAttr
+			return attrBrightBlackBackgroundColor
 		case BrightRed:
-			return brightRedBackgroundColorAttr
+			return attrBrightRedBackgroundColor
 		case BrightGreen:
-			return brightGreenBackgroundColorAttr
+			return attrBrightGreenBackgroundColor
 		case BrightYellow:
-			return brightYellowBackgroundColorAttr
+			return attrBrightYellowBackgroundColor
 		case BrightBlue:
-			return brightBlueBackgroundColorAttr
+			return attrBrightBlueBackgroundColor
 		case BrightMagenta:
-			return brightMagentaBackgroundColorAttr
+			return attrBrightMagentaBackgroundColor
 		case BrightCyan:
-			return brightCyanBackgroundColorAttr
+			return attrBrightCyanBackgroundColor
 		case BrightWhite:
-			return brightWhiteBackgroundColorAttr
+			return attrBrightWhiteBackgroundColor
 		}
 	case ExtendedColor:
 		// 256-color ANSI foreground
@@ -472,7 +595,7 @@ func backgroundColorString(c Color) string {
 			strconv.FormatUint(uint64(shift(g)), 10) + ";" +
 			strconv.FormatUint(uint64(shift(b)), 10)
 	}
-	return defaultBackgroundColorAttr
+	return attrDefaultBackgroundColor
 }
 
 // underlineColorString returns the style SGR attribute for the given underline
@@ -498,7 +621,7 @@ func underlineColorString(c Color) string {
 			strconv.FormatUint(uint64(shift(g)), 10) + ";" +
 			strconv.FormatUint(uint64(shift(b)), 10)
 	}
-	return defaultUnderlineColorAttr
+	return attrDefaultUnderlineColor
 }
 
 // ReadStyleColor decodes a color from a slice of parameters. It returns the
@@ -526,7 +649,7 @@ func underlineColorString(c Color) string {
 //  2. Support ignoring and omitting the color space id (second parameter) with respect to RGB colors
 //  3. Support ignoring and omitting the 6th parameter with respect to RGB and CMY colors
 //  4. Support reading RGBA colors
-func ReadStyleColor(params Params, co *color.Color) (n int) {
+func ReadStyleColor(params Params, co *color.Color) int {
 	if len(params) < 2 { // Need at least SGR type and color type
 		return 0
 	}
@@ -535,7 +658,7 @@ func ReadStyleColor(params Params, co *color.Color) (n int) {
 	s := params[0]
 	p := params[1]
 	colorType := p.Param(0)
-	n = 2
+	n := 2
 
 	paramsfn := func() (p1, p2, p3, p4 int) {
 		// Where should we start reading the color?
@@ -594,7 +717,7 @@ func ReadStyleColor(params Params, co *color.Color) (n int) {
 			B: uint8(b), //nolint:gosec
 			A: 0xff,
 		}
-		return //nolint:nakedret
+		return n
 
 	case 3: // CMY direct color
 		if len(params) < 5 {
@@ -612,7 +735,7 @@ func ReadStyleColor(params Params, co *color.Color) (n int) {
 			Y: uint8(y), //nolint:gosec
 			K: 0,
 		}
-		return //nolint:nakedret
+		return n
 
 	case 4: // CMYK direct color
 		if len(params) < 6 {
@@ -630,7 +753,7 @@ func ReadStyleColor(params Params, co *color.Color) (n int) {
 			Y: uint8(y), //nolint:gosec
 			K: uint8(k), //nolint:gosec
 		}
-		return //nolint:nakedret
+		return n
 
 	case 5: // indexed color
 		if len(params) < 3 {
@@ -665,7 +788,7 @@ func ReadStyleColor(params Params, co *color.Color) (n int) {
 			B: uint8(b), //nolint:gosec
 			A: uint8(a), //nolint:gosec
 		}
-		return //nolint:nakedret
+		return n
 
 	default:
 		return 0

vendor/github.com/charmbracelet/x/ansi/truncate.go

@@ -1,11 +1,11 @@
 package ansi
 
 import (
-	"bytes"
+	"strings"
 
 	"github.com/charmbracelet/x/ansi/parser"
-	"github.com/mattn/go-runewidth"
-	"github.com/rivo/uniseg"
+	"github.com/clipperhouse/displaywidth"
+	"github.com/clipperhouse/uax29/v2/graphemes"
 )
 
 // Cut the string, without adding any prefix or tail strings. This function is
@@ -74,12 +74,11 @@ func truncate(m Method, s string, length int, tail string) string {
 		return ""
 	}
 
-	var cluster []byte
-	var buf bytes.Buffer
+	var cluster string
+	var buf strings.Builder
 	curWidth := 0
 	ignoring := false
 	pstate := parser.GroundState // initial state
-	b := []byte(s)
 	i := 0
 
 	// Here we iterate over the bytes of the string and collect printable
@@ -88,16 +87,12 @@ func truncate(m Method, s string, length int, tail string) string {
 	//
 	// Once we reach the given length, we start ignoring characters and only
 	// collect ANSI escape codes until we reach the end of string.
-	for i < len(b) {
-		state, action := parser.Table.Transition(pstate, b[i])
+	for i < len(s) {
+		state, action := parser.Table.Transition(pstate, s[i])
 		if state == parser.Utf8State {
 			// This action happens when we transition to the Utf8State.
 			var width int
-			cluster, _, width, _ = uniseg.FirstGraphemeCluster(b[i:], -1)
-			if m == WcWidth {
-				width = runewidth.StringWidth(string(cluster))
-			}
-
+			cluster, width = FirstGraphemeCluster(s[i:], m)
 			// increment the index by the length of the cluster
 			i += len(cluster)
 			curWidth += width
@@ -118,7 +113,7 @@ func truncate(m Method, s string, length int, tail string) string {
 				continue
 			}
 
-			buf.Write(cluster)
+			buf.WriteString(cluster)
 
 			// Done collecting, now we're back in the ground state.
 			pstate = parser.GroundState
@@ -152,7 +147,7 @@ func truncate(m Method, s string, length int, tail string) string {
 			}
 			fallthrough
 		default:
-			buf.WriteByte(b[i])
+			buf.WriteByte(s[i])
 			i++
 		}
 
@@ -193,27 +188,23 @@ func truncateLeft(m Method, s string, n int, prefix string) string {
 		return s
 	}
 
-	var cluster []byte
-	var buf bytes.Buffer
+	var cluster string
+	var buf strings.Builder
 	curWidth := 0
 	ignoring := true
 	pstate := parser.GroundState
-	b := []byte(s)
 	i := 0
 
-	for i < len(b) {
+	for i < len(s) {
 		if !ignoring {
-			buf.Write(b[i:])
+			buf.WriteString(s[i:])
 			break
 		}
 
-		state, action := parser.Table.Transition(pstate, b[i])
+		state, action := parser.Table.Transition(pstate, s[i])
 		if state == parser.Utf8State {
 			var width int
-			cluster, _, width, _ = uniseg.FirstGraphemeCluster(b[i:], -1)
-			if m == WcWidth {
-				width = runewidth.StringWidth(string(cluster))
-			}
+			cluster, width = FirstGraphemeCluster(s[i:], m)
 
 			i += len(cluster)
 			curWidth += width
@@ -224,7 +215,7 @@ func truncateLeft(m Method, s string, n int, prefix string) string {
 			}
 
 			if curWidth > n {
-				buf.Write(cluster)
+				buf.WriteString(cluster)
 			}
 
 			if ignoring {
@@ -259,7 +250,7 @@ func truncateLeft(m Method, s string, n int, prefix string) string {
 			}
 			fallthrough
 		default:
-			buf.WriteByte(b[i])
+			buf.WriteByte(s[i])
 			i++
 		}
 
@@ -278,22 +269,22 @@ func truncateLeft(m Method, s string, n int, prefix string) string {
 // You can use this with [Truncate], [TruncateLeft], and [Cut].
 func ByteToGraphemeRange(str string, byteStart, byteStop int) (charStart, charStop int) {
 	bytePos, charPos := 0, 0
-	gr := uniseg.NewGraphemes(str)
+	gr := graphemes.FromString(str)
 	for byteStart > bytePos {
 		if !gr.Next() {
 			break
 		}
-		bytePos += len(gr.Str())
-		charPos += max(1, gr.Width())
+		bytePos += len(gr.Value())
+		charPos += max(1, displaywidth.String(gr.Value()))
 	}
 	charStart = charPos
 	for byteStop > bytePos {
 		if !gr.Next() {
 			break
 		}
-		bytePos += len(gr.Str())
-		charPos += max(1, gr.Width())
+		bytePos += len(gr.Value())
+		charPos += max(1, displaywidth.String(gr.Value()))
 	}
 	charStop = charPos
-	return
+	return charStart, charStop
 }

vendor/github.com/charmbracelet/x/ansi/urxvt.go

@@ -0,0 +1,17 @@
+package ansi
+
+import (
+	"fmt"
+	"strings"
+)
+
+// URxvtExt returns an escape sequence for calling a URxvt perl extension with
+// the given name and parameters.
+//
+//	OSC 777 ; extension_name ; param1 ; param2 ; ... ST
+//	OSC 777 ; extension_name ; param1 ; param2 ; ... BEL
+//
+// See: https://man.archlinux.org/man/extra/rxvt-unicode/urxvt.7.en#XTerm_Operating_System_Commands
+func URxvtExt(extension string, params ...string) string {
+	return fmt.Sprintf("\x1b]777;%s;%s\x07", extension, strings.Join(params, ";"))
+}

vendor/github.com/charmbracelet/x/ansi/width.go

@@ -4,8 +4,6 @@ import (
 	"bytes"
 
 	"github.com/charmbracelet/x/ansi/parser"
-	"github.com/mattn/go-runewidth"
-	"github.com/rivo/uniseg"
 )
 
 // Strip removes ANSI escape codes from a string.
@@ -83,20 +81,16 @@ func stringWidth(m Method, s string) int {
 	}
 
 	var (
-		pstate  = parser.GroundState // initial state
-		cluster string
-		width   int
+		pstate = parser.GroundState // initial state
+		width  int
 	)
 
 	for i := 0; i < len(s); i++ {
 		state, action := parser.Table.Transition(pstate, s[i])
 		if state == parser.Utf8State {
-			var w int
-			cluster, _, w, _ = uniseg.FirstGraphemeClusterInString(s[i:], -1)
-			if m == WcWidth {
-				w = runewidth.StringWidth(cluster)
-			}
+			cluster, w := FirstGraphemeCluster(s[i:], m)
 			width += w
+
 			i += len(cluster) - 1
 			pstate = parser.GroundState
 			continue

vendor/github.com/charmbracelet/x/ansi/wrap.go

@@ -2,12 +2,11 @@ package ansi
 
 import (
 	"bytes"
+	"strings"
 	"unicode"
 	"unicode/utf8"
 
 	"github.com/charmbracelet/x/ansi/parser"
-	"github.com/mattn/go-runewidth"
-	"github.com/rivo/uniseg"
 )
 
 // nbsp is a non-breaking space.
@@ -55,12 +54,9 @@ func hardwrap(m Method, s string, limit int, preserveSpace bool) string {
 	i := 0
 	for i < len(b) {
 		state, action := parser.Table.Transition(pstate, b[i])
-		if state == parser.Utf8State { //nolint:nestif
+		if state == parser.Utf8State {
 			var width int
-			cluster, _, width, _ = uniseg.FirstGraphemeCluster(b[i:], -1)
-			if m == WcWidth {
-				width = runewidth.StringWidth(string(cluster))
-			}
+			cluster, width = FirstGraphemeCluster(b[i:], m)
 			i += len(cluster)
 
 			if curWidth+width > limit {
@@ -192,10 +188,7 @@ func wordwrap(m Method, s string, limit int, breakpoints string) string {
 		state, action := parser.Table.Transition(pstate, b[i])
 		if state == parser.Utf8State { //nolint:nestif
 			var width int
-			cluster, _, width, _ = uniseg.FirstGraphemeCluster(b[i:], -1)
-			if m == WcWidth {
-				width = runewidth.StringWidth(string(cluster))
-			}
+			cluster, width = FirstGraphemeCluster(b[i:], m)
 			i += len(cluster)
 
 			r, _ := utf8.DecodeRune(cluster)
@@ -303,7 +296,7 @@ func wrap(m Method, s string, limit int, breakpoints string) string {
 	}
 
 	var (
-		cluster    []byte
+		cluster    string
 		buf        bytes.Buffer
 		word       bytes.Buffer
 		space      bytes.Buffer
@@ -311,10 +304,12 @@ func wrap(m Method, s string, limit int, breakpoints string) string {
 		curWidth   int                  // written width of the line
 		wordLen    int                  // word buffer len without ANSI escape codes
 		pstate     = parser.GroundState // initial state
-		b          = []byte(s)
 	)
 
 	addSpace := func() {
+		if spaceWidth == 0 && space.Len() == 0 {
+			return
+		}
 		curWidth += spaceWidth
 		buf.Write(space.Bytes())
 		space.Reset()
@@ -341,30 +336,27 @@ func wrap(m Method, s string, limit int, breakpoints string) string {
 	}
 
 	i := 0
-	for i < len(b) {
-		state, action := parser.Table.Transition(pstate, b[i])
+	for i < len(s) {
+		state, action := parser.Table.Transition(pstate, s[i])
 		if state == parser.Utf8State { //nolint:nestif
 			var width int
-			cluster, _, width, _ = uniseg.FirstGraphemeCluster(b[i:], -1)
-			if m == WcWidth {
-				width = runewidth.StringWidth(string(cluster))
-			}
+			cluster, width = FirstGraphemeCluster(s[i:], m)
 			i += len(cluster)
 
-			r, _ := utf8.DecodeRune(cluster)
+			r, _ := utf8.DecodeRuneInString(cluster)
 			switch {
 			case r != utf8.RuneError && unicode.IsSpace(r) && r != nbsp: // nbsp is a non-breaking space
 				addWord()
 				space.WriteRune(r)
 				spaceWidth += width
-			case bytes.ContainsAny(cluster, breakpoints):
+			case strings.ContainsAny(cluster, breakpoints):
 				addSpace()
 				if curWidth+wordLen+width > limit {
-					word.Write(cluster)
+					word.WriteString(cluster)
 					wordLen += width
 				} else {
 					addWord()
-					buf.Write(cluster)
+					buf.WriteString(cluster)
 					curWidth += width
 				}
 			default:
@@ -373,12 +365,17 @@ func wrap(m Method, s string, limit int, breakpoints string) string {
 					addWord()
 				}
 
-				word.Write(cluster)
+				word.WriteString(cluster)
 				wordLen += width
 
 				if curWidth+wordLen+spaceWidth > limit {
 					addNewline()
 				}
+
+				if wordLen == limit {
+					// Hardwrap the word if it's too long
+					addWord()
+				}
 			}
 
 			pstate = parser.GroundState
@@ -387,7 +384,7 @@ func wrap(m Method, s string, limit int, breakpoints string) string {
 
 		switch action {
 		case parser.PrintAction, parser.ExecuteAction:
-			switch r := rune(b[i]); {
+			switch r := rune(s[i]); {
 			case r == '\n':
 				if wordLen == 0 {
 					if curWidth+spaceWidth > limit {
@@ -424,6 +421,7 @@ func wrap(m Method, s string, limit int, breakpoints string) string {
 				if curWidth == limit {
 					addNewline()
 				}
+
 				word.WriteRune(r)
 				wordLen++
 
@@ -438,7 +436,7 @@ func wrap(m Method, s string, limit int, breakpoints string) string {
 			}
 
 		default:
-			word.WriteByte(b[i])
+			word.WriteByte(s[i])
 		}
 
 		// We manage the UTF8 state separately manually above.

vendor/github.com/charmbracelet/x/cellbuf/buffer.go

@@ -1,3 +1,4 @@
+// Package cellbuf provides terminal cell buffer functionality.
 package cellbuf
 
 import (
@@ -24,7 +25,7 @@ func NewCell(r rune, comb ...rune) (c *Cell) {
 	}
 	c.Comb = comb
 	c.Width = runewidth.StringWidth(string(append([]rune{r}, comb...)))
-	return
+	return c
 }
 
 // NewCellString returns a new cell with the given string content. This is a
@@ -46,7 +47,7 @@ func NewCellString(s string) (c *Cell) {
 			c.Comb = append(c.Comb, r)
 		}
 	}
-	return
+	return c
 }
 
 // NewGraphemeCell returns a new cell. This is a convenience function that
@@ -71,7 +72,7 @@ func newGraphemeCell(s string, w int) (c *Cell) {
 			c.Comb = append(c.Comb, r)
 		}
 	}
-	return
+	return c
 }
 
 // Line represents a line in the terminal.
@@ -104,7 +105,7 @@ func (l Line) String() (s string) {
 		}
 	}
 	s = strings.TrimRight(s, " ")
-	return
+	return s
 }
 
 // At returns the cell at the given x position.
@@ -150,7 +151,7 @@ func (l Line) set(x int, c *Cell, clone bool) bool {
 		for j := 1; j < maxCellWidth && x-j >= 0; j++ {
 			wide := l.At(x - j)
 			if wide != nil && wide.Width > 1 && j < wide.Width {
-				for k := 0; k < wide.Width; k++ {
+				for k := range wide.Width {
 					l[x-j+k] = wide.Clone().Blank()
 				}
 				break
@@ -206,7 +207,7 @@ func (b *Buffer) String() (s string) {
 			s += "\r\n"
 		}
 	}
-	return
+	return s
 }
 
 // Line returns a pointer to the line at the given y position.
@@ -296,7 +297,7 @@ func (b *Buffer) FillRect(c *Cell, rect Rectangle) {
 	}
 	for y := rect.Min.Y; y < rect.Max.Y; y++ {
 		for x := rect.Min.X; x < rect.Max.X; x += cellWidth {
-			b.setCell(x, y, c, false) //nolint:errcheck
+			b.setCell(x, y, c, false)
 		}
 	}
 }

vendor/github.com/charmbracelet/x/cellbuf/cell.go

@@ -96,7 +96,7 @@ func (c *Cell) Clear() bool {
 func (c *Cell) Clone() (n *Cell) {
 	n = new(Cell)
 	*n = *c
-	return
+	return n
 }
 
 // Blank makes the cell a blank cell by setting the rune to a space, comb to
@@ -164,12 +164,12 @@ type UnderlineStyle = ansi.UnderlineStyle
 
 // These are the available underline styles.
 const (
-	NoUnderline     = ansi.NoUnderlineStyle
-	SingleUnderline = ansi.SingleUnderlineStyle
-	DoubleUnderline = ansi.DoubleUnderlineStyle
-	CurlyUnderline  = ansi.CurlyUnderlineStyle
-	DottedUnderline = ansi.DottedUnderlineStyle
-	DashedUnderline = ansi.DashedUnderlineStyle
+	NoUnderline     = ansi.UnderlineStyleNone
+	SingleUnderline = ansi.UnderlineStyleSingle
+	DoubleUnderline = ansi.UnderlineStyleDouble
+	CurlyUnderline  = ansi.UnderlineStyleCurly
+	DottedUnderline = ansi.UnderlineStyleDotted
+	DashedUnderline = ansi.UnderlineStyleDashed
 )
 
 // Style represents the Style of a cell.
@@ -189,7 +189,7 @@ func (s Style) Sequence() string {
 
 	var b ansi.Style
 
-	if s.Attrs != 0 {
+	if s.Attrs != 0 { //nolint:nestif
 		if s.Attrs&BoldAttr != 0 {
 			b = b.Bold()
 		}
@@ -197,36 +197,31 @@ func (s Style) Sequence() string {
 			b = b.Faint()
 		}
 		if s.Attrs&ItalicAttr != 0 {
-			b = b.Italic()
+			b = b.Italic(true)
 		}
 		if s.Attrs&SlowBlinkAttr != 0 {
-			b = b.SlowBlink()
+			b = b.Blink(true)
 		}
 		if s.Attrs&RapidBlinkAttr != 0 {
-			b = b.RapidBlink()
+			b = b.RapidBlink(true)
 		}
 		if s.Attrs&ReverseAttr != 0 {
-			b = b.Reverse()
+			b = b.Reverse(true)
 		}
 		if s.Attrs&ConcealAttr != 0 {
-			b = b.Conceal()
+			b = b.Conceal(true)
 		}
 		if s.Attrs&StrikethroughAttr != 0 {
-			b = b.Strikethrough()
+			b = b.Strikethrough(true)
 		}
 	}
 	if s.UlStyle != NoUnderline {
-		switch s.UlStyle {
-		case SingleUnderline:
-			b = b.Underline()
-		case DoubleUnderline:
-			b = b.DoubleUnderline()
-		case CurlyUnderline:
-			b = b.CurlyUnderline()
-		case DottedUnderline:
-			b = b.DottedUnderline()
-		case DashedUnderline:
-			b = b.DashedUnderline()
+		switch u := s.UlStyle; u {
+		case NoUnderline:
+			b = b.Underline(false)
+		default:
+			b = b.Underline(true)
+			b = b.UnderlineStyle(u)
 		}
 	}
 	if s.Fg != nil {
@@ -268,64 +263,48 @@ func (s Style) DiffSequence(o Style) string {
 		isNormal bool
 	)
 
-	if s.Attrs != o.Attrs {
+	if s.Attrs != o.Attrs { //nolint:nestif
 		if s.Attrs&BoldAttr != o.Attrs&BoldAttr {
 			if s.Attrs&BoldAttr != 0 {
 				b = b.Bold()
 			} else if !isNormal {
 				isNormal = true
-				b = b.NormalIntensity()
+				b = b.Normal()
 			}
 		}
 		if s.Attrs&FaintAttr != o.Attrs&FaintAttr {
 			if s.Attrs&FaintAttr != 0 {
 				b = b.Faint()
 			} else if !isNormal {
-				b = b.NormalIntensity()
+				b = b.Normal()
 			}
 		}
 		if s.Attrs&ItalicAttr != o.Attrs&ItalicAttr {
-			if s.Attrs&ItalicAttr != 0 {
-				b = b.Italic()
-			} else {
-				b = b.NoItalic()
-			}
+			b = b.Italic(s.Attrs&ItalicAttr != 0)
 		}
 		if s.Attrs&SlowBlinkAttr != o.Attrs&SlowBlinkAttr {
 			if s.Attrs&SlowBlinkAttr != 0 {
-				b = b.SlowBlink()
+				b = b.Blink(true)
 			} else if !noBlink {
 				noBlink = true
-				b = b.NoBlink()
+				b = b.Blink(false)
 			}
 		}
 		if s.Attrs&RapidBlinkAttr != o.Attrs&RapidBlinkAttr {
 			if s.Attrs&RapidBlinkAttr != 0 {
-				b = b.RapidBlink()
+				b = b.RapidBlink(true)
 			} else if !noBlink {
-				b = b.NoBlink()
+				b = b.Blink(false)
 			}
 		}
 		if s.Attrs&ReverseAttr != o.Attrs&ReverseAttr {
-			if s.Attrs&ReverseAttr != 0 {
-				b = b.Reverse()
-			} else {
-				b = b.NoReverse()
-			}
+			b = b.Reverse(s.Attrs&ReverseAttr != 0)
 		}
 		if s.Attrs&ConcealAttr != o.Attrs&ConcealAttr {
-			if s.Attrs&ConcealAttr != 0 {
-				b = b.Conceal()
-			} else {
-				b = b.NoConceal()
-			}
+			b = b.Conceal(s.Attrs&ConcealAttr != 0)
 		}
 		if s.Attrs&StrikethroughAttr != o.Attrs&StrikethroughAttr {
-			if s.Attrs&StrikethroughAttr != 0 {
-				b = b.Strikethrough()
-			} else {
-				b = b.NoStrikethrough()
-			}
+			b = b.Strikethrough(s.Attrs&StrikethroughAttr != 0)
 		}
 	}
 

vendor/github.com/charmbracelet/x/cellbuf/geom.go

@@ -12,7 +12,7 @@ func Pos(x, y int) Position {
 	return image.Pt(x, y)
 }
 
-// Rectange represents a rectangle.
+// Rectangle represents a rectangle.
 type Rectangle = image.Rectangle
 
 // Rect is a shorthand for Rectangle.

vendor/github.com/charmbracelet/x/cellbuf/hardscroll.go

@@ -75,7 +75,7 @@ func (s *Screen) scrolln(n, top, bot, maxY int) (v bool) { //nolint:unparam
 	)
 
 	blank := s.clearBlank()
-	if n > 0 {
+	if n > 0 { //nolint:nestif
 		// Scroll up (forward)
 		v = s.scrollUp(n, top, bot, 0, maxY, blank)
 		if !v {
@@ -99,7 +99,7 @@ func (s *Screen) scrolln(n, top, bot, maxY int) (v bool) { //nolint:unparam
 				s.move(0, bot-n+1)
 				s.clearToBottom(nil)
 			} else {
-				for i := 0; i < n; i++ {
+				for i := range n {
 					s.move(0, bot-i)
 					s.clearToEnd(nil, false)
 				}
@@ -124,7 +124,7 @@ func (s *Screen) scrolln(n, top, bot, maxY int) (v bool) { //nolint:unparam
 			// Clear newly shifted-in lines.
 			if v &&
 				(nonDestScrollRegion || (memoryBelow && top == 0)) {
-				for i := 0; i < -n; i++ {
+				for i := range -n {
 					s.move(0, top+i)
 					s.clearToEnd(nil, false)
 				}
@@ -133,7 +133,7 @@ func (s *Screen) scrolln(n, top, bot, maxY int) (v bool) { //nolint:unparam
 	}
 
 	if !v {
-		return
+		return v
 	}
 
 	s.scrollBuffer(s.curbuf, n, top, bot, blank)
@@ -193,7 +193,7 @@ func (s *Screen) touchLine(width, height, y, n int, changed bool) {
 
 // scrollUp scrolls the screen up by n lines.
 func (s *Screen) scrollUp(n, top, bot, minY, maxY int, blank *Cell) bool {
-	if n == 1 && top == minY && bot == maxY {
+	if n == 1 && top == minY && bot == maxY { //nolint:nestif
 		s.move(0, bot)
 		s.updatePen(blank)
 		s.buf.WriteByte('\n')
@@ -202,13 +202,14 @@ func (s *Screen) scrollUp(n, top, bot, minY, maxY int, blank *Cell) bool {
 		s.updatePen(blank)
 		s.buf.WriteString(ansi.DeleteLine(1))
 	} else if top == minY && bot == maxY {
-		if s.xtermLike {
+		supportsSU := s.caps.Contains(capSU)
+		if supportsSU {
 			s.move(0, bot)
 		} else {
 			s.move(0, top)
 		}
 		s.updatePen(blank)
-		if s.xtermLike {
+		if supportsSU {
 			s.buf.WriteString(ansi.ScrollUp(n))
 		} else {
 			s.buf.WriteString(strings.Repeat("\n", n))
@@ -225,7 +226,7 @@ func (s *Screen) scrollUp(n, top, bot, minY, maxY int, blank *Cell) bool {
 
 // scrollDown scrolls the screen down by n lines.
 func (s *Screen) scrollDown(n, top, bot, minY, maxY int, blank *Cell) bool {
-	if n == 1 && top == minY && bot == maxY {
+	if n == 1 && top == minY && bot == maxY { //nolint:nestif
 		s.move(0, top)
 		s.updatePen(blank)
 		s.buf.WriteString(ansi.ReverseIndex)
@@ -236,7 +237,7 @@ func (s *Screen) scrollDown(n, top, bot, minY, maxY int, blank *Cell) bool {
 	} else if top == minY && bot == maxY {
 		s.move(0, top)
 		s.updatePen(blank)
-		if s.xtermLike {
+		if s.caps.Contains(capSD) {
 			s.buf.WriteString(ansi.ScrollDown(n))
 		} else {
 			s.buf.WriteString(strings.Repeat(ansi.ReverseIndex, n))

vendor/github.com/charmbracelet/x/cellbuf/hashmap.go

@@ -15,7 +15,7 @@ func hash(l Line) (h uint64) {
 		}
 		h += (h << 5) + uint64(r)
 	}
-	return
+	return h
 }
 
 // hashmap represents a single [Line] hash.
@@ -33,7 +33,7 @@ func (s *Screen) updateHashmap() {
 	height := s.newbuf.Height()
 	if len(s.oldhash) >= height && len(s.newhash) >= height {
 		// rehash changed lines
-		for i := 0; i < height; i++ {
+		for i := range height {
 			_, ok := s.touch[i]
 			if ok {
 				s.oldhash[i] = hash(s.curbuf.Line(i))
@@ -48,14 +48,14 @@ func (s *Screen) updateHashmap() {
 		if len(s.newhash) != height {
 			s.newhash = make([]uint64, height)
 		}
-		for i := 0; i < height; i++ {
+		for i := range height {
 			s.oldhash[i] = hash(s.curbuf.Line(i))
 			s.newhash[i] = hash(s.newbuf.Line(i))
 		}
 	}
 
 	s.hashtab = make([]hashmap, height*2)
-	for i := 0; i < height; i++ {
+	for i := range height {
 		hashval := s.oldhash[i]
 
 		// Find matching hash or empty slot
@@ -71,7 +71,7 @@ func (s *Screen) updateHashmap() {
 		s.hashtab[idx].oldcount++
 		s.hashtab[idx].oldindex = i
 	}
-	for i := 0; i < height; i++ {
+	for i := range height {
 		hashval := s.newhash[i]
 
 		// Find matching hash or empty slot
@@ -130,7 +130,7 @@ func (s *Screen) updateHashmap() {
 	s.growHunks()
 }
 
-// scrollOldhash
+// scrollOldhash.
 func (s *Screen) scrollOldhash(n, top, bot int) {
 	if len(s.oldhash) == 0 {
 		return
@@ -287,7 +287,7 @@ func (s *Screen) updateCost(from, to Line) (cost int) {
 			cost++
 		}
 	}
-	return
+	return cost
 }
 
 func (s *Screen) updateCostBlank(to Line) (cost int) {
@@ -297,5 +297,5 @@ func (s *Screen) updateCostBlank(to Line) (cost int) {
 			cost++
 		}
 	}
-	return
+	return cost
 }

vendor/github.com/charmbracelet/x/cellbuf/link.go

@@ -4,7 +4,7 @@ import (
 	"github.com/charmbracelet/colorprofile"
 )
 
-// Convert converts a hyperlink to respect the given color profile.
+// ConvertLink converts a hyperlink to respect the given color profile.
 func ConvertLink(h Link, p colorprofile.Profile) Link {
 	if p == colorprofile.NoTTY {
 		return Link{}

vendor/github.com/charmbracelet/x/cellbuf/pen.go

@@ -0,0 +1,92 @@
+package cellbuf
+
+import (
+	"io"
+
+	"github.com/charmbracelet/x/ansi"
+)
+
+// PenWriter is a writer that writes to a buffer and keeps track of the current
+// pen style and link state for the purpose of wrapping with newlines.
+type PenWriter struct {
+	w     io.Writer
+	p     *ansi.Parser
+	style Style
+	link  Link
+}
+
+// NewPenWriter returns a new PenWriter.
+func NewPenWriter(w io.Writer) *PenWriter {
+	pw := &PenWriter{w: w}
+	pw.p = ansi.GetParser()
+	handleCsi := func(cmd ansi.Cmd, params ansi.Params) {
+		if cmd == 'm' {
+			ReadStyle(params, &pw.style)
+		}
+	}
+	handleOsc := func(cmd int, data []byte) {
+		if cmd == 8 {
+			ReadLink(data, &pw.link)
+		}
+	}
+	pw.p.SetHandler(ansi.Handler{
+		HandleCsi: handleCsi,
+		HandleOsc: handleOsc,
+	})
+	return pw
+}
+
+// Style returns the current pen style.
+func (w *PenWriter) Style() Style {
+	return w.style
+}
+
+// Link returns the current pen link.
+func (w *PenWriter) Link() Link {
+	return w.link
+}
+
+// Write writes to the buffer.
+func (w *PenWriter) Write(p []byte) (int, error) {
+	for i := range p {
+		b := p[i]
+		w.p.Advance(b)
+		if b == '\n' {
+			if !w.style.Empty() {
+				_, _ = w.w.Write([]byte(ansi.ResetStyle))
+			}
+			if !w.link.Empty() {
+				_, _ = w.w.Write([]byte(ansi.ResetHyperlink()))
+			}
+		}
+
+		_, _ = w.w.Write([]byte{b})
+		if b == '\n' {
+			if !w.link.Empty() {
+				_, _ = w.w.Write([]byte(ansi.SetHyperlink(w.link.URL, w.link.Params)))
+			}
+			if !w.style.Empty() {
+				_, _ = w.w.Write([]byte(w.style.Sequence()))
+			}
+		}
+	}
+
+	return len(p), nil
+}
+
+// Close closes the writer, resets the style and link if necessary, and releases
+// its parser. Calling it is performance critical, but forgetting it does not
+// cause safety issues or leaks.
+func (w *PenWriter) Close() error {
+	if !w.style.Empty() {
+		_, _ = w.w.Write([]byte(ansi.ResetStyle))
+	}
+	if !w.link.Empty() {
+		_, _ = w.w.Write([]byte(ansi.ResetHyperlink()))
+	}
+	if w.p != nil {
+		ansi.PutParser(w.p)
+		w.p = nil
+	}
+	return nil
+}

vendor/github.com/charmbracelet/x/cellbuf/screen.go

@@ -39,9 +39,9 @@ func relativeCursorMove(s *Screen, fx, fy, tx, ty int, overwrite, useTabs, useBa
 	var seq strings.Builder
 
 	width, height := s.newbuf.Width(), s.newbuf.Height()
-	if ty != fy {
+	if ty != fy { //nolint:nestif
 		var yseq string
-		if s.xtermLike && !s.opts.RelativeCursor {
+		if s.caps.Contains(capVPA) && !s.opts.RelativeCursor {
 			yseq = ansi.VerticalPositionAbsolute(ty + 1)
 		}
 
@@ -54,9 +54,13 @@ func relativeCursorMove(s *Screen, fx, fy, tx, ty int, overwrite, useTabs, useBa
 			}
 			shouldScroll := !s.opts.AltScreen && fy+n >= s.scrollHeight
 			if lf := strings.Repeat("\n", n); shouldScroll || (fy+n < height && len(lf) < len(yseq)) {
+				//nolint:godox
 				// TODO: Ensure we're not unintentionally scrolling the screen down.
 				yseq = lf
 				s.scrollHeight = max(s.scrollHeight, fy+n)
+				if s.opts.MapNL {
+					fx = 0
+				}
 			}
 		} else if ty < fy {
 			n := fy - ty
@@ -64,6 +68,7 @@ func relativeCursorMove(s *Screen, fx, fy, tx, ty int, overwrite, useTabs, useBa
 				yseq = cuu
 			}
 			if n == 1 && fy-1 > 0 {
+				//nolint:godox
 				// TODO: Ensure we're not unintentionally scrolling the screen up.
 				yseq = ansi.ReverseIndex
 			}
@@ -72,9 +77,9 @@ func relativeCursorMove(s *Screen, fx, fy, tx, ty int, overwrite, useTabs, useBa
 		seq.WriteString(yseq)
 	}
 
-	if tx != fx {
+	if tx != fx { //nolint:nestif
 		var xseq string
-		if s.xtermLike && !s.opts.RelativeCursor {
+		if s.caps.Contains(capHPA) && !s.opts.RelativeCursor {
 			xseq = ansi.HorizontalPositionAbsolute(tx + 1)
 		}
 
@@ -93,7 +98,8 @@ func relativeCursorMove(s *Screen, fx, fy, tx, ty int, overwrite, useTabs, useBa
 				if tabs > 0 {
 					cht := ansi.CursorHorizontalForwardTab(tabs)
 					tab := strings.Repeat("\t", tabs)
-					if false && s.xtermLike && len(cht) < len(tab) {
+					if false && s.caps.Contains(capCHT) && len(cht) < len(tab) {
+						//nolint:godox
 						// TODO: The linux console and some terminals such as
 						// Alacritty don't support [ansi.CHT]. Enable this when
 						// we have a way to detect this, or after 5 years when
@@ -144,7 +150,7 @@ func relativeCursorMove(s *Screen, fx, fy, tx, ty int, overwrite, useTabs, useBa
 			}
 		} else if tx < fx {
 			n := fx - tx
-			if useTabs && s.xtermLike {
+			if useTabs && s.caps.Contains(capCBT) {
 				// VT100 does not support backward tabs [ansi.CBT].
 
 				col := fx
@@ -190,7 +196,7 @@ func moveCursor(s *Screen, x, y int, overwrite bool) (seq string) {
 		// Method #0: Use [ansi.CUP] if the distance is long.
 		seq = ansi.CursorPosition(x+1, y+1)
 		if fx == -1 || fy == -1 || notLocal(s.newbuf.Width(), fx, fy, x, y) {
-			return
+			return seq
 		}
 	}
 
@@ -234,7 +240,7 @@ func moveCursor(s *Screen, x, y int, overwrite bool) (seq string) {
 		}
 	}
 
-	return
+	return seq
 }
 
 // moveCursor moves the cursor to the specified position.
@@ -242,10 +248,10 @@ func (s *Screen) moveCursor(x, y int, overwrite bool) {
 	if !s.opts.AltScreen && s.cur.X == -1 && s.cur.Y == -1 {
 		// First cursor movement in inline mode, move the cursor to the first
 		// column before moving to the target position.
-		s.buf.WriteByte('\r') //nolint:errcheck
+		s.buf.WriteByte('\r')
 		s.cur.X, s.cur.Y = 0, 0
 	}
-	s.buf.WriteString(moveCursor(s, x, y, overwrite)) //nolint:errcheck
+	s.buf.WriteString(moveCursor(s, x, y, overwrite))
 	s.cur.X, s.cur.Y = x, y
 }
 
@@ -274,10 +280,11 @@ func (s *Screen) move(x, y int) {
 	// Reset wrap around (phantom cursor) state
 	if s.atPhantom {
 		s.cur.X = 0
-		s.buf.WriteByte('\r') //nolint:errcheck
-		s.atPhantom = false   // reset phantom cell state
+		s.buf.WriteByte('\r')
+		s.atPhantom = false // reset phantom cell state
 	}
 
+	//nolint:godox
 	// TODO: Investigate if we need to handle this case and/or if we need the
 	// following code.
 	//
@@ -291,7 +298,7 @@ func (s *Screen) move(x, y int) {
 	//
 	// 	if l > 0 {
 	// 		s.cur.X = 0
-	// 		s.buf.WriteString("\r" + strings.Repeat("\n", l)) //nolint:errcheck
+	// 		s.buf.WriteString("\r" + strings.Repeat("\n", l))
 	// 	}
 	// }
 
@@ -339,6 +346,10 @@ type ScreenOptions struct {
 	HardTabs bool
 	// Backspace is whether to use backspace characters to move the cursor.
 	Backspace bool
+	// MapNL whether we have ONLCR mapping enabled. When we set the terminal to
+	// raw mode, the ONLCR mode gets disabled. ONLCR maps any newline/linefeed
+	// (`\n`) character to carriage return + line feed (`\r\n`).
+	MapNL bool
 }
 
 // lineData represents the metadata for a line.
@@ -365,13 +376,13 @@ type Screen struct {
 	opts             ScreenOptions
 	mu               sync.Mutex
 	method           ansi.Method
-	scrollHeight     int  // keeps track of how many lines we've scrolled down (inline mode)
-	altScreenMode    bool // whether alternate screen mode is enabled
-	cursorHidden     bool // whether text cursor mode is enabled
-	clear            bool // whether to force clear the screen
-	xtermLike        bool // whether to use xterm-like optimizations, otherwise, it uses vt100 only
-	queuedText       bool // whether we have queued non-zero width text queued up
-	atPhantom        bool // whether the cursor is out of bounds and at a phantom cell
+	scrollHeight     int          // keeps track of how many lines we've scrolled down (inline mode)
+	altScreenMode    bool         // whether alternate screen mode is enabled
+	cursorHidden     bool         // whether text cursor mode is enabled
+	clear            bool         // whether to force clear the screen
+	caps             capabilities // terminal control sequence capabilities
+	queuedText       bool         // whether we have queued non-zero width text queued up
+	atPhantom        bool         // whether the cursor is out of bounds and at a phantom cell
 }
 
 // SetMethod sets the method used to calculate the width of cells.
@@ -491,36 +502,77 @@ func (s *Screen) FillRect(cell *Cell, r Rectangle) bool {
 	return true
 }
 
-// isXtermLike returns whether the terminal is xterm-like. This means that the
+// capabilities represents a mask of supported ANSI escape sequences.
+type capabilities uint
+
+const (
+	// Vertical Position Absolute [ansi.VPA].
+	capVPA capabilities = 1 << iota
+	// Horizontal Position Absolute [ansi.HPA].
+	capHPA
+	// Cursor Horizontal Tab [ansi.CHT].
+	capCHT
+	// Cursor Backward Tab [ansi.CBT].
+	capCBT
+	// Repeat Previous Character [ansi.REP].
+	capREP
+	// Erase Character [ansi.ECH].
+	capECH
+	// Insert Character [ansi.ICH].
+	capICH
+	// Scroll Down [ansi.SD].
+	capSD
+	// Scroll Up [ansi.SU].
+	capSU
+
+	noCaps  capabilities = 0
+	allCaps              = capVPA | capHPA | capCHT | capCBT | capREP | capECH | capICH |
+		capSD | capSU
+)
+
+// Contains returns whether the capabilities contains the given capability.
+func (v capabilities) Contains(c capabilities) bool {
+	return v&c == c
+}
+
+// xtermCaps returns whether the terminal is xterm-like. This means that the
 // terminal supports ECMA-48 and ANSI X3.64 escape sequences.
-// TODO: Should this be a lookup table into each $TERM terminfo database? Like
-// we could keep a map of ANSI escape sequence to terminfo capability name and
-// check if the database supports the escape sequence. Instead of keeping a
-// list of terminal names here.
-func isXtermLike(termtype string) (v bool) {
+// xtermCaps returns a list of control sequence capabilities for the given
+// terminal type. This only supports a subset of sequences that can
+// be different among terminals.
+// NOTE: A hybrid approach would be to support Terminfo databases for a full
+// set of capabilities.
+func xtermCaps(termtype string) (v capabilities) {
 	parts := strings.Split(termtype, "-")
 	if len(parts) == 0 {
-		return
+		return v
 	}
 
 	switch parts[0] {
 	case
-		"alacritty",
 		"contour",
 		"foot",
 		"ghostty",
 		"kitty",
-		"linux",
 		"rio",
-		"screen",
 		"st",
 		"tmux",
 		"wezterm",
 		"xterm":
-		v = true
+		v = allCaps
+	case "alacritty":
+		v = allCaps
+		v &^= capCHT // NOTE: alacritty added support for [ansi.CHT] in 2024-12-28 #62d5b13.
+	case "screen":
+		// See https://www.gnu.org/software/screen/manual/screen.html#Control-Sequences-1
+		v = allCaps
+		v &^= capREP
+	case "linux":
+		// See https://man7.org/linux/man-pages/man4/console_codes.4.html
+		v = capVPA | capHPA | capECH | capICH
 	}
 
-	return
+	return v
 }
 
 // NewScreen creates a new Screen.
@@ -548,14 +600,14 @@ func NewScreen(w io.Writer, width, height int, opts *ScreenOptions) (s *Screen)
 	}
 
 	s.buf = new(bytes.Buffer)
-	s.xtermLike = isXtermLike(s.opts.Term)
+	s.caps = xtermCaps(s.opts.Term)
 	s.curbuf = NewBuffer(width, height)
 	s.newbuf = NewBuffer(width, height)
 	s.cur = Cursor{Position: Pos(-1, -1)} // start at -1 to force a move
 	s.saved = s.cur
 	s.reset()
 
-	return
+	return s
 }
 
 // Width returns the width of the screen.
@@ -595,7 +647,7 @@ func (s *Screen) putCell(cell *Cell) {
 
 // wrapCursor wraps the cursor to the next line.
 //
-//nolint:unused
+
 func (s *Screen) wrapCursor() {
 	const autoRightMargin = true
 	if autoRightMargin {
@@ -628,9 +680,9 @@ func (s *Screen) putAttrCell(cell *Cell) {
 	}
 
 	s.updatePen(cell)
-	s.buf.WriteRune(cell.Rune) //nolint:errcheck
+	s.buf.WriteRune(cell.Rune)
 	for _, c := range cell.Comb {
-		s.buf.WriteRune(c) //nolint:errcheck
+		s.buf.WriteRune(c)
 	}
 
 	s.cur.X += cell.Width
@@ -649,12 +701,12 @@ func (s *Screen) putCellLR(cell *Cell) {
 	// Optimize for the lower right corner cell.
 	curX := s.cur.X
 	if cell == nil || !cell.Empty() {
-		s.buf.WriteString(ansi.ResetAutoWrapMode) //nolint:errcheck
+		s.buf.WriteString(ansi.ResetModeAutoWrap)
 		s.putAttrCell(cell)
 		// Writing to lower-right corner cell should not wrap.
 		s.atPhantom = false
 		s.cur.X = curX
-		s.buf.WriteString(ansi.SetAutoWrapMode) //nolint:errcheck
+		s.buf.WriteString(ansi.SetModeAutoWrap)
 	}
 }
 
@@ -675,11 +727,11 @@ func (s *Screen) updatePen(cell *Cell) {
 		if cell.Style.Empty() && len(seq) > len(ansi.ResetStyle) {
 			seq = ansi.ResetStyle
 		}
-		s.buf.WriteString(seq) //nolint:errcheck
+		s.buf.WriteString(seq)
 		s.cur.Style = cell.Style
 	}
 	if !cell.Link.Equal(&s.cur.Link) {
-		s.buf.WriteString(ansi.SetHyperlink(cell.Link.URL, cell.Link.Params)) //nolint:errcheck
+		s.buf.WriteString(ansi.SetHyperlink(cell.Link.URL, cell.Link.Params))
 		s.cur.Link = cell.Link
 	}
 }
@@ -712,9 +764,9 @@ func (s *Screen) emitRange(line Line, n int) (eoi bool) {
 		ech := ansi.EraseCharacter(count)
 		cup := ansi.CursorPosition(s.cur.X+count, s.cur.Y)
 		rep := ansi.RepeatPreviousCharacter(count)
-		if s.xtermLike && count > len(ech)+len(cup) && cell0 != nil && cell0.Clear() {
+		if s.caps.Contains(capECH) && count > len(ech)+len(cup) && cell0 != nil && cell0.Clear() { //nolint:nestif
 			s.updatePen(cell0)
-			s.buf.WriteString(ech) //nolint:errcheck
+			s.buf.WriteString(ech)
 
 			// If this is the last cell, we don't need to move the cursor.
 			if count < n {
@@ -722,7 +774,7 @@ func (s *Screen) emitRange(line Line, n int) (eoi bool) {
 			} else {
 				return true // cursor in the middle
 			}
-		} else if s.xtermLike && count > len(rep) &&
+		} else if s.caps.Contains(capREP) && count > len(rep) &&
 			(cell0 == nil || (len(cell0.Comb) == 0 && cell0.Rune < 256)) {
 			// We only support ASCII characters. Most terminals will handle
 			// non-ASCII characters correctly, but some might not, ahem xterm.
@@ -740,13 +792,13 @@ func (s *Screen) emitRange(line Line, n int) (eoi bool) {
 			s.putCell(cell0)
 			repCount-- // cell0 is a single width cell ASCII character
 
-			s.buf.WriteString(ansi.RepeatPreviousCharacter(repCount)) //nolint:errcheck
+			s.buf.WriteString(ansi.RepeatPreviousCharacter(repCount))
 			s.cur.X += repCount
 			if wrapPossible {
 				s.putCell(cell0)
 			}
 		} else {
-			for i := 0; i < count; i++ {
+			for i := range count {
 				s.putCell(line.At(i))
 			}
 		}
@@ -755,7 +807,7 @@ func (s *Screen) emitRange(line Line, n int) (eoi bool) {
 		n -= count
 	}
 
-	return
+	return eoi
 }
 
 // putRange puts a range of cells from the old line to the new line.
@@ -765,7 +817,7 @@ func (s *Screen) putRange(oldLine, newLine Line, y, start, end int) (eoi bool) {
 	inline := min(len(ansi.CursorPosition(start+1, y+1)),
 		min(len(ansi.HorizontalPositionAbsolute(start+1)),
 			len(ansi.CursorForward(start+1))))
-	if (end - start + 1) > inline {
+	if (end - start + 1) > inline { //nolint:nestif
 		var j, same int
 		for j, same = start, 0; j <= end; j++ {
 			oldCell, newCell := oldLine.At(j), newLine.At(j)
@@ -817,9 +869,9 @@ func (s *Screen) clearToEnd(blank *Cell, force bool) { //nolint:unparam
 		s.updatePen(blank)
 		count := s.newbuf.Width() - s.cur.X
 		if s.el0Cost() <= count {
-			s.buf.WriteString(ansi.EraseLineRight) //nolint:errcheck
+			s.buf.WriteString(ansi.EraseLineRight)
 		} else {
-			for i := 0; i < count; i++ {
+			for range count {
 				s.putCell(blank)
 			}
 		}
@@ -839,12 +891,13 @@ func (s *Screen) clearBlank() *Cell {
 // insertCells inserts the count cells pointed by the given line at the current
 // cursor position.
 func (s *Screen) insertCells(line Line, count int) {
-	if s.xtermLike {
+	supportsICH := s.caps.Contains(capICH)
+	if supportsICH {
 		// Use [ansi.ICH] as an optimization.
-		s.buf.WriteString(ansi.InsertCharacter(count)) //nolint:errcheck
+		s.buf.WriteString(ansi.InsertCharacter(count))
 	} else {
 		// Otherwise, use [ansi.IRM] mode.
-		s.buf.WriteString(ansi.SetInsertReplaceMode) //nolint:errcheck
+		s.buf.WriteString(ansi.SetModeInsertReplace)
 	}
 
 	for i := 0; count > 0; i++ {
@@ -852,8 +905,8 @@ func (s *Screen) insertCells(line Line, count int) {
 		count--
 	}
 
-	if !s.xtermLike {
-		s.buf.WriteString(ansi.ResetInsertReplaceMode) //nolint:errcheck
+	if !supportsICH {
+		s.buf.WriteString(ansi.ResetModeInsertReplace)
 	}
 }
 
@@ -862,7 +915,7 @@ func (s *Screen) insertCells(line Line, count int) {
 // [ansi.EL] 0 i.e. [ansi.EraseLineRight] to clear
 // trailing spaces.
 func (s *Screen) el0Cost() int {
-	if s.xtermLike {
+	if s.caps != noCaps {
 		return 0
 	}
 	return len(ansi.EraseLineRight)
@@ -878,7 +931,7 @@ func (s *Screen) transformLine(y int) {
 
 	// Find the first changed cell in the line
 	var lineChanged bool
-	for i := 0; i < s.newbuf.Width(); i++ {
+	for i := range s.newbuf.Width() {
 		if !cellEqual(newLine.At(i), oldLine.At(i)) {
 			lineChanged = true
 			break
@@ -886,7 +939,7 @@ func (s *Screen) transformLine(y int) {
 	}
 
 	const ceolStandoutGlitch = false
-	if ceolStandoutGlitch && lineChanged {
+	if ceolStandoutGlitch && lineChanged { //nolint:nestif
 		s.move(0, y)
 		s.clearToEnd(nil, false)
 		s.putRange(oldLine, newLine, y, 0, s.newbuf.Width()-1)
@@ -897,12 +950,12 @@ func (s *Screen) transformLine(y int) {
 		// [ansi.EraseLineLeft].
 		if blank == nil || blank.Clear() {
 			var oFirstCell, nFirstCell int
-			for oFirstCell = 0; oFirstCell < s.curbuf.Width(); oFirstCell++ {
+			for oFirstCell = range s.curbuf.Width() {
 				if !cellEqual(oldLine.At(oFirstCell), blank) {
 					break
 				}
 			}
-			for nFirstCell = 0; nFirstCell < s.newbuf.Width(); nFirstCell++ {
+			for nFirstCell = range s.newbuf.Width() {
 				if !cellEqual(newLine.At(nFirstCell), blank) {
 					break
 				}
@@ -925,11 +978,11 @@ func (s *Screen) transformLine(y int) {
 					if nFirstCell >= s.newbuf.Width() {
 						s.move(0, y)
 						s.updatePen(blank)
-						s.buf.WriteString(ansi.EraseLineRight) //nolint:errcheck
+						s.buf.WriteString(ansi.EraseLineRight)
 					} else {
 						s.move(nFirstCell-1, y)
 						s.updatePen(blank)
-						s.buf.WriteString(ansi.EraseLineLeft) //nolint:errcheck
+						s.buf.WriteString(ansi.EraseLineLeft)
 					}
 
 					for firstCell < nFirstCell {
@@ -1045,7 +1098,7 @@ func (s *Screen) transformLine(y int) {
 
 				s.move(n+1, y)
 				ichCost := 3 + nLastCell - oLastCell
-				if s.xtermLike && (nLastCell < nLastNonBlank || ichCost > (m-n)) {
+				if s.caps.Contains(capICH) && (nLastCell < nLastNonBlank || ichCost > (m-n)) {
 					s.putRange(oldLine, newLine, y, n+1, m)
 				} else {
 					s.insertCells(newLine[n+1:], nLastCell-oLastCell)
@@ -1079,7 +1132,7 @@ func (s *Screen) transformLine(y int) {
 func (s *Screen) deleteCells(count int) {
 	// [ansi.DCH] will shift in cells from the right margin so we need to
 	// ensure that they are the right style.
-	s.buf.WriteString(ansi.DeleteCharacter(count)) //nolint:errcheck
+	s.buf.WriteString(ansi.DeleteCharacter(count))
 }
 
 // clearToBottom clears the screen from the current cursor position to the end
@@ -1091,7 +1144,7 @@ func (s *Screen) clearToBottom(blank *Cell) {
 	}
 
 	s.updatePen(blank)
-	s.buf.WriteString(ansi.EraseScreenBelow) //nolint:errcheck
+	s.buf.WriteString(ansi.EraseScreenBelow)
 	// Clear the rest of the current line
 	s.curbuf.ClearRect(Rect(col, row, s.curbuf.Width()-col, 1))
 	// Clear everything below the current line
@@ -1104,7 +1157,7 @@ func (s *Screen) clearToBottom(blank *Cell) {
 // It returns the top line.
 func (s *Screen) clearBottom(total int) (top int) {
 	if total <= 0 {
-		return
+		return top
 	}
 
 	top = total
@@ -1112,7 +1165,7 @@ func (s *Screen) clearBottom(total int) (top int) {
 	blank := s.clearBlank()
 	canClearWithBlank := blank == nil || blank.Clear()
 
-	if canClearWithBlank {
+	if canClearWithBlank { //nolint:nestif
 		var row int
 		for row = total - 1; row >= 0; row-- {
 			oldLine := s.curbuf.Line(row)
@@ -1147,14 +1200,14 @@ func (s *Screen) clearBottom(total int) (top int) {
 		}
 	}
 
-	return
+	return top
 }
 
 // clearScreen clears the screen and put cursor at home.
 func (s *Screen) clearScreen(blank *Cell) {
 	s.updatePen(blank)
-	s.buf.WriteString(ansi.CursorHomePosition) //nolint:errcheck
-	s.buf.WriteString(ansi.EraseEntireScreen)  //nolint:errcheck
+	s.buf.WriteString(ansi.CursorHomePosition)
+	s.buf.WriteString(ansi.EraseEntireScreen)
 	s.cur.X, s.cur.Y = 0, 0
 	s.curbuf.Fill(blank)
 }
@@ -1179,7 +1232,7 @@ func (s *Screen) clearUpdate() {
 		s.clearBelow(blank, 0)
 	}
 	nonEmpty = s.clearBottom(nonEmpty)
-	for i := 0; i < nonEmpty; i++ {
+	for i := range nonEmpty {
 		s.transformLine(i)
 	}
 }
@@ -1194,13 +1247,13 @@ func (s *Screen) Flush() (err error) {
 func (s *Screen) flush() (err error) {
 	// Write the buffer
 	if s.buf.Len() > 0 {
-		_, err = s.w.Write(s.buf.Bytes()) //nolint:errcheck
+		_, err = s.w.Write(s.buf.Bytes())
 		if err == nil {
 			s.buf.Reset()
 		}
 	}
 
-	return
+	return err //nolint:wrapcheck
 }
 
 // Render renders changes of the screen to the internal buffer. Call
@@ -1221,6 +1274,7 @@ func (s *Screen) render() {
 		return
 	}
 
+	//nolint:godox
 	// TODO: Investigate whether this is necessary. Theoretically, terminals
 	// can add/remove tab stops and we should be able to handle that. We could
 	// use [ansi.DECTABSR] to read the tab stops, but that's not implemented in
@@ -1235,9 +1289,9 @@ func (s *Screen) render() {
 	// Do we need alt-screen mode?
 	if s.opts.AltScreen != s.altScreenMode {
 		if s.opts.AltScreen {
-			s.buf.WriteString(ansi.SetAltScreenSaveCursorMode)
+			s.buf.WriteString(ansi.SetModeAltScreenSaveCursor)
 		} else {
-			s.buf.WriteString(ansi.ResetAltScreenSaveCursorMode)
+			s.buf.WriteString(ansi.ResetModeAltScreenSaveCursor)
 		}
 		s.altScreenMode = s.opts.AltScreen
 	}
@@ -1252,7 +1306,9 @@ func (s *Screen) render() {
 
 	// Do we have queued strings to write above the screen?
 	if len(s.queueAbove) > 0 {
+		//nolint:godox
 		// TODO: Use scrolling region if available.
+		//nolint:godox
 		// TODO: Use [Screen.Write] [io.Writer] interface.
 
 		// We need to scroll the screen up by the number of lines in the queue.
@@ -1290,12 +1346,13 @@ func (s *Screen) render() {
 		s.clearBelow(nil, s.newbuf.Height()-1)
 	}
 
-	if s.clear {
+	if s.clear { //nolint:nestif
 		s.clearUpdate()
 		s.clear = false
 	} else if len(s.touch) > 0 {
 		if s.opts.AltScreen {
 			// Optimize scrolling for the alternate screen buffer.
+			//nolint:godox
 			// TODO: Should we optimize for inline mode as well? If so, we need
 			// to know the actual cursor position to use [ansi.DECSTBM].
 			s.scrollOptimize()
@@ -1311,7 +1368,7 @@ func (s *Screen) render() {
 		}
 
 		nonEmpty = s.clearBottom(nonEmpty)
-		for i = 0; i < nonEmpty; i++ {
+		for i = range nonEmpty {
 			_, ok := s.touch[i]
 			if ok {
 				s.transformLine(i)
@@ -1359,7 +1416,7 @@ func (s *Screen) Close() (err error) {
 	s.move(0, s.newbuf.Height()-1)
 
 	if s.altScreenMode {
-		s.buf.WriteString(ansi.ResetAltScreenSaveCursorMode)
+		s.buf.WriteString(ansi.ResetModeAltScreenSaveCursor)
 		s.altScreenMode = false
 	}
 
@@ -1371,11 +1428,11 @@ func (s *Screen) Close() (err error) {
 	// Write the buffer
 	err = s.flush()
 	if err != nil {
-		return
+		return err
 	}
 
 	s.reset()
-	return
+	return err
 }
 
 // reset resets the screen to its initial state.
@@ -1420,9 +1477,9 @@ func (s *Screen) Resize(width, height int) bool {
 	}
 
 	if height > oldh {
-		s.ClearRect(Rect(0, max(oldh-1, 0), width, height-oldh))
+		s.ClearRect(Rect(0, max(oldh, 0), width, height-oldh))
 	} else if height < oldh {
-		s.ClearRect(Rect(0, max(height-1, 0), width, oldh-height))
+		s.ClearRect(Rect(0, max(height, 0), width, oldh-height))
 	}
 
 	s.mu.Lock()

vendor/github.com/charmbracelet/x/cellbuf/style.go

@@ -4,9 +4,9 @@ import (
 	"github.com/charmbracelet/colorprofile"
 )
 
-// Convert converts a style to respect the given color profile.
+// ConvertStyle converts a style to respect the given color profile.
 func ConvertStyle(s Style, p colorprofile.Profile) Style {
-	switch p {
+	switch p { //nolint:exhaustive
 	case colorprofile.TrueColor:
 		return s
 	case colorprofile.Ascii:

vendor/github.com/charmbracelet/x/cellbuf/utils.go

@@ -9,20 +9,6 @@ func Height(s string) int {
 	return strings.Count(s, "\n") + 1
 }
 
-func min(a, b int) int { //nolint:predeclared
-	if a > b {
-		return b
-	}
-	return a
-}
-
-func max(a, b int) int { //nolint:predeclared
-	if a > b {
-		return a
-	}
-	return b
-}
-
 func clamp(v, low, high int) int {
 	if high < low {
 		low, high = high, low

vendor/github.com/charmbracelet/x/cellbuf/wrap.go

@@ -2,6 +2,7 @@ package cellbuf
 
 import (
 	"bytes"
+	"slices"
 	"unicode"
 	"unicode/utf8"
 
@@ -20,6 +21,16 @@ const nbsp = '\u00a0'
 //
 // Note: breakpoints must be a string of 1-cell wide rune characters.
 func Wrap(s string, limit int, breakpoints string) string {
+	//nolint:godox
+	// TODO: Use [PenWriter] once we get
+	// https://github.com/charmbracelet/lipgloss/pull/489 out the door and
+	// released.
+	// The problem is that [ansi.Wrap] doesn't keep track of style and link
+	// state, so combining both breaks styled space cells. To fix this, we use
+	// non-breaking space cells for padding and styled blank cells. And since
+	// both wrapping methods respect non-breaking spaces, we can use them to
+	// preserve styled spaces in the output.
+
 	if len(s) == 0 {
 		return ""
 	}
@@ -90,7 +101,7 @@ func Wrap(s string, limit int, breakpoints string) string {
 		seq, width, n, newState := ansi.DecodeSequence(s, state, p)
 		switch width {
 		case 0:
-			if ansi.Equal(seq, "\t") {
+			if ansi.Equal(seq, "\t") { //nolint:nestif
 				addWord()
 				space.WriteString(seq)
 				break
@@ -176,10 +187,5 @@ func Wrap(s string, limit int, breakpoints string) string {
 }
 
 func runeContainsAny[T string | []rune](r rune, s T) bool {
-	for _, c := range []rune(s) {
-		if c == r {
-			return true
-		}
-	}
-	return false
+	return slices.Contains([]rune(s), r)
 }

vendor/github.com/charmbracelet/x/cellbuf/writer.go

@@ -25,7 +25,7 @@ type CellBuffer interface {
 func FillRect(s CellBuffer, c *Cell, rect Rectangle) {
 	for y := rect.Min.Y; y < rect.Max.Y; y++ {
 		for x := rect.Min.X; x < rect.Max.X; x++ {
-			s.SetCell(x, y, c) //nolint:errcheck
+			s.SetCell(x, y, c)
 		}
 	}
 }
@@ -68,7 +68,7 @@ func SetContent(s CellBuffer, str string) {
 func Render(d CellBuffer) string {
 	var buf bytes.Buffer
 	height := d.Bounds().Dy()
-	for y := 0; y < height; y++ {
+	for y := range height {
 		_, line := RenderLine(d, y)
 		buf.WriteString(line)
 		if y < height-1 {
@@ -98,32 +98,32 @@ func RenderLine(d CellBuffer, n int) (w int, line string) {
 		pendingLine = ""
 	}
 
-	for x := 0; x < d.Bounds().Dx(); x++ {
-		if cell := d.Cell(x, n); cell != nil && cell.Width > 0 {
+	for x := range d.Bounds().Dx() {
+		if cell := d.Cell(x, n); cell != nil && cell.Width > 0 { //nolint:nestif
 			// Convert the cell's style and link to the given color profile.
 			cellStyle := cell.Style
 			cellLink := cell.Link
 			if cellStyle.Empty() && !pen.Empty() {
 				writePending()
-				buf.WriteString(ansi.ResetStyle) //nolint:errcheck
+				buf.WriteString(ansi.ResetStyle)
 				pen.Reset()
 			}
 			if !cellStyle.Equal(&pen) {
 				writePending()
 				seq := cellStyle.DiffSequence(pen)
-				buf.WriteString(seq) // nolint:errcheck
+				buf.WriteString(seq)
 				pen = cellStyle
 			}
 
 			// Write the URL escape sequence
 			if cellLink != link && link.URL != "" {
 				writePending()
-				buf.WriteString(ansi.ResetHyperlink()) //nolint:errcheck
+				buf.WriteString(ansi.ResetHyperlink())
 				link.Reset()
 			}
 			if cellLink != link {
 				writePending()
-				buf.WriteString(ansi.SetHyperlink(cellLink.URL, cellLink.Params)) //nolint:errcheck
+				buf.WriteString(ansi.SetHyperlink(cellLink.URL, cellLink.Params))
 				link = cellLink
 			}
 
@@ -140,10 +140,10 @@ func RenderLine(d CellBuffer, n int) (w int, line string) {
 		}
 	}
 	if link.URL != "" {
-		buf.WriteString(ansi.ResetHyperlink()) //nolint:errcheck
+		buf.WriteString(ansi.ResetHyperlink())
 	}
 	if !pen.Empty() {
-		buf.WriteString(ansi.ResetStyle) //nolint:errcheck
+		buf.WriteString(ansi.ResetStyle)
 	}
 	return w, strings.TrimRight(buf.String(), " ") // Trim trailing spaces
 }
@@ -201,7 +201,7 @@ func (s *ScreenWriter) SetContentRect(str string, rect Rectangle) {
 // string to the width of the screen if it exceeds the width of the screen.
 // This will recognize ANSI [ansi.SGR] style and [ansi.SetHyperlink] escape
 // sequences.
-func (s *ScreenWriter) Print(str string, v ...interface{}) {
+func (s *ScreenWriter) Print(str string, v ...any) {
 	if len(v) > 0 {
 		str = fmt.Sprintf(str, v...)
 	}
@@ -214,7 +214,7 @@ func (s *ScreenWriter) Print(str string, v ...interface{}) {
 // the width of the screen if it exceeds the width of the screen.
 // This will recognize ANSI [ansi.SGR] style and [ansi.SetHyperlink] escape
 // sequences.
-func (s *ScreenWriter) PrintAt(x, y int, str string, v ...interface{}) {
+func (s *ScreenWriter) PrintAt(x, y int, str string, v ...any) {
 	if len(v) > 0 {
 		str = fmt.Sprintf(str, v...)
 	}
@@ -299,7 +299,7 @@ func printString[T []byte | string](
 					// Print the cell to the screen
 					cell.Style = style
 					cell.Link = link
-					s.SetCell(x, y, &cell) //nolint:errcheck
+					s.SetCell(x, y, &cell)
 					x += width
 				}
 			}
@@ -309,6 +309,7 @@ func printString[T []byte | string](
 			cell.Reset()
 		default:
 			// Valid sequences always have a non-zero Cmd.
+			//nolint:godox
 			// TODO: Handle cursor movement and other sequences
 			switch {
 			case ansi.HasCsiPrefix(seq) && p.Command() == 'm':
@@ -333,7 +334,7 @@ func printString[T []byte | string](
 
 	// Make sure to set the last cell if it's not empty.
 	if !cell.Empty() {
-		s.SetCell(x, y, &cell) //nolint:errcheck
+		s.SetCell(x, y, &cell)
 		cell.Reset()
 	}
 }

vendor/github.com/charmbracelet/x/term/term.go

@@ -1,3 +1,5 @@
+// Package term provides a platform-independent interfaces for interacting with
+// Terminal and TTY devices.
 package term
 
 // State contains platform-specific state of a terminal.

vendor/github.com/charmbracelet/x/term/term_plan9.go

@@ -0,0 +1,118 @@
+package term
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+type state struct {
+	termName string
+	raw      bool
+	ctl      *os.File
+}
+
+// termName returns the name of the terminal or os.ErrNotExist if there is no terminal.
+func termName(fd uintptr) (string, error) {
+	ctl, err := os.ReadFile(filepath.Join("/fd", fmt.Sprintf("%dctl", fd)))
+	if err != nil {
+		return "", err
+	}
+	f := strings.Fields(string(ctl))
+	if len(f) == 0 {
+		return "", os.ErrNotExist
+	}
+	return f[len(f)-1], nil
+}
+
+func isTerminal(fd uintptr) bool {
+	ctl, err := os.ReadFile(filepath.Join("/fd", fmt.Sprintf("%dctl", fd)))
+	if err != nil {
+		return false
+	}
+	if strings.Contains(string(ctl), "/dev/cons") {
+		return true
+	}
+	return false
+}
+
+func makeRaw(fd uintptr) (*State, error) {
+	t, err := termName(fd)
+	if err != nil {
+		return nil, err
+	}
+	ctl, err := os.OpenFile(t, os.O_RDWR, 0)
+	if err != nil {
+		return nil, err
+	}
+	if _, err := ctl.Write([]byte("rawon")); err != nil {
+		return nil, err
+	}
+	return &State{state: state{termName: t, raw: true, ctl: ctl}}, nil
+}
+
+func getState(fd uintptr) (*State, error) {
+	t, err := termName(fd)
+	if err != nil {
+		return nil, err
+	}
+	ctl, err := os.OpenFile(t, os.O_RDWR, 0)
+	if err != nil {
+		return nil, err
+	}
+	return &State{state: state{termName: t, raw: false, ctl: ctl}}, nil
+
+}
+
+func restore(_ uintptr, state *State) error {
+	if _, err := state.ctl.Write([]byte("rawoff")); err != nil {
+		return err
+	}
+	return nil
+}
+
+// getSize returns the size. This will only work if you are running
+// under a window manager in Plan 9. Else, the only option
+// is to return a reasonable default.
+func getSize(fd uintptr) (int, int, error) {
+	w, h := 80, 40
+	b, err := os.ReadFile("/dev/wctl")
+	if err != nil {
+		return w, h, err
+	}
+	f := strings.Fields(string(b))
+	if len(f) != 4 {
+		return w, h, fmt.Errorf("%q only has %d of 4 needed fields:%w", f, len(f), os.ErrInvalid)
+	}
+	// The contents of wctl, as defined in the driver, are
+	// 4 12-char fields: upper left x, y; and lower-right x, y
+	var ulx, uly, lrx, lry int
+	if n, err := fmt.Sscanf(string(b[:48]), "%d%d%d%d", &ulx, &uly, &lrx, &lry); n != 4 || err != nil {
+		return w, h, fmt.Errorf("scanning %q:%d of 4 items scanned:%w", string(b[:48]), n, err)
+	}
+
+	w, h = lrx-lrx, lry-uly
+	return w, h, nil
+}
+
+func setState(_ uintptr, state *State) error {
+	raw := "rawoff"
+	if state.raw {
+		raw = "rawon"
+	}
+	if _, err := state.ctl.Write([]byte(raw)); err != nil {
+		return err
+	}
+	return nil
+}
+
+func readPassword(fd uintptr) ([]byte, error) {
+	f := os.NewFile(fd, "cons")
+	var b [128]byte
+	n, err := f.Read(b[:])
+	if err != nil {
+		return nil, err
+	}
+	return b[:n], nil
+}

vendor/github.com/charmbracelet/x/term/term_unix.go

@@ -19,7 +19,7 @@ func isTerminal(fd uintptr) bool {
 func makeRaw(fd uintptr) (*State, error) {
 	termios, err := unix.IoctlGetTermios(int(fd), ioctlReadTermios)
 	if err != nil {
-		return nil, err
+		return nil, err //nolint:wrapcheck
 	}
 
 	oldState := State{state{Termios: *termios}}
@@ -34,7 +34,7 @@ func makeRaw(fd uintptr) (*State, error) {
 	termios.Cc[unix.VMIN] = 1
 	termios.Cc[unix.VTIME] = 0
 	if err := unix.IoctlSetTermios(int(fd), ioctlWriteTermios, termios); err != nil {
-		return nil, err
+		return nil, err //nolint:wrapcheck
 	}
 
 	return &oldState, nil
@@ -45,26 +45,26 @@ func setState(fd uintptr, state *State) error {
 	if state != nil {
 		termios = &state.Termios
 	}
-	return unix.IoctlSetTermios(int(fd), ioctlWriteTermios, termios)
+	return unix.IoctlSetTermios(int(fd), ioctlWriteTermios, termios) //nolint:wrapcheck
 }
 
 func getState(fd uintptr) (*State, error) {
 	termios, err := unix.IoctlGetTermios(int(fd), ioctlReadTermios)
 	if err != nil {
-		return nil, err
+		return nil, err //nolint:wrapcheck
 	}
 
 	return &State{state{Termios: *termios}}, nil
 }
 
 func restore(fd uintptr, state *State) error {
-	return unix.IoctlSetTermios(int(fd), ioctlWriteTermios, &state.Termios)
+	return unix.IoctlSetTermios(int(fd), ioctlWriteTermios, &state.Termios) //nolint:wrapcheck
 }
 
 func getSize(fd uintptr) (width, height int, err error) {
 	ws, err := unix.IoctlGetWinsize(int(fd), unix.TIOCGWINSZ)
 	if err != nil {
-		return 0, 0, err
+		return 0, 0, err //nolint:wrapcheck
 	}
 	return int(ws.Col), int(ws.Row), nil
 }
@@ -73,13 +73,13 @@ func getSize(fd uintptr) (width, height int, err error) {
 type passwordReader int
 
 func (r passwordReader) Read(buf []byte) (int, error) {
-	return unix.Read(int(r), buf)
+	return unix.Read(int(r), buf) //nolint:wrapcheck
 }
 
 func readPassword(fd uintptr) ([]byte, error) {
 	termios, err := unix.IoctlGetTermios(int(fd), ioctlReadTermios)
 	if err != nil {
-		return nil, err
+		return nil, err //nolint:wrapcheck
 	}
 
 	newState := *termios
@@ -87,10 +87,10 @@ func readPassword(fd uintptr) ([]byte, error) {
 	newState.Lflag |= unix.ICANON | unix.ISIG
 	newState.Iflag |= unix.ICRNL
 	if err := unix.IoctlSetTermios(int(fd), ioctlWriteTermios, &newState); err != nil {
-		return nil, err
+		return nil, err //nolint:wrapcheck
 	}
 
-	defer unix.IoctlSetTermios(int(fd), ioctlWriteTermios, termios)
+	defer unix.IoctlSetTermios(int(fd), ioctlWriteTermios, termios) //nolint:errcheck
 
 	return readPasswordLine(passwordReader(fd))
 }

vendor/github.com/charmbracelet/x/term/term_windows.go

@@ -24,7 +24,7 @@ func makeRaw(fd uintptr) (*State, error) {
 	if err := windows.GetConsoleMode(windows.Handle(fd), &st); err != nil {
 		return nil, err
 	}
-	raw := st &^ (windows.ENABLE_ECHO_INPUT | windows.ENABLE_PROCESSED_INPUT | windows.ENABLE_LINE_INPUT | windows.ENABLE_PROCESSED_OUTPUT)
+	raw := st &^ (windows.ENABLE_ECHO_INPUT | windows.ENABLE_PROCESSED_INPUT | windows.ENABLE_LINE_INPUT)
 	raw |= windows.ENABLE_VIRTUAL_TERMINAL_INPUT
 	if err := windows.SetConsoleMode(windows.Handle(fd), raw); err != nil {
 		return nil, err

vendor/github.com/charmbracelet/x/term/util.go

@@ -41,7 +41,7 @@ func readPasswordLine(reader io.Reader) ([]byte, error) {
 			if err == io.EOF && len(ret) > 0 {
 				return ret, nil
 			}
-			return ret, err
+			return ret, err //nolint:wrapcheck
 		}
 	}
 }

vendor/github.com/clipperhouse/displaywidth/.gitignore

@@ -0,0 +1 @@
+.DS_Store

vendor/github.com/clipperhouse/displaywidth/AGENTS.md

@@ -0,0 +1,37 @@
+The goals and overview of this package can be found in the README.md file,
+start by reading that.
+
+The goal of this package is to determine the display (column) width of a
+string, UTF-8 bytes, or runes, as would happen in a monospace font, especially
+in a terminal.
+
+When troubleshooting, write Go unit tests instead of executing debug scripts.
+The tests can return whatever logs or output you need. If those tests are
+only for temporary troubleshooting, clean up the tests after the debugging is
+done.
+
+(Separate executable debugging scripts are messy, tend to have conflicting
+dependencies and are hard to cleanup.)
+
+If you make changes to the trie generation in internal/gen, it can be invoked
+by running `go generate` from the top package directory.
+
+## Pull Requests and branches
+
+For PRs (pull requests), you can use the gh CLI tool to retrieve details,
+or post comments. Then, compare the current branch with main. Reviewing a PR
+and reviewing a branch are about the same, but the PR may add context.
+
+Look for bugs. Think like GitHub Copilot or Cursor BugBot.
+
+Offer to post a brief summary of the review to the PR, via the gh CLI tool.
+
+## Comparisons to go-runewidth
+
+We originally attempted to make this package compatible with go-runewidth.
+However, we found that there were too many differences in the handling of
+certain characters and properties.
+
+We believe, preliminarily, that our choices are more correct and complete,
+by using more complete categories such as Unicode Cf (format) for zero-width
+and Mn (Nonspacing_Mark) for combining marks.

vendor/github.com/clipperhouse/displaywidth/CHANGELOG.md

@@ -0,0 +1,49 @@
+# Changelog
+
+## [0.5.0]
+
+[Compare](https://github.com/clipperhouse/displaywidth/compare/v0.4.1...v0.5.0)
+
+### Added
+- Unicode 16 support
+- Improved emoji presentation handling per Unicode TR51
+
+### Changed
+- Corrected VS15 (U+FE0E) handling: now preserves base character width (no-op) per Unicode TR51
+- Performance optimizations: reduced property lookups
+
+### Fixed
+- VS15 variation selector now correctly preserves base character width instead of forcing width 1
+
+## [0.4.1]
+
+[Compare](https://github.com/clipperhouse/displaywidth/compare/v0.4.0...v0.4.1)
+
+### Changed
+- Updated uax29 dependency
+- Improved flag handling
+
+## [0.4.0]
+
+[Compare](https://github.com/clipperhouse/displaywidth/compare/v0.3.1...v0.4.0)
+
+### Added
+- Support for variation selectors (VS15, VS16) and regional indicator pairs (flags)
+
+## [0.3.1]
+
+[Compare](https://github.com/clipperhouse/displaywidth/compare/v0.3.0...v0.3.1)
+
+### Added
+- Fuzz testing support
+
+### Changed
+- Updated stringish dependency
+
+## [0.3.0]
+
+[Compare](https://github.com/clipperhouse/displaywidth/compare/v0.2.0...v0.3.0)
+
+### Changed
+- Dropped compatibility with go-runewidth
+- Trie implementation cleanup

vendor/github.com/clipperhouse/displaywidth/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Matt Sherman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vendor/github.com/clipperhouse/displaywidth/README.md

@@ -0,0 +1,123 @@
+# displaywidth
+
+A high-performance Go package for measuring the monospace display width of strings, UTF-8 bytes, and runes.
+
+[![Documentation](https://pkg.go.dev/badge/github.com/clipperhouse/displaywidth.svg)](https://pkg.go.dev/github.com/clipperhouse/displaywidth)
+[![Test](https://github.com/clipperhouse/displaywidth/actions/workflows/gotest.yml/badge.svg)](https://github.com/clipperhouse/displaywidth/actions/workflows/gotest.yml)
+[![Fuzz](https://github.com/clipperhouse/displaywidth/actions/workflows/gofuzz.yml/badge.svg)](https://github.com/clipperhouse/displaywidth/actions/workflows/gofuzz.yml)
+
+## Install
+```bash
+go get github.com/clipperhouse/displaywidth
+```
+
+## Usage
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/clipperhouse/displaywidth"
+)
+
+func main() {
+    width := displaywidth.String("Hello, 世界!")
+    fmt.Println(width)
+
+    width = displaywidth.Bytes([]byte("🌍"))
+    fmt.Println(width)
+
+    width = displaywidth.Rune('🌍')
+    fmt.Println(width)
+}
+```
+
+For most purposes, you should use the `String` or `Bytes` methods.
+
+
+### Options
+
+You can specify East Asian Width settings. When false (default),
+[East Asian Ambiguous characters](https://www.unicode.org/reports/tr11/#Ambiguous)
+are treated as width 1. When true, East Asian Ambiguous characters are treated
+as width 2.
+
+```go
+myOptions := displaywidth.Options{
+    EastAsianWidth: true,
+}
+
+width := myOptions.String("Hello, 世界!")
+fmt.Println(width)
+```
+
+## Technical details
+
+This package implements the Unicode East Asian Width standard
+([UAX #11](https://www.unicode.org/reports/tr11/)), and handles
+[version selectors](https://en.wikipedia.org/wiki/Variation_Selectors_(Unicode_block)),
+and [regional indicator pairs](https://en.wikipedia.org/wiki/Regional_indicator_symbol)
+(flags). We implement [Unicode TR51](https://unicode.org/reports/tr51/).
+
+`clipperhouse/displaywidth`, `mattn/go-runewidth`, and `rivo/uniseg` will
+give the same outputs for most real-world text. See extensive details in the
+[compatibility analysis](comparison/COMPATIBILITY_ANALYSIS.md).
+
+If you wish to investigate the core logic, see the `lookupProperties` and `width`
+functions in [width.go](width.go#L135). The essential trie generation logic is in
+`buildPropertyBitmap` in [unicode.go](internal/gen/unicode.go#L317).
+
+I (@clipperhouse) am keeping an eye on [emerging standards and test suites](https://www.jeffquast.com/post/state-of-terminal-emulation-2025/).
+
+## Prior Art
+
+[mattn/go-runewidth](https://github.com/mattn/go-runewidth)
+
+[rivo/uniseg](https://github.com/rivo/uniseg)
+
+[x/text/width](https://pkg.go.dev/golang.org/x/text/width)
+
+[x/text/internal/triegen](https://pkg.go.dev/golang.org/x/text/internal/triegen)
+
+## Benchmarks
+
+```bash
+cd comparison
+go test -bench=. -benchmem
+```
+
+```
+goos: darwin
+goarch: arm64
+pkg: github.com/clipperhouse/displaywidth/comparison
+cpu: Apple M2
+
+BenchmarkString_Mixed/clipperhouse/displaywidth-8         10929 ns/op	    154.36 MB/s	      0 B/op     0 allocs/op
+BenchmarkString_Mixed/mattn/go-runewidth-8                14540 ns/op	    116.02 MB/s	      0 B/op     0 allocs/op
+BenchmarkString_Mixed/rivo/uniseg-8                       19751 ns/op	     85.41 MB/s	      0 B/op     0 allocs/op
+
+BenchmarkString_EastAsian/clipperhouse/displaywidth-8     10885 ns/op	    154.98 MB/s	      0 B/op     0 allocs/op
+BenchmarkString_EastAsian/mattn/go-runewidth-8            23969 ns/op	     70.38 MB/s	      0 B/op     0 allocs/op
+BenchmarkString_EastAsian/rivo/uniseg-8                   19852 ns/op	     84.98 MB/s	      0 B/op     0 allocs/op
+
+BenchmarkString_ASCII/clipperhouse/displaywidth-8          1103 ns/op	    116.01 MB/s	      0 B/op     0 allocs/op
+BenchmarkString_ASCII/mattn/go-runewidth-8                 1166 ns/op	    109.79 MB/s	      0 B/op     0 allocs/op
+BenchmarkString_ASCII/rivo/uniseg-8                        1584 ns/op	     80.83 MB/s	      0 B/op     0 allocs/op
+
+BenchmarkString_Emoji/clipperhouse/displaywidth-8          3108 ns/op	    232.93 MB/s	      0 B/op     0 allocs/op
+BenchmarkString_Emoji/mattn/go-runewidth-8                 4802 ns/op	    150.76 MB/s	      0 B/op     0 allocs/op
+BenchmarkString_Emoji/rivo/uniseg-8                        6607 ns/op	    109.58 MB/s	      0 B/op     0 allocs/op
+
+BenchmarkRune_Mixed/clipperhouse/displaywidth-8            3456 ns/op	    488.20 MB/s	      0 B/op     0 allocs/op
+BenchmarkRune_Mixed/mattn/go-runewidth-8                   5400 ns/op	    312.39 MB/s	      0 B/op     0 allocs/op
+
+BenchmarkRune_EastAsian/clipperhouse/displaywidth-8        3475 ns/op	    485.41 MB/s	      0 B/op     0 allocs/op
+BenchmarkRune_EastAsian/mattn/go-runewidth-8              15701 ns/op	    107.44 MB/s	      0 B/op     0 allocs/op
+
+BenchmarkRune_ASCII/clipperhouse/displaywidth-8             257.0 ns/op	    498.13 MB/s	      0 B/op     0 allocs/op
+BenchmarkRune_ASCII/mattn/go-runewidth-8                    266.4 ns/op	    480.50 MB/s	      0 B/op     0 allocs/op
+
+BenchmarkRune_Emoji/clipperhouse/displaywidth-8            1384 ns/op	    523.02 MB/s	      0 B/op     0 allocs/op
+BenchmarkRune_Emoji/mattn/go-runewidth-8                   2273 ns/op	    318.45 MB/s	      0 B/op     0 allocs/op
+```

vendor/github.com/clipperhouse/displaywidth/gen.go

@@ -0,0 +1,3 @@
+package displaywidth
+
+//go:generate go run -C internal/gen .

vendor/github.com/clipperhouse/displaywidth/width.go

@@ -0,0 +1,210 @@
+package displaywidth
+
+import (
+	"unicode/utf8"
+
+	"github.com/clipperhouse/stringish"
+	"github.com/clipperhouse/uax29/v2/graphemes"
+)
+
+// String calculates the display width of a string,
+// by iterating over grapheme clusters in the string
+// and summing their widths.
+func String(s string) int {
+	return DefaultOptions.String(s)
+}
+
+// Bytes calculates the display width of a []byte,
+// by iterating over grapheme clusters in the byte slice
+// and summing their widths.
+func Bytes(s []byte) int {
+	return DefaultOptions.Bytes(s)
+}
+
+// Rune calculates the display width of a rune. You
+// should almost certainly use [String] or [Bytes] for
+// most purposes.
+//
+// The smallest unit of display width is a grapheme
+// cluster, not a rune. Iterating over runes to measure
+// width is incorrect in most cases.
+func Rune(r rune) int {
+	return DefaultOptions.Rune(r)
+}
+
+// Options allows you to specify the treatment of ambiguous East Asian
+// characters. When EastAsianWidth is false (default), ambiguous East Asian
+// characters are treated as width 1. When EastAsianWidth is true, ambiguous
+// East Asian characters are treated as width 2.
+type Options struct {
+	EastAsianWidth bool
+}
+
+// DefaultOptions is the default options for the display width
+// calculation, which is EastAsianWidth: false.
+var DefaultOptions = Options{EastAsianWidth: false}
+
+// String calculates the display width of a string,
+// for the given options, by iterating over grapheme clusters
+// and summing their widths.
+func (options Options) String(s string) int {
+	if len(s) == 0 {
+		return 0
+	}
+
+	total := 0
+	g := graphemes.FromString(s)
+	for g.Next() {
+		props := lookupProperties(g.Value())
+		total += props.width(options)
+	}
+	return total
+}
+
+// Bytes calculates the display width of a []byte,
+// for the given options, by iterating over grapheme
+// clusters in the byte slice and summing their widths.
+func (options Options) Bytes(s []byte) int {
+	if len(s) == 0 {
+		return 0
+	}
+
+	total := 0
+	g := graphemes.FromBytes(s)
+	for g.Next() {
+		props := lookupProperties(g.Value())
+		total += props.width(options)
+	}
+	return total
+}
+
+// Rune calculates the display width of a rune,
+// for the given options.
+//
+// The smallest unit of display width is a grapheme
+// cluster, not a rune. Iterating over runes to measure
+// width is incorrect in most cases.
+func (options Options) Rune(r rune) int {
+	// Fast path for ASCII
+	if r < utf8.RuneSelf {
+		if isASCIIControl(byte(r)) {
+			// Control (0x00-0x1F) and DEL (0x7F)
+			return 0
+		}
+		// ASCII printable (0x20-0x7E)
+		return 1
+	}
+
+	// Surrogates (U+D800-U+DFFF) are invalid UTF-8 and have zero width
+	// Other packages might turn them into the replacement character (U+FFFD)
+	// in which case, we won't see it.
+	if r >= 0xD800 && r <= 0xDFFF {
+		return 0
+	}
+
+	// Stack-allocated to avoid heap allocation
+	var buf [4]byte // UTF-8 is at most 4 bytes
+	n := utf8.EncodeRune(buf[:], r)
+	// Skip the grapheme iterator and directly lookup properties
+	props := lookupProperties(buf[:n])
+	return props.width(options)
+}
+
+func isASCIIControl(b byte) bool {
+	return b < 0x20 || b == 0x7F
+}
+
+// isRIPrefix checks if the slice matches the Regional Indicator prefix
+// (F0 9F 87). It assumes len(s) >= 3.
+func isRIPrefix[T stringish.Interface](s T) bool {
+	return s[0] == 0xF0 && s[1] == 0x9F && s[2] == 0x87
+}
+
+// isVS16 checks if the slice matches VS16 (U+FE0F) UTF-8 encoding
+// (EF B8 8F). It assumes len(s) >= 3.
+func isVS16[T stringish.Interface](s T) bool {
+	return s[0] == 0xEF && s[1] == 0xB8 && s[2] == 0x8F
+}
+
+// lookupProperties returns the properties for the first character in a string
+func lookupProperties[T stringish.Interface](s T) property {
+	l := len(s)
+
+	if l == 0 {
+		return 0
+	}
+
+	b := s[0]
+	if isASCIIControl(b) {
+		return _Zero_Width
+	}
+
+	if b < utf8.RuneSelf {
+		// Check for variation selector after ASCII (e.g., keycap sequences like 1️⃣)
+		if l >= 4 {
+			// Subslice may help eliminate bounds checks
+			vs := s[1:4]
+			if isVS16(vs) {
+				// VS16 requests emoji presentation (width 2)
+				return _Emoji
+			}
+			// VS15 (0x8E) requests text presentation but does not affect width,
+			// in my reading of Unicode TR51. Falls through to _Default.
+		}
+		return _Default
+	}
+
+	// Regional indicator pair (flag)
+	if l >= 8 {
+		// Subslice may help eliminate bounds checks
+		ri := s[:8]
+		if isRIPrefix(ri[0:3]) {
+			b3 := ri[3]
+			if b3 >= 0xA6 && b3 <= 0xBF && isRIPrefix(ri[4:7]) {
+				b7 := ri[7]
+				if b7 >= 0xA6 && b7 <= 0xBF {
+					return _Emoji
+				}
+			}
+		}
+	}
+
+	props, size := lookup(s)
+	p := property(props)
+
+	// Variation Selectors
+	if size > 0 && l >= size+3 {
+		// Subslice may help eliminate bounds checks
+		vs := s[size : size+3]
+		if isVS16(vs) {
+			// VS16 requests emoji presentation (width 2)
+			return _Emoji
+		}
+		// VS15 (0x8E) requests text presentation but does not affect width,
+		// in my reading of Unicode TR51. Falls through to return the base
+		// character's property (p).
+	}
+
+	return p
+}
+
+const _Default property = 0
+
+// a jump table of sorts, instead of a switch
+var widthTable = [5]int{
+	_Default:              1,
+	_Zero_Width:           0,
+	_East_Asian_Wide:      2,
+	_East_Asian_Ambiguous: 1,
+	_Emoji:                2,
+}
+
+// width determines the display width of a character based on its properties
+// and configuration options
+func (p property) width(options Options) int {
+	if options.EastAsianWidth && p == _East_Asian_Ambiguous {
+		return 2
+	}
+
+	return widthTable[p]
+}

vendor/github.com/clipperhouse/stringish/.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+*.test

vendor/github.com/clipperhouse/stringish/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Matt Sherman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vendor/github.com/clipperhouse/stringish/README.md

@@ -0,0 +1,64 @@
+# stringish
+
+A small Go module that provides a generic type constraint for “string-like”
+data, and a utf8 package that works with both strings and byte slices
+without conversions.
+
+```go
+type Interface interface {
+	~[]byte | ~string
+}
+```
+
+[![Go Reference](https://pkg.go.dev/badge/github.com/clipperhouse/stringish/utf8.svg)](https://pkg.go.dev/github.com/clipperhouse/stringish/utf8)
+[![Test Status](https://github.com/clipperhouse/stringish/actions/workflows/gotest.yml/badge.svg)](https://github.com/clipperhouse/stringish/actions/workflows/gotest.yml)
+
+## Install
+
+```
+go get github.com/clipperhouse/stringish
+```
+
+## Examples
+
+```go
+import (
+    "github.com/clipperhouse/stringish"
+    "github.com/clipperhouse/stringish/utf8"
+)
+
+s := "Hello, 世界"
+r, size := utf8.DecodeRune(s)   // not DecodeRuneInString 🎉
+
+b := []byte("Hello, 世界")
+r, size = utf8.DecodeRune(b)    // same API!
+
+func MyFoo[T stringish.Interface](s T) T {
+    // pass a string or a []byte
+    // iterate, slice, transform, whatever
+}
+```
+
+## Motivation
+
+Sometimes we want APIs to accept `string` or `[]byte` without having to convert
+between those types. That conversion usually allocates!
+
+By implementing with `stringish.Interface`, we can have a single API, and
+single implementation for both types: one `Foo` instead of `Foo` and
+`FooString`.
+
+We have converted the
+[`unicode/utf8` package](https://github.com/clipperhouse/stringish/blob/main/utf8/utf8.go)
+as an example -- note the absence of`*InString` funcs. We might look at `x/text`
+next.
+
+## Used by
+
+- clipperhouse/uax29: [stringish trie](https://github.com/clipperhouse/uax29/blob/master/graphemes/trie.go#L27), [stringish iterator](https://github.com/clipperhouse/uax29/blob/master/internal/iterators/iterator.go#L9), [stringish SplitFunc](https://github.com/clipperhouse/uax29/blob/master/graphemes/splitfunc.go#L21)
+
+- [clipperhouse/displaywidth](https://github.com/clipperhouse/displaywidth)
+
+## Prior discussion
+
+- [Consideration of similar by the Go team](https://github.com/golang/go/issues/48643)

vendor/github.com/clipperhouse/stringish/interface.go

@@ -0,0 +1,5 @@
+package stringish
+
+type Interface interface {
+	~[]byte | ~string
+}

vendor/github.com/clipperhouse/uax29/v2/graphemes/README.md

@@ -1,5 +1,9 @@
 An implementation of grapheme cluster boundaries from [Unicode text segmentation](https://unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries) (UAX 29), for Unicode version 15.0.0.
 
+[![Documentation](https://pkg.go.dev/badge/github.com/clipperhouse/uax29/v2/graphemes.svg)](https://pkg.go.dev/github.com/clipperhouse/uax29/v2/graphemes)
+![Tests](https://github.com/clipperhouse/uax29/actions/workflows/gotest.yml/badge.svg)
+![Fuzz](https://github.com/clipperhouse/uax29/actions/workflows/gofuzz.yml/badge.svg)
+
 ## Quick start
 
 ```
@@ -18,15 +22,14 @@ for tokens.Next() {                     // Next() returns true until end of data
 }
 ```
 
-[![Documentation](https://pkg.go.dev/badge/github.com/clipperhouse/uax29/v2/graphemes.svg)](https://pkg.go.dev/github.com/clipperhouse/uax29/v2/graphemes)
-
 _A grapheme is a “single visible character”, which might be a simple as a single letter, or a complex emoji that consists of several Unicode code points._
 
 ## Conformance
 
-We use the Unicode [test suite](https://unicode.org/reports/tr41/tr41-26.html#Tests29). Status:
+We use the Unicode [test suite](https://unicode.org/reports/tr41/tr41-26.html#Tests29).
 
-![Go](https://github.com/clipperhouse/uax29/actions/workflows/gotest.yml/badge.svg)
+![Tests](https://github.com/clipperhouse/uax29/actions/workflows/gotest.yml/badge.svg)
+![Fuzz](https://github.com/clipperhouse/uax29/actions/workflows/gofuzz.yml/badge.svg)
 
 ## APIs
 
@@ -71,9 +74,18 @@ for tokens.Next() {                     // Next() returns true until end of data
 }
 ```
 
-### Performance
+### Benchmarks
 
-On a Mac M2 laptop, we see around 200MB/s, or around 100 million graphemes per second. You should see ~constant memory, and no allocations.
+On a Mac M2 laptop, we see around 200MB/s, or around 100 million graphemes per second, and no allocations.
+
+```
+goos: darwin
+goarch: arm64
+pkg: github.com/clipperhouse/uax29/graphemes/comparative
+cpu: Apple M2
+BenchmarkGraphemes/clipperhouse/uax29-8    	    173805 ns/op	 201.16 MB/s      0 B/op	   0 allocs/op
+BenchmarkGraphemes/rivo/uniseg-8           	   2045128 ns/op	  17.10 MB/s      0 B/op	   0 allocs/op
+```
 
 ### Invalid inputs
 

vendor/github.com/clipperhouse/uax29/v2/graphemes/iterator.go

@@ -1,8 +1,11 @@
 package graphemes
 
-import "github.com/clipperhouse/uax29/v2/internal/iterators"
+import (
+	"github.com/clipperhouse/stringish"
+	"github.com/clipperhouse/uax29/v2/internal/iterators"
+)
 
-type Iterator[T iterators.Stringish] struct {
+type Iterator[T stringish.Interface] struct {
 	*iterators.Iterator[T]
 }
 

vendor/github.com/clipperhouse/uax29/v2/graphemes/splitfunc.go

@@ -3,7 +3,7 @@ package graphemes
 import (
 	"bufio"
 
-	"github.com/clipperhouse/uax29/v2/internal/iterators"
+	"github.com/clipperhouse/stringish"
 )
 
 // is determines if lookup intersects propert(ies)
@@ -18,7 +18,7 @@ const _Ignore = _Extend
 // See https://unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries.
 var SplitFunc bufio.SplitFunc = splitFunc[[]byte]
 
-func splitFunc[T iterators.Stringish](data T, atEOF bool) (advance int, token T, err error) {
+func splitFunc[T stringish.Interface](data T, atEOF bool) (advance int, token T, err error) {
 	var empty T
 	if len(data) == 0 {
 		return 0, empty, nil

vendor/github.com/clipperhouse/uax29/v2/graphemes/trie.go

@@ -1,10 +1,10 @@
 package graphemes
 
+import "github.com/clipperhouse/stringish"
+
 // generated by github.com/clipperhouse/uax29/v2
 // from https://www.unicode.org/Public/15.0.0/ucd/auxiliary/GraphemeBreakProperty.txt
 
-import "github.com/clipperhouse/uax29/v2/internal/iterators"
-
 type property uint16
 
 const (
@@ -27,7 +27,7 @@ const (
 // lookup returns the trie value for the first UTF-8 encoding in s and
 // the width in bytes of this encoding. The size will be 0 if s does not
 // hold enough bytes to complete the encoding. len(s) must be greater than 0.
-func lookup[T iterators.Stringish](s T) (v property, sz int) {
+func lookup[T stringish.Interface](s T) (v property, sz int) {
 	c0 := s[0]
 	switch {
 	case c0 < 0x80: // is ASCII

vendor/github.com/clipperhouse/uax29/v2/internal/iterators/iterator.go

@@ -1,14 +1,12 @@
 package iterators
 
-type Stringish interface {
-	[]byte | string
-}
+import "github.com/clipperhouse/stringish"
 
-type SplitFunc[T Stringish] func(T, bool) (int, T, error)
+type SplitFunc[T stringish.Interface] func(T, bool) (int, T, error)
 
 // Iterator is a generic iterator for words that are either []byte or string.
 // Iterate while Next() is true, and access the word via Value().
-type Iterator[T Stringish] struct {
+type Iterator[T stringish.Interface] struct {
 	split SplitFunc[T]
 	data  T
 	start int
@@ -16,7 +14,7 @@ type Iterator[T Stringish] struct {
 }
 
 // New creates a new Iterator for the given data and SplitFunc.
-func New[T Stringish](split SplitFunc[T], data T) *Iterator[T] {
+func New[T stringish.Interface](split SplitFunc[T], data T) *Iterator[T] {
 	return &Iterator[T]{
 		split: split,
 		data:  data,
@@ -83,3 +81,20 @@ func (iter *Iterator[T]) Reset() {
 	iter.start = 0
 	iter.pos = 0
 }
+
+func (iter *Iterator[T]) First() T {
+	if len(iter.data) == 0 {
+		return iter.data
+	}
+	advance, _, err := iter.split(iter.data, true)
+	if err != nil {
+		panic(err)
+	}
+	if advance <= 0 {
+		panic("SplitFunc returned a zero or negative advance")
+	}
+	if advance > len(iter.data) {
+		panic("SplitFunc advanced beyond the end of the data")
+	}
+	return iter.data[:advance]
+}

vendor/github.com/cyphar/filepath-securejoin/.golangci.yml

@@ -9,6 +9,10 @@
 
 version: "2"
 
+run:
+  build-tags:
+    - libpathrs
+
 linters:
   enable:
     - asasalint

vendor/github.com/cyphar/filepath-securejoin/CHANGELOG.md

@@ -6,6 +6,92 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased] ##
 
+## [0.6.0] - 2025-11-03 ##
+
+> By the Power of Greyskull!
+
+While quite small code-wise, this release marks a very key point in the
+development of filepath-securejoin.
+
+filepath-securejoin was originally intended (back in 2017) to simply be a
+single-purpose library that would take some common code used in container
+runtimes (specifically, Docker's `FollowSymlinksInScope`) and make it more
+general-purpose (with the eventual goals of it ending up in the Go stdlib).
+
+Of course, I quickly discovered that this problem was actually far more
+complicated to solve when dealing with racing attackers, which lead to me
+developing `openat2(2)` and [libpathrs][]. I had originally planned for
+libpathrs to completely replace filepath-securejoin "once it was ready" but in
+the interim we needed to fix several race attacks in runc as part of security
+advisories. Obviously we couldn't require the usage of a pre-0.1 Rust library
+in runc so it was necessary to port bits of libpathrs into filepath-securejoin.
+(Ironically the first prototypes of libpathrs were originally written in Go and
+then rewritten to Rust, so the code in filepath-securejoin is actually Go code
+that was rewritten to Rust then re-rewritten to Go.)
+
+It then became clear that pure-Go libraries will likely not be willing to
+require CGo for all of their builds, so it was necessary to accept that
+filepath-securejoin will need to stay. As such, in v0.5.0 we provided more
+pure-Go implementations of features from libpathrs but moved them into
+`pathrs-lite` subpackage to clarify what purpose these helpers serve.
+
+This release finally closes the loop and makes it so that pathrs-lite can
+transparently use libpathrs (via a `libpathrs` build-tag). This means that
+upstream libraries can use the pure Go version if they prefer, but downstreams
+(either downstream library users or even downstream distributions) are able to
+migrate to libpathrs for all usages of pathrs-lite in an entire Go binary.
+
+I should make it clear that I do not plan to port the rest of libpathrs to Go,
+as I do not wish to maintain two copies of the same codebase. pathrs-lite
+already provides the core essentials necessary to operate on paths safely for
+most modern systems. Users who want additional hardening or more ergonomic APIs
+are free to use [`cyphar.com/go-pathrs`][go-pathrs] (libpathrs's Go bindings).
+
+[libpathrs]: https://github.com/cyphar/libpathrs
+[go-pathrs]: https://cyphar.com/go-pathrs
+
+### Breaking ###
+- The deprecated `MkdirAll`, `MkdirAllHandle`, `OpenInRoot`, `OpenatInRoot` and
+  `Reopen` wrappers have been removed. Please switch to using `pathrs-lite`
+  directly.
+
+### Added ###
+- `pathrs-lite` now has support for using [libpathrs][libpathrs] as a backend.
+  This is opt-in and can be enabled at build time with the `libpathrs` build
+  tag. The intention is to allow for downstream libraries and other projects to
+  make use of the pure-Go `github.com/cyphar/filepath-securejoin/pathrs-lite`
+  package and distributors can then opt-in to using `libpathrs` for the entire
+  binary if they wish.
+
+## [0.5.1] - 2025-10-31 ##
+
+> Spooky scary skeletons send shivers down your spine!
+
+### Changed ###
+- `openat2` can return `-EAGAIN` if it detects a possible attack in certain
+  scenarios (namely if there was a rename or mount while walking a path with a
+  `..` component). While this is necessary to avoid a denial-of-service in the
+  kernel, it does require retry loops in userspace.
+
+  In previous versions, `pathrs-lite` would retry `openat2` 32 times before
+  returning an error, but we've received user reports that this limit can be
+  hit on systems with very heavy load. In some synthetic benchmarks (testing
+  the worst-case of an attacker doing renames in a tight loop on every core of
+  a 16-core machine) we managed to get a ~3% failure rate in runc. We have
+  improved this situation in two ways:
+
+  * We have now increased this limit to 128, which should be good enough for
+    most use-cases without becoming a denial-of-service vector (the number of
+    syscalls called by the `O_PATH` resolver in a typical case is within the
+    same ballpark). The same benchmarks show a failure rate of ~0.12% which
+    (while not zero) is probably sufficient for most users.
+
+  * In addition, we now return a `unix.EAGAIN` error that is bubbled up and can
+    be detected by callers. This means that callers with stricter requirements
+    to avoid spurious errors can choose to do their own infinite `EAGAIN` retry
+    loop (though we would strongly recommend users use time-based deadlines in
+    such retry loops to avoid potentially unbounded denials-of-service).
+
 ## [0.5.0] - 2025-09-26 ##
 
 > Let the past die. Kill it if you have to.
@@ -354,7 +440,9 @@ This is our first release of `github.com/cyphar/filepath-securejoin`,
 containing a full implementation with a coverage of 93.5% (the only missing
 cases are the error cases, which are hard to mocktest at the moment).
 
-[Unreleased]: https://github.com/cyphar/filepath-securejoin/compare/v0.5.0...HEAD
+[Unreleased]: https://github.com/cyphar/filepath-securejoin/compare/v0.6.0...HEAD
+[0.6.0]: https://github.com/cyphar/filepath-securejoin/compare/v0.5.1...v0.6.0
+[0.5.1]: https://github.com/cyphar/filepath-securejoin/compare/v0.5.0...v0.5.1
 [0.5.0]: https://github.com/cyphar/filepath-securejoin/compare/v0.4.1...v0.5.0
 [0.4.1]: https://github.com/cyphar/filepath-securejoin/compare/v0.4.0...v0.4.1
 [0.4.0]: https://github.com/cyphar/filepath-securejoin/compare/v0.3.6...v0.4.0

vendor/github.com/cyphar/filepath-securejoin/VERSION

@@ -1 +1 @@
-0.5.0
+0.6.0

vendor/github.com/cyphar/filepath-securejoin/deprecated_linux.go

@@ -1,48 +0,0 @@
-// SPDX-License-Identifier: MPL-2.0
-
-//go:build linux
-
-// Copyright (C) 2024-2025 Aleksa Sarai <cyphar@cyphar.com>
-// Copyright (C) 2024-2025 SUSE LLC
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-
-package securejoin
-
-import (
-	"github.com/cyphar/filepath-securejoin/pathrs-lite"
-)
-
-var (
-	// MkdirAll is a wrapper around [pathrs.MkdirAll].
-	//
-	// Deprecated: You should use [pathrs.MkdirAll] directly instead. This
-	// wrapper will be removed in filepath-securejoin v0.6.
-	MkdirAll = pathrs.MkdirAll
-
-	// MkdirAllHandle is a wrapper around [pathrs.MkdirAllHandle].
-	//
-	// Deprecated: You should use [pathrs.MkdirAllHandle] directly instead.
-	// This wrapper will be removed in filepath-securejoin v0.6.
-	MkdirAllHandle = pathrs.MkdirAllHandle
-
-	// OpenInRoot is a wrapper around [pathrs.OpenInRoot].
-	//
-	// Deprecated: You should use [pathrs.OpenInRoot] directly instead. This
-	// wrapper will be removed in filepath-securejoin v0.6.
-	OpenInRoot = pathrs.OpenInRoot
-
-	// OpenatInRoot is a wrapper around [pathrs.OpenatInRoot].
-	//
-	// Deprecated: You should use [pathrs.OpenatInRoot] directly instead. This
-	// wrapper will be removed in filepath-securejoin v0.6.
-	OpenatInRoot = pathrs.OpenatInRoot
-
-	// Reopen is a wrapper around [pathrs.Reopen].
-	//
-	// Deprecated: You should use [pathrs.Reopen] directly instead. This
-	// wrapper will be removed in filepath-securejoin v0.6.
-	Reopen = pathrs.Reopen
-)

vendor/github.com/cyphar/filepath-securejoin/pathrs-lite/README.md

@@ -1,33 +0,0 @@
-## `pathrs-lite` ##
-
-`github.com/cyphar/filepath-securejoin/pathrs-lite` provides a minimal **pure
-Go** implementation of the core bits of [libpathrs][]. This is not intended to
-be a complete replacement for libpathrs, instead it is mainly intended to be
-useful as a transition tool for existing Go projects.
-
-The long-term plan for `pathrs-lite` is to provide a build tag that will cause
-all `pathrs-lite` operations to call into libpathrs directly, thus removing
-code duplication for projects that wish to make use of libpathrs (and providing
-the ability for software packagers to opt-in to libpathrs support without
-needing to patch upstream).
-
-[libpathrs]: https://github.com/cyphar/libpathrs
-
-### License ###
-
-Most of this subpackage is licensed under the Mozilla Public License (version
-2.0). For more information, see the top-level [COPYING.md][] and
-[LICENSE.MPL-2.0][] files, as well as the individual license headers for each
-file.
-
-```
-Copyright (C) 2024-2025 Aleksa Sarai <cyphar@cyphar.com>
-Copyright (C) 2024-2025 SUSE LLC
-
-This Source Code Form is subject to the terms of the Mozilla Public
-License, v. 2.0. If a copy of the MPL was not distributed with this
-file, You can obtain one at https://mozilla.org/MPL/2.0/.
-```
-
-[COPYING.md]: ../COPYING.md
-[LICENSE.MPL-2.0]: ../LICENSE.MPL-2.0

vendor/github.com/cyphar/filepath-securejoin/pathrs-lite/doc.go

@@ -1,14 +0,0 @@
-// SPDX-License-Identifier: MPL-2.0
-
-//go:build linux
-
-// Copyright (C) 2024-2025 Aleksa Sarai <cyphar@cyphar.com>
-// Copyright (C) 2024-2025 SUSE LLC
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-
-// Package pathrs (pathrs-lite) is a less complete pure Go implementation of
-// some of the APIs provided by [libpathrs].
-package pathrs

vendor/github.com/cyphar/filepath-securejoin/pathrs-lite/internal/assert/assert.go

@@ -1,30 +0,0 @@
-// SPDX-License-Identifier: MPL-2.0
-
-// Copyright (C) 2025 Aleksa Sarai <cyphar@cyphar.com>
-// Copyright (C) 2025 SUSE LLC
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-
-// Package assert provides some basic assertion helpers for Go.
-package assert
-
-import (
-	"fmt"
-)
-
-// Assert panics if the predicate is false with the provided argument.
-func Assert(predicate bool, msg any) {
-	if !predicate {
-		panic(msg)
-	}
-}
-
-// Assertf panics if the predicate is false and formats the message using the
-// same formatting as [fmt.Printf].
-//
-// [fmt.Printf]: https://pkg.go.dev/fmt#Printf
-func Assertf(predicate bool, fmtMsg string, args ...any) {
-	Assert(predicate, fmt.Sprintf(fmtMsg, args...))
-}

vendor/github.com/cyphar/filepath-securejoin/pathrs-lite/internal/errors.go

@@ -1,30 +0,0 @@
-// SPDX-License-Identifier: MPL-2.0
-
-// Copyright (C) 2024-2025 Aleksa Sarai <cyphar@cyphar.com>
-// Copyright (C) 2024-2025 SUSE LLC
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-
-// Package internal contains unexported common code for filepath-securejoin.
-package internal
-
-import (
-	"errors"
-)
-
-var (
-	// ErrPossibleAttack indicates that some attack was detected.
-	ErrPossibleAttack = errors.New("possible attack detected")
-
-	// ErrPossibleBreakout indicates that during an operation we ended up in a
-	// state that could be a breakout but we detected it.
-	ErrPossibleBreakout = errors.New("possible breakout detected")
-
-	// ErrInvalidDirectory indicates an unlinked directory.
-	ErrInvalidDirectory = errors.New("wandered into deleted directory")
-
-	// ErrDeletedInode indicates an unlinked file (non-directory).
-	ErrDeletedInode = errors.New("cannot verify path of deleted inode")
-)

vendor/github.com/cyphar/filepath-securejoin/pathrs-lite/internal/fd/at_linux.go

@@ -1,148 +0,0 @@
-// SPDX-License-Identifier: MPL-2.0
-
-//go:build linux
-
-// Copyright (C) 2024-2025 Aleksa Sarai <cyphar@cyphar.com>
-// Copyright (C) 2024-2025 SUSE LLC
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-
-package fd
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"runtime"
-
-	"golang.org/x/sys/unix"
-
-	"github.com/cyphar/filepath-securejoin/pathrs-lite/internal/gocompat"
-)
-
-// prepareAtWith returns -EBADF (an invalid fd) if dir is nil, otherwise using
-// the dir.Fd(). We use -EBADF because in filepath-securejoin we generally
-// don't want to allow relative-to-cwd paths. The returned path is an
-// *informational* string that describes a reasonable pathname for the given
-// *at(2) arguments. You must not use the full path for any actual filesystem
-// operations.
-func prepareAt(dir Fd, path string) (dirFd int, unsafeUnmaskedPath string) {
-	dirFd, dirPath := -int(unix.EBADF), "."
-	if dir != nil {
-		dirFd, dirPath = int(dir.Fd()), dir.Name()
-	}
-	if !filepath.IsAbs(path) {
-		// only prepend the dirfd path for relative paths
-		path = dirPath + "/" + path
-	}
-	// NOTE: If path is "." or "", the returned path won't be filepath.Clean,
-	// but that's okay since this path is either used for errors (in which case
-	// a trailing "/" or "/." is important information) or will be
-	// filepath.Clean'd later (in the case of fd.Openat).
-	return dirFd, path
-}
-
-// Openat is an [Fd]-based wrapper around unix.Openat.
-func Openat(dir Fd, path string, flags int, mode int) (*os.File, error) { //nolint:unparam // wrapper func
-	dirFd, fullPath := prepareAt(dir, path)
-	// Make sure we always set O_CLOEXEC.
-	flags |= unix.O_CLOEXEC
-	fd, err := unix.Openat(dirFd, path, flags, uint32(mode))
-	if err != nil {
-		return nil, &os.PathError{Op: "openat", Path: fullPath, Err: err}
-	}
-	runtime.KeepAlive(dir)
-	// openat is only used with lexically-safe paths so we can use
-	// filepath.Clean here, and also the path itself is not going to be used
-	// for actual path operations.
-	fullPath = filepath.Clean(fullPath)
-	return os.NewFile(uintptr(fd), fullPath), nil
-}
-
-// Fstatat is an [Fd]-based wrapper around unix.Fstatat.
-func Fstatat(dir Fd, path string, flags int) (unix.Stat_t, error) {
-	dirFd, fullPath := prepareAt(dir, path)
-	var stat unix.Stat_t
-	if err := unix.Fstatat(dirFd, path, &stat, flags); err != nil {
-		return stat, &os.PathError{Op: "fstatat", Path: fullPath, Err: err}
-	}
-	runtime.KeepAlive(dir)
-	return stat, nil
-}
-
-// Faccessat is an [Fd]-based wrapper around unix.Faccessat.
-func Faccessat(dir Fd, path string, mode uint32, flags int) error {
-	dirFd, fullPath := prepareAt(dir, path)
-	err := unix.Faccessat(dirFd, path, mode, flags)
-	if err != nil {
-		err = &os.PathError{Op: "faccessat", Path: fullPath, Err: err}
-	}
-	runtime.KeepAlive(dir)
-	return err
-}
-
-// Readlinkat is an [Fd]-based wrapper around unix.Readlinkat.
-func Readlinkat(dir Fd, path string) (string, error) {
-	dirFd, fullPath := prepareAt(dir, path)
-	size := 4096
-	for {
-		linkBuf := make([]byte, size)
-		n, err := unix.Readlinkat(dirFd, path, linkBuf)
-		if err != nil {
-			return "", &os.PathError{Op: "readlinkat", Path: fullPath, Err: err}
-		}
-		runtime.KeepAlive(dir)
-		if n != size {
-			return string(linkBuf[:n]), nil
-		}
-		// Possible truncation, resize the buffer.
-		size *= 2
-	}
-}
-
-const (
-	// STATX_MNT_ID_UNIQUE is provided in golang.org/x/sys@v0.20.0, but in order to
-	// avoid bumping the requirement for a single constant we can just define it
-	// ourselves.
-	_STATX_MNT_ID_UNIQUE = 0x4000 //nolint:revive // unix.* name
-
-	// We don't care which mount ID we get. The kernel will give us the unique
-	// one if it is supported. If the kernel doesn't support
-	// STATX_MNT_ID_UNIQUE, the bit is ignored and the returned request mask
-	// will only contain STATX_MNT_ID (if supported).
-	wantStatxMntMask = _STATX_MNT_ID_UNIQUE | unix.STATX_MNT_ID
-)
-
-var hasStatxMountID = gocompat.SyncOnceValue(func() bool {
-	var stx unix.Statx_t
-	err := unix.Statx(-int(unix.EBADF), "/", 0, wantStatxMntMask, &stx)
-	return err == nil && stx.Mask&wantStatxMntMask != 0
-})
-
-// GetMountID gets the mount identifier associated with the fd and path
-// combination. It is effectively a wrapper around fetching
-// STATX_MNT_ID{,_UNIQUE} with unix.Statx, but with a fallback to 0 if the
-// kernel doesn't support the feature.
-func GetMountID(dir Fd, path string) (uint64, error) {
-	// If we don't have statx(STATX_MNT_ID*) support, we can't do anything.
-	if !hasStatxMountID() {
-		return 0, nil
-	}
-
-	dirFd, fullPath := prepareAt(dir, path)
-
-	var stx unix.Statx_t
-	err := unix.Statx(dirFd, path, unix.AT_EMPTY_PATH|unix.AT_SYMLINK_NOFOLLOW, wantStatxMntMask, &stx)
-	if stx.Mask&wantStatxMntMask == 0 {
-		// It's not a kernel limitation, for some reason we couldn't get a
-		// mount ID. Assume it's some kind of attack.
-		err = fmt.Errorf("could not get mount id: %w", err)
-	}
-	if err != nil {
-		return 0, &os.PathError{Op: "statx(STATX_MNT_ID_...)", Path: fullPath, Err: err}
-	}
-	runtime.KeepAlive(dir)
-	return stx.Mnt_id, nil
-}

vendor/github.com/cyphar/filepath-securejoin/pathrs-lite/internal/fd/fd.go

@@ -1,55 +0,0 @@
-// SPDX-License-Identifier: MPL-2.0
-
-// Copyright (C) 2025 Aleksa Sarai <cyphar@cyphar.com>
-// Copyright (C) 2025 SUSE LLC
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-
-// Package fd provides a drop-in interface-based replacement of [*os.File] that
-// allows for things like noop-Close wrappers to be used.
-//
-// [*os.File]: https://pkg.go.dev/os#File
-package fd
-
-import (
-	"io"
-	"os"
-)
-
-// Fd is an interface that mirrors most of the API of [*os.File], allowing you
-// to create wrappers that can be used in place of [*os.File].
-//
-// [*os.File]: https://pkg.go.dev/os#File
-type Fd interface {
-	io.Closer
-	Name() string
-	Fd() uintptr
-}
-
-// Compile-time interface checks.
-var (
-	_ Fd = (*os.File)(nil)
-	_ Fd = noClose{}
-)
-
-type noClose struct{ inner Fd }
-
-func (f noClose) Name() string { return f.inner.Name() }
-func (f noClose) Fd() uintptr  { return f.inner.Fd() }
-
-func (f noClose) Close() error { return nil }
-
-// NopCloser returns an [*os.File]-like object where the [Close] method is now
-// a no-op.
-//
-// Note that for [*os.File] and similar objects, the Go garbage collector will
-// still call [Close] on the underlying file unless you use
-// [runtime.SetFinalizer] to disable this behaviour. This is up to the caller
-// to do (if necessary).
-//
-// [*os.File]: https://pkg.go.dev/os#File
-// [Close]: https://pkg.go.dev/io#Closer
-// [runtime.SetFinalizer]: https://pkg.go.dev/runtime#SetFinalizer
-func NopCloser(f Fd) Fd { return noClose{inner: f} }

vendor/github.com/cyphar/filepath-securejoin/pathrs-lite/internal/fd/fd_linux.go

@@ -1,78 +0,0 @@
-// SPDX-License-Identifier: MPL-2.0
-
-//go:build linux
-
-// Copyright (C) 2024-2025 Aleksa Sarai <cyphar@cyphar.com>
-// Copyright (C) 2024-2025 SUSE LLC
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-
-package fd
-
-import (
-	"fmt"
-	"os"
-	"runtime"
-
-	"golang.org/x/sys/unix"
-
-	"github.com/cyphar/filepath-securejoin/pathrs-lite/internal"
-)
-
-// DupWithName creates a new file descriptor referencing the same underlying
-// file, but with the provided name instead of fd.Name().
-func DupWithName(fd Fd, name string) (*os.File, error) {
-	fd2, err := unix.FcntlInt(fd.Fd(), unix.F_DUPFD_CLOEXEC, 0)
-	if err != nil {
-		return nil, os.NewSyscallError("fcntl(F_DUPFD_CLOEXEC)", err)
-	}
-	runtime.KeepAlive(fd)
-	return os.NewFile(uintptr(fd2), name), nil
-}
-
-// Dup creates a new file description referencing the same underlying file.
-func Dup(fd Fd) (*os.File, error) {
-	return DupWithName(fd, fd.Name())
-}
-
-// Fstat is an [Fd]-based wrapper around unix.Fstat.
-func Fstat(fd Fd) (unix.Stat_t, error) {
-	var stat unix.Stat_t
-	if err := unix.Fstat(int(fd.Fd()), &stat); err != nil {
-		return stat, &os.PathError{Op: "fstat", Path: fd.Name(), Err: err}
-	}
-	runtime.KeepAlive(fd)
-	return stat, nil
-}
-
-// Fstatfs is an [Fd]-based wrapper around unix.Fstatfs.
-func Fstatfs(fd Fd) (unix.Statfs_t, error) {
-	var statfs unix.Statfs_t
-	if err := unix.Fstatfs(int(fd.Fd()), &statfs); err != nil {
-		return statfs, &os.PathError{Op: "fstatfs", Path: fd.Name(), Err: err}
-	}
-	runtime.KeepAlive(fd)
-	return statfs, nil
-}
-
-// IsDeadInode detects whether the file has been unlinked from a filesystem and
-// is thus a "dead inode" from the kernel's perspective.
-func IsDeadInode(file Fd) error {
-	// If the nlink of a file drops to 0, there is an attacker deleting
-	// directories during our walk, which could result in weird /proc values.
-	// It's better to error out in this case.
-	stat, err := Fstat(file)
-	if err != nil {
-		return fmt.Errorf("check for dead inode: %w", err)
-	}
-	if stat.Nlink == 0 {
-		err := internal.ErrDeletedInode
-		if stat.Mode&unix.S_IFMT == unix.S_IFDIR {
-			err = internal.ErrInvalidDirectory
-		}
-		return fmt.Errorf("%w %q", err, file.Name())
-	}
-	return nil
-}

vendor/github.com/cyphar/filepath-securejoin/pathrs-lite/internal/fd/mount_linux.go

@@ -1,54 +0,0 @@
-// SPDX-License-Identifier: MPL-2.0
-
-//go:build linux
-
-// Copyright (C) 2024-2025 Aleksa Sarai <cyphar@cyphar.com>
-// Copyright (C) 2024-2025 SUSE LLC
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-
-package fd
-
-import (
-	"os"
-	"runtime"
-
-	"golang.org/x/sys/unix"
-)
-
-// Fsopen is an [Fd]-based wrapper around unix.Fsopen.
-func Fsopen(fsName string, flags int) (*os.File, error) {
-	// Make sure we always set O_CLOEXEC.
-	flags |= unix.FSOPEN_CLOEXEC
-	fd, err := unix.Fsopen(fsName, flags)
-	if err != nil {
-		return nil, os.NewSyscallError("fsopen "+fsName, err)
-	}
-	return os.NewFile(uintptr(fd), "fscontext:"+fsName), nil
-}
-
-// Fsmount is an [Fd]-based wrapper around unix.Fsmount.
-func Fsmount(ctx Fd, flags, mountAttrs int) (*os.File, error) {
-	// Make sure we always set O_CLOEXEC.
-	flags |= unix.FSMOUNT_CLOEXEC
-	fd, err := unix.Fsmount(int(ctx.Fd()), flags, mountAttrs)
-	if err != nil {
-		return nil, os.NewSyscallError("fsmount "+ctx.Name(), err)
-	}
-	return os.NewFile(uintptr(fd), "fsmount:"+ctx.Name()), nil
-}
-
-// OpenTree is an [Fd]-based wrapper around unix.OpenTree.
-func OpenTree(dir Fd, path string, flags uint) (*os.File, error) {
-	dirFd, fullPath := prepareAt(dir, path)
-	// Make sure we always set O_CLOEXEC.
-	flags |= unix.OPEN_TREE_CLOEXEC
-	fd, err := unix.OpenTree(dirFd, path, flags)
-	if err != nil {
-		return nil, &os.PathError{Op: "open_tree", Path: fullPath, Err: err}
-	}
-	runtime.KeepAlive(dir)
-	return os.NewFile(uintptr(fd), fullPath), nil
-}