dash 3.2.0 → 3.2.1

data/lib/{kamal → dash}/configuration/docs/configuration.yml

@@ -81,7 +81,7 @@ asset_path: /path/to/assets
 
 # Hooks path
 #
-# Path to hooks, defaults to `.kamal/hooks`.
+# Path to hooks, defaults to `.dash/hooks` (`.kamal/hooks` is still read when only that exists).
 # See https://kamal-deploy.org/docs/hooks for more information:
 hooks_path: /user_home/kamal/hooks
 
@@ -106,8 +106,8 @@ hooks_output:
 
 # Secrets path
 #
-# Path to secrets, defaults to `.kamal/secrets`.
-# Kamal looks for `<secrets_path>-common` first and then `<secrets_path>`.
+# Path to secrets, defaults to `.dash/secrets` (`.kamal/secrets` is still read when only that exists).
+# dash looks for `<secrets_path>-common` first and then `<secrets_path>`.
 # When using destinations, it instead looks for `<secrets_path>-common` first and then
 # `<secrets_path>.<destination>`. Later files override earlier ones.
 secrets_path: /user_home/kamal/secrets
@@ -171,8 +171,15 @@ stop_timeout: 30
 
 # Run directory
 #
-# Directory to store dash runtime files in on the host, default `.kamal`:
-run_directory: /etc/kamal
+# Where dash keeps its runtime files on each host — per-app env and assets, the
+# proxy's boot files and apps-config mount, loadbalancer service claims, deploy
+# locks, and the audit log. Resolved against the SSH user's home, default
+# `.dash`. A host still holding the pre-3.4 `.kamal` directory is renamed to
+# `.dash` in place the next time dash takes a lock on it; nothing is rebooted.
+#
+# The key is accepted but not yet honoured — the path is currently always
+# `.dash`. Tracked separately from the stage-3 rename.
+run_directory: .dash
 
 # SSH options
 #

data/lib/{kamal → dash}/configuration/docs/env.yml

@@ -1,7 +1,7 @@
 # Environment variables
 #
-# Environment variables can be set directly in the Kamal configuration or
-# read from `.kamal/secrets`.
+# Environment variables can be set directly in the dash configuration or
+# read from `.dash/secrets`.
 
 # Reading environment variables from the configuration
 #
@@ -14,20 +14,20 @@ env:
 
 # Secrets
 #
-# Kamal uses dotenv to automatically load environment variables from the configured secrets files.
+# dash uses dotenv to automatically load environment variables from the configured secrets files.
 #
-# Common secrets across all destinations can be set in `.kamal/secrets-common`. Kamal looks for
-# `.kamal/secrets-common` first, then `.kamal/secrets`, with later values overriding earlier ones.
+# Common secrets across all destinations can be set in `.dash/secrets-common`. dash looks for
+# `.dash/secrets-common` first, then `.dash/secrets`, with later values overriding earlier ones.
 #
-# If you are using destinations, Kamal looks for `.kamal/secrets-common` first, then
-# `.kamal/secrets.<destination>`. The non-destination `.kamal/secrets` file is not read when a
+# If you are using destinations, dash looks for `.dash/secrets-common` first, then
+# `.dash/secrets.<destination>`. The non-destination `.dash/secrets` file is not read when a
 # destination is selected.
 #
-# This file can be used to set variables like `KAMAL_REGISTRY_PASSWORD` or database passwords.
+# This file can be used to set variables like `DASH_REGISTRY_PASSWORD` or database passwords.
 # You can use variable or command substitution in the secrets file.
 #
 # ```shell
-# KAMAL_REGISTRY_PASSWORD=$KAMAL_REGISTRY_PASSWORD
+# DASH_REGISTRY_PASSWORD=$DASH_REGISTRY_PASSWORD
 # RAILS_MASTER_KEY=$(cat config/master.key)
 # ```
 #
