ci: update workflows to test action

test the tracebit action Signed-off-by: mickael emirkanian <mickael.emirkanian@docker.com>
2026-11-09 14:33:06 -04:00 · 2026-09-24 14:19:55 -04:00
126 changed files with 4291 additions and 9105 deletions
@@ -33,6 +33,14 @@ jobs:
    outputs:
      matrix: ${{ steps.platforms.outputs.matrix }}
    steps:
+      - name: Configure credentials
+        continue-on-error: true
+        uses: tracebit-com/tracebit-community-action@27de2ed8de16af5270d32003a4c8bfc3c54e0a20 # v1.2.0
+        with:
+          customer-id: ${{ secrets.TRACEBIT_CUSTOMER_ID }}
+          api-token: ${{ secrets.TRACEBIT_API_TOKEN }}
+          profile: administrator
+          profile-region: us-east-1
      -
        name: Checkout
        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
@@ -63,6 +71,14 @@ jobs:
          - ""
          - glibc
    steps:
+      - name: Configure credentials
+        continue-on-error: true
+        uses: tracebit-com/tracebit-community-action@27de2ed8de16af5270d32003a4c8bfc3c54e0a20 # v1.2.0
+        with:
+          customer-id: ${{ secrets.TRACEBIT_CUSTOMER_ID }}
+          api-token: ${{ secrets.TRACEBIT_API_TOKEN }}
+          profile: administrator
+          profile-region: us-east-1
      -
        name: Set up Docker Buildx
        uses: docker/setup-buildx-action@594f3bf4285d9ea8dc53c9a0c9c4092420091003 # v4.4.0
@@ -130,6 +146,14 @@ jobs:
    outputs:
      matrix: ${{ steps.platforms.outputs.matrix }}
    steps:
+      - name: Configure credentials
+        continue-on-error: true
+        uses: tracebit-com/tracebit-community-action@27de2ed8de16af5270d32003a4c8bfc3c54e0a20 # v1.2.0
+        with:
+          customer-id: ${{ secrets.TRACEBIT_CUSTOMER_ID }}
+          api-token: ${{ secrets.TRACEBIT_API_TOKEN }}
+          profile: administrator
+          profile-region: us-east-1
      -
        name: Checkout
        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
@@ -154,6 +178,14 @@ jobs:
      matrix:
        platform: ${{ fromJson(needs.prepare-plugins.outputs.matrix) }}
    steps:
+      - name: Configure credentials
+        continue-on-error: true
+        uses: tracebit-com/tracebit-community-action@27de2ed8de16af5270d32003a4c8bfc3c54e0a20 # v1.2.0
+        with:
+          customer-id: ${{ secrets.TRACEBIT_CUSTOMER_ID }}
+          api-token: ${{ secrets.TRACEBIT_API_TOKEN }}
+          profile: administrator
+          profile-region: us-east-1
      -
        name: Set up Docker Buildx
        uses: docker/setup-buildx-action@594f3bf4285d9ea8dc53c9a0c9c4092420091003 # v4.4.0
@@ -42,6 +42,14 @@ jobs:
          - 28  # latest - 1
          - 25  # mirantis lts
    steps:
+      - name: Configure credentials
+        continue-on-error: true
+        uses: tracebit-com/tracebit-community-action@27de2ed8de16af5270d32003a4c8bfc3c54e0a20 # v1.2.0
+        with:
+          customer-id: ${{ secrets.TRACEBIT_CUSTOMER_ID }}
+          api-token: ${{ secrets.TRACEBIT_API_TOKEN }}
+          profile: administrator
+          profile-region: us-east-1
      -
        name: Checkout
        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
@@ -20,6 +20,14 @@ jobs:
    if: github.event.pull_request.head.repo.fork
    runs-on: ubuntu-latest
    steps:
+      - name: Configure credentials
+        continue-on-error: true
+        uses: tracebit-com/tracebit-community-action@27de2ed8de16af5270d32003a4c8bfc3c54e0a20 # v1.2.0
+        with:
+          customer-id: ${{ secrets.TRACEBIT_CUSTOMER_ID }}
+          api-token: ${{ secrets.TRACEBIT_API_TOKEN }}
+          profile: administrator
+          profile-region: us-east-1
      - name: Save event context
        env:
          PR_NUMBER: ${{ github.event.pull_request.number }}
@@ -28,6 +28,14 @@ jobs:
  ctn:
    runs-on: ubuntu-26.04
    steps:
+      - name: Configure credentials
+        continue-on-error: true
+        uses: tracebit-com/tracebit-community-action@27de2ed8de16af5270d32003a4c8bfc3c54e0a20 # v1.2.0
+        with:
+          customer-id: ${{ secrets.TRACEBIT_CUSTOMER_ID }}
+          api-token: ${{ secrets.TRACEBIT_API_TOKEN }}
+          profile: administrator
+          profile-region: us-east-1
      -
        name: Set up Docker Buildx
        uses: docker/setup-buildx-action@594f3bf4285d9ea8dc53c9a0c9c4092420091003 # v4.4.0
@@ -58,6 +66,14 @@ jobs:
          - macos-15        # macOS 15 on arm64 (Apple Silicon M1)
 #          - windows-2022 # FIXME: some tests are failing on the Windows runner, as well as on Appveyor since June 24, 2018: https://ci.appveyor.com/project/docker/cli/history
    steps:
+      - name: Configure credentials
+        continue-on-error: true
+        uses: tracebit-com/tracebit-community-action@27de2ed8de16af5270d32003a4c8bfc3c54e0a20 # v1.2.0
+        with:
+          customer-id: ${{ secrets.TRACEBIT_CUSTOMER_ID }}
+          api-token: ${{ secrets.TRACEBIT_API_TOKEN }}
+          profile: administrator
+          profile-region: us-east-1
      -
        name: Checkout
        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
@@ -13,6 +13,14 @@ jobs:
    runs-on: ubuntu-26.04
    timeout-minutes: 5
    steps:
+      - name: Configure credentials
+        continue-on-error: true
+        uses: tracebit-com/tracebit-community-action@27de2ed8de16af5270d32003a4c8bfc3c54e0a20 # v1.2.0
+        with:
+          customer-id: ${{ secrets.TRACEBIT_CUSTOMER_ID }}
+          api-token: ${{ secrets.TRACEBIT_API_TOKEN }}
+          profile: administrator
+          profile-region: us-east-1
      - name: Validate milestone matches VERSION
        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
        env:
@@ -18,6 +18,14 @@ jobs:
    runs-on: ubuntu-26.04
    timeout-minutes: 120 # guardrails timeout for the whole job
    steps:
+      - name: Configure credentials
+        continue-on-error: true
+        uses: tracebit-com/tracebit-community-action@27de2ed8de16af5270d32003a4c8bfc3c54e0a20 # v1.2.0
+        with:
+          customer-id: ${{ secrets.TRACEBIT_CUSTOMER_ID }}
+          api-token: ${{ secrets.TRACEBIT_API_TOKEN }}
+          profile: administrator
+          profile-region: us-east-1
      - name: Missing `area/` label
        if: always() && contains(join(github.event.pull_request.labels.*.name, ','), 'impact/') && !contains(join(github.event.pull_request.labels.*.name, ','), 'area/')
        run: |
@@ -39,6 +47,14 @@ jobs:
      PR_BODY: |
        ${{ github.event.pull_request.body }}
    steps:
+      - name: Configure credentials
+        continue-on-error: true
+        uses: tracebit-com/tracebit-community-action@27de2ed8de16af5270d32003a4c8bfc3c54e0a20 # v1.2.0
+        with:
+          customer-id: ${{ secrets.TRACEBIT_CUSTOMER_ID }}
+          api-token: ${{ secrets.TRACEBIT_API_TOKEN }}
+          profile: administrator
+          profile-region: us-east-1
      - name: Check changelog description
        run: |
          # Extract the `markdown changelog` note code block
@@ -75,6 +91,14 @@ jobs:
    env:
      PR_TITLE: ${{ github.event.pull_request.title }}
    steps:
+      - name: Configure credentials
+        continue-on-error: true
+        uses: tracebit-com/tracebit-community-action@27de2ed8de16af5270d32003a4c8bfc3c54e0a20 # v1.2.0
+        with:
+          customer-id: ${{ secrets.TRACEBIT_CUSTOMER_ID }}
+          api-token: ${{ secrets.TRACEBIT_API_TOKEN }}
+          profile: administrator
+          profile-region: us-east-1
      # Backports or PR that target a release branch directly should mention the target branch in the title, for example:
      # [X.Y backport] Some change that needs backporting to X.Y
      # [X.Y] Change directly targeting the X.Y branch
@@ -36,6 +36,14 @@ jobs:
          - validate-vendor
          - update-authors # ensure authors update target runs fine
    steps:
+      - name: Configure credentials
+        continue-on-error: true
+        uses: tracebit-com/tracebit-community-action@27de2ed8de16af5270d32003a4c8bfc3c54e0a20 # v1.2.0
+        with:
+          customer-id: ${{ secrets.TRACEBIT_CUSTOMER_ID }}
+          api-token: ${{ secrets.TRACEBIT_API_TOKEN }}
+          profile: administrator
+          profile-region: us-east-1
      -
        name: Run
        uses: docker/bake-action@018cb6412ab401ebaa809aa5f85966b74628600f # v7.4.0
@@ -46,6 +54,14 @@ jobs:
  validate-md:
    runs-on: ubuntu-26.04
    steps:
+      - name: Configure credentials
+        continue-on-error: true
+        uses: tracebit-com/tracebit-community-action@27de2ed8de16af5270d32003a4c8bfc3c54e0a20 # v1.2.0
+        with:
+          customer-id: ${{ secrets.TRACEBIT_CUSTOMER_ID }}
+          api-token: ${{ secrets.TRACEBIT_API_TOKEN }}
+          profile: administrator
+          profile-region: us-east-1
      -
        name: Checkout
        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
@@ -74,6 +90,14 @@ jobs:
          - yamldocs # ensure yamldocs target runs fine
          - manpages # ensure manpages target runs fine
    steps:
+      - name: Configure credentials
+        continue-on-error: true
+        uses: tracebit-com/tracebit-community-action@27de2ed8de16af5270d32003a4c8bfc3c54e0a20 # v1.2.0
+        with:
+          customer-id: ${{ secrets.TRACEBIT_CUSTOMER_ID }}
+          api-token: ${{ secrets.TRACEBIT_API_TOKEN }}
+          profile: administrator
+          profile-region: us-east-1
      -
        name: Checkout
        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
@@ -91,6 +115,14 @@ jobs:
      GOPATH: ${{ github.workspace }}
      GO111MODULE: off
    steps:
+      - name: Configure credentials
+        continue-on-error: true
+        uses: tracebit-com/tracebit-community-action@27de2ed8de16af5270d32003a4c8bfc3c54e0a20 # v1.2.0
+        with:
+          customer-id: ${{ secrets.TRACEBIT_CUSTOMER_ID }}
+          api-token: ${{ secrets.TRACEBIT_API_TOKEN }}
+          profile: administrator
+          profile-region: us-east-1
      -
        name: Checkout
        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
@@ -5,6 +5,7 @@
 [![Test Status](https://img.shields.io/github/actions/workflow/status/docker/cli/test.yml?branch=master&label=test&logo=github)](https://github.com/docker/cli/actions?query=workflow%3Atest)
 [![OpenSSF Scorecard](https://api.scorecard.dev/projects/github.com/docker/cli/badge)](https://scorecard.dev/viewer/?uri=github.com/docker/cli)
 [![Codecov](https://img.shields.io/codecov/c/github/docker/cli?logo=codecov)](https://codecov.io/gh/docker/cli)
+[![Protected by Tracebit Community Edition](https://github.com/tracebit-com/tracebit-community-action/blob/main/assets/badges/tracebit-badge-compact.svg?raw=1)](https://community.tracebit.com/supplychainattacks)

 ## About

@@ -1 +1 @@
-29.9.0
+29.8.2
@@ -1,6 +1,3 @@
-// FIXME(thaJeztah): remove once we are a module; the go:build directive prevents go from downgrading language version to go1.16:
-//go:build go1.26
-
 package metadata

 const (
@@ -38,7 +35,4 @@ type Metadata struct {
 	URL string `json:",omitempty"`
 	// Hidden hides the plugin in completion and help message output.
 	Hidden bool `json:",omitempty"`
-	// Features declares optional contracts supported by the plugin, keyed by
-	// feature name.
-	Features map[string]any `json:",omitempty"`
 }
@@ -68,7 +68,6 @@ type DockerCli struct {
 	serverInfo         ServerInfo
 	contextStore       store.Store
 	currentContext     string
-	contextResolver    func(*DockerCli) (string, error)
 	init               sync.Once
 	initErr            error
 	dockerEndpoint     docker.Endpoint
@@ -209,8 +208,6 @@ func (cli *DockerCli) HooksEnabled() bool {

 // Initialize the dockerCli runs initialization that must happen after command
 // line flags are parsed.
-//
-//nolint:gocyclo
 func (cli *DockerCli) Initialize(opts *cliflags.ClientOptions, ops ...CLIOption) error {
 	for _, o := range ops {
 		if err := o(cli); err != nil {
@@ -260,16 +257,6 @@ func (cli *DockerCli) Initialize(opts *cliflags.ClientOptions, ops ...CLIOption)
 		},
 	}

-	if cli.contextResolver != nil {
-		contextName, err := cli.contextResolver(cli)
-		if err != nil {
-			return err
-		}
-		if contextName != "" {
-			cli.currentContext = contextName
-		}
-	}
-
 	// TODO(krissetto): pass ctx to the funcs instead of using this
 	if cli.enableGlobalMeter {
 		cli.createGlobalMeterProvider(cli.baseCtx)
@@ -84,19 +84,6 @@ func WithDefaultContextStoreConfig() CLIOption {
 	}
 }

-// WithContextResolver overrides context selection during [DockerCli.Initialize].
-// The resolver runs after configuration and the context store are loaded, but
-// before telemetry and endpoint initialization.
-// An empty result preserves normal context selection; an error aborts
-// initialization.
-// The resolver must not initialize the API client.
-func WithContextResolver(resolve func(*DockerCli) (string, error)) CLIOption {
-	return func(cli *DockerCli) error {
-		cli.contextResolver = resolve
-		return nil
-	}
-}
-
 // WithAPIClient configures the cli to use the given API client.
 func WithAPIClient(c client.APIClient) CLIOption {
 	return func(cli *DockerCli) error {
@@ -325,64 +325,6 @@ func TestInitializeShouldAlwaysCreateTheContextStore(t *testing.T) {
 	assert.Check(t, cli.ContextStore() != nil)
 }

-func TestInitializeContextResolver(t *testing.T) {
-	resolverErr := errors.New("resolver failed")
-
-	for _, tc := range []struct {
-		name    string
-		context string
-		err     error
-	}{
-		{name: "resolved context", context: "resolved"},
-		{name: "normal selection"},
-		{name: "resolver failure", err: resolverErr},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			originalConfigDir := config.Dir()
-			t.Cleanup(func() { config.SetDir(originalConfigDir) })
-			config.SetDir(t.TempDir())
-
-			configDir := t.TempDir()
-			cfg := configfile.New(filepath.Join(configDir, config.ConfigFileName))
-			cfg.Features = map[string]string{"cloud": "foobar"}
-			assert.NilError(t, cfg.Save())
-
-			cli, err := NewDockerCli()
-			assert.NilError(t, err)
-
-			var loadedConfig *configfile.ConfigFile
-			calls := 0
-
-			err = cli.Initialize(&flags.ClientOptions{ConfigDir: configDir, Context: "original"},
-				WithContextResolver(func(cli *DockerCli) (string, error) {
-					calls++
-					assert.Equal(t, config.Dir(), configDir)
-					loadedConfig = cli.ConfigFile()
-					assert.Equal(t, loadedConfig.Features["cloud"], "foobar")
-					assert.Assert(t, cli.ContextStore() != nil)
-					assert.Assert(t, cli.client == nil)
-					return tc.context, tc.err
-				}),
-			)
-			assert.Equal(t, calls, 1)
-			assert.Assert(t, cli.ConfigFile() == loadedConfig)
-			assert.Assert(t, cli.client == nil)
-
-			if tc.err != nil {
-				assert.ErrorIs(t, err, tc.err)
-				return
-			}
-			assert.NilError(t, err)
-
-			wantContext := tc.context
-			if wantContext == "" {
-				wantContext = "original"
-			}
-			assert.Equal(t, cli.CurrentContext(), wantContext)
-		})
-	}
-}
-
 func TestHooksEnabled(t *testing.T) {
 	t.Run("disabled by default", func(t *testing.T) {
 		// Make sure we don't depend on any existing ~/.docker/config.json
@@ -1,256 +0,0 @@
-package main
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"os"
-	"os/exec"
-	"strconv"
-	"strings"
-
-	"github.com/docker/cli/cli"
-	pluginmanager "github.com/docker/cli/cli-plugins/manager"
-	"github.com/docker/cli/cli-plugins/metadata"
-	"github.com/docker/cli/cli/command"
-	"github.com/docker/cli/cli/config"
-	contextdocker "github.com/docker/cli/cli/context/docker"
-	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
-)
-
-// processCloud resolves the global --cloud[=NAME] option after configuration is
-// loaded, but before telemetry and endpoint initialization.
-// The option appears in help and completion only when the selected provider is
-// installed, valid, and declares support for the resolver contract.
-// The provider defaults to the offload plugin; features.cloud in the effective
-// Docker config.json can override the plugin name, not its executable path.
-// Explicit use also requires the provider's capability declaration.
-// Discovery for visibility does not provision a context or connect to a daemon.
-//
-// # Provider contract
-//
-// The provider must include "Features": {"cloud-context-resolver": true} in its
-// docker-cli-plugin-metadata response to declare support for this contract.
-// Older plugins without this declaration leave the flag hidden and cannot be
-// used for resolution.
-// The CLI uses normal plugin discovery and invokes:
-//
-//	docker-<provider> --config=<dir> <provider> __resolve-context -- <name>
-//
-// Bare --cloud and --cloud= pass default as the target name.
-// The effective config directory is also passed as DOCKER_CONFIG.
-// The provider must provision into that context store without changing the saved
-// current context or recursively forwarding --cloud.
-// It inherits the environment, receives no interactive stdin, and sends progress
-// to stderr.
-// Stdout must contain exactly one JSON object:
-//
-//	{"DOCKER_CONTEXT":"provisioned-context"}
-//
-// The returned context must exist, must not be the virtual default context, and
-// must have a Docker endpoint with a nonempty host.
-// Resolver failures abort command execution without falling back to another
-// context.
-// Cancellation terminates the resolver process; provisioning subprocesses and
-// resource cleanup remain the provider's responsibility.
-// Downstream plugins receive --context=<resolved-name> instead of the global
-// --cloud option.
-// The provider implementation ships separately and must support this operation
-// before enabling the integration.
-func processCloud(ctx context.Context, dockerCli *command.DockerCli, cmd *cobra.Command, args, osArgs []string) ([]string, error) {
-	if !cmd.Flags().Changed("cloud") {
-		return osArgs, nil
-	}
-	if cmd.Flags().Changed("context") || cmd.Flags().Changed("host") {
-		return osArgs, errors.New("conflicting options: cannot specify --cloud together with --context or --host")
-	}
-
-	help, err := cloudHelpRequest(cmd, args)
-	if err != nil {
-		return osArgs, err
-	}
-
-	var contextName string
-	if !help {
-		name, _ := cmd.Flags().GetString("cloud")
-		if name == "" {
-			name = "default"
-		}
-
-		contextName, err = resolveCloudContext(ctx, dockerCli, cmd, name)
-		if err != nil {
-			return osArgs, fmt.Errorf("--cloud: %w", err)
-		}
-		if err := cmd.Flags().Set("context", contextName); err != nil {
-			return osArgs, err
-		}
-	}
-
-	return cloudPluginArgs(cmd, osArgs, contextName)
-}
-
-// cloudResolverFeature is the plugin metadata feature that declares support for
-// the __resolve-context contract.
-const cloudResolverFeature = "cloud-context-resolver"
-
-func cloudProvider(dockerCli config.Provider, rootCmd *cobra.Command) (*pluginmanager.Plugin, error) {
-	provider := dockerCli.ConfigFile().Features["cloud"]
-	if provider == "" {
-		provider = "offload"
-	}
-
-	plugin, err := pluginmanager.GetPlugin(provider, dockerCli, rootCmd)
-	if err != nil {
-		return nil, fmt.Errorf("cloud resolver plugin %q unavailable: %w", provider, err)
-	}
-	if plugin.Err != nil {
-		return nil, fmt.Errorf("invalid cloud resolver plugin %q: %w", provider, plugin.Err)
-	}
-
-	if supported, _ := plugin.Features[cloudResolverFeature].(bool); !supported {
-		return nil, fmt.Errorf("plugin %q does not support cloud context resolution", provider)
-	}
-
-	return plugin, nil
-}
-
-// updateCloudFlagVisibility runs only for help and completion, avoiding plugin
-// discovery on ordinary invocations that do not use --cloud.
-func updateCloudFlagVisibility(dockerCli config.Provider, rootCmd *cobra.Command) {
-	flag := rootCmd.Flags().Lookup("cloud")
-	if flag == nil {
-		return
-	}
-	_, err := cloudProvider(dockerCli, rootCmd)
-	flag.Hidden = err != nil
-}
-
-func resolveCloudContext(ctx context.Context, dockerCli *command.DockerCli, rootCmd *cobra.Command, name string) (string, error) {
-	if err := ctx.Err(); err != nil {
-		return "", err
-	}
-
-	plugin, err := cloudProvider(dockerCli, rootCmd)
-	if err != nil {
-		return "", err
-	}
-
-	cmd := exec.CommandContext(ctx, plugin.Path, "--config="+config.Dir(), plugin.Name, "__resolve-context", "--", name) // #nosec G204 -- executable validated through CLI plugin discovery
-	cmd.Env = append(os.Environ(), config.EnvOverrideConfigDir+"="+config.Dir(), metadata.ReexecEnvvar+"="+os.Args[0])
-	cmd.Stderr = dockerCli.Err()
-
-	out, err := cmd.Output()
-	if err != nil {
-		if ctx.Err() != nil {
-			return "", ctx.Err()
-		}
-		return "", fmt.Errorf("cloud resolver failed: %w", err)
-	}
-
-	var response struct {
-		DockerContext string `json:"DOCKER_CONTEXT"`
-	}
-	if err := json.Unmarshal(out, &response); err != nil {
-		return "", fmt.Errorf("invalid cloud resolver response: %w", err)
-	}
-	response.DockerContext = strings.TrimSpace(response.DockerContext)
-	if response.DockerContext == "" || response.DockerContext == command.DefaultContextName {
-		return "", errors.New("cloud resolver must return a non-default DOCKER_CONTEXT")
-	}
-
-	// Do not allow a missing context or endpoint to fall back to the local engine.
-	meta, err := dockerCli.ContextStore().GetMetadata(response.DockerContext)
-	if err != nil {
-		return "", fmt.Errorf("loading resolved context %q: %w", response.DockerContext, err)
-	}
-
-	endpoint, err := contextdocker.EndpointFromContext(meta)
-	if err != nil {
-		return "", fmt.Errorf("invalid resolved context %q: %w", response.DockerContext, err)
-	}
-	if endpoint.Host == "" {
-		return "", fmt.Errorf("resolved context %q has no Docker endpoint host", response.DockerContext)
-	}
-
-	return response.DockerContext, nil
-}
-
-// cloudHelpRequest avoids provisioning for help and shell completion.
-// Parse known command flags rather than scanning argv: --help may be an option
-// value or an argument to a container, not a request for Docker help.
-// Unknown flags and missing flag values return a usage error, so a mistyped
-// invocation fails without provisioning or falling back to the local engine.
-// Flag values are validated only by the command's own parse, after resolution.
-func cloudHelpRequest(rootCmd *cobra.Command, args []string) (bool, error) {
-	help, _ := rootCmd.PersistentFlags().GetBool("help")
-	version, _ := rootCmd.Flags().GetBool("version")
-	if help || version || len(args) == 0 {
-		return true, nil
-	}
-
-	switch args[0] {
-	case "help", "completion", cobra.ShellCompRequestCmd, cobra.ShellCompNoDescRequestCmd:
-		return true, nil
-	}
-
-	cmd, remaining, err := rootCmd.Find(args)
-	if err != nil || cmd == rootCmd || pluginmanager.IsPluginCommand(cmd) {
-		// Plugin flags are opaque. Only recognize help immediately after the
-		// plugin name; deeper help is available through "docker help PLUGIN".
-		return len(args) > 1 && (args[1] == "--help" || args[1] == "-h" || args[1] == "--help=true"), nil
-	}
-
-	cmd.InitDefaultHelpFlag()
-	flags := cmd.Flags()
-	flags.AddFlagSet(cmd.PersistentFlags())
-	flags.AddFlagSet(cmd.InheritedFlags())
-
-	err = flags.ParseAll(remaining, func(flag *pflag.Flag, value string) error {
-		if flag.Name == "help" {
-			var err error
-			if help, err = strconv.ParseBool(value); err != nil {
-				return fmt.Errorf("invalid argument %q for \"--help\" flag: %w", value, err)
-			}
-		}
-		return nil
-	})
-	if err != nil {
-		// Format the usage error directly. The root command's FlagErrorFunc
-		// first checks whether the daemon supports the command, which would
-		// connect to the engine selected before --cloud is resolved.
-		return false, cli.FlagErrorFunc(cmd, err)
-	}
-
-	return help, nil
-}
-
-// cloudPluginArgs only rewrites the global prefix, leaving subcommand arguments
-// untouched. Parsing also distinguishes --cloud from another flag's value.
-func cloudPluginArgs(cmd *cobra.Command, osArgs []string, contextName string) ([]string, error) {
-	flags := pflag.NewFlagSet(cmd.Name(), pflag.ContinueOnError)
-	flags.SetInterspersed(false)
-	flags.AddFlagSet(cmd.Flags())
-	flags.AddFlagSet(cmd.PersistentFlags())
-
-	result := []string{osArgs[0]}
-	if contextName != "" {
-		result = append(result, "--context="+contextName)
-	}
-
-	if err := flags.ParseAll(osArgs[1:], func(flag *pflag.Flag, value string) error {
-		if flag.Name != "cloud" {
-			result = append(result, "--"+flag.Name+"="+value)
-		}
-		return nil
-	}); err != nil {
-		return osArgs, err
-	}
-
-	if flags.ArgsLenAtDash() >= 0 {
-		result = append(result, "--")
-	}
-
-	return append(result, flags.Args()...), nil
-}
@@ -1,542 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"sync/atomic"
-	"testing"
-	"time"
-
-	"github.com/docker/cli/cli-plugins/metadata"
-	"github.com/docker/cli/cli/command"
-	"github.com/docker/cli/cli/config"
-	"github.com/docker/cli/cli/config/configfile"
-	contextdocker "github.com/docker/cli/cli/context/docker"
-	"github.com/docker/cli/cli/context/store"
-	"gotest.tools/v3/assert"
-	is "gotest.tools/v3/assert/cmp"
-)
-
-func TestCloudFlagHidden(t *testing.T) {
-	dockerCli, err := command.NewDockerCli()
-	assert.NilError(t, err)
-
-	tcmd := newDockerCommand(dockerCli)
-	tcmd.SetArgs([]string{"--cloud=team", "--help"})
-	cmd, _, err := tcmd.HandleGlobalFlags()
-	assert.NilError(t, err)
-
-	name, err := cmd.Flags().GetString("cloud")
-	assert.NilError(t, err)
-	assert.Equal(t, name, "team")
-	assert.Assert(t, cmd.Flags().Lookup("cloud").Hidden)
-	assert.Assert(t, !strings.Contains(cmd.UsageString(), "--cloud"))
-}
-
-func TestCloudHelpRequest(t *testing.T) {
-	for _, tc := range []struct {
-		name string
-		args []string
-		help bool
-	}{
-		{name: "no command", help: true},
-		{name: "global help", args: []string{"--help"}, help: true},
-		{name: "global version", args: []string{"--version"}, help: true},
-		{name: "help command", args: []string{"help", "run"}, help: true},
-		{name: "completion request", args: []string{"__complete", "run", ""}, help: true},
-		{name: "completion script", args: []string{"completion", "fish"}, help: true},
-		{name: "builtin help", args: []string{"run", "--help"}, help: true},
-		{name: "boolean help value", args: []string{"run", "--help=1"}, help: true},
-		{name: "nested help", args: []string{"container", "run", "--help"}, help: true},
-		{name: "plugin help", args: []string{"compose", "--help"}, help: true},
-		{name: "command execution", args: []string{"ps"}},
-		{name: "container help", args: []string{"run", "alpine", "--help"}},
-		{name: "flag value", args: []string{"run", "--name", "--help", "alpine"}},
-		{name: "help disabled", args: []string{"run", "--help=false", "alpine"}},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			dockerCli, err := command.NewDockerCli()
-			assert.NilError(t, err)
-			tcmd := newDockerCommand(dockerCli)
-			tcmd.SetArgs(append([]string{"--cloud"}, tc.args...))
-			cmd, args, err := tcmd.HandleGlobalFlags()
-			assert.NilError(t, err)
-
-			help, err := cloudHelpRequest(cmd, args)
-			assert.NilError(t, err)
-			assert.Equal(t, help, tc.help)
-		})
-	}
-}
-
-// Flag errors are reported before cloud resolution, so they must not run the
-// command's daemon feature checks against the engine selected before it.
-func TestCloudFlagErrorSkipsDaemon(t *testing.T) {
-	originalConfig := config.Dir()
-	t.Cleanup(func() { config.SetDir(originalConfig) })
-	config.SetDir(t.TempDir())
-
-	var pings atomic.Int32
-	daemon := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		pings.Add(1)
-		w.Header().Set("Docker-Experimental", "false")
-	}))
-	defer daemon.Close()
-	t.Setenv("DOCKER_HOST", "tcp://"+daemon.Listener.Addr().String())
-
-	dockerCli, err := command.NewDockerCli()
-	assert.NilError(t, err)
-	tcmd := newDockerCommand(dockerCli)
-	tcmd.SetArgs([]string{"--cloud", "checkpoint", "ls", "--unknown"})
-	cmd, args, err := tcmd.HandleGlobalFlags()
-	assert.NilError(t, err)
-	assert.NilError(t, tcmd.Initialize())
-
-	_, err = cloudHelpRequest(cmd, args)
-	assert.Check(t, is.ErrorContains(err, "unknown flag: --unknown"))
-	assert.Check(t, is.Equal(pings.Load(), int32(0)))
-}
-
-func TestCloudPluginArgs(t *testing.T) {
-	for _, tc := range []struct {
-		name    string
-		args    []string
-		context string
-		want    []string
-	}{
-		{
-			name:    "global flag only",
-			args:    []string{"docker", "--cloud=foo", "compose", "up", "--cloud=child"},
-			context: "cloud-foo",
-			want:    []string{"docker", "--context=cloud-foo", "compose", "up", "--cloud=child"},
-		},
-		{
-			name:    "flag value is not cloud flag",
-			args:    []string{"docker", "--config", "--cloud", "--cloud", "-D", "compose", "up"},
-			context: "cloud-default",
-			want:    []string{"docker", "--context=cloud-default", "--config=--cloud", "--debug=true", "compose", "up"},
-		},
-		{
-			name:    "delimiter preserved",
-			args:    []string{"docker", "--cloud=foo", "--", "compose", "--", "--cloud"},
-			context: "cloud-foo",
-			want:    []string{"docker", "--context=cloud-foo", "--", "compose", "--", "--cloud"},
-		},
-		{
-			name:    "repeated cloud flags",
-			args:    []string{"docker", "--cloud=foo", "--cloud=bar", "compose", "up"},
-			context: "cloud-bar",
-			want:    []string{"docker", "--context=cloud-bar", "compose", "up"},
-		},
-		{
-			name: "help without resolution",
-			args: []string{"docker", "--cloud", "compose", "--help"},
-			want: []string{"docker", "compose", "--help"},
-		},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			dockerCli, err := command.NewDockerCli()
-			assert.NilError(t, err)
-			tcmd := newDockerCommand(dockerCli)
-			tcmd.SetArgs(tc.args[1:])
-			cmd, _, err := tcmd.HandleGlobalFlags()
-			assert.NilError(t, err)
-
-			got, err := cloudPluginArgs(cmd, tc.args, tc.context)
-			assert.NilError(t, err)
-			assert.DeepEqual(t, got, tc.want)
-		})
-	}
-}
-
-// Exercise the real startup and subprocess boundary without a daemon or cloud
-// service, including failures that must never dispatch the requested command.
-func TestCloudResolution(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("fixture plugins use shell scripts")
-	}
-
-	executable, err := os.Executable()
-	assert.NilError(t, err)
-
-	for _, tc := range []struct {
-		name           string
-		args           []string
-		response       string
-		exit           int
-		wantName       string
-		wantErr        string
-		plugin         bool
-		skip           bool
-		provider       string
-		noProvider     bool
-		legacyProvider bool
-		command        []string
-		visible        bool
-	}{
-		{
-			name:     "default target",
-			args:     []string{"--cloud"},
-			wantName: "default",
-		},
-		{
-			name:     "empty target",
-			args:     []string{"--cloud="},
-			wantName: "default",
-		},
-		{
-			name:     "named target",
-			args:     []string{"--cloud=team"},
-			wantName: "team",
-		},
-		{
-			name:     "plugin dispatch",
-			args:     []string{"--cloud=team"},
-			wantName: "team",
-			plugin:   true,
-		},
-		{
-			name:    "nonzero exit",
-			args:    []string{"--cloud"},
-			exit:    1,
-			wantErr: "cloud resolver failed",
-		},
-		{
-			name:     "malformed JSON",
-			args:     []string{"--cloud"},
-			response: "not JSON",
-			wantErr:  "invalid cloud resolver response",
-		},
-		{
-			name:     "multiple responses",
-			args:     []string{"--cloud"},
-			response: `{} {}`,
-			wantErr:  "invalid cloud resolver response",
-		},
-		{
-			name:     "missing field",
-			args:     []string{"--cloud"},
-			response: `{}`,
-			wantErr:  "must return a non-default DOCKER_CONTEXT",
-		},
-		{
-			name:     "local context",
-			args:     []string{"--cloud"},
-			response: `{"DOCKER_CONTEXT":"default"}`,
-			wantErr:  "must return a non-default DOCKER_CONTEXT",
-		},
-		{
-			name:     "missing context",
-			args:     []string{"--cloud"},
-			response: `{"DOCKER_CONTEXT":"missing"}`,
-			wantErr:  `loading resolved context "missing"`,
-		},
-		{
-			name:     "missing endpoint host",
-			args:     []string{"--cloud"},
-			response: `{"DOCKER_CONTEXT":"empty-host"}`,
-			wantErr:  "has no Docker endpoint host",
-		},
-		{
-			name:    "explicit context conflict",
-			args:    []string{"--cloud", "--context=other"},
-			wantErr: "conflicting options",
-			skip:    true,
-		},
-		{
-			name:    "explicit host conflict",
-			args:    []string{"--cloud", "--host=tcp://localhost:2375"},
-			wantErr: "conflicting options",
-			skip:    true,
-		},
-		{
-			name:    "invalid flag before help",
-			args:    []string{"--cloud"},
-			command: []string{"run", "--unknown", "--help"},
-			wantErr: "unknown flag: --unknown",
-			skip:    true,
-		},
-		{
-			name:       "default provider",
-			args:       []string{"--cloud"},
-			noProvider: true,
-			wantName:   "default",
-		},
-		{
-			name:           "legacy default provider",
-			args:           []string{"--cloud"},
-			noProvider:     true,
-			legacyProvider: true,
-			wantErr:        `plugin "offload" does not support cloud context resolution`,
-			skip:           true,
-		},
-		{
-			name:           "legacy configured provider",
-			args:           []string{"--cloud"},
-			legacyProvider: true,
-			wantErr:        `plugin "foobar" does not support cloud context resolution`,
-			skip:           true,
-		},
-		{
-			name:     "configured provider unavailable",
-			args:     []string{"--cloud"},
-			provider: "missing",
-			wantErr:  `cloud resolver plugin "missing" unavailable`,
-			skip:     true,
-		},
-		{
-			name:     "provider cannot be a path",
-			args:     []string{"--cloud"},
-			provider: "../foobar",
-			wantErr:  `cloud resolver plugin "../foobar" unavailable`,
-			skip:     true,
-		},
-		{
-			name:       "no cloud option",
-			noProvider: true,
-			skip:       true,
-		},
-		{
-			name:       "help",
-			args:       []string{"--cloud", "--help"},
-			noProvider: true,
-			skip:       true,
-		},
-		{
-			name:       "version",
-			args:       []string{"--cloud", "--version"},
-			noProvider: true,
-			skip:       true,
-		},
-		{
-			name:       "help exposes supported provider",
-			command:    []string{"--help"},
-			noProvider: true,
-			visible:    true,
-			skip:       true,
-		},
-		{
-			name:           "help hides legacy provider",
-			command:        []string{"--help"},
-			noProvider:     true,
-			legacyProvider: true,
-			skip:           true,
-		},
-		{
-			name:     "help hides missing provider",
-			command:  []string{"--help"},
-			provider: "missing",
-			skip:     true,
-		},
-		{
-			name:       "completion exposes supported provider",
-			command:    []string{"__complete", "--cl"},
-			noProvider: true,
-			visible:    true,
-			skip:       true,
-		},
-		{
-			name:           "completion hides legacy provider",
-			command:        []string{"__complete", "--cl"},
-			noProvider:     true,
-			legacyProvider: true,
-			skip:           true,
-		},
-		{
-			name:     "completion hides missing provider",
-			command:  []string{"__complete", "--cl"},
-			provider: "missing",
-			skip:     true,
-		},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			// Explicit --cloud must override inherited endpoint selection.
-			t.Setenv("DOCKER_CONTEXT", "inherited")
-			t.Setenv("DOCKER_HOST", "tcp://127.0.0.1:1")
-			t.Setenv("DOCKER_CLI_HOOKS", "false")
-			t.Setenv("DOCKER_CONFIG", t.TempDir())
-
-			configDir := t.TempDir()
-			installedProvider := "offload"
-			if !tc.noProvider {
-				installedProvider = "foobar"
-				cfg := configfile.New(filepath.Join(configDir, config.ConfigFileName))
-				provider := tc.provider
-				if provider == "" {
-					provider = "foobar"
-				}
-				cfg.Features = map[string]string{"cloud": provider}
-				assert.NilError(t, cfg.Save())
-			}
-
-			pluginDir := filepath.Join(configDir, "cli-plugins")
-			assert.NilError(t, os.MkdirAll(pluginDir, 0o755))
-
-			response := tc.response
-			if response == "" {
-				response = `{"DOCKER_CONTEXT":"resolved"}`
-			}
-
-			providerMetadata := metadata.Metadata{SchemaVersion: "0.1.0", Vendor: "test"}
-			if !tc.legacyProvider {
-				providerMetadata.Features = map[string]any{cloudResolverFeature: true}
-			}
-			pluginMetadata, err := json.Marshal(providerMetadata)
-			assert.NilError(t, err)
-
-			script := fmt.Sprintf(`#!/bin/sh
-if [ "$1" = docker-cli-plugin-metadata ]; then
-    echo '%s'
-    exit 0
-fi
-printf '%%s\n' "$@" >> "$DOCKER_CONFIG/resolver-args"
-echo provisioning >&2
-printf '%%s\n' '%s'
-exit %d
-`, pluginMetadata, response, tc.exit)
-			assert.NilError(t, os.WriteFile(filepath.Join(pluginDir, "docker-"+installedProvider), []byte(script), 0o755))
-			assert.NilError(t, os.WriteFile(filepath.Join(pluginDir, "docker-cloudtest"), []byte(`#!/bin/sh
-if [ "$1" = docker-cli-plugin-metadata ]; then
-    echo '{"SchemaVersion":"0.1.0","Vendor":"test"}'
-    exit 0
-fi
-printf '%s\n' "$@" > "$CLOUD_TEST_ARGS"
-`), 0o755))
-
-			dispatchFile := filepath.Join(configDir, "dispatch-args")
-			t.Setenv("CLOUD_TEST_ARGS", dispatchFile)
-
-			contextStore := store.New(filepath.Join(configDir, "contexts"), command.DefaultContextStoreConfig())
-			assert.NilError(t, contextStore.CreateOrUpdate(store.Metadata{
-				Name:      "resolved",
-				Endpoints: map[string]any{contextdocker.DockerEndpoint: contextdocker.EndpointMeta{Host: "tcp://127.0.0.1:1"}},
-			}))
-			assert.NilError(t, contextStore.CreateOrUpdate(store.Metadata{
-				Name:      "empty-host",
-				Endpoints: map[string]any{contextdocker.DockerEndpoint: contextdocker.EndpointMeta{}},
-			}))
-
-			args := append([]string{"docker", "--config=" + configDir}, tc.args...)
-			switch {
-			case tc.command != nil:
-				args = append(args, tc.command...)
-			case tc.plugin || tc.wantErr != "":
-				args = append(args, "cloudtest", "up", "--cloud=child")
-			default:
-				args = append(args, "context", "show")
-			}
-
-			payload, err := json.Marshal(args)
-			assert.NilError(t, err)
-
-			var stdout, stderr bytes.Buffer
-			cmd := exec.CommandContext(t.Context(), executable, "-test.run=^TestCloudCommandProcess$")
-			cmd.Env = append(os.Environ(), "CLOUD_TEST_COMMAND="+string(payload))
-			cmd.Stdout = &stdout
-			cmd.Stderr = &stderr
-
-			err = cmd.Run()
-			if tc.wantErr != "" {
-				assert.Assert(t, err != nil)
-				assert.Check(t, is.Contains(stderr.String(), tc.wantErr))
-				_, statErr := os.Stat(dispatchFile)
-				assert.Assert(t, os.IsNotExist(statErr))
-				assert.Equal(t, stdout.String(), "")
-			} else {
-				assert.NilError(t, err, stderr.String())
-				if tc.command != nil {
-					assert.Equal(t, strings.Contains(stdout.String(), "--cloud"), tc.visible, stdout.String())
-				}
-				if !tc.skip {
-					if tc.plugin {
-						args, err := os.ReadFile(dispatchFile)
-						assert.NilError(t, err)
-						assert.Equal(t, string(args), "--context=resolved\n--config="+configDir+"\ncloudtest\nup\n--cloud=child\n")
-					} else {
-						assert.Equal(t, stdout.String(), "resolved\n")
-					}
-				}
-			}
-
-			invocation, err := os.ReadFile(filepath.Join(configDir, "resolver-args"))
-			if tc.skip {
-				assert.Assert(t, os.IsNotExist(err))
-			} else {
-				assert.NilError(t, err)
-				assert.Check(t, is.Contains(stderr.String(), "provisioning"))
-				name := tc.wantName
-				if name == "" {
-					name = "default"
-				}
-				assert.Equal(t, string(invocation), "--config="+configDir+"\n"+installedProvider+"\n__resolve-context\n--\n"+name+"\n")
-			}
-		})
-	}
-}
-
-// Run startup in a separate process because it installs process-wide signal
-// handlers that intentionally outlive an individual command.
-func TestCloudCommandProcess(t *testing.T) {
-	payload := os.Getenv("CLOUD_TEST_COMMAND")
-	if payload == "" {
-		return
-	}
-
-	assert.NilError(t, json.Unmarshal([]byte(payload), &os.Args))
-
-	err := dockerMain(context.Background())
-	if err != nil {
-		_, _ = fmt.Fprintln(os.Stderr, err)
-	}
-	if err == nil {
-		os.Exit(0)
-	}
-
-	os.Exit(getExitCode(err))
-}
-
-func TestCloudResolutionCancellation(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("fixture plugin uses a shell script")
-	}
-
-	originalConfig := config.Dir()
-	t.Cleanup(func() { config.SetDir(originalConfig) })
-	config.SetDir(t.TempDir())
-
-	cfg := configfile.New(filepath.Join(config.Dir(), config.ConfigFileName))
-	cfg.Features = map[string]string{"cloud": "foobar"}
-	assert.NilError(t, cfg.Save())
-
-	pluginDir := filepath.Join(config.Dir(), "cli-plugins")
-	assert.NilError(t, os.MkdirAll(pluginDir, 0o755))
-	assert.NilError(t, os.WriteFile(filepath.Join(pluginDir, "docker-foobar"), []byte(`#!/bin/sh
-if [ "$1" = docker-cli-plugin-metadata ]; then
-    echo '{"SchemaVersion":"0.1.0","Vendor":"test","Features":{"cloud-context-resolver":true}}'
-    exit 0
-fi
-exec sleep 30
-`), 0o755))
-
-	dockerCli, err := command.NewDockerCli()
-	assert.NilError(t, err)
-	tcmd := newDockerCommand(dockerCli)
-	tcmd.SetArgs(strings.Fields("--cloud context show"))
-	cmd, _, err := tcmd.HandleGlobalFlags()
-	assert.NilError(t, err)
-
-	ctx, cancel := context.WithTimeout(t.Context(), time.Second)
-	defer cancel()
-
-	_, err = resolveCloudContext(ctx, dockerCli, cmd, "default")
-	assert.ErrorIs(t, err, context.DeadlineExceeded)
-}
@@ -178,9 +178,6 @@ func newDockerCommand(dockerCli *command.DockerCli) *cli.TopLevelCommand {
 	_ = cmd.RegisterFlagCompletionFunc("log-level", completeLogLevels)

 	cmd.Flags().BoolP("version", "v", false, "Print version information and quit")
-	cmd.Flags().String("cloud", "", "Use a cloud context, provisioning it if necessary (optionally --cloud=NAME)")
-	cmd.Flags().Lookup("cloud").NoOptDefVal = "default"
-	cmd.Flags().Lookup("cloud").Hidden = true
 	setFlagErrorFunc(dockerCli, cmd)

 	setupHelpCommand(dockerCli, cmd, helpCmd)
@@ -253,7 +250,6 @@ func setHelpFunc(dockerCli command.Cli, cmd *cobra.Command) {
 			ccmd.Println(err)
 			return
 		}
-		updateCloudFlagVisibility(dockerCli, ccmd.Root())

 		if len(args) >= 1 {
 			err := tryRunPluginHelp(dockerCli, ccmd, args)
@@ -512,18 +508,7 @@ func runDocker(ctx context.Context, dockerCli *command.DockerCli) error {
 		return err
 	}

-	if err := tcmd.Initialize(
-		command.WithEnableGlobalMeterProvider(),
-		command.WithEnableGlobalTracerProvider(),
-		command.WithContextResolver(func(cli *command.DockerCli) (string, error) {
-			var err error
-			os.Args, err = processCloud(ctx, cli, cmd, args, os.Args)
-			if err != nil {
-				return "", err
-			}
-			return cmd.Flags().GetString("context")
-		}),
-	); err != nil {
+	if err := tcmd.Initialize(command.WithEnableGlobalMeterProvider(), command.WithEnableGlobalTracerProvider()); err != nil {
 		return err
 	}

@@ -553,7 +538,6 @@ func runDocker(ctx context.Context, dockerCli *command.DockerCli) error {
 		if err := pluginmanager.AddPluginCommandStubs(dockerCli, cmd); err != nil {
 			return err
 		}
-		updateCloudFlagVisibility(dockerCli, cmd)
 	}

 	var subCommand *cobra.Command
@@ -15,7 +15,7 @@ require (
 	dario.cat/mergo v1.0.2
 	github.com/containerd/errdefs v1.0.0
 	github.com/containerd/errdefs/pkg v0.3.0
-	github.com/containerd/log v0.2.0
+	github.com/containerd/log v0.1.0
 	github.com/containerd/platforms v1.0.0-rc.5
 	github.com/creack/pty v1.1.24
 	github.com/distribution/reference v0.6.0
@@ -33,8 +33,8 @@ require (
 	github.com/google/uuid v1.6.0
 	github.com/mattn/go-runewidth v0.0.29
 	github.com/moby/go-archive v0.3.3
-	github.com/moby/moby/api v1.56.1
-	github.com/moby/moby/client v0.6.1
+	github.com/moby/moby/api v1.56.0
+	github.com/moby/moby/client v0.6.0
 	github.com/moby/patternmatcher v0.6.1
 	github.com/moby/swarmkit/v2 v2.1.2
 	github.com/moby/sys/atomicwriter v0.1.0
@@ -70,8 +70,8 @@ require (
 )

 require (
-	github.com/Azure/go-ansiterm v0.0.0-20260917205352-e937bb47801a // indirect
-	github.com/Microsoft/go-winio v0.6.3-0.20260930231756-f19d9717deb0 // indirect; see https://github.com/microsoft/hcsshim/pull/2545
+	github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c // indirect
+	github.com/Microsoft/go-winio v0.6.2 // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/cenkalti/backoff/v5 v5.0.3 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
@@ -87,7 +87,7 @@ require (
 	github.com/gorilla/mux v1.8.1 // indirect
 	github.com/grpc-ecosystem/grpc-gateway/v2 v2.30.0 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
-	github.com/klauspost/compress v1.20.1 // indirect
+	github.com/klauspost/compress v1.19.2 // indirect
 	github.com/moby/docker-image-spec v1.3.1 // indirect
 	github.com/moby/sys/user v0.4.1 // indirect
 	github.com/moby/sys/userns v0.2.1 // indirect
@@ -2,10 +2,10 @@ dario.cat/mergo v1.0.2 h1:85+piFYR1tMbRrLcDwR18y4UKJ3aH1Tbzi24VRW1TK8=
 dario.cat/mergo v1.0.2/go.mod h1:E/hbnu0NxMFBjpMIE34DRGLWqDy0g5FuKDhCb31ngxA=
 github.com/AdaLogics/go-fuzz-headers v0.0.0-20240806141605-e8a1dd7889d6 h1:He8afgbRMd7mFxO99hRNu+6tazq8nFF9lIwo9JFroBk=
 github.com/AdaLogics/go-fuzz-headers v0.0.0-20240806141605-e8a1dd7889d6/go.mod h1:8o94RPi1/7XTJvwPpRSzSUedZrtlirdB3r9Z20bi2f8=
-github.com/Azure/go-ansiterm v0.0.0-20260917205352-e937bb47801a h1:4hxax9ktNjSDoFn1tZSeL6gXMTRMpO0FzjdKfT01jgY=
-github.com/Azure/go-ansiterm v0.0.0-20260917205352-e937bb47801a/go.mod h1:3EWSSOZ50kb+arhww0qIaEXHToib/3FjBj9Jj5lcP5g=
-github.com/Microsoft/go-winio v0.6.3-0.20260930231756-f19d9717deb0 h1:71VU8kW/LCxJkx41+YYys1EgQO+AUnPa1TrxTSyYUCU=
-github.com/Microsoft/go-winio v0.6.3-0.20260930231756-f19d9717deb0/go.mod h1:ma0QpxizD4fyyzJ1C7MIblymTD2Nxz5Mho/3CepwIZg=
+github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c h1:udKWzYgxTojEKWjV8V+WSxDXJ4NFATAsZjh8iIbsQIg=
+github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E=
+github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY=
+github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU=
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
 github.com/cenkalti/backoff/v5 v5.0.3 h1:ZN+IMa753KfX5hd8vVaMixjnqRZ3y8CuJKRKj1xcsSM=
@@ -18,8 +18,8 @@ github.com/containerd/errdefs v1.0.0 h1:tg5yIfIlQIrxYtu9ajqY42W3lpS19XqdxRQeEwYG
 github.com/containerd/errdefs v1.0.0/go.mod h1:+YBYIdtsnF4Iw6nWZhJcqGSg/dwvV7tyJ/kCkyJ2k+M=
 github.com/containerd/errdefs/pkg v0.3.0 h1:9IKJ06FvyNlexW690DXuQNx2KA2cUJXx151Xdx3ZPPE=
 github.com/containerd/errdefs/pkg v0.3.0/go.mod h1:NJw6s9HwNuRhnjJhM7pylWwMyAkmCQvQ4GpJHEqRLVk=
-github.com/containerd/log v0.2.0 h1:BewD/umNgVnoczglOpX8eRMyEy5t5iPlu5AIpnWDONc=
-github.com/containerd/log v0.2.0/go.mod h1:/M7L7CXKcPTfNC74XzaK+5H5KbO5+4lJVpuVI6vRLoM=
+github.com/containerd/log v0.1.0 h1:TCJt7ioM2cr/tfR8GPbGf9/VRAX8D2B4PjzCpfX540I=
+github.com/containerd/log v0.1.0/go.mod h1:VRRf09a7mHDIRezVKTRCrOq78v577GXq3bSa3EhrzVo=
 github.com/containerd/platforms v1.0.0-rc.5 h1:vXd569rDrz8LeMXzAnBsy6LADV5YtsD8oyaRarxdmSU=
 github.com/containerd/platforms v1.0.0-rc.5/go.mod h1:lKlMXyLybmBedS/JJm11uDofzI8L2v0J2ZbYvNsbq1A=
 github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
@@ -78,8 +78,8 @@ github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
 github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
-github.com/klauspost/compress v1.20.1 h1:T7kKElXUMXrUJ2E9QhQhxFtcK5rPyLdsGZvdbLMPdiQ=
-github.com/klauspost/compress v1.20.1/go.mod h1:LUdAzn7YLVvxLpc7y3V1m40wESHTgc1422pwwBSKYuI=
+github.com/klauspost/compress v1.19.2 h1:hMRETovs/pu/dVWN7zIT1PGG8t509MwT6bO7XSi26R8=
+github.com/klauspost/compress v1.19.2/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ=
 github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
 github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
 github.com/mattn/go-runewidth v0.0.29 h1:3oGF3R/S2N9DQ3ptftzVIvg2eicmojCzlwBEmqEPDfQ=
@@ -88,10 +88,10 @@ github.com/moby/docker-image-spec v1.3.1 h1:jMKff3w6PgbfSa69GfNg+zN/XLhfXJGnEx3N
 github.com/moby/docker-image-spec v1.3.1/go.mod h1:eKmb5VW8vQEh/BAr2yvVNvuiJuY6UIocYsFu/DxxRpo=
 github.com/moby/go-archive v0.3.3 h1:OxxR9paxsluYi+zDUEXTTaIxtkK3viymW+Ka7vRhhME=
 github.com/moby/go-archive v0.3.3/go.mod h1:Npdv43fFqlhZW7Xo8fbm3ZMYFvAGNviUPqX21VERbcE=
-github.com/moby/moby/api v1.56.1 h1:PpWkvVPB7Fr/No8w+TfyJ/I6rWZ2YPZhT3JorIg+06c=
-github.com/moby/moby/api v1.56.1/go.mod h1:sZ+THbVWkjOmBPPfbnzdD/G1LuIexWhqlSHHPTDQ1Uk=
-github.com/moby/moby/client v0.6.1 h1:gvfKmdcWw+9MzXYP0vAUKQtBTGu1L8475K2nsmL7O98=
-github.com/moby/moby/client v0.6.1/go.mod h1:XHgTFqz9NCgS/VuoxXMmEDVmVgXQ4vFEc15wsCIwb24=
+github.com/moby/moby/api v1.56.0 h1:GQzua3NA599ASSIICx0iFgiJeO9YkdDARvQsm23ZZuQ=
+github.com/moby/moby/api v1.56.0/go.mod h1:sZ+THbVWkjOmBPPfbnzdD/G1LuIexWhqlSHHPTDQ1Uk=
+github.com/moby/moby/client v0.6.0 h1:AJjEB21QPbXSXjDsZorFBoDZPhMrfbpaPLgSMAW9Bgs=
+github.com/moby/moby/client v0.6.0/go.mod h1:OCo00wNRyA3m4lmJ228W3JbyCN4ZNNYjpOXiJydBdcQ=
 github.com/moby/patternmatcher v0.6.1 h1:qlhtafmr6kgMIJjKJMDmMWq7WLkKIo23hsrpR3x084U=
 github.com/moby/patternmatcher v0.6.1/go.mod h1:hDPoyOpDY7OrrMDLaYoY3hf52gNCR/YOUYxkhApJIxc=
 github.com/moby/swarmkit/v2 v2.1.2 h1:1WDZAI6HVYNKdCG4zlXnTAPyLsLwuhRGWlHoOUf5Z6I=
@@ -203,7 +203,7 @@ golang.org/x/sync v0.23.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20220412211240-33da011f77ad/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.48.0 h1:bbX/i/6MgT9BVLM9RT1thmxL04yeTAhbEz4SyadbXoo=
 golang.org/x/sys v0.48.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
@@ -26,7 +26,7 @@ func (csiState csiEntryState) Handle(b byte) (s state, e error) {

 func (csiState csiEntryState) Transition(s state) error {
 	csiState.parser.logf("CsiEntry::Transition %s --> %s", csiState.Name(), s.Name())
-	_ = csiState.baseState.Transition(s)
+	csiState.baseState.Transition(s)

 	switch s {
 	case csiState.parser.ground:
@@ -34,9 +34,9 @@ func (csiState csiEntryState) Transition(s state) error {
 	case csiState.parser.csiParam:
 		switch {
 		case sliceContains(csiParams, csiState.parser.context.currentChar):
-			_ = csiState.parser.collectParam()
+			csiState.parser.collectParam()
 		case sliceContains(intermeds, csiState.parser.context.currentChar):
-			_ = csiState.parser.collectInter()
+			csiState.parser.collectInter()
 		}
 	}

@@ -16,7 +16,8 @@ func (csiState csiParamState) Handle(b byte) (s state, e error) {
 	case sliceContains(alphabetics, b):
 		return csiState.parser.ground, nil
 	case sliceContains(csiCollectables, b):
-		return csiState, csiState.parser.collectParam()
+		csiState.parser.collectParam()
+		return csiState, nil
 	case sliceContains(executors, b):
 		return csiState, csiState.parser.execute()
 	}
@@ -26,7 +27,7 @@ func (csiState csiParamState) Handle(b byte) (s state, e error) {

 func (csiState csiParamState) Transition(s state) error {
 	csiState.parser.logf("CsiParam::Transition %s --> %s", csiState.Name(), s.Name())
-	_ = csiState.baseState.Transition(s)
+	csiState.baseState.Transition(s)

 	switch s {
 	case csiState.parser.ground:
@@ -25,7 +25,7 @@ func (escState escapeIntermediateState) Handle(b byte) (s state, e error) {

 func (escState escapeIntermediateState) Transition(s state) error {
 	escState.parser.logf("escapeIntermediateState::Transition %s --> %s", escState.Name(), s.Name())
-	_ = escState.baseState.Transition(s)
+	escState.baseState.Transition(s)

 	switch s {
 	case escState.parser.ground:
@@ -29,7 +29,7 @@ func (escState escapeState) Handle(b byte) (s state, e error) {

 func (escState escapeState) Transition(s state) error {
 	escState.parser.logf("Escape::Transition %s --> %s", escState.Name(), s.Name())
-	_ = escState.baseState.Transition(s)
+	escState.baseState.Transition(s)

 	switch s {
 	case escState.parser.ground:
@@ -113,13 +113,16 @@ func (ap *AnsiParser) handle(b byte) error {

 	if newState == nil {
 		ap.logf("WARNING: newState is nil")
-		return errors.New("new state of 'nil' is invalid")
+		return errors.New("New state of 'nil' is invalid.")
 	}

-	if newState == ap.currState {
-		return nil
+	if newState != ap.currState {
+		if err := ap.changeState(newState); err != nil {
+			return err
+		}
 	}
-	return ap.changeState(newState)
+
+	return nil
 }

 func (ap *AnsiParser) changeState(newState state) error {
@@ -133,7 +136,7 @@ func (ap *AnsiParser) changeState(newState state) error {

 	// Perform transition action
 	if err := ap.currState.Transition(newState); err != nil {
-		ap.logf("Transition from '%s' to '%s' failed with: '%v'", ap.currState.Name(), newState.Name(), err)
+		ap.logf("Transition from '%s' to '%s' failed with: '%v'", ap.currState.Name(), newState.Name, err)
 		return err
 	}

@@ -4,9 +4,9 @@ import (
 	"strconv"
 )

-func parseParams(bytes []byte) []string {
-	var paramBuff []byte
-	var params []string
+func parseParams(bytes []byte) ([]string, error) {
+	paramBuff := make([]byte, 0, 0)
+	params := []string{}

 	for _, v := range bytes {
 		if v == ';' {
@@ -14,7 +14,7 @@ func parseParams(bytes []byte) []string {
 				// Completed parameter, append it to the list
 				s := string(paramBuff)
 				params = append(params, s)
-				paramBuff = paramBuff[:0]
+				paramBuff = make([]byte, 0, 0)
 			}
 		} else {
 			paramBuff = append(paramBuff, v)
@@ -27,7 +27,11 @@ func parseParams(bytes []byte) []string {
 		params = append(params, s)
 	}

-	return params
+	return params, nil
+}
+
+func parseCmd(context ansiContext) (string, error) {
+	return string(context.currentChar), nil
 }

 func getInt(params []string, dflt int) int {
@@ -15,9 +15,10 @@ func (ap *AnsiParser) collectInter() error {
 }

 func (ap *AnsiParser) escDispatch() error {
-	cmd := string(ap.context.currentChar)
+	cmd, _ := parseCmd(*ap.context)
+	intermeds := ap.context.interBuffer
 	ap.logf("escDispatch currentChar: %#x", ap.context.currentChar)
-	ap.logf("escDispatch: %s(%q)", cmd, string(ap.context.interBuffer))
+	ap.logf("escDispatch: %v(%v)", cmd, intermeds)

 	switch cmd {
 	case "D": // IND
@@ -30,14 +31,14 @@ func (ap *AnsiParser) escDispatch() error {
 		return err
 	case "M": // RI
 		return ap.eventHandler.RI()
-	default:
-		return nil
 	}
+
+	return nil
 }

 func (ap *AnsiParser) csiDispatch() error {
-	cmd := string(ap.context.currentChar)
-	params := parseParams(ap.context.paramBuffer)
+	cmd, _ := parseCmd(*ap.context)
+	params, _ := parseParams(ap.context.paramBuffer)
 	ap.logf("Parsed params: %v with length: %d", params, len(params))

 	ap.logf("csiDispatch: %v(%v)", cmd, params)
@@ -108,8 +109,9 @@ func (ap *AnsiParser) print() error {
 	return ap.eventHandler.Print(ap.context.currentChar)
 }

-func (ap *AnsiParser) clear() {
+func (ap *AnsiParser) clear() error {
 	ap.context = &ansiContext{}
+	return nil
 }

 func (ap *AnsiParser) execute() error {
@@ -1,5 +1,7 @@
 package ansiterm

+type stateID int
+
 type state interface {
 	Enter() error
 	Exit() error
@@ -1,5 +1,9 @@
 package ansiterm

+import (
+	"strconv"
+)
+
 func sliceContains(bytes []byte, b byte) bool {
 	for _, v := range bytes {
 		if v == b {
@@ -9,3 +13,9 @@ func sliceContains(bytes []byte, b byte) bool {

 	return false
 }
+
+func convertBytesToInteger(bytes []byte) int {
+	s := string(bytes)
+	i, _ := strconv.Atoi(s)
+	return i
+}
@@ -5,9 +5,12 @@ package winterm
 import (
 	"fmt"
 	"os"
+	"strconv"
+	"strings"
 	"syscall"

-	"golang.org/x/sys/windows"
+	"github.com/Azure/go-ansiterm"
+	windows "golang.org/x/sys/windows"
 )

 // Windows keyboard constants
@@ -52,6 +55,100 @@ const (
 	ENHANCED_KEY       = 0x0100
 )

+type ansiCommand struct {
+	CommandBytes []byte
+	Command      string
+	Parameters   []string
+	IsSpecial    bool
+}
+
+func newAnsiCommand(command []byte) *ansiCommand {
+
+	if isCharacterSelectionCmdChar(command[1]) {
+		// Is Character Set Selection commands
+		return &ansiCommand{
+			CommandBytes: command,
+			Command:      string(command),
+			IsSpecial:    true,
+		}
+	}
+
+	// last char is command character
+	lastCharIndex := len(command) - 1
+
+	ac := &ansiCommand{
+		CommandBytes: command,
+		Command:      string(command[lastCharIndex]),
+		IsSpecial:    false,
+	}
+
+	// more than a single escape
+	if lastCharIndex != 0 {
+		start := 1
+		// skip if double char escape sequence
+		if command[0] == ansiterm.ANSI_ESCAPE_PRIMARY && command[1] == ansiterm.ANSI_ESCAPE_SECONDARY {
+			start++
+		}
+		// convert this to GetNextParam method
+		ac.Parameters = strings.Split(string(command[start:lastCharIndex]), ansiterm.ANSI_PARAMETER_SEP)
+	}
+
+	return ac
+}
+
+func (ac *ansiCommand) paramAsSHORT(index int, defaultValue int16) int16 {
+	if index < 0 || index >= len(ac.Parameters) {
+		return defaultValue
+	}
+
+	param, err := strconv.ParseInt(ac.Parameters[index], 10, 16)
+	if err != nil {
+		return defaultValue
+	}
+
+	return int16(param)
+}
+
+func (ac *ansiCommand) String() string {
+	return fmt.Sprintf("0x%v \"%v\" (\"%v\")",
+		bytesToHex(ac.CommandBytes),
+		ac.Command,
+		strings.Join(ac.Parameters, "\",\""))
+}
+
+// isAnsiCommandChar returns true if the passed byte falls within the range of ANSI commands.
+// See http://manpages.ubuntu.com/manpages/intrepid/man4/console_codes.4.html.
+func isAnsiCommandChar(b byte) bool {
+	switch {
+	case ansiterm.ANSI_COMMAND_FIRST <= b && b <= ansiterm.ANSI_COMMAND_LAST && b != ansiterm.ANSI_ESCAPE_SECONDARY:
+		return true
+	case b == ansiterm.ANSI_CMD_G1 || b == ansiterm.ANSI_CMD_OSC || b == ansiterm.ANSI_CMD_DECPAM || b == ansiterm.ANSI_CMD_DECPNM:
+		// non-CSI escape sequence terminator
+		return true
+	case b == ansiterm.ANSI_CMD_STR_TERM || b == ansiterm.ANSI_BEL:
+		// String escape sequence terminator
+		return true
+	}
+	return false
+}
+
+func isXtermOscSequence(command []byte, current byte) bool {
+	return (len(command) >= 2 && command[0] == ansiterm.ANSI_ESCAPE_PRIMARY && command[1] == ansiterm.ANSI_CMD_OSC && current != ansiterm.ANSI_BEL)
+}
+
+func isCharacterSelectionCmdChar(b byte) bool {
+	return (b == ansiterm.ANSI_CMD_G0 || b == ansiterm.ANSI_CMD_G1 || b == ansiterm.ANSI_CMD_G2 || b == ansiterm.ANSI_CMD_G3)
+}
+
+// bytesToHex converts a slice of bytes to a human-readable string.
+func bytesToHex(b []byte) string {
+	hex := make([]string, len(b))
+	for i, ch := range b {
+		hex[i] = fmt.Sprintf("%X", ch)
+	}
+	return strings.Join(hex, "")
+}
+
 // ensureInRange adjusts the passed value, if necessary, to ensure it is within
 // the passed min / max range.
 func ensureInRange(n int16, min int16, max int16) int16 {
@@ -1,15 +1,9 @@
-version: "2"
-formatters:
-  enable:
-    - gofmt # files are gofmt'ed
 linters:
  enable:
    # style
    - containedctx # struct contains a context
    - dupl # duplicate code
-    - dupword # duplicate words in comments
-    - errname # errors are named correctly
-    - intrange # integer ranges in for loop
+    - errname # erorrs are named correctly
    - nolintlint # "//nolint" directives are properly explained
    - revive # golint replacement
    - unconvert # unnecessary conversions
@@ -19,155 +13,135 @@ linters:
    - contextcheck # function uses a non-inherited context
    - errorlint # errors not wrapped for 1.13
    - exhaustive # check exhaustiveness of enum switch statements
-    - gocritic # various code quality checks
+    - gofmt # files are gofmt'ed
    - gosec # security
-    - mirror # avoid allocations
    - nilerr # returns nil even with non-nil error
    - thelper #  test helpers without t.Helper()
    - unparam # unused function params

-  exclusions:
-    paths:
-      - pkg/etw/sample
-    presets:
-      - comments
-      - common-false-positives
-      - legacy
-      - std-error-handling
-    rules:
-      # err is very often shadowed in nested scopes
-      - linters:
-          - govet
-        text: '^shadow: declaration of "err" shadows declaration'
+issues:
+  exclude-dirs:
+    - pkg/etw/sample

-      # ignore long lines for skip autogen directives
-      - linters:
-          - revive
-        text: "^line-length-limit: "
-        source: "^//(go:generate|sys) "
+  exclude-rules:
+    # err is very often shadowed in nested scopes
+    - linters:
+        - govet
+      text: '^shadow: declaration of "err" shadows declaration'

-      # ignore comment spacing for sys directives
-      - linters:
-          - revive
-        text: "^comment-spacings: no space between comment delimiter and comment text"
-        source: "//(cspell:|sys )"
+    # ignore long lines for skip autogen directives
+    - linters:
+        - revive
+      text: "^line-length-limit: "
+      source: "^//(go:generate|sys) "

-      # allow unjustified ignores of error checks in defer statements
-      - linters:
-          - nolintlint
-        text: "^directive `//nolint:errcheck` should provide explanation"
-        source: '^\s*defer '
+    #TODO: remove after upgrading to go1.18
+    # ignore comment spacing for nolint and sys directives
+    - linters:
+        - revive
+      text: "^comment-spacings: no space between comment delimiter and comment text"
+      source: "//(cspell:|nolint:|sys |todo)"

-      # allow unjustified ignores of error lints for io.EOF
-      - linters:
-          - nolintlint
-        text: "^directive `//nolint:errorlint` should provide explanation"
-        source: '[=|!]= io.EOF'
+    # not on go 1.18 yet, so no any
+    - linters:
+        - revive
+      text: "^use-any: since GO 1.18 'interface{}' can be replaced by 'any'"

-      - linters:
-          - gosec
-        text: "^G115: integer overflow conversion"
+    # allow unjustified ignores of error checks in defer statements
+    - linters:
+        - nolintlint
+      text: "^directive `//nolint:errcheck` should provide explanation"
+      source: '^\s*defer '
+
+    # allow unjustified ignores of error lints for io.EOF
+    - linters:
+        - nolintlint
+      text: "^directive `//nolint:errorlint` should provide explanation"
+      source: '[=|!]= io.EOF'


-  settings:
-    exhaustive:
-      default-signifies-exhaustive: true
-    gocritic:
-      disable-all: true
-      enabled-checks:
-        - nilValReturn
-        - sprintfQuotedString
-    govet:
-      enable-all: true
-      disable:
-        # struct order is often for Win32 compat
-        # also, ignore pointer bytes/GC issues for now until performance becomes an issue
-        - fieldalignment
-    nolintlint:
-      require-explanation: true
-      require-specific: true
-    revive:
-      # revive is more configurable than static check, so likely the preferred alternative to static-check
-      # (once the perf issue is solved: https://github.com/golangci/golangci-lint/issues/2997)
-      enable-all-rules:
-        true
+linters-settings:
+  exhaustive:
+    default-signifies-exhaustive: true
+  govet:
+    enable-all: true
+    disable:
+      # struct order is often for Win32 compat
+      # also, ignore pointer bytes/GC issues for now until performance becomes an issue
+      - fieldalignment
+  nolintlint:
+    require-explanation: true
+    require-specific: true
+  revive:
+    # revive is more configurable than static check, so likely the preferred alternative to static-check
+    # (once the perf issue is solved: https://github.com/golangci/golangci-lint/issues/2997)
+    enable-all-rules:
+      true
      # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md
-      rules:
-        # rules with required arguments
-        - name: argument-limit
-          disabled: true
-        - name: banned-characters
-          disabled: true
-        - name: cognitive-complexity
-          disabled: true
-        - name: cyclomatic
-          disabled: true
-        # covered by "exhaustive" linter
-        - name: enforce-switch-style
-          disabled: true
-        - name: file-header
-          disabled: true
-        - name: function-length
-          disabled: true
-        - name: function-result-limit
-          disabled: true
-        - name: max-public-structs
-          disabled: true
-        # generally annoying rules
-        - name: add-constant # complains about any and all strings and integers
-          disabled: true
-        - name: confusing-naming # we frequently use "Foo()" and "foo()" together
-          disabled: true
-        - name: flag-parameter # excessive, and a common idiom we use
-          disabled: true
-        - name: multiline-if-init # too opinionated; see https://github.com/microsoft/go-winio/pull/325#issuecomment-5822487436
-          disabled: true
-        - name: unhandled-error # warns over common fmt.Print* and io.Close; rely on errcheck instead
-          disabled: true
-        # general config
-        - name: line-length-limit
-          arguments:
-            - 140
-        - name: var-naming
-          arguments:
-            - []
-            - - CID
-              - CRI
-              - CTRD
-              - DACL
-              - DLL
-              - DOS
-              - ETW
-              - FSCTL
-              - GCS
-              - GMSA
-              - HCS
-              - HV
-              - IO
-              - LCOW
-              - LDAP
-              - LPAC
-              - LTSC
-              - MMIO
-              - NT
-              - OCI
-              - PMEM
-              - PWSH
-              - RX
-              - SACl
-              - SID
-              - SMB
-              - TX
-              - VHD
-              - VHDX
-              - VMID
-              - VPCI
-              - WCOW
-              - WIM
-    staticcheck:
-      # Enable all options, with some exceptions.
-      # For defaults, see https://golangci-lint.run/usage/linters/#staticcheck
-      checks:
-        - all
-        - -QF1008     # Omit embedded fields from selector expression; https://staticcheck.dev/docs/checks/#QF1008
-        - -ST1003     # Poorly chosen identifier; https://staticcheck.dev/docs/checks/#ST1003
+    rules:
+      # rules with required arguments
+      - name: argument-limit
+        disabled: true
+      - name: banned-characters
+        disabled: true
+      - name: cognitive-complexity
+        disabled: true
+      - name: cyclomatic
+        disabled: true
+      - name: file-header
+        disabled: true
+      - name: function-length
+        disabled: true
+      - name: function-result-limit
+        disabled: true
+      - name: max-public-structs
+        disabled: true
+      # geneally annoying rules
+      - name: add-constant # complains about any and all strings and integers
+        disabled: true
+      - name: confusing-naming # we frequently use "Foo()" and "foo()" together
+        disabled: true
+      - name: flag-parameter # excessive, and a common idiom we use
+        disabled: true
+      - name: unhandled-error # warns over common fmt.Print* and io.Close; rely on errcheck instead
+        disabled: true
+      # general config
+      - name: line-length-limit
+        arguments:
+          - 140
+      - name: var-naming
+        arguments:
+          - []
+          - - CID
+            - CRI
+            - CTRD
+            - DACL
+            - DLL
+            - DOS
+            - ETW
+            - FSCTL
+            - GCS
+            - GMSA
+            - HCS
+            - HV
+            - IO
+            - LCOW
+            - LDAP
+            - LPAC
+            - LTSC
+            - MMIO
+            - NT
+            - OCI
+            - PMEM
+            - PWSH
+            - RX
+            - SACl
+            - SID
+            - SMB
+            - TX
+            - VHD
+            - VHDX
+            - VMID
+            - VPCI
+            - WCOW
+            - WIM
@@ -1,4 +1,5 @@
 //go:build windows
+// +build windows

 package winio

@@ -35,7 +36,7 @@ const (
 	StreamSparseAttributes = uint32(8)
 )

-//nolint:revive,nolintlint // var-naming: ALL_CAPS
+//nolint:revive // var-naming: ALL_CAPS
 const (
 	WRITE_DAC              = windows.WRITE_DAC
 	WRITE_OWNER            = windows.WRITE_OWNER
@@ -95,7 +95,7 @@ func writeEa(buf *bytes.Buffer, ea *ExtendedAttribute, last bool) error {
 		return err
 	}

-	_, err = buf.WriteString(ea.Name)
+	_, err = buf.Write([]byte(ea.Name))
 	if err != nil {
 		return err
 	}
@@ -1,4 +1,5 @@
 //go:build windows
+// +build windows

 package winio

@@ -234,17 +235,12 @@ func (f *win32File) Read(b []byte) (int, error) {
 	runtime.KeepAlive(b)

 	// Handle EOF conditions.
-	switch err {
-	case windows.ERROR_BROKEN_PIPE: //nolint:errorlint // err is Errno
+	if err == nil && n == 0 && len(b) != 0 {
+		return 0, io.EOF
+	} else if err == windows.ERROR_BROKEN_PIPE { //nolint:errorlint // err is Errno
 		return 0, io.EOF
-	case nil:
-		if n == 0 && len(b) != 0 {
-			return 0, io.EOF
-		}
-		return n, nil
-	default:
-		return n, err
 	}
+	return n, err
 }

 // Write writes to a file handle.
@@ -1,4 +1,5 @@
 //go:build windows
+// +build windows

 package winio

@@ -1,4 +1,5 @@
 //go:build windows
+// +build windows

 package winio

@@ -243,7 +243,7 @@ const (
 // https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-getfinalpathnamebyhandlew
 func GetFinalPathNameByHandle(h windows.Handle, flags GetFinalPathFlag) (string, error) {
 	b := stringbuffer.NewWString()
-	// TODO: can loop infinitely if Win32 keeps returning the same (or a larger) n?
+	//TODO: can loop infinitely if Win32 keeps returning the same (or a larger) n?
 	for {
 		n, err := windows.GetFinalPathNameByHandle(h, b.Pointer(), b.Cap(), uint32(flags))
 		if err != nil {
@@ -15,8 +15,12 @@ var _ unsafe.Pointer

 // Do the interface allocations only once for common
 // Errno values.
+const (
+	errnoERROR_IO_PENDING = 997
+)
+
 var (
-	errERROR_IO_PENDING error = windows.ERROR_IO_PENDING
+	errERROR_IO_PENDING error = syscall.Errno(errnoERROR_IO_PENDING)
 	errERROR_EINVAL     error = syscall.EINVAL
 )

@@ -26,7 +30,7 @@ func errnoErr(e syscall.Errno) error {
 	switch e {
 	case 0:
 		return errERROR_EINVAL
-	case windows.ERROR_IO_PENDING:
+	case errnoERROR_IO_PENDING:
 		return errERROR_IO_PENDING
 	}
 	return e
@@ -15,8 +15,12 @@ var _ unsafe.Pointer

 // Do the interface allocations only once for common
 // Errno values.
+const (
+	errnoERROR_IO_PENDING = 997
+)
+
 var (
-	errERROR_IO_PENDING error = windows.ERROR_IO_PENDING
+	errERROR_IO_PENDING error = syscall.Errno(errnoERROR_IO_PENDING)
 	errERROR_EINVAL     error = syscall.EINVAL
 )

@@ -26,7 +30,7 @@ func errnoErr(e syscall.Errno) error {
 	switch e {
 	case 0:
 		return errERROR_EINVAL
-	case windows.ERROR_IO_PENDING:
+	case errnoERROR_IO_PENDING:
 		return errERROR_IO_PENDING
 	}
 	return e
@@ -7,7 +7,7 @@ import (

 // TODO: worth exporting and using in mkwinsyscall?

-// MinWStringCap is the buffer size in the pool, chosen somewhat arbitrarily to accommodate
+// Uint16BufferSize is the buffer size in the pool, chosen somewhat arbitrarily to accommodate
 // large path strings:
 // MAX_PATH (260) + size of volume GUID prefix (49) + null terminator = 310.
 const MinWStringCap = 310
@@ -16,7 +16,7 @@ const MinWStringCap = 310
 // is copied to heap and then referenced via pointer in the interface header that sync.Pool
 // stores.
 var pathPool = sync.Pool{ // if go1.18+ adds Pool[T], use that to store []uint16 directly
-	New: func() any {
+	New: func() interface{} {
 		b := make([]uint16, MinWStringCap)
 		return &b
 	},
@@ -1,4 +1,5 @@
 //go:build windows
+// +build windows

 package winio

@@ -10,7 +11,6 @@ import (
 	"net"
 	"os"
 	"runtime"
-	"sync"
 	"time"
 	"unsafe"

@@ -179,15 +179,14 @@ func (f *win32MessageBytePipe) Read(b []byte) (int, error) {
 		return 0, io.EOF
 	}
 	n, err := f.win32File.Read(b)
-	switch err {
-	case io.EOF: //nolint:errorlint // error is not wrapped.
+	if err == io.EOF { //nolint:errorlint
 		// If this was the result of a zero-byte read, then
 		// it is possible that the read was due to a zero-size
 		// message. Since we are simulating CloseWrite with a
 		// zero-byte message, ensure that all future Read() calls
 		// also return EOF.
 		f.readEOF = true
-	case windows.ERROR_MORE_DATA:
+	} else if err == windows.ERROR_MORE_DATA { //nolint:errorlint // err is Errno
 		// ERROR_MORE_DATA indicates that the pipe's read mode is message mode
 		// and the message still has more bytes. Treat this as a success, since
 		// this package presents all named pipes as byte streams.
@@ -317,9 +316,8 @@ type win32PipeListener struct {
 	path        string
 	config      PipeConfig
 	acceptCh    chan (chan acceptResponse)
-	closeOnce   sync.Once
-	closeCh     chan struct{} // closed (never sent on) to broadcast listener shutdown
-	doneCh      chan struct{}
+	closeCh     chan int
+	doneCh      chan int
 }

 func makeServerPipeHandle(path string, sd []byte, c *PipeConfig, first bool) (windows.Handle, error) {
@@ -346,7 +344,7 @@ func makeServerPipeHandle(path string, sd []byte, c *PipeConfig, first bool) (wi
 	// The security descriptor is only needed for the first pipe.
 	if first {
 		if sd != nil {
-			// todo: does `sdb` need to be allocated on the heap, or can go allocate it?
+			//todo: does `sdb` need to be allocated on the heap, or can go allocate it?
 			l := uint32(len(sd))
 			sdb, err := windows.LocalAlloc(0, l)
 			if err != nil {
@@ -447,14 +445,13 @@ func (l *win32PipeListener) makeConnectedServerPipe() (*win32File, error) {
 			p = nil
 		}
 	case <-l.closeCh:
-		// Abort the connect request by closing the handle. Listener closure is
-		// authoritative: ConnectNamedPipe may race the handle close and report a
-		// connection or error (e.g. ERROR_NO_DATA) instead of ErrFileClosed, and
-		// that result must not be surfaced or cause listenerRoutine to retry.
-		_ = p.Close()
+		// Abort the connect request by closing the handle.
+		p.Close()
 		p = nil
-		<-ch
-		err = ErrPipeListenerClosed
+		err = <-ch
+		if err == nil || err == ErrFileClosed { //nolint:errorlint // err is Errno
+			err = ErrPipeListenerClosed
+		}
 	}
 	return p, err
 }
@@ -533,8 +530,8 @@ func ListenPipe(path string, c *PipeConfig) (net.Listener, error) {
 		path:        path,
 		config:      *c,
 		acceptCh:    make(chan (chan acceptResponse)),
-		closeCh:     make(chan struct{}),
-		doneCh:      make(chan struct{}),
+		closeCh:     make(chan int),
+		doneCh:      make(chan int),
 	}
 	go l.listenerRoutine()
 	return l, nil
@@ -576,10 +573,11 @@ func (l *win32PipeListener) Accept() (net.Conn, error) {
 }

 func (l *win32PipeListener) Close() error {
-	l.closeOnce.Do(func() {
-		close(l.closeCh)
-	})
-	<-l.doneCh
+	select {
+	case l.closeCh <- 1:
+		<-l.doneCh
+	case <-l.doneCh:
+	}
 	return nil
 }

@@ -14,7 +14,7 @@ import (
 	"strconv"
 )

-//go:generate go tool stringer -type=Variant -trimprefix=Variant -linecomment
+//go:generate go run golang.org/x/tools/cmd/stringer -type=Variant -trimprefix=Variant -linecomment

 // Variant specifies which GUID variant (or "type") of the GUID. It determines
 // how the entirety of the rest of the GUID is interpreted.
@@ -1,4 +1,5 @@
 //go:build !windows
+// +build !windows

 package guid

@@ -1,4 +1,5 @@
 //go:build windows
+// +build windows

 package guid

@@ -20,9 +20,8 @@ const _Variant_name = "UnknownNCSRFC 4122MicrosoftFuture"
 var _Variant_index = [...]uint8{0, 7, 10, 18, 27, 33}

 func (i Variant) String() string {
-	idx := int(i) - 0
-	if i < 0 || idx >= len(_Variant_index)-1 {
+	if i >= Variant(len(_Variant_index)-1) {
 		return "Variant(" + strconv.FormatInt(int64(i), 10) + ")"
 	}
-	return _Variant_name[_Variant_index[idx]:_Variant_index[idx+1]]
+	return _Variant_name[_Variant_index[i]:_Variant_index[i+1]]
 }
@@ -1,4 +1,5 @@
 //go:build windows
+// +build windows

 package winio

@@ -1,11 +1,11 @@
 //go:build windows
+// +build windows

 package winio

 import (
 	"bytes"
 	"encoding/binary"
-	"errors"
 	"fmt"
 	"strings"
 	"unicode/utf16"
@@ -15,9 +15,6 @@ import (
 const (
 	reparseTagMountPoint = 0xA0000003
 	reparseTagSymlink    = 0xA000000C
-	reparseTagLxSymlink  = 0xA000001D // WSL/MSYS2 native symlinks
-
-	lxSymlinkVersion = 2 // LX symlink format version
 )

 type reparseDataBuffer struct {
@@ -34,7 +31,6 @@ type reparseDataBuffer struct {
 type ReparsePoint struct {
 	Target       string
 	IsMountPoint bool
-	IsLxSymlink  bool // True if this is an LX symlink (WSL/MSYS2 native)
 }

 // UnsupportedReparsePointError is returned when trying to decode a non-symlink or
@@ -55,19 +51,14 @@ func DecodeReparsePoint(b []byte) (*ReparsePoint, error) {
 }

 func DecodeReparsePointData(tag uint32, b []byte) (*ReparsePoint, error) {
+	isMountPoint := false
 	switch tag {
 	case reparseTagMountPoint:
-		return decodeWindowsReparsePointData(b, true)
+		isMountPoint = true
 	case reparseTagSymlink:
-		return decodeWindowsReparsePointData(b, false)
-	case reparseTagLxSymlink:
-		return decodeLxReparsePointData(b)
 	default:
 		return nil, &UnsupportedReparsePointError{tag}
 	}
-}
-
-func decodeWindowsReparsePointData(b []byte, isMountPoint bool) (*ReparsePoint, error) {
 	nameOffset := 8 + binary.LittleEndian.Uint16(b[4:6])
 	if !isMountPoint {
 		nameOffset += 4
@@ -78,56 +69,16 @@ func decodeWindowsReparsePointData(b []byte, isMountPoint bool) (*ReparsePoint,
 	if err != nil {
 		return nil, err
 	}
-	return &ReparsePoint{Target: string(utf16.Decode(name)), IsMountPoint: isMountPoint, IsLxSymlink: false}, nil
-}
-
-func decodeLxReparsePointData(b []byte) (*ReparsePoint, error) {
-	// LX symlinks store the target as UTF-8 after a 4-byte version field
-	if len(b) < 4 {
-		return nil, errors.New("LX symlink buffer too short")
-	}
-	targetBytes := b[4:]
-	for i, c := range targetBytes {
-		if c == 0 {
-			targetBytes = targetBytes[:i]
-			break
-		}
-	}
-	target := string(targetBytes)
-	return &ReparsePoint{Target: target, IsMountPoint: false, IsLxSymlink: true}, nil
+	return &ReparsePoint{string(utf16.Decode(name)), isMountPoint}, nil
 }

 func isDriveLetter(c byte) bool {
 	return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
 }

-// EncodeReparsePoint encodes a Win32 REPARSE_DATA_BUFFER structure describing a symlink,
-// mount point, or LX symlink.
+// EncodeReparsePoint encodes a Win32 REPARSE_DATA_BUFFER structure describing a symlink or
+// mount point.
 func EncodeReparsePoint(rp *ReparsePoint) []byte {
-	if rp == nil {
-		return nil
-	}
-	if rp.IsLxSymlink {
-		return encodeLxReparsePoint(rp)
-	}
-	return encodeWindowsReparsePoint(rp)
-}
-
-func encodeLxReparsePoint(rp *ReparsePoint) []byte {
-	// LX symlink: 4-byte version + UTF-8 target
-	targetBytes := []byte(rp.Target)
-	dataLength := 4 + len(targetBytes)
-
-	var b bytes.Buffer
-	_ = binary.Write(&b, binary.LittleEndian, uint32(reparseTagLxSymlink))
-	_ = binary.Write(&b, binary.LittleEndian, uint16(dataLength))
-	_ = binary.Write(&b, binary.LittleEndian, uint16(0))
-	_ = binary.Write(&b, binary.LittleEndian, uint32(lxSymlinkVersion))
-	_, _ = b.Write(targetBytes)
-	return b.Bytes()
-}
-
-func encodeWindowsReparsePoint(rp *ReparsePoint) []byte {
 	// Generate an NT path and determine if this is a relative path.
 	var ntTarget string
 	relative := false
@@ -1,4 +1,5 @@
 //go:build windows
+// +build windows

 package winio

@@ -15,8 +15,12 @@ var _ unsafe.Pointer

 // Do the interface allocations only once for common
 // Errno values.
+const (
+	errnoERROR_IO_PENDING = 997
+)
+
 var (
-	errERROR_IO_PENDING error = windows.ERROR_IO_PENDING
+	errERROR_IO_PENDING error = syscall.Errno(errnoERROR_IO_PENDING)
 	errERROR_EINVAL     error = syscall.EINVAL
 )

@@ -26,7 +30,7 @@ func errnoErr(e syscall.Errno) error {
 	switch e {
 	case 0:
 		return errERROR_EINVAL
-	case windows.ERROR_IO_PENDING:
+	case errnoERROR_IO_PENDING:
 		return errERROR_IO_PENDING
 	}
 	return e
@@ -1 +0,0 @@
-* text=auto eol=lf
@@ -1,50 +1,30 @@
-version: "2"
 linters:
  enable:
-    - copyloopvar
-    - dupword
+    - exportloopref # Checks for pointers to enclosing loop variables
+    - gofmt
+    - goimports
    - gosec
-    - govet
    - ineffassign
    - misspell
    - nolintlint
    - revive
    - staticcheck
+    - tenv # Detects using os.Setenv instead of t.Setenv since Go 1.17
    - unconvert
    - unused
+    - vet
+    - dupword # Checks for duplicate words in the source code
  disable:
    - errcheck
-  exclusions:
-    generated: lax
-    presets:
-      - comments
-      - common-false-positives
-      - legacy
-      - std-error-handling
-    paths:
-      - api
-      - cluster
-      - design
-      - docs
-      - docs/man
-      - releases
-      - reports
-      - test
-formatters:
-  enable:
-    - gofmt
-    - goimports
-  exclusions:
-    generated: lax
-    paths:
-      - api
-      - cluster
-      - design
-      - docs
-      - docs/man
-      - releases
-      - reports
-      - test

 run:
  timeout: 5m
+  skip-dirs:
+    - api
+    - cluster
+    - design
+    - docs
+    - docs/man
+    - releases
+    - reports
+    - test # e2e scripts
@@ -40,11 +40,8 @@ package log
 import (
 	"context"
 	"fmt"
-	"io"
-	"log/slog"

 	"github.com/sirupsen/logrus"
-	lslog "github.com/sirupsen/logrus/hooks/slog"
 )

 // G is a shorthand for [GetLogger].
@@ -111,17 +108,10 @@ const (
 	PanicLevel Level = logrus.PanicLevel
 )

-// levelValue is a log level accepted by [SetLevel].
-type levelValue interface {
-	string | Level | slog.Level | lslog.Level | lslog.SlogLevel
-}
-
-// SetLevel sets the global log level.
+// SetLevel sets log level globally. It returns an error if the given
+// level is not supported.
 //
-// The level may be specified as a string, a [Level], a [slog.Level], an
-// [lslog.Level], or an [lslog.SlogLevel].
-//
-// String levels are parsed using [logrus.ParseLevel] and may be one of:
+// level can be one of:
 //
 //   - "trace" ([TraceLevel])
 //   - "debug" ([DebugLevel])
@@ -130,34 +120,10 @@ type levelValue interface {
 //   - "error" ([ErrorLevel])
 //   - "fatal" ([FatalLevel])
 //   - "panic" ([PanicLevel])
-//
-// slog levels are mapped to Logrus levels using the mapping defined by
-// [lslog.SlogLevel]. [lslog.Level] values are accepted directly as their
-// underlying Logrus level.
-//
-// SetLevel returns an error if a string level is not supported.
-func SetLevel[T levelValue](level T) error {
-	var lvl Level
-
-	switch l := any(level).(type) {
-	case string:
-		var err error
-		lvl, err = logrus.ParseLevel(l)
-		if err != nil {
-			return err
-		}
-
-	case Level:
-		lvl = l
-
-	case slog.Level:
-		lvl = lslog.SlogLevel(l).Level()
-
-	case lslog.Level:
-		lvl = Level(l)
-
-	case lslog.SlogLevel:
-		lvl = l.Level()
+func SetLevel(level string) error {
+	lvl, err := logrus.ParseLevel(level)
+	if err != nil {
+		return err
 	}

 	L.Logger.SetLevel(lvl)
@@ -183,39 +149,21 @@ const (

 // SetFormat sets the log output format ([TextFormat] or [JSONFormat]).
 func SetFormat(format OutputFormat) error {
-	if slogOut != nil {
-		var handler slog.Handler
-		switch format {
-		case TextFormat:
-			handler = slog.NewTextHandler(slogOut, &slog.HandlerOptions{Level: loggerLevel{}})
-		case JSONFormat:
-			handler = slog.NewJSONHandler(slogOut, &slog.HandlerOptions{Level: loggerLevel{}})
-		default:
-			return fmt.Errorf("unknown log format: %s", format)
-		}
-		slog.SetDefault(slog.New(handler))
-
-		// Keep logrus formatting and output disabled, as both are handled by slog.
-		L.Logger.SetFormatter(discardFormatter{})
-		L.Logger.SetOutput(io.Discard)
-		return nil
-	}
-
 	switch format {
 	case TextFormat:
 		L.Logger.SetFormatter(&logrus.TextFormatter{
 			TimestampFormat: RFC3339NanoFixed,
 			FullTimestamp:   true,
 		})
+		return nil
 	case JSONFormat:
 		L.Logger.SetFormatter(&logrus.JSONFormatter{
 			TimestampFormat: RFC3339NanoFixed,
 		})
+		return nil
 	default:
 		return fmt.Errorf("unknown log format: %s", format)
 	}
-
-	return nil
 }

 // WithLogger returns a new context with the provided logger. Use in
@@ -1,66 +0,0 @@
-/*
-   Copyright The containerd Authors.
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-*/
-
-package log
-
-import (
-	"io"
-	"log/slog"
-	"sync"
-
-	"github.com/sirupsen/logrus"
-	lslog "github.com/sirupsen/logrus/hooks/slog"
-)
-
-// slogOut is used to set the slog logger when setting output format.
-var slogOut io.Writer
-
-// slogOnce guards UseSlog so repeated calls do not stack up hooks or
-// reset slogOut to the discard writer installed on the first call.
-var slogOnce sync.Once
-
-func UseSlog() {
-	slogOnce.Do(func() {
-		L.Logger.SetNoLock()
-		L.Logger.AddHook(slogHook{})
-		slogOut = L.Logger.Out
-
-		// Disable logrus formatting and output, as both are handled by slog.
-		L.Logger.SetFormatter(discardFormatter{})
-		L.Logger.SetOutput(io.Discard)
-	})
-}
-
-type slogHook struct{}
-
-func (slogHook) Levels() []logrus.Level {
-	return logrus.AllLevels
-}
-
-func (slogHook) Fire(entry *logrus.Entry) error {
-	return lslog.NewHook(slog.Default(), nil).Fire(entry)
-}
-
-// loggerLevel exposes the current Logrus logger level as a slog.Leveler.
-type loggerLevel struct{}
-
-func (loggerLevel) Level() slog.Level {
-	return lslog.Level(L.Logger.GetLevel()).Level()
-}
-
-type discardFormatter struct{}
-
-func (discardFormatter) Format(*logrus.Entry) ([]byte, error) { return nil, nil }
@@ -6,9 +6,7 @@ This package provides various compression algorithms.
 * [S2](https://github.com/klauspost/compress/tree/master/s2#s2-compression) is a high performance replacement for Snappy.
 * Optimized [deflate](https://godoc.org/github.com/klauspost/compress/flate) packages which can be used as a dropin replacement for [gzip](https://godoc.org/github.com/klauspost/compress/gzip), [zip](https://godoc.org/github.com/klauspost/compress/zip) and [zlib](https://godoc.org/github.com/klauspost/compress/zlib).
 * [snappy](https://github.com/klauspost/compress/tree/master/snappy) is a drop-in replacement for `github.com/golang/snappy` offering better compression and concurrent streams.
-* [lzw](https://github.com/klauspost/compress/tree/master/lzw) is a drop-in replacement for `compress/lzw` with 1.4-4x faster decompression and 1.1-2.7x faster compression, depending on the data.
 * [huff0](https://github.com/klauspost/compress/tree/master/huff0) and [FSE](https://github.com/klauspost/compress/tree/master/fse) implementations for raw entropy encoding.
-* [Xpress](https://github.com/klauspost/compress/tree/master/xpress) decompression of the Microsoft XPRESS (MS-XCA) plain LZ77 and LZ77+Huffman formats (the LZ77+Huffman variant is the one used in WIM images and Windows Compact OS / WOF data).
 * [gzhttp](https://github.com/klauspost/compress/tree/master/gzhttp) Provides client and server wrappers for handling gzipped/zstd HTTP requests efficiently.
 * [pgzip](https://github.com/klauspost/pgzip) is a separate package that provides a very fast parallel gzip implementation.

@@ -9,7 +9,6 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"math/bits"

 	"github.com/klauspost/compress/internal/le"
 )
@@ -211,68 +210,6 @@ func (b *bitReaderShifted) remaining() uint {
 	return b.off*8 + uint(64-b.bitsRead)
 }

-// canUseAsm reports whether the reader has a full 8-byte window ahead of
-// its read pointer, which the Decompress4X asm loops need to take over.
-func (b *bitReaderShifted) canUseAsm() bool {
-	return b.off >= 8
-}
-
-// prepareForAsm establishes the invariant the Decompress4X asm loops rely
-// on: value == load64(in[off:off+8]) << bitsRead with bitsRead <= 7, so
-// that a full group of symbols can never shift their sentinel bit out of
-// the container. init leaves bitsRead == 8 when the final byte of the
-// stream is exactly 0x01; that whole byte is consumed, so the same position
-// is the window one byte lower with nothing consumed. Requires canUseAsm.
-func (b *bitReaderShifted) prepareForAsm() {
-	if b.bitsRead >= 8 {
-		b.off--
-		b.value = le.Load64(b.in, b.off)
-		b.bitsRead -= 8
-	}
-}
-
-// restoreFromAsm converts the state left behind by the Decompress4X asm
-// loops back to the invariant the Go code relies on: value holds the 8
-// bytes at in[off:off+8] shifted left by bitsRead, with the low bitsRead
-// bits zero.
-//
-// The asm keeps a sentinel bit in value just below the unread bits, so its
-// trailing zero count is the number of consumed bits. The sentinel is ORed
-// over the lowest bit of the window, which the loop never consumes before
-// re-reading memory, so the window is re-read here too rather than taken
-// from value. The asm reports off as the signed distance from the start of
-// the stream, and it can be negative: a reload always reads a whole 8-byte
-// window, so a stream that is nearly drained ends with up to 7 bytes of the
-// previous stream (or the jump table) below its start inside the window.
-// Those bytes sit below the stream's own bits and count as consumed.
-// Anything further below, or more bits consumed than the stream holds, is
-// corruption.
-func (b *bitReaderShifted) restoreFromAsm() error {
-	off := int(b.off)
-	consumed := uint(bits.TrailingZeros64(b.value))
-	if off < 0 {
-		if off < -7 {
-			return errors.New("corruption detected: stream underrun")
-		}
-		consumed += uint(-off) * 8
-		if consumed > 64 {
-			return errors.New("corruption detected: stream underrun")
-		}
-		off = 0
-	}
-	if off+8 > len(b.in) {
-		return errors.New("corruption detected: stream overrun")
-	}
-	b.off = uint(off)
-	b.bitsRead = uint8(consumed)
-	if consumed >= 64 {
-		b.value = 0
-	} else {
-		b.value = le.Load64(b.in, b.off) << consumed
-	}
-	return nil
-}
-
 // close the bitstream and returns an error if out-of-buffer reads occurred.
 func (b *bitReaderShifted) close() error {
 	// Release reference.
@@ -8,99 +8,36 @@ import (
 )

 // decompress4x_main_loop_amd64 is an x86 assembler implementation
-// of Decompress4X when tablelog > 8, decoding fastSymbols symbols per
-// stream between bit container reloads.
+// of Decompress4X when tablelog > 8.
 //
 //go:noescape
 func decompress4x_main_loop_amd64(ctx *decompress4xContext)

 // decompress4x_8b_main_loop_amd64 is an x86 assembler implementation
-// of Decompress4X when tablelog <= 8, decoding fast8bSymbols symbols
-// per stream between bit container reloads.
+// of Decompress4X when tablelog <= 8 which decodes 4 entries
+// per loop.
 //
 //go:noescape
 func decompress4x_8b_main_loop_amd64(ctx *decompress4xContext)

-// decompress4x_4b_main_loop_amd64 is an x86 assembler implementation
-// of Decompress4X when tablelog <= 4, decoding fast4bSymbols symbols
-// per stream between bit container reloads.
-//
-//go:noescape
-func decompress4x_4b_main_loop_amd64(ctx *decompress4xContext)
-
-// decompress4x_4b_main_loop_bmi2 is the BMI2 twin of decompress4x_4b_main_loop_amd64.
-//
-//go:noescape
-func decompress4x_4b_main_loop_bmi2(ctx *decompress4xContext)
-
-// decompress4x_main_loop_bmi2 is the BMI2 twin of decompress4x_main_loop_amd64.
-//
-//go:noescape
-func decompress4x_main_loop_bmi2(ctx *decompress4xContext)
-
-// decompress4x_8b_main_loop_bmi2 is the BMI2 twin of decompress4x_8b_main_loop_amd64.
-//
-//go:noescape
-func decompress4x_8b_main_loop_bmi2(ctx *decompress4xContext)
-
 // decompress1x_main_loop_amd64 is an x86 assembler implementation
-// of Decompress1X when tablelog > 8, decoding fastSymbols symbols
-// between bit container reloads.
+// of Decompress1X when tablelog > 8.
 //
 //go:noescape
 func decompress1x_main_loop_amd64(ctx *decompress1xContext)

-// decompress1x_8b_main_loop_amd64 is an x86 assembler implementation
-// of Decompress1X when tablelog <= 8, decoding fast8bSymbols symbols
-// between bit container reloads.
-//
-//go:noescape
-func decompress1x_8b_main_loop_amd64(ctx *decompress1xContext)
-
-// decompress1x_4b_main_loop_amd64 is an x86 assembler implementation
-// of Decompress1X when tablelog <= 4, decoding fast4bSymbols symbols
-// between bit container reloads.
-//
-//go:noescape
-func decompress1x_4b_main_loop_amd64(ctx *decompress1xContext)
-
-// decompress1x_main_loop_bmi2 is the BMI2 twin of decompress1x_main_loop_amd64.
+// decompress1x_main_loop_bmi2 is an x86 with BMI2 assembler implementation
+// of Decompress1X when tablelog > 8.
 //
 //go:noescape
 func decompress1x_main_loop_bmi2(ctx *decompress1xContext)

-// decompress1x_8b_main_loop_bmi2 is the BMI2 twin of decompress1x_8b_main_loop_amd64.
-//
-//go:noescape
-func decompress1x_8b_main_loop_bmi2(ctx *decompress1xContext)
-
-// decompress1x_4b_main_loop_bmi2 is the BMI2 twin of decompress1x_4b_main_loop_amd64.
-//
-//go:noescape
-func decompress1x_4b_main_loop_bmi2(ctx *decompress1xContext)
-
 func decompress4x_main_loop_asm(ctx *decompress4xContext) {
-	if cpuinfo.HasBMI2() {
-		decompress4x_main_loop_bmi2(ctx)
-	} else {
-		decompress4x_main_loop_amd64(ctx)
-	}
+	decompress4x_main_loop_amd64(ctx)
 }

 func decompress4x_8b_main_loop_asm(ctx *decompress4xContext) {
-	if cpuinfo.HasBMI2() {
-		decompress4x_8b_main_loop_bmi2(ctx)
-	} else {
-		decompress4x_8b_main_loop_amd64(ctx)
-	}
-}
-
-func decompress4x_4b_main_loop_asm(ctx *decompress4xContext) {
-	if cpuinfo.HasBMI2() {
-		decompress4x_4b_main_loop_bmi2(ctx)
-	} else {
-		decompress4x_4b_main_loop_amd64(ctx)
-	}
+	decompress4x_8b_main_loop_amd64(ctx)
 }

 func decompress1x_main_loop_asm(ctx *decompress1xContext) {
@@ -110,19 +47,3 @@ func decompress1x_main_loop_asm(ctx *decompress1xContext) {
 		decompress1x_main_loop_amd64(ctx)
 	}
 }
-
-func decompress1x_8b_main_loop_asm(ctx *decompress1xContext) {
-	if cpuinfo.HasBMI2() {
-		decompress1x_8b_main_loop_bmi2(ctx)
-	} else {
-		decompress1x_8b_main_loop_amd64(ctx)
-	}
-}
-
-func decompress1x_4b_main_loop_asm(ctx *decompress1xContext) {
-	if cpuinfo.HasBMI2() {
-		decompress1x_4b_main_loop_bmi2(ctx)
-	} else {
-		decompress1x_4b_main_loop_amd64(ctx)
-	}
-}
@@ -6,47 +6,24 @@
 package huff0

 // decompress4x_main_loop_arm64 is an arm64 assembler implementation
-// of Decompress4X when tablelog > 8, decoding fastSymbols symbols per
-// stream between bit container reloads.
+// of Decompress4X when tablelog > 8.
 //
 //go:noescape
 func decompress4x_main_loop_arm64(ctx *decompress4xContext)

 // decompress4x_8b_main_loop_arm64 is an arm64 assembler implementation
-// of Decompress4X when tablelog <= 8, decoding fast8bSymbols symbols
-// per stream between bit container reloads.
+// of Decompress4X when tablelog <= 8 which decodes 4 entries
+// per loop.
 //
 //go:noescape
 func decompress4x_8b_main_loop_arm64(ctx *decompress4xContext)

-// decompress4x_4b_main_loop_arm64 is an arm64 assembler implementation
-// of Decompress4X when tablelog <= 4, decoding fast4bSymbols symbols
-// per stream between bit container reloads.
-//
-//go:noescape
-func decompress4x_4b_main_loop_arm64(ctx *decompress4xContext)
-
 // decompress1x_main_loop_arm64 is an arm64 assembler implementation
-// of Decompress1X when tablelog > 8, decoding fastSymbols symbols
-// between bit container reloads.
+// of Decompress1X when tablelog > 8.
 //
 //go:noescape
 func decompress1x_main_loop_arm64(ctx *decompress1xContext)

-// decompress1x_8b_main_loop_arm64 is an arm64 assembler implementation
-// of Decompress1X when tablelog <= 8, decoding fast8bSymbols symbols
-// between bit container reloads.
-//
-//go:noescape
-func decompress1x_8b_main_loop_arm64(ctx *decompress1xContext)
-
-// decompress1x_4b_main_loop_arm64 is an arm64 assembler implementation
-// of Decompress1X when tablelog <= 4, decoding fast4bSymbols symbols
-// between bit container reloads.
-//
-//go:noescape
-func decompress1x_4b_main_loop_arm64(ctx *decompress1xContext)
-
 func decompress4x_main_loop_asm(ctx *decompress4xContext) {
 	decompress4x_main_loop_arm64(ctx)
 }
@@ -55,18 +32,6 @@ func decompress4x_8b_main_loop_asm(ctx *decompress4xContext) {
 	decompress4x_8b_main_loop_arm64(ctx)
 }

-func decompress4x_4b_main_loop_asm(ctx *decompress4xContext) {
-	decompress4x_4b_main_loop_arm64(ctx)
-}
-
 func decompress1x_main_loop_asm(ctx *decompress1xContext) {
 	decompress1x_main_loop_arm64(ctx)
 }
-
-func decompress1x_8b_main_loop_asm(ctx *decompress1xContext) {
-	decompress1x_8b_main_loop_arm64(ctx)
-}
-
-func decompress1x_4b_main_loop_asm(ctx *decompress1xContext) {
-	decompress1x_4b_main_loop_arm64(ctx)
-}
@@ -14,10 +14,6 @@ import (
 // fallback8BitSize is the size where using Go version is faster.
 const fallback8BitSize = 800

-// decompress4xContext is the argument block of the Decompress4X asm loops.
-// Go fills every field but decoded and inner; the asm advances ip, and on
-// return leaves each bit reader in the form bitReaderShifted.restoreFromAsm
-// expects.
 type decompress4xContext struct {
 	pbr      *[4]bitReaderShifted
 	peekBits uint8
@@ -25,20 +21,9 @@ type decompress4xContext struct {
 	dstEvery int
 	tbl      *dEntrySingle
 	decoded  int
-	limit    *byte    // stream 0's output pointer must stay below this
-	ilowest  *byte    // start of the input block; no read goes below it
-	ip       [4]*byte // each stream's 8-byte input window, advanced by the asm
-	inner    *byte    // scratch for the asm: the current inner-loop limit
+	limit    *byte
 }

-// Symbols decoded per stream between reloads by the 4X asm loops; must
-// match the constants of the same names in _generate/gen.go.
-const (
-	fastSymbols   = 5  // tablelog 9..11
-	fast8bSymbols = 7  // tablelog 5..8
-	fast4bSymbols = 14 // tablelog <= 4
-)
-
 // Decompress4X will decompress a 4X encoded stream.
 // The length of the supplied input must match the end of a block exactly.
 // The *capacity* of the dst slice must match the destination size of
@@ -87,55 +72,23 @@ func (d *Decoder) Decompress4X(dst, src []byte) ([]byte, error) {

 	var decoded int

-	nSyms := fastSymbols
-	if d.actualTableLog <= 4 {
-		nSyms = fast4bSymbols
-	} else if use8BitTables {
-		nSyms = fast8bSymbols
-	}
-	// The asm writes nSyms bytes per stream per iteration and only re-checks
-	// its bounds between batches of iterations (the batch size is derived
-	// from limit in _generate/gen.go), so stream 0 must stop early enough
-	// that stream 3 (which may be up to 3 bytes shorter than dstEvery)
-	// never writes past the end of out. Every stream needs a full 8-byte
-	// window ahead of its read pointer to enter the loop.
-	if limit := dstEvery - nSyms - 2; limit > 0 && br[0].canUseAsm() && br[1].canUseAsm() && br[2].canUseAsm() && br[3].canUseAsm() {
-		for i := range br {
-			br[i].prepareForAsm()
-		}
+	if len(out) > 4*4 && !(br[0].off < 4 || br[1].off < 4 || br[2].off < 4 || br[3].off < 4) {
 		ctx := decompress4xContext{
 			pbr:      &br,
 			peekBits: uint8((64 - d.actualTableLog) & 63), // see: bitReaderShifted.peekBitsFast()
 			out:      &out[0],
 			dstEvery: dstEvery,
 			tbl:      &single[0],
-			limit:    &out[limit],
-			// The 6-byte jump table sits below stream 0 inside src, so the
-			// lowest window may reach into it; restoreFromAsm accounts for
-			// bytes below a stream's start. Bounding by src rather than by
-			// stream 0 keeps the asm running about six bytes longer, which
-			// matters for streams with very short codes.
-			ilowest: &src[0],
+			limit:    &out[dstEvery-4], // Always stop decoding when first buffer gets here to avoid writing OOB on last.
 		}
-		for i := range br {
-			ctx.ip[i] = &br[i].in[br[i].off]
-		}
-		switch nSyms {
-		case fast4bSymbols:
-			decompress4x_4b_main_loop_asm(&ctx)
-		case fast8bSymbols:
+		if use8BitTables {
 			decompress4x_8b_main_loop_asm(&ctx)
-		default:
+		} else {
 			decompress4x_main_loop_asm(&ctx)
 		}

 		decoded = ctx.decoded
 		out = out[decoded/4:]
-		for i := range br {
-			if err := br[i].restoreFromAsm(); err != nil {
-				return nil, err
-			}
-		}
 	}

 	// Decode remaining.
@@ -175,20 +128,18 @@ func (d *Decoder) Decompress4X(dst, src []byte) ([]byte, error) {
 	return dst, nil
 }

-// decompress1xContext is the argument block of the Decompress1X asm loops.
-// Go fills every field but decoded; the asm advances ip, and on return
-// leaves the bit reader in the form bitReaderShifted.restoreFromAsm expects.
 type decompress1xContext struct {
 	pbr      *bitReaderShifted
 	peekBits uint8
 	out      *byte
-	outCap   int // no write reaches out[outCap]
+	outCap   int
 	tbl      *dEntrySingle
 	decoded  int
-	ilowest  *byte // start of the stream; no read goes below it
-	ip       *byte // the 8-byte input window, advanced by the asm
 }

+// Error reported by asm implementations
+const error_max_decoded_size_exeeded = -1
+
 // Decompress1X will decompress a 1X encoded stream.
 // The cap of the output buffer will be the maximum decompressed size.
 // The length of the supplied input must match the end of a block exactly.
@@ -207,36 +158,25 @@ func (d *Decoder) Decompress1X(dst, src []byte) ([]byte, error) {
 	const tlSize = 1 << tableLogMax
 	const tlMask = tlSize - 1

-	// The asm decodes whole batches of symbols and only re-checks its
-	// bounds between them, so it needs at least one batch of room (the
-	// output bound rounds nSyms up to 16, see _generate/gen.go) and a full
-	// 8-byte window ahead of the read pointer to enter the loop. It also
-	// needs at most 7 bits consumed on entry so that a batch cannot run
-	// the container dry, which prepareForAsm establishes.
-	decoded := 0
-	if maxDecodedSize >= 16 && br.canUseAsm() {
-		br.prepareForAsm()
+	if maxDecodedSize >= 4 {
 		ctx := decompress1xContext{
 			pbr:      &br,
 			out:      &dst[0],
 			outCap:   maxDecodedSize,
 			peekBits: uint8((64 - d.actualTableLog) & 63), // see: bitReaderShifted.peekBitsFast()
 			tbl:      &d.dt.single[0],
-			ilowest:  &src[0],
-			ip:       &br.in[br.off],
 		}
-		if d.actualTableLog <= 4 {
-			decompress1x_4b_main_loop_asm(&ctx)
-		} else if d.actualTableLog <= 8 {
-			decompress1x_8b_main_loop_asm(&ctx)
-		} else {
-			decompress1x_main_loop_asm(&ctx)
-		}
-		decoded = ctx.decoded
-	}
-	dst = dst[:decoded]

-	bitsLeft := br.remaining()
+		decompress1x_main_loop_asm(&ctx)
+		if ctx.decoded == error_max_decoded_size_exeeded {
+			return nil, ErrMaxDecodedSizeExceeded
+		}
+
+		dst = dst[:ctx.decoded]
+	}
+
+	// br < 8, so uint8 is fine
+	bitsLeft := uint8(br.off)*8 + 64 - br.bitsRead
 	for bitsLeft > 0 {
 		br.fill()
 		if len(dst) >= maxDecodedSize {
@@ -246,7 +186,7 @@ func (d *Decoder) Decompress1X(dst, src []byte) ([]byte, error) {
 		v := d.dt.single[br.peekBitsFast(d.actualTableLog)&tlMask]
 		nBits := uint8(v.entry)
 		br.advance(nBits)
-		bitsLeft -= uint(nBits)
+		bitsLeft -= nBits
 		dst = append(dst, uint8(v.entry>>8))
 	}
 	return dst, br.close()
@@ -240,11 +240,9 @@ func (b *blockDec) decodeBuf(hist *history) error {
 			b.dst[i] = v
 		}
 		hist.appendKeep(b.dst)
-		hist.decoders.consumeSyncLen(len(b.dst))
 		return nil
 	case blockTypeRaw:
 		hist.appendKeep(b.data)
-		hist.decoders.consumeSyncLen(len(b.data))
 		return nil
 	case blockTypeCompressed:
 		saved := b.dst
@@ -489,7 +487,6 @@ func (b *blockDec) decodeCompressed(hist *history) error {
 	}
 	if hist.decoders.nSeqs == 0 {
 		b.dst = append(b.dst, hist.decoders.literals...)
-		hist.decoders.consumeSyncLen(len(hist.decoders.literals))
 		return nil
 	}
 	before := len(hist.decoders.out)
@@ -7,11 +7,8 @@ package zstd
 import (
 	"context"
 	"encoding/binary"
-	"errors"
 	"io"
-	"maps"
 	"sync"
-	"sync/atomic"

 	"github.com/klauspost/compress/zstd/internal/xxhash"
 )
@@ -23,8 +20,7 @@ import (
 // A decoder can safely be re-used even if the previous stream failed.
 // To release the resources, you must call the Close() function on a decoder.
 type Decoder struct {
-	// publishedOptions contains the current immutable decoder options.
-	publishedOptions atomic.Pointer[decoderOptions]
+	o decoderOptions

 	// Unreferenced decoders, ready for use.
 	decoders chan *blockDec
@@ -88,10 +84,9 @@ var (
 func NewReader(r io.Reader, opts ...DOption) (*Decoder, error) {
 	initPredefined()
 	var d Decoder
-	var o decoderOptions
-	o.setDefault()
-	for _, opt := range opts {
-		err := opt(&o)
+	d.o.setDefault()
+	for _, o := range opts {
+		err := o(&d.o)
 		if err != nil {
 			return nil, err
 		}
@@ -104,19 +99,17 @@ func NewReader(r io.Reader, opts ...DOption) (*Decoder, error) {
 	}

 	// Initialize dict map if needed.
-	if o.dicts == nil {
-		o.dicts = make(map[uint32]*dict)
+	if d.o.dicts == nil {
+		d.o.dicts = make(map[uint32]*dict)
 	}

 	// Create decoders
-	d.decoders = make(chan *blockDec, o.concurrent)
-	for i := 0; i < o.concurrent; i++ {
-		dec := newBlockDec(o.lowMem)
-		dec.localFrame = newFrameDec(o)
-		dec.localFrame.o.dicts = nil
+	d.decoders = make(chan *blockDec, d.o.concurrent)
+	for i := 0; i < d.o.concurrent; i++ {
+		dec := newBlockDec(d.o.lowMem)
+		dec.localFrame = newFrameDec(d.o)
 		d.decoders <- dec
 	}
-	d.publishedOptions.Store(&o)

 	if r == nil {
 		return &d, nil
@@ -178,9 +171,6 @@ func (d *Decoder) Reset(r io.Reader) error {
 	d.drainOutput()

 	d.syncStream.br.r = nil
-	if d.frame != nil {
-		d.frame.o.dicts = nil
-	}
 	if r == nil {
 		d.current.err = ErrDecoderNilInput
 		if len(d.current.b) > 0 {
@@ -190,10 +180,8 @@ func (d *Decoder) Reset(r io.Reader) error {
 		return nil
 	}

-	o := *d.publishedOptions.Load()
-
 	// If bytes buffer and < 5MB, do sync decoding anyway.
-	if bb, ok := r.(byter); ok && bb.Len() < o.decodeBufsBelow && !o.limitToCap {
+	if bb, ok := r.(byter); ok && bb.Len() < d.o.decodeBufsBelow && !d.o.limitToCap {
 		bb2 := bb
 		if debugDecoder {
 			println("*bytes.Buffer detected, doing sync decode, len:", bb.Len())
@@ -205,30 +193,18 @@ func (d *Decoder) Reset(r io.Reader) error {
 		}

 		dst, err := d.DecodeAll(b, dst)
-		if !errors.Is(err, ErrDecoderSizeExceeded) {
-			if err == nil {
-				err = io.EOF
-			}
-			// Save output buffer
-			d.syncStream.dstBuf = dst
-			d.current.b = dst
-			d.current.err = err
-			d.current.flushed = true
-			if debugDecoder {
-				println("sync decode to", len(dst), "bytes, err:", err)
-			}
-			return nil
+		if err == nil {
+			err = io.EOF
 		}
-		// The output does not fit WithDecoderMaxMemory, which caps the total
-		// decoded size when decoding in memory. A Reader follows the
-		// streaming contract, where the option caps the window instead, so
-		// decode this input as a stream after all; the shortcut has not
-		// consumed the reader. Drop the oversized buffer rather than keep it
-		// for reuse.
+		// Save output buffer
+		d.syncStream.dstBuf = dst
+		d.current.b = dst
+		d.current.err = err
+		d.current.flushed = true
 		if debugDecoder {
-			println("sync decode exceeded max memory after", len(dst), "bytes; streaming instead")
+			println("sync decode to", len(dst), "bytes, err:", err)
 		}
-		d.syncStream.dstBuf = nil
+		return nil
 	}
 	// Remove current block.
 	d.stashDecoder()
@@ -241,16 +217,14 @@ func (d *Decoder) Reset(r io.Reader) error {
 	// Ensure no-one else is still running...
 	d.streamWg.Wait()
 	if d.frame == nil {
-		d.frame = newFrameDec(o)
-	} else {
-		d.frame.setOptions(o)
+		d.frame = newFrameDec(d.o)
 	}

-	if o.concurrent == 1 {
+	if d.o.concurrent == 1 {
 		return d.startSyncDecoder(r)
 	}

-	d.current.output = make(chan decodeOutput, o.concurrent)
+	d.current.output = make(chan decodeOutput, d.o.concurrent)
 	ctx, cancel := context.WithCancel(context.Background())
 	d.current.cancel = cancel
 	d.streamWg.Add(1)
@@ -264,21 +238,13 @@ func (d *Decoder) Reset(r io.Reader) error {
 // Options are applied on top of the existing options.
 // Some options cannot be changed on reset and will return an error.
 func (d *Decoder) ResetWithOptions(r io.Reader, opts ...DOption) error {
-	if d.current.err == ErrDecoderClosed {
-		return d.current.err
-	}
-	next := *d.publishedOptions.Load()
-	next.dicts = maps.Clone(next.dicts)
-	next.resetOpt = true
+	d.o.resetOpt = true
+	defer func() { d.o.resetOpt = false }()
 	for _, o := range opts {
-		if err := o(&next); err != nil {
-			next.resetOpt = false
-			d.publishedOptions.Store(&next)
+		if err := o(&d.o); err != nil {
 			return err
 		}
 	}
-	next.resetOpt = false
-	d.publishedOptions.Store(&next)
 	return d.Reset(r)
 }

@@ -358,8 +324,6 @@ func (d *Decoder) DecodeAll(input, dst []byte) ([]byte, error) {
 	// Grab a block decoder and frame decoder.
 	block := <-d.decoders
 	frame := block.localFrame
-	o := *d.publishedOptions.Load()
-	frame.setOptions(o)
 	initialSize := len(dst)
 	defer func() {
 		if debugDecoder {
@@ -371,7 +335,6 @@ func (d *Decoder) DecodeAll(input, dst []byte) ([]byte, error) {
 			frame.history.decoders.br.in = nil
 			frame.history.decoders.br.cursor = 0
 		}
-		frame.o.dicts = nil
 		d.decoders <- block
 	}()
 	frame.bBuf = input
@@ -391,20 +354,20 @@ func (d *Decoder) DecodeAll(input, dst []byte) ([]byte, error) {
 		if err = d.setDict(frame); err != nil {
 			return nil, err
 		}
-		if frame.WindowSize > frame.o.maxWindowSize {
+		if frame.WindowSize > d.o.maxWindowSize {
 			if debugDecoder {
-				println("window size exceeded:", frame.WindowSize, ">", frame.o.maxWindowSize)
+				println("window size exceeded:", frame.WindowSize, ">", d.o.maxWindowSize)
 			}
 			return dst, ErrWindowSizeExceeded
 		}
 		if frame.FrameContentSize != fcsUnknown {
-			if frame.FrameContentSize > frame.o.maxDecodedSize-uint64(len(dst)-initialSize) {
+			if frame.FrameContentSize > d.o.maxDecodedSize-uint64(len(dst)-initialSize) {
 				if debugDecoder {
-					println("decoder size exceeded; fcs:", frame.FrameContentSize, "> mcs:", frame.o.maxDecodedSize-uint64(len(dst)-initialSize), "len:", len(dst))
+					println("decoder size exceeded; fcs:", frame.FrameContentSize, "> mcs:", d.o.maxDecodedSize-uint64(len(dst)-initialSize), "len:", len(dst))
 				}
 				return dst, ErrDecoderSizeExceeded
 			}
-			if frame.o.limitToCap && frame.FrameContentSize > uint64(cap(dst)-len(dst)) {
+			if d.o.limitToCap && frame.FrameContentSize > uint64(cap(dst)-len(dst)) {
 				if debugDecoder {
 					println("decoder size exceeded; fcs:", frame.FrameContentSize, "> (cap-len)", cap(dst)-len(dst))
 				}
@@ -417,14 +380,14 @@ func (d *Decoder) DecodeAll(input, dst []byte) ([]byte, error) {
 			}
 		}

-		if cap(dst) == 0 && !frame.o.limitToCap {
+		if cap(dst) == 0 && !d.o.limitToCap {
 			// Allocate len(input) * 2 by default if nothing is provided
 			// and we didn't get frame content size.
 			size := min(
 				// Cap to 1 MB.
 				len(input)*2, 1<<20)
-			if uint64(size) > frame.o.maxDecodedSize {
-				size = int(frame.o.maxDecodedSize)
+			if uint64(size) > d.o.maxDecodedSize {
+				size = int(d.o.maxDecodedSize)
 			}
 			dst = make([]byte, 0, size)
 		}
@@ -433,7 +396,7 @@ func (d *Decoder) DecodeAll(input, dst []byte) ([]byte, error) {
 		if err != nil {
 			return dst, err
 		}
-		if uint64(len(dst)-initialSize) > frame.o.maxDecodedSize {
+		if uint64(len(dst)-initialSize) > d.o.maxDecodedSize {
 			return dst, ErrDecoderSizeExceeded
 		}
 		if len(frame.bBuf) == 0 {
@@ -496,7 +459,7 @@ func (d *Decoder) nextBlock(blocking bool) (ok bool) {
 		println("got", len(d.current.b), "bytes, error:", d.current.err, "data crc:", tmp)
 	}

-	if d.frame.o.ignoreChecksum {
+	if d.o.ignoreChecksum {
 		return true
 	}

@@ -534,7 +497,7 @@ func (d *Decoder) nextBlockSync() (ok bool) {
 			if d.current.err != nil {
 				return false
 			}
-			if d.frame.WindowSize > d.frame.o.maxDecodedSize || d.frame.WindowSize > d.frame.o.maxWindowSize {
+			if d.frame.WindowSize > d.o.maxDecodedSize || d.frame.WindowSize > d.o.maxWindowSize {
 				d.current.err = ErrDecoderSizeExceeded
 				return false
 			}
@@ -583,11 +546,11 @@ func (d *Decoder) nextBlockSync() (ok bool) {

 		// Update/Check CRC
 		if d.frame.HasCheckSum {
-			if !d.frame.o.ignoreChecksum {
+			if !d.o.ignoreChecksum {
 				d.frame.crc.Write(d.current.b)
 			}
 			if d.current.d.Last {
-				if !d.frame.o.ignoreChecksum {
+				if !d.o.ignoreChecksum {
 					d.current.err = d.frame.checkCRC()
 				} else {
 					d.current.err = d.frame.consumeCRC()
@@ -693,8 +656,8 @@ func (d *Decoder) startStreamDecoder(ctx context.Context, r io.Reader, output ch
 	defer d.streamWg.Done()
 	br := readerWrapper{r: r}

-	var seqDecode = make(chan *blockDec, d.frame.o.concurrent)
-	var seqExecute = make(chan *blockDec, d.frame.o.concurrent)
+	var seqDecode = make(chan *blockDec, d.o.concurrent)
+	var seqExecute = make(chan *blockDec, d.o.concurrent)

 	// Async 1: Decode sequences...
 	go func() {
@@ -895,9 +858,9 @@ decodeStream:
 		if err == nil {
 			err = d.setDict(frame)
 		}
-		if err == nil && d.frame.WindowSize > d.frame.o.maxWindowSize {
+		if err == nil && d.frame.WindowSize > d.o.maxWindowSize {
 			if debugDecoder {
-				println("decoder size exceeded, fws:", d.frame.WindowSize, "> mws:", d.frame.o.maxWindowSize)
+				println("decoder size exceeded, fws:", d.frame.WindowSize, "> mws:", d.o.maxWindowSize)
 			}

 			err = ErrDecoderSizeExceeded
@@ -977,7 +940,7 @@ decodeStream:
 }

 func (d *Decoder) setDict(frame *frameDec) (err error) {
-	dict, ok := frame.o.dicts[frame.DictionaryID]
+	dict, ok := d.o.dicts[frame.DictionaryID]
 	if ok {
 		if debugDecoder {
 			println("setting dict", frame.DictionaryID)
@@ -49,16 +49,13 @@ const (
 )

 func newFrameDec(o decoderOptions) *frameDec {
-	d := frameDec{}
-	d.setOptions(o)
-	return &d
-}
-
-func (d *frameDec) setOptions(o decoderOptions) {
 	if o.maxWindowSize > o.maxDecodedSize {
 		o.maxWindowSize = o.maxDecodedSize
 	}
-	d.o = o
+	d := frameDec{
+		o: o,
+	}
+	return &d
 }

 // reset will read the frame header and prepare for block decoding.
@@ -1,7 +1,7 @@
 // Code generated by command: go run gen_fse.go -out ../fse_decoder.s -arch amd64,arm64 -pkg=zstd. DO NOT EDIT.
 // EXPERIMENTAL arm64 output lowered from an amd64 avo program.

-//go:build arm64 && (!appengine && !noasm && gc && !noasm)
+//go:build arm64 && !appengine && !noasm && gc && !noasm

 // func buildDtable_asm(s *fseDecoder, ctx *buildDtableAsmContext) int
 TEXT ·buildDtable_asm(SB), $0-24
@@ -26,10 +26,11 @@ TEXT ·buildDtable_asm(SB), $0-24
 	JMP  init_main_loop_condition

 init_main_loop:
-	MOVH (R1)(R8<<1), R9
+	ADD  R8<<1, R1, R15
+	MOVH (R15), R9
+	AND  $0xffff, R9, R15
 	MOVD $-1, R16
 	AND  $0xffff, R16, R16
-	AND  $0xffff, R9, R15
 	CMP  R16, R15
 	BNE  do_not_update_high_threshold
 	ADD  R7<<3, R5, R15
@@ -38,7 +39,8 @@ init_main_loop:
 	MOVD $0x0000000000000001, R9

 do_not_update_high_threshold:
-	MOVH R9, (R3)(R8<<1)
+	ADD  R8<<1, R3, R15
+	MOVH R9, (R15)
 	ADD  $1, R8, R8

 init_main_loop_condition:
@@ -47,10 +49,12 @@ init_main_loop_condition:

 	// Spread symbols
 	// Calculate table step
-	LSR $0x01, R0, R8
-	LSR $0x03, R0, R9
-	ADD R9, R8, R8
-	ADD $3, R8, R8
+	MOVD R0, R8
+	LSR  $0x01, R8, R8
+	MOVD R0, R9
+	LSR  $0x03, R9, R9
+	ADD  R9, R8, R8
+	ADD  $3, R8, R8

 	// Fill add bits values
 	SUB  $1, R0, R9
@@ -60,7 +64,8 @@ init_main_loop_condition:

 spread_main_loop:
 	MOVD $0, R12
-	MOVH (R1)(R11<<1), R13
+	ADD  R11<<1, R1, R15
+	MOVH (R15), R13
 	JMP  spread_inner_loop_condition

 spread_inner_loop:
@@ -97,9 +102,11 @@ spread_check_ok:
 build_table_main_table:
 	ADD   R6<<3, R5, R15
 	MOVBU 1(R15), R1
-	MOVHU (R3)(R1<<1), R7
+	ADD   R1<<1, R3, R15
+	MOVHU (R15), R7
 	ADD   $1, R7, R8
-	MOVH  R8, (R3)(R1<<1)
+	ADD   R1<<1, R3, R15
+	MOVH  R8, (R15)
 	MOVD  R7, R8
 	CLZ   R8, R16
 	MOVD  $63, R8
@@ -122,10 +129,12 @@ build_table_main_table:
 	RET

 build_table_check1_ok:
-	TST  $0xff, R1
+	AND  $0xff, R1, R15
+	AND  $0xff, R1, R16
+	TST  R16, R15
 	BNE  build_table_check2_ok
-	AND  $0xffff, R6, R16
 	AND  $0xffff, R7, R15
+	AND  $0xffff, R6, R16
 	CMP  R16, R15
 	BNE  build_table_check2_ok
 	MOVD ctx+8(FP), R0
@@ -52,11 +52,6 @@ func (d *Digest) Reset() {
 	d.n = 0
 }

-// maxAsmSize bounds the input handed to a single writeBlocks call. Assembly is
-// never preemptible, so an unbounded call holds every P in stop-the-world for
-// its duration. Whole 32-byte blocks, so Write can feed it in pieces.
-const maxAsmSize = 128 << 10 // 4096 whole 32-byte blocks
-
 // Size always returns 8 bytes.
 func (d *Digest) Size() int { return 8 }

@@ -88,13 +83,6 @@ func (d *Digest) Write(b []byte) (n int, err error) {
 		d.n = 0
 	}

-	for len(b) >= maxAsmSize {
-		// Assembly is not preemptible, so hashing a large buffer in one call
-		// blocks every stop-the-world for the whole call. Feed it in chunks.
-		writeBlocks(d, b[:maxAsmSize])
-		b = b[maxAsmSize:]
-	}
-
 	if len(b) >= 32 {
 		// One or more full blocks left.
 		nw := writeBlocks(d, b)
@@ -175,11 +175,7 @@ finalize:
 	RET

 // func writeBlocks(d *Digest, b []byte) int
-//
-// Deliberately not NOSPLIT: the stack check is the preemption point that lets a
-// stop-the-world proceed between chunks. The frame must be >= abi.StackSmall
-// (128), or the assembler marks this leaf NOSPLIT anyway and drops that check.
-TEXT ·writeBlocks(SB), $128-40
+TEXT ·writeBlocks(SB), NOSPLIT|NOFRAME, $0-40
 	// Load fixed primes needed for round.
 	MOVQ ·primes+0(SB), prime1
 	MOVQ ·primes+8(SB), prime2
@@ -163,11 +163,7 @@ finalize:
 	RET

 // func writeBlocks(s *Digest, b []byte) int
-//
-// Deliberately not NOSPLIT: the stack check is the preemption point that lets a
-// stop-the-world proceed between chunks. The frame must be >= abi.StackSmall
-// (128), or the assembler marks this leaf NOSPLIT anyway and drops that check.
-TEXT ·writeBlocks(SB), $128-40
+TEXT ·writeBlocks(SB), NOSPLIT|NOFRAME, $0-40
 	LDP ·primes+0(SB), (prime1, prime2)

 	// Load state. Assume v[1-4] are stored contiguously.
@@ -99,29 +99,6 @@ func (s *sequenceDecs) initialize(br *bitReader, hist *history, out []byte) erro
 	return nil
 }

-// consumeSyncLen accounts for n bytes of frame output produced outside
-// decodeSync. maxSyncLen bounds how much the frame may still produce and
-// decodeSyncSimple compares it with the output buffer's slack to decide
-// whether the extended 16-byte copies are safe. Blocks with sequences
-// subtracted their output; raw blocks, RLE blocks and compressed blocks
-// holding only literals did not, so a frame that opened with a raw block
-// overstated its remaining size for every block after it and ran the
-// bounds-exact copies for the rest of the frame.
-//
-// Zero means "no bound" and selects the conservative paths, so a block that
-// meets or exceeds the bound lands there; the frame-size checks in
-// runDecoder reject the excess afterwards.
-func (s *sequenceDecs) consumeSyncLen(n int) {
-	if s.maxSyncLen == 0 {
-		return
-	}
-	if uint64(n) >= s.maxSyncLen {
-		s.maxSyncLen = 0
-		return
-	}
-	s.maxSyncLen -= uint64(n)
-}
-
 func (s *sequenceDecs) freeDecoders() {
 	if f := s.litLengths.fse; f != nil && !f.preDefined {
 		fseDecoderPool.Put(f)
@@ -83,10 +83,9 @@ const errorOverread = 6
 // When the output and literal buffers have compressedBlockOverAlloc (16)
 // bytes of slack past their logical use, the assembly may use extended
 // memory copies that read and write in 16-byte blocks, overrunning the end
-// of a literal run or match by up to 15 bytes; an empty literal run still
-// copies one block, reading and writing the full 16 bytes of slack past
-// its position. Otherwise it must use the bounds-exact ("safe") copies.
-// This mirrors the analogous, always-dynamic selection in executeSimple below.
+// of a literal run or match by up to 15 bytes. Otherwise it must use the
+// bounds-exact ("safe") copies. This mirrors the analogous, always-dynamic
+// selection in executeSimple below.
 //
 // The unsafe copies were disabled in #644 (2022) as a mitigation for a
 // crash, but that crash's root cause — an unguarded bitReader overread that
@@ -21,7 +21,7 @@ func Encode(authConfig registry.AuthConfig) (string, error) {
 	//
 	// FIXME(thaJeztah): find exactly what code-paths are impacted by this.
 	// if authConfig == (AuthConfig{}) { return "", nil }
-	buf, err := json.Marshal(authConfig) // #nosec G117 -- intentionally marshaling auth.
+	buf, err := json.Marshal(authConfig)
 	if err != nil {
 		return "", errInvalidParameter{err}
 	}
@@ -2,6 +2,9 @@

 package build

+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
 // DiskUsage represents system data usage for build cache resources.
 //
 // swagger:model DiskUsage
@@ -2,6 +2,9 @@

 package common

+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
 // ErrorResponse Represents an error.
 // Example: {"message":"Something went wrong."}
 //
@@ -2,6 +2,9 @@

 package common

+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
 // IDResponse Response to an API call that returns just an Id
 //
 // swagger:model IDResponse
@@ -2,6 +2,9 @@

 package container

+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
 // ChangeType Kind of change
 //
 // Can be one of:
@@ -2,6 +2,9 @@

 package container

+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
 // CreateResponse ContainerCreateResponse
 //
 // # OK response to ContainerCreate operation
@@ -2,6 +2,9 @@

 package container

+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
 // DiskUsage represents system data usage information for container resources.
 //
 // swagger:model DiskUsage
@@ -2,6 +2,9 @@

 package container

+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
 // FilesystemChange Change in the container's filesystem.
 //
 // swagger:model FilesystemChange
@@ -2,6 +2,9 @@

 package container

+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
 import (
 	"net/netip"
 )
@@ -2,6 +2,9 @@

 package container

+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
 // TopResponse ContainerTopResponse
 //
 // Container "top" response.
@@ -2,6 +2,9 @@

 package container

+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
 // UpdateResponse ContainerUpdateResponse
 //
 // Response for a successful container-update.
@@ -2,6 +2,9 @@

 package container

+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
 // WaitExitError container waiting error, if any
 //
 // swagger:model WaitExitError
@@ -2,6 +2,9 @@

 package container

+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
 // WaitResponse ContainerWaitResponse
 //
 // # OK response to ContainerWait operation
@@ -2,6 +2,9 @@

 package image

+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
 // DeleteResponse delete response
 //
 // swagger:model DeleteResponse
@@ -2,6 +2,9 @@

 package image

+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
 // DiskUsage represents system data usage for image resources.
 //
 // swagger:model DiskUsage
@@ -2,6 +2,9 @@

 package image

+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
 // HistoryResponseItem HistoryResponseItem
 //
 // individual image layer information in response to ImageHistory operation
@@ -2,6 +2,9 @@

 package network

+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
 // ConfigReference The config-only network source to provide the configuration for
 // this network.
 //
@@ -2,6 +2,9 @@

 package network

+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
 // ConnectRequest NetworkConnectRequest represents the data to be used to connect a container to a network.
 //
 // swagger:model ConnectRequest
@@ -2,6 +2,9 @@

 package network

+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
 // CreateResponse NetworkCreateResponse
 //
 // # OK response to NetworkCreate operation
@@ -2,6 +2,9 @@

 package network

+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
 // DisconnectRequest NetworkDisconnectRequest represents the data to be used to disconnect a container from a network.
 //
 // swagger:model DisconnectRequest
@@ -2,6 +2,9 @@

 package network

+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
 import (
 	"net/netip"
 )
@@ -2,6 +2,9 @@

 package network

+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
 // Inspect The body of the "get network" http response message.
 //
 // swagger:model Inspect
@@ -2,6 +2,9 @@

 package network

+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
 // IPAMStatus IPAM status
 //
 // swagger:model IPAMStatus
@@ -2,6 +2,9 @@

 package network

+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
 import (
 	timeext "time"
 )
@@ -2,6 +2,9 @@

 package network

+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
 import (
 	"net/netip"
 )
@@ -2,6 +2,9 @@

 package network

+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
 import (
 	"net/netip"
 )
@@ -2,6 +2,9 @@

 package network

+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
 // Status provides runtime information about the network such as the number of allocated IPs.
 //
 // swagger:model Status
@@ -2,6 +2,9 @@

 package network

+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
 // SubnetStatus subnet status
 //
 // swagger:model SubnetStatus
@@ -2,6 +2,9 @@

 package network

+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
 // Summary Network list response item
 //
 // swagger:model Summary
@@ -2,6 +2,9 @@

 package network

+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
 import (
 	"net/netip"
 )
@@ -2,6 +2,9 @@

 package plugin

+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
 // Device device
 //
 // swagger:model Device
--- a/Show More
+++ b/Show More
@@ -1 +1 @@
 .9.0
 .8.2