dash 3.2.0 → 4.0.0

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
 #
@@ -194,7 +201,7 @@ accessories:
 
 # Proxy
 #
-# Configuration for kamal-proxy, see dash docs proxy:
+# Configuration for dash-proxy, see dash docs proxy:
 proxy:
   ...
 

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

@@ -1,6 +1,6 @@
 # Proxy
 #
-# Kamal uses [kamal-proxy](https://github.com/basecamp/kamal-proxy) to provide
+# Kamal uses [dash-proxy](https://github.com/basecamp/dash-proxy) to provide
 # gapless deployments. It runs on ports 80 and 443 and forwards requests to the
 # application container.
 #
@@ -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
@@ -74,13 +74,13 @@ proxy:
   # Sharing one loadbalancer between several dash apps
   #
   # More than one dash app may point `loadbalancer:` at the same host. Each app
-  # registers its own service on the shared kamal-proxy and keeps its own
+  # registers its own service on the shared dash-proxy and keeps its own
   # deploy.yml; the load balancer multiplexes them by hostname.
   #
   # The rules dash enforces for that topology:
   #
-  # * Service state survives a reboot. kamal-proxy persists its services in the
-  #   `kamal-loadbalancer-config` volume (or `kamal-proxy-config` when the
+  # * Service state survives a reboot. dash-proxy persists its services in the
+  #   `dash-loadbalancer-config` volume (or `dash-proxy-config` when the
   #   loadbalancer shares a proxy host), and `dash proxy reboot` only replaces
   #   the container. Rebooting from app A does not drop app B's routes — the
   #   surviving service list is printed after the restart.
@@ -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`.
   #
@@ -104,7 +104,7 @@ proxy:
 
   # Automatic proxy reboot on deploy
   #
-  # When `dash deploy` detects that the running kamal-proxy container was
+  # When `dash deploy` detects that the running dash-proxy container was
   # started with a different image, version or run options than the current
   # configuration, it reboots the proxy automatically — one host at a time —
   # before booting the app.
@@ -126,13 +126,13 @@ proxy:
 
   # SSL
   #
-  # kamal-proxy can provide automatic HTTPS for your application via Let's Encrypt.
+  # dash-proxy can provide automatic HTTPS for your application via Let's Encrypt.
   #
   # This requires that we are deploying to one server and the host option is set.
   # The host value must point to the server we are deploying to, and port 443 must be
   # open for the Let's Encrypt challenge to succeed.
   #
-  # If you set `ssl` to `true`, `kamal-proxy` will stop forwarding headers to your app,
+  # If you set `ssl` to `true`, `dash-proxy` will stop forwarding headers to your app,
   # unless you explicitly set `forward_headers: true`
   #
   # Defaults to `false`:
@@ -156,13 +156,13 @@ proxy:
   # absolute http(s) URL is called directly. Answer 2xx to approve. On-demand TLS
   # replaces the static hostname list, so it cannot be combined with
   # `host`/`hosts`, with `certificate_pem`, or with `ssl_domains` — dash rejects
-  # those at config time, because kamal-proxy would reject the deploy and there
+  # those at config time, because dash-proxy would reject the deploy and there
   # is no sensible winner to pick.
   #
   # `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:
@@ -176,7 +176,7 @@ proxy:
 
   # SSL redirect
   #
-  # By default, kamal-proxy will redirect all HTTP requests to HTTPS when SSL is enabled.
+  # By default, dash-proxy will redirect all HTTP requests to HTTPS when SSL is enabled.
   # If you prefer that HTTP traffic is passed through to your application (along with
   # HTTPS traffic), you can disable this redirect by setting `ssl_redirect: false`:
   ssl_redirect: false
@@ -244,7 +244,7 @@ proxy:
   #
   # If you are behind a trusted proxy, you can set this to `true` to forward the headers.
   #
-  # By default, kamal-proxy will not forward the headers if the `ssl` option is set to `true`, and
+  # By default, dash-proxy will not forward the headers if the `ssl` option is set to `true`, and
   # will forward them if it is set to `false`.
   forward_headers: true
 
@@ -278,7 +278,7 @@ proxy:
       set:
         Strict-Transport-Security: max-age=31536000
       add:
-        X-Served-By: kamal-proxy
+        X-Served-By: dash-proxy
       remove:
         - Server
 
@@ -329,7 +329,7 @@ proxy:
   #
   # Authentication tokens live in the PROXY's environment, not the app's: polls
   # send `KAMAL_PROXY_REDIRECTS_TOKEN` as a bearer token when set, and
-  # `POST /.kamal-proxy/redirects/refresh` nudges an immediate re-poll when
+  # `POST /.dash-proxy/redirects/refresh` nudges an immediate re-poll when
   # authenticated with `KAMAL_PROXY_REFRESH_TOKEN`. Set both via
   # `proxy.run.options.env`, next to `KAMAL_PROXY_DOMAINS_TOKEN` — never as
   # deploy flags, which leak into process listings and audit logs.
@@ -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:
@@ -397,19 +397,19 @@ proxy:
     password_secret: WEB_BASIC_AUTH_PASSWORD
   #
   # ### Notes
-  # - Requires a kamal-proxy that supports `--basic-auth`. This is newer than
+  # - Requires a dash-proxy that supports `--basic-auth`. This is newer than
   #   the current `MINIMUM_VERSION`, so make sure your proxy is up to date
   #   before enabling it — an older proxy fails the deploy on an unknown flag.
   # - Basic credentials are replayable and are sent on every request. Use this
   #   with `ssl: true`, or terminate TLS in front of the proxy.
-  # - kamal-proxy removes the `Authorization` header before forwarding, so a
+  # - dash-proxy removes the `Authorization` header before forwarding, so a
   #   service behind basic auth cannot also pass credentials through to its
   #   target. When load balancing, the credentials are enforced by the load
   #   balancer only.
 
   # Dynamic TLS domains
   #
-  # kamal-proxy can learn TLS hostnames from your application at runtime
+  # dash-proxy can learn TLS hostnames from your application at runtime
   # instead of fixing them at deploy time. It polls `source` — a path
   # (resolved against a healthy app target) or an absolute http(s) URL —
   # for the domain list and manages Let's Encrypt certificates for it
@@ -434,21 +434,21 @@ proxy:
   # Who the client is
   #
   # Rate limiting and IP allow lists are both only as correct as the address they
-  # key on, so configure this first if anything sits in front of kamal-proxy.
+  # key on, so configure this first if anything sits in front of dash-proxy.
   #
   # With no `trusted_proxies`, the client is always the address that opened the
   # connection — nothing a client sends can influence it, which is what makes the
   # allow list meaningful.
   #
   # Once you declare `trusted_proxies`, and only when the connecting address is
-  # one of them, kamal-proxy reads the forwarded chain instead: it walks the
+  # one of them, dash-proxy reads the forwarded chain instead: it walks the
   # chain from the nearest hop backwards past every proxy you declared, and the
   # first address none of your proxies wrote is the client. **List every hop**,
-  # not only the one that connects to kamal-proxy — a chain it cannot resolve
+  # not only the one that connects to dash-proxy — a chain it cannot resolve
   # denies the request rather than falling back to the connecting address.
   #
   # `header` names the header carrying the original client IP (`CF-Connecting-IP`
-  # behind Cloudflare, `True-Client-IP` behind some others); kamal-proxy reads it
+  # behind Cloudflare, `True-Client-IP` behind some others); dash-proxy reads it
   # instead of `X-Forwarded-For`. It is only honoured when `trusted_proxies` is
   # set, because otherwise it is just something the client wrote — dash rejects
   # that combination rather than appearing to honour it.
@@ -501,7 +501,7 @@ proxy:
   #
   # Refuse requests whose full User-Agent matches one of these RE2 patterns,
   # checked after the IP rules. A missing User-Agent only matches an explicit
-  # '^$' pattern. Patterns are matched by kamal-proxy (Go RE2), so dash checks
+  # '^$' pattern. Patterns are matched by dash-proxy (Go RE2), so dash checks
   # only their shape, not their syntax.
   deny_user_agents:
     - 'BadBot/.*'
@@ -661,7 +661,7 @@ proxy:
   # This block is the *policy*, and it is per service. Where the entries live is
   # proxy-wide and set under `run/cache` below.
   #
-  # Only `enabled` is required. Everything else keeps kamal-proxy's own default
+  # Only `enabled` is required. Everything else keeps dash-proxy's own default
   # until you set it.
   #
   # `max_ttl` caps the lifetime the app asks for, in seconds, so one mistaken
@@ -690,7 +690,7 @@ proxy:
   # ### When it is not caching
   #
   # A cache that quietly stores nothing is the usual first surprise. Start with
-  # `dash proxy cache stats`; kamal-proxy also explains every refusal — check
+  # `dash proxy cache stats`; dash-proxy also explains every refusal — check
   # `dash proxy logs` for the reason, and the `cache_refusals_total` metric
   # (by `reason`) if you run with `metrics_port`.
   # The common reasons are a missing `Cache-Control: public, max-age=...` on the
@@ -739,7 +739,7 @@ proxy:
 
   # Read-only targets
   #
-  # kamal-proxy can split traffic between the deployed (writer) targets and a
+  # dash-proxy can split traffic between the deployed (writer) targets and a
   # set of read-only targets, e.g. app instances backed by database replicas.
   # Read requests are routed to the read targets; write requests always go to
   # the writers.
@@ -771,7 +771,7 @@ proxy:
   # re-pinned, so a deploy does not strand anybody. Reads served by a
   # `read_targets` replica are never pinned.
   #
-  # `cookie` renames the pin cookie; kamal-proxy picks a sensible default.
+  # `cookie` renames the pin cookie; dash-proxy picks a sensible default.
   session_affinity:
     enabled: true
     cookie: _kamal_affinity
@@ -827,19 +827,19 @@ proxy:
     publish: false                 # Publish ports to the host (default: true)
     bind_ips:                      # List of IPs to bind to when publishing ports
       - 0.0.0.0
-    registry: registry:4443        # Extra registry prefix for the kamal-proxy image
+    registry: registry:4443        # Extra registry prefix for the dash-proxy image
                                    # (default: none). If you set this, also override
                                    # `repository` to a host-less path (e.g.
-                                   # myfork/kamal-proxy) - the default repository
+                                   # myfork/dash-proxy) - the default repository
                                    # 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.
+                                   # dash-proxy image (this is the default)
+    version: v1.1.0.0              # Version tag of the dash-proxy image to use.
                                    # Defaults to the minimum version this gem
                                    # requires - only pin it to roll forward early,
                                    # never below the default
     port_holder: true              # Zero-downtime proxy reboots (default: false).
-                                   # Runs a minimal long-lived kamal-proxy-net container that
+                                   # Runs a minimal long-lived dash-proxy-net container that
                                    # owns the published ports; proxy generations join its
                                    # network namespace and overlap during a reboot, so config
                                    # and version changes apply without dropping requests.
@@ -857,7 +857,7 @@ proxy:
     # DNS-01 on their own. `auto` is an explicit opt-in that picks the provider
     # from the credentials it can see and logs at boot which one it armed;
     # `none` says "no DNS-01" explicitly. An unsupported name is rejected here,
-    # at config time - kamal-proxy would only log a warning and then never
+    # at config time - dash-proxy would only log a warning and then never
     # issue a certificate.
     #
     # A plain string (`dns_provider: cloudflare`) uses one provider for every
@@ -866,7 +866,7 @@ proxy:
     # spread across registrars. Each provider's API credentials must be present
     # under `credentials` for its challenges to succeed.
     #
-    # kamal-proxy also accepts short aliases for the canonical names - `cf`
+    # dash-proxy also accepts short aliases for the canonical names - `cf`
     # (cloudflare), `do` (digitalocean), `gcp`/`google`/`googledns` (gcloud),
     # `gd` (godaddy), `hz` (hetzner), `nc` (namecheap), `aws`/`r53` (route53)
     # and `vr` (vultr). Prefer the canonical name; the aliases exist so a
@@ -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
@@ -995,15 +1018,15 @@ proxy:
     # Defaults to false:
     reuse_port: true
 
-    # Escape hatch for `kamal-proxy run`
+    # Escape hatch for `dash-proxy run`
     #
-    # Anything kamal-proxy accepts that has no key above. Note the difference
+    # Anything dash-proxy accepts that has no key above. Note the difference
     # from `options` below, which many people expect to do this: `flags` goes to
-    # `kamal-proxy run`, `options` goes to `docker run`.
+    # `dash-proxy run`, `options` goes to `docker run`.
     #
     # `true` renders a bare flag; anything else renders `--flag value`. No
     # translation is applied, so write Go durations and lists the way
-    # kamal-proxy wants them.
+    # dash-proxy wants them.
     #
     # A key here that a named setting already emits is rejected rather than
     # passed twice — set one or the other.
@@ -1014,7 +1037,7 @@ proxy:
     #
     # Path to the container runtime socket, which is what `proxy/sleep` needs in
     # order to stop and start containers. Setting it does two things: it passes
-    # the path to kamal-proxy, and it mounts that path into the proxy container,
+    # the path to dash-proxy, and it mounts that path into the proxy container,
     # since the flag alone only says where to look.
     #
     # **Reaching this socket is root-equivalent on the host.** It is a separate,
@@ -1050,11 +1073,11 @@ proxy:
       store_timeout: 2
       memory_size: 134_217_728
     # `options` are `docker run` options for the proxy container - resource
-    # limits, labels, extra mounts - NOT kamal-proxy flags. A kamal-proxy flag
+    # limits, labels, extra mounts - NOT dash-proxy flags. A dash-proxy flag
     # the gem has no key for goes in `flags` above instead.
     options:                       # Additional options to pass to `docker run`
       label:
-        - custom.label=kamal-proxy
+        - custom.label=dash-proxy
       memory: 512m
       cpus: 0.5
 

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,6 +1,6 @@
-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
+  SHARED_CONTAINER_NAME = "dash-proxy".freeze
 
   def self.validation_config_key
     "proxy"
@@ -34,13 +34,13 @@ class Kamal::Configuration::Loadbalancer < Kamal::Configuration::Proxy
     File.join config.run_directory, "loadbalancer"
   end
 
-  # The load balancer is a kamal-proxy container, so proxy/run applies to it
+  # The load balancer is a dash-proxy container, so proxy/run applies to it
   # exactly as it does to the per-host proxies. Without a run block it still
   # needs the default surface (published ports, log rotation, the apps-config
   # 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

@@ -1,22 +1,22 @@
-# ACME configuration for the kamal-proxy container, including the DNS-01
+# ACME configuration for the dash-proxy container, including the DNS-01
 # challenge credentials.
 #
-# Everything here except the credentials becomes a `kamal-proxy run` flag, so it
+# Everything here except the credentials becomes a `dash-proxy run` flag, so it
 # lands in the run command and therefore in Proxy::Run#config_digest — changing
 # the block reboots the proxy on the next deploy.
 #
 # 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
-  # The canonical provider names kamal-proxy MINIMUM_VERSION advertises. Kept in
+class Dash::Configuration::Proxy::Acme
+  # The canonical provider names dash-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.
   DNS_PROVIDERS = %w[
     auto cloudflare digitalocean gcloud godaddy hetzner namecheap none route53 vultr
   ].freeze
 
-  # Short forms kamal-proxy's ParseProviderName accepts but does not advertise,
+  # Short forms dash-proxy's ParseProviderName accepts but does not advertise,
   # so they cannot be generated from --help and are not drift-checked.
   DNS_PROVIDER_ALIASES = %w[ cf do gcp google googledns gd hz nc aws r53 vr ].freeze
 
@@ -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,13 +63,14 @@ 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
 
   private
     # The hash form pins zones to the DNS host that serves them; `default`
-    # covers unmatched zones. kamal-proxy takes repeatable --acme-dns-provider
+    # covers unmatched zones. dash-proxy takes repeatable --acme-dns-provider
     # entries — zone=provider pairs plus at most one bare default — so the hash
     # becomes an array and Utils.optionize repeats the flag. The string form
     # passes through untouched and keeps meaning what it always has.