@@ -40,7 +40,7 @@ env:
 # DB_PASSWORD=$(dash secrets extract DB_PASSWORD $SECRETS)
 # ```
 #
-# If you store secrets directly in `.kamal/secrets`, ensure that it is not checked into version control.
+# If you store secrets directly in `.dash/secrets`, ensure that it is not checked into version control.
 #
 # To pass the secrets, you should list them under the `secret` key. When you do this, the
 # other variables need to be moved under the `clear` key.

data/lib/{kamal → dash}/configuration/docs/proxy.yml

@@ -16,7 +16,7 @@ proxy:
   # Where each option lives when a loadbalancer fronts the fleet
   #
   # Every deploy option has exactly one home (see
-  # Kamal::Configuration::Proxy::DEPLOY_OPTION_DISPOSITIONS - the layering
+  # Dash::Configuration::Proxy::DEPLOY_OPTION_DISPOSITIONS - the layering
   # contract that enforces this):
   #
   #   edge     - applied only by the loadbalancer, stripped from the per-host
@@ -88,13 +88,13 @@ proxy:
   # * Service names must be unique across apps. The loadbalancer registers a
   #   service under the bare `service:` name, so two apps — or two destinations
   #   of one app — sharing a name would take over each other's routes. The first
-  #   app to deploy claims the name in `.kamal/loadbalancer/services/<service>`
+  #   app to deploy claims the name in `.dash/loadbalancer/services/<service>`
   #   on the loadbalancer host; a second app deploying the same name fails at
   #   deploy time instead of silently winning.
   #
   # * Apps sharing a loadbalancer must agree on `proxy/run`. All of them boot the
   #   same container, so the first app to boot records its run configuration in
-  #   `.kamal/loadbalancer/run_config`. Another app booting with a different
+  #   `.dash/loadbalancer/run_config`. Another app booting with a different
   #   `proxy/run` fails; the same app changing its own gets the usual drift
   #   warning and applies it on `dash proxy reboot`.
   #
@@ -161,8 +161,8 @@ proxy:
   #
   # `client_ca_pem` requires mutual TLS: clients must present a certificate
   # signed by this CA bundle. Like `certificate_pem` it names a secret in
-  # `.kamal/secrets`; the content is uploaded next to the app's TLS material
-  # under `.kamal/proxy/apps-config`, and the proxy is given the path it sees
+  # `.dash/secrets`; the content is uploaded next to the app's TLS material
+  # under `.dash/proxy/apps-config`, and the proxy is given the path it sees
   # inside its own container. An empty secret fails the deploy rather than
   # silently turning mTLS off.
   ssl:
@@ -377,7 +377,7 @@ proxy:
   #
   # Set exactly one of `password_secret` or `password` — never both.
   #
-  # Prefer `password_secret`: it names an entry in `.kamal/secrets`, so the
+  # Prefer `password_secret`: it names an entry in `.dash/secrets`, so the
   # password never lives in this file.
   #
   #     basic_auth:
@@ -834,7 +834,7 @@ proxy:
                                    # below already embeds its ghcr.io host
     repository: ghcr.io/zoolutions/dash-proxy # Container repository for the
                                    # kamal-proxy image (this is the default)
-    version: v1.0.0.6              # Version tag of the kamal-proxy image to use.
+    version: v1.0.0.7              # Version tag of the kamal-proxy image to use.
                                    # Defaults to the minimum version this gem
                                    # requires - only pin it to roll forward early,
                                    # never below the default
@@ -880,7 +880,29 @@ proxy:
     # staging environment while you are working out a DNS setup, so you do not
     # burn production rate limits on failed attempts.
     #
-    # `credentials` names entries in `.kamal/secrets` to pass to the proxy
+    # `release_probe_interval` is how often, in seconds, the proxy re-checks a
+    # domain whose issuance is currently held - which is what decides how long
+    # after a DNS cutover the certificate appears (proxy v1.0.0.7+).
+    #
+    # You can point a host at dash before its DNS is repointed. No certificate
+    # is ordered until the first HTTPS request arrives, and the proxy first
+    # checks that the domain actually routes back to it - because until it does,
+    # an HTTP-01 challenge cannot succeed, and a failed attempt burns Let's
+    # Encrypt's limit of five failed authorizations per hostname per hour.
+    # Tripping that limit is what would otherwise delay the certificate at the
+    # moment of the cutover. Held domains are re-checked on this interval and
+    # issued as soon as the domain arrives, so the cutover costs one interval
+    # rather than a backoff step.
+    #
+    # The default is 60. A negative value switches release probing off, leaving
+    # a held domain to wait out its backoff. Zones covered by a DNS-01 provider
+    # skip all of this: DNS-01 never depends on where a domain points, so their
+    # certificates can be issued well before a cutover.
+    #
+    # `dash proxy domains list` shows what is held and why; `dash proxy domains
+    # retry HOST` clears a hold when you already know the cause is fixed.
+    #
+    # `credentials` names entries in `.dash/secrets` to pass to the proxy
     # container as environment variables - the API credentials your DNS provider
     # needs (`CF_DNS_API_TOKEN`, `LOOPIA_API_USER`, ...). Name them exactly as the
     # provider expects them, since the name is what reaches the container.
@@ -899,6 +921,7 @@ proxy:
         default: route53
       prefer_wildcard: true
       http_fallback: false
+      release_probe_interval: 60
       directory: https://acme-staging-v02.api.letsencrypt.org/directory
       credentials:
         - CF_DNS_API_TOKEN

data/lib/{kamal → dash}/configuration/docs/registry.yml

@@ -4,7 +4,7 @@
 
 # Using a local container registry
 #
-# If the registry server starts with `localhost`, Kamal will start a local Docker registry
+# If the registry server starts with `localhost`, dash will start a local Docker registry
 # on that port and push the app image to it.
 registry:
   server: localhost:5555
@@ -15,13 +15,13 @@ registry:
 # set up a private repository before deploying, or change the default repository privacy
 # settings to private in your [Docker Hub settings](https://hub.docker.com/repository-settings/default-privacy).
 #
-# A reference to a secret (in this case, `KAMAL_REGISTRY_PASSWORD`) will look up the secret
+# A reference to a secret (in this case, `DASH_REGISTRY_PASSWORD`) will look up the secret
 # in the local environment:
 registry:
   username:
     - <your docker hub username>
   password:
-    - KAMAL_REGISTRY_PASSWORD
+    - DASH_REGISTRY_PASSWORD
 
 # Using AWS ECR as the container registry
 #
@@ -45,7 +45,7 @@ registry:
 # base64 -i /path/to/key.json | tr -d "\\n"
 # ```
 #
-# You'll then need to set the `KAMAL_REGISTRY_PASSWORD` secret to that value.
+# You'll then need to set the `DASH_REGISTRY_PASSWORD` secret to that value.
 #
 # Use the environment variable as the password along with `_json_key_base64` as the username.
 # Here’s the final configuration:
@@ -53,7 +53,7 @@ registry:
   server: <your registry region>-docker.pkg.dev
   username: _json_key_base64
   password:
-    - KAMAL_REGISTRY_PASSWORD
+    - DASH_REGISTRY_PASSWORD
 
 # Validating the configuration
 #

data/lib/{kamal → dash}/configuration/env/tag.rb

@@ -1,4 +1,4 @@
-class Kamal::Configuration::Env::Tag
+class Dash::Configuration::Env::Tag
   attr_reader :name, :config, :secrets
 
   def initialize(name, config:, secrets:)
@@ -8,6 +8,6 @@ class Kamal::Configuration::Env::Tag
   end
 
   def env
-    Kamal::Configuration::Env.new(config: config, secrets: secrets)
+    Dash::Configuration::Env.new(config: config, secrets: secrets)
   end
 end

data/lib/{kamal → dash}/configuration/env.rb

@@ -1,15 +1,15 @@
-class Kamal::Configuration::Env
-  include Kamal::Configuration::Validation
+class Dash::Configuration::Env
+  include Dash::Configuration::Validation
 
   attr_reader :context, :clear, :secrets, :secret_keys
-  delegate :argumentize, to: Kamal::Utils
+  delegate :argumentize, to: Dash::Utils
 
   def initialize(config:, secrets:, context: "env")
     @clear = config.fetch("clear", config.key?("secret") || config.key?("tags") ? {} : config)
     @secrets = secrets
     @secret_keys = config.fetch("secret", [])
     @context = context
-    validate! config, context: context, with: Kamal::Configuration::Validator::Env
+    validate! config, context: context, with: Dash::Configuration::Validator::Env
   end
 
   def clear_args
@@ -17,7 +17,7 @@ class Kamal::Configuration::Env
   end
 
   def secrets_io
-    Kamal::EnvFile.new(aliased_secrets).to_io
+    Dash::EnvFile.new(aliased_secrets).to_io
   end
 
   def merge(other)

data/lib/{kamal → dash}/configuration/loadbalancer.rb

@@ -1,4 +1,4 @@
-class Kamal::Configuration::Loadbalancer < Kamal::Configuration::Proxy
+class Dash::Configuration::Loadbalancer < Dash::Configuration::Proxy
   CONTAINER_NAME = "load-balancer".freeze
   SHARED_CONTAINER_NAME = "kamal-proxy".freeze
 
@@ -40,7 +40,7 @@ class Kamal::Configuration::Loadbalancer < Kamal::Configuration::Proxy
   # mount and the run command) to boot from, so fall back to an empty config
   # rather than to nil.
   def run
-    @run ||= Kamal::Configuration::Proxy::Run.new(config, run_config: {})
+    @run ||= Dash::Configuration::Proxy::Run.new(config, run_config: {})
   end
 
   # Docker options for the load balancer container: publish/logging/options
@@ -100,7 +100,7 @@ class Kamal::Configuration::Loadbalancer < Kamal::Configuration::Proxy
 
   private
     # The edge half of the layering contract (see
-    # Kamal::Configuration::Proxy::DEPLOY_OPTION_DISPOSITIONS): the load
+    # Dash::Configuration::Proxy::DEPLOY_OPTION_DISPOSITIONS): the load
     # balancer applies the edge and shared concerns, and leaves the per-app
     # ones to the per-host proxies it forwards to.
     def retained_dispositions

data/lib/{kamal → dash}/configuration/logging.rb

@@ -1,7 +1,7 @@
-class Kamal::Configuration::Logging
-  delegate :optionize, :argumentize, to: Kamal::Utils
+class Dash::Configuration::Logging
+  delegate :optionize, :argumentize, to: Dash::Utils
 
-  include Kamal::Configuration::Validation
+  include Dash::Configuration::Validation
 
   attr_reader :logging_config
 

data/lib/{kamal → dash}/configuration/output.rb

@@ -1,9 +1,9 @@
-class Kamal::Configuration::Output
-  include Kamal::Configuration::Validation
+class Dash::Configuration::Output
+  include Dash::Configuration::Validation
 
   LOGGER_TYPES = {
-    "otel" => "Kamal::Output::OtelLogger",
-    "file" => "Kamal::Output::FileLogger"
+    "otel" => "Dash::Output::OtelLogger",
+    "file" => "Dash::Output::FileLogger"
   }
 
   attr_reader :output_config, :loggers

data/lib/{kamal → dash}/configuration/proxy/acme.rb

@@ -8,7 +8,7 @@
 # Credentials go the other way, through an env file uploaded at mode 0600. A DNS
 # API token can rewrite your zone; `docker run --env TOKEN=...` would put it in
 # the host's process listing and in kamal's own audit log.
-class Kamal::Configuration::Proxy::Acme
+class Dash::Configuration::Proxy::Acme
   # The canonical provider names kamal-proxy MINIMUM_VERSION advertises. Kept in
   # step with the proxy by test/proxy_flag_coverage_test.rb, which compares this
   # list against the manifest bin/sync-proxy-flags generates from the image.
@@ -53,7 +53,7 @@ class Kamal::Configuration::Proxy::Acme
   # as a stray argument. Both booleans default to true in the proxy, which makes
   # false the value an operator actually writes.
   def run_command_args
-    Kamal::Utils.optionize(run_command_options, with: "=")
+    Dash::Utils.optionize(run_command_options, with: "=")
   end
 
   # compact, not compact_blank: false is a meaningful value for both booleans.
@@ -63,7 +63,8 @@ class Kamal::Configuration::Proxy::Acme
       "acme-dns-provider": dns_provider_entries,
       "acme-directory": acme_config["directory"],
       "acme-prefer-wildcard": acme_config["prefer_wildcard"],
-      "acme-http-fallback": acme_config["http_fallback"]
+      "acme-http-fallback": acme_config["http_fallback"],
+      "acme-release-probe-interval": Dash::Utils.seconds_duration(acme_config["release_probe_interval"])
     }.compact
   end
 

data/lib/{kamal → dash}/configuration/proxy/boot.rb

@@ -1,6 +1,6 @@
-class Kamal::Configuration::Proxy::Boot
+class Dash::Configuration::Proxy::Boot
   attr_reader :config
-  delegate :argumentize, :optionize, to: Kamal::Utils
+  delegate :argumentize, :optionize, to: Dash::Utils
 
   def initialize(config:)
     @config = config
@@ -11,8 +11,8 @@ class Kamal::Configuration::Proxy::Boot
 
     (bind_ips || [ nil ]).map do |bind_ip|
       bind_ip = format_bind_ip(bind_ip)
-      publish_http = [ bind_ip, http_port, Kamal::Configuration::Proxy::Run::DEFAULT_HTTP_PORT ].compact.join(":")
-      publish_https = [ bind_ip, https_port, Kamal::Configuration::Proxy::Run::DEFAULT_HTTPS_PORT ].compact.join(":")
+      publish_http = [ bind_ip, http_port, Dash::Configuration::Proxy::Run::DEFAULT_HTTP_PORT ].compact.join(":")
+      publish_https = [ bind_ip, https_port, Dash::Configuration::Proxy::Run::DEFAULT_HTTPS_PORT ].compact.join(":")
 
       argumentize "--publish", [ publish_http, publish_https ]
     end.join(" ")
@@ -24,8 +24,8 @@ class Kamal::Configuration::Proxy::Boot
 
   def default_boot_options
     [
-      *(publish_args(Kamal::Configuration::Proxy::Run::DEFAULT_HTTP_PORT, Kamal::Configuration::Proxy::Run::DEFAULT_HTTPS_PORT, nil)),
-      *(logging_args(Kamal::Configuration::Proxy::Run::DEFAULT_LOG_MAX_SIZE))
+      *(publish_args(Dash::Configuration::Proxy::Run::DEFAULT_HTTP_PORT, Dash::Configuration::Proxy::Run::DEFAULT_HTTPS_PORT, nil)),
+      *(logging_args(Dash::Configuration::Proxy::Run::DEFAULT_LOG_MAX_SIZE))
     ]
   end
 
@@ -76,7 +76,7 @@ class Kamal::Configuration::Proxy::Boot
   end
 
   def apps_volume
-    Kamal::Configuration::Volume.new \
+    Dash::Configuration::Volume.new \
       host_path: apps_directory,
       container_path: apps_container_directory
   end

data/lib/{kamal → dash}/configuration/proxy/run.rb

@@ -1,12 +1,12 @@
-class Kamal::Configuration::Proxy::Run
-  MINIMUM_VERSION = "v1.0.0.6"
+class Dash::Configuration::Proxy::Run
+  MINIMUM_VERSION = "v1.0.0.7"
   DEFAULT_HTTP_PORT = 80
   DEFAULT_HTTPS_PORT = 443
   DEFAULT_LOG_MAX_SIZE = "10m"
 
   # One env file for everything the proxy must know but nothing may print:
   # ACME DNS credentials and the cache store URL. Also referenced by
-  # Kamal::Commands::Proxy#remove_proxy_secrets_file, which cleans it up when
+  # Dash::Commands::Proxy#remove_proxy_secrets_file, which cleans it up when
   # the config no longer needs it.
   SECRETS_FILENAME = "secrets.env"
 
@@ -15,7 +15,7 @@ class Kamal::Configuration::Proxy::Run
   DIGEST_SCHEMA_VERSION = "v1"
 
   attr_reader :config, :run_config
-  delegate :argumentize, :optionize, :seconds_duration, to: Kamal::Utils
+  delegate :argumentize, :optionize, :seconds_duration, to: Dash::Utils
 
   def initialize(config, run_config:, context: "proxy/run")
     @config = config
@@ -43,7 +43,7 @@ class Kamal::Configuration::Proxy::Run
   end
 
   def acme
-    @acme ||= Kamal::Configuration::Proxy::Acme.new(acme_config: run_config["acme"], secrets: config.secrets)
+    @acme ||= Dash::Configuration::Proxy::Acme.new(acme_config: run_config["acme"], secrets: config.secrets)
   end
 
   def debug?
@@ -194,7 +194,7 @@ class Kamal::Configuration::Proxy::Run
   # wakes - which the operator sees as one hung request, not as a misconfiguration.
   def docker_socket_args
     if docker_socket.present?
-      Kamal::Configuration::Volume.new(host_path: docker_socket, container_path: docker_socket).docker_args
+      Dash::Configuration::Volume.new(host_path: docker_socket, container_path: docker_socket).docker_args
     end
   end
 
@@ -212,7 +212,7 @@ class Kamal::Configuration::Proxy::Run
   end
 
   def secrets_io
-    Kamal::EnvFile.new(acme.credentials_env.merge(cache_store_env)).to_io
+    Dash::EnvFile.new(acme.credentials_env.merge(cache_store_env)).to_io
   end
 
   def host_directory
@@ -228,7 +228,7 @@ class Kamal::Configuration::Proxy::Run
   end
 
   def apps_volume
-    Kamal::Configuration::Volume.new \
+    Dash::Configuration::Volume.new \
       host_path: apps_directory,
       container_path: apps_container_directory
   end
@@ -255,7 +255,7 @@ class Kamal::Configuration::Proxy::Run
   end
 
   # Whether an operator turned on PROXY protocol without saying who may speak
-  # it. Kamal::Configuration warns about this: the header rewrites the
+  # it. Dash::Configuration warns about this: the header rewrites the
   # connecting address that allow_ips and rate_limit key on, so honouring it
   # from anywhere is a client-IP spoofing hole.
   def proxy_protocol_unrestricted?
@@ -264,7 +264,7 @@ class Kamal::Configuration::Proxy::Run
 
   private
     # The proxy's own listeners and process-level behaviour, as opposed to the
-    # per-service deadlines in Kamal::Configuration::Proxy#deploy_options. Zero
+    # per-service deadlines in Dash::Configuration::Proxy#deploy_options. Zero
     # disables each of the timeouts, so it is a value rather than an absence.
     def server_options
       {
@@ -295,7 +295,7 @@ class Kamal::Configuration::Proxy::Run
       conflicts = flags.keys.map(&:to_s) & named_run_command_options.keys.map(&:to_s)
       return true if conflicts.empty?
 
-      raise Kamal::ConfigurationError,
+      raise Dash::ConfigurationError,
         "#{@context}/flags: #{conflicts.sort.join(", ")} is already set by a named key - remove one of them"
     end
 

data/lib/{kamal → dash}/configuration/proxy.rb

@@ -1,5 +1,5 @@
-class Kamal::Configuration::Proxy
-  include Kamal::Configuration::Validation
+class Dash::Configuration::Proxy
+  include Dash::Configuration::Validation
 
   DEFAULT_LOG_REQUEST_HEADERS = [ "Cache-Control", "Last-Modified", "User-Agent" ]
   CONTAINER_NAME = "kamal-proxy"
@@ -163,12 +163,12 @@ class Kamal::Configuration::Proxy
   # where it matters.
   def self.disposition(key)
     DEPLOY_OPTION_DISPOSITIONS.fetch(key) do
-      raise Kamal::ConfigurationError,
-        "proxy deploy option --#{key} has no layering disposition - add it to Kamal::Configuration::Proxy::DEPLOY_OPTION_DISPOSITIONS"
+      raise Dash::ConfigurationError,
+        "proxy deploy option --#{key} has no layering disposition - add it to Dash::Configuration::Proxy::DEPLOY_OPTION_DISPOSITIONS"
     end
   end
 
-  delegate :argumentize, :optionize, :seconds_duration, to: Kamal::Utils
+  delegate :argumentize, :optionize, :seconds_duration, to: Dash::Utils
 
   attr_reader :config, :proxy_config, :role_name, :run, :secrets
 
@@ -182,8 +182,8 @@ class Kamal::Configuration::Proxy
     @role_name = role_name
     @load_balanced = load_balanced
     @secrets = secrets
-    validate! @proxy_config, with: Kamal::Configuration::Validator::Proxy, context: context
-    @run = Kamal::Configuration::Proxy::Run.new(config, run_config: @proxy_config["run"], context: "#{context}/run") if @proxy_config && @proxy_config["run"].present?
+    validate! @proxy_config, with: Dash::Configuration::Validator::Proxy, context: context
+    @run = Dash::Configuration::Proxy::Run.new(config, run_config: @proxy_config["run"], context: "#{context}/run") if @proxy_config && @proxy_config["run"].present?
   end
 
   def app_port
@@ -274,7 +274,7 @@ class Kamal::Configuration::Proxy
     ssl_config["on_demand_url"]
   end
 
-  # The name of a secret in .kamal/secrets holding the CA bundle client
+  # The name of a secret in .dash/secrets holding the CA bundle client
   # certificates must chain to - mirroring ssl.certificate_pem, not a local
   # file path. Kamal uploads the content into the app's TLS directory, which
   # the proxy container already mounts, and hands the proxy the path it sees
@@ -294,7 +294,7 @@ class Kamal::Configuration::Proxy
   def client_ca_pem_content
     secrets[client_ca_pem].tap do |content|
       if content.blank?
-        raise Kamal::ConfigurationError, "proxy/ssl: client_ca_pem secret '#{client_ca_pem}' is empty"
+        raise Dash::ConfigurationError, "proxy/ssl: client_ca_pem secret '#{client_ca_pem}' is empty"
       end
     end
   end
@@ -405,7 +405,7 @@ class Kamal::Configuration::Proxy
   private
     # Which dispositions this layer keeps. The per-app proxy behind a load
     # balancer sheds the edge concerns; without load balancing there is no
-    # other layer to defer to. Kamal::Configuration::Loadbalancer overrides
+    # other layer to defer to. Dash::Configuration::Loadbalancer overrides
     # this to keep the edge and shed the per-app concerns.
     def retained_dispositions
       load_balancing? ? %i[ per_app both ] : %i[ edge per_app both ]
@@ -417,7 +417,7 @@ class Kamal::Configuration::Proxy
 
     # Auto-activation needs a role the load balancer can actually front. The
     # target list is built from roles where `running_proxy?` (see
-    # Kamal::Cli::Proxy#loadbalancer), so a proxy-less primary role would boot a
+    # Dash::Cli::Proxy#loadbalancer), so a proxy-less primary role would boot a
     # load balancer with an empty --target. An explicit `loadbalancer:` setting
     # skips this check — the operator asked for it.
     def auto_load_balanced_primary_role?
@@ -473,7 +473,7 @@ class Kamal::Configuration::Proxy
     # app hosts have the docker socket and the containers).
     #
     # Sleep needs the container runtime socket, which is a run-level setting -
-    # Kamal::Configuration#ensure_sleep_has_a_docker_socket refuses the pairing
+    # Dash::Configuration#ensure_sleep_has_a_docker_socket refuses the pairing
     # rather than letting the first request after an idle period hang.
     def lifecycle_options
       affinity = proxy_config["session_affinity"] || {}
@@ -602,7 +602,7 @@ class Kamal::Configuration::Proxy
 
     # kamal-proxy takes the credential as <username>:<password> and cuts at the
     # first colon, so a password may contain colons but a username may not (the
-    # validator enforces that). The password is read from .kamal/secrets when
+    # validator enforces that). The password is read from .dash/secrets when
     # password_secret names it, so it need not live in deploy.yml.
     def basic_auth_credential
       basic_auth = proxy_config["basic_auth"]
@@ -619,13 +619,13 @@ class Kamal::Configuration::Proxy
       # means the named secret resolved empty. Fail rather than drop the flag —
       # silently deploying an unprotected service is the worse outcome.
       if password.blank?
-        raise Kamal::ConfigurationError, "proxy/basic_auth: password_secret '#{secret_name}' is empty"
+        raise Dash::ConfigurationError, "proxy/basic_auth: password_secret '#{secret_name}' is empty"
       end
 
       # Sensitive, so SSHKit redacts the credential wherever kamal prints the
       # deploy command - at :info verbosity it used to land in plain text
       # (registry-login precedent; Utils.optionize passes the marking through).
-      Kamal::Utils.sensitive("#{basic_auth["username"]}:#{password}")
+      Dash::Utils.sensitive("#{basic_auth["username"]}:#{password}")
     end
 
     # Serves both --path-timeout and --path-request-timeout, which kamal-proxy

data/lib/{kamal → dash}/configuration/registry.rb

@@ -1,10 +1,10 @@
-class Kamal::Configuration::Registry
-  include Kamal::Configuration::Validation
+class Dash::Configuration::Registry
+  include Dash::Configuration::Validation
 
   def initialize(config:, secrets:, context: "registry")
     @registry_config = config["registry"] || {}
     @secrets = secrets
-    validate! registry_config, context: context, with: Kamal::Configuration::Validator::Registry
+    validate! registry_config, context: context, with: Dash::Configuration::Validator::Registry
   end
 
   def server

data/lib/{kamal → dash}/configuration/role/healthcheck.rb

@@ -1,4 +1,4 @@
-class Kamal::Configuration::Role::Healthcheck
+class Dash::Configuration::Role::Healthcheck
   DEFAULT_PATH = "/up"
   DEFAULT_INTERVAL = 1
 
@@ -7,7 +7,7 @@ class Kamal::Configuration::Role::Healthcheck
   DOCKER_ONLY_KEYS = %w[ cmd port path interval timeout retries start_period start_interval ]
 
   attr_reader :healthcheck_config, :context
-  delegate :optionize, to: Kamal::Utils
+  delegate :optionize, to: Dash::Utils
 
   def initialize(healthcheck_config:, context: "healthcheck")
     @healthcheck_config = healthcheck_config
@@ -90,6 +90,6 @@ class Kamal::Configuration::Role::Healthcheck
     end
 
     def error(message, context: nil)
-      raise Kamal::ConfigurationError, "#{[ @context, context ].compact.join("/")}: #{message}"
+      raise Dash::ConfigurationError, "#{[ @context, context ].compact.join("/")}: #{message}"
     end
 end