A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
// SPDX-License-Identifier: AGPL-3.0-or-later
package instance
var envSecretVars = []string{
"FLUXER_SETUP_TOKEN", "POSTGRES_PASSWORD", "MEILI_MASTER_KEY", "FLUXER_S3_SECRET_KEY", "LIVEKIT_API_SECRET",
"FLUXER_SUDO_MODE_SECRET", "FLUXER_CONNECTION_INITIATION_SECRET", "FLUXER_PROFILE_PSEUDONYM_SECRET", "FLUXER_VAPID_PRIVATE_KEY",
"FLUXER_GATEWAY_RPC_AUTH_TOKEN", "FLUXER_MEDIA_PROXY_SECRET_KEY", "FLUXER_MEDIA_PROXY_UPLOAD_RELAY_SECRET_BASE64",
"FLUXER_ADMIN_SECRET_KEY_BASE", "FLUXER_ADMIN_OAUTH_CLIENT_SECRET", "FLUXER_ADMIN_SSO_CLIENT_SECRET", "FLUXER_ERLANG_COOKIE", "FLUXER_ACTIVITYPUB_SIGNING_KEY_BASE64",
"FLUXER_API_DONATION_PROXY_KEY", "FLUXER_API_TRUSTED_CALLERS", "FLUXER_CACHE_PURGE_HTTP_TOKEN", "FLUXER_CACHE_PURGE_CONTROLLER_TOKEN",
"FLUXER_NATS_AUTH_TOKEN", "FLUXER_SEARCH_PASSWORD", "FLUXER_AUTH_BLUESKY_KEYS", "FLUXER_EMAIL_WEBHOOK_SECRET",
"FLUXER_EMAIL_SMTP_PASSWORD", "FLUXER_EMAIL_FALLBACK_SMTP_PASSWORD", "FLUXER_PUSH_APNS_PRIVATE_KEY", "FLUXER_PUSH_FCM_PRIVATE_KEY",
"FLUXER_MEDIA_PROXY_ATTACHMENT_URL_SECRETS_BASE64", "FLUXER_STRIPE_SECRET_KEY", "FLUXER_STRIPE_WEBHOOK_SECRET",
"FLUXER_KLIPY_API_KEY", "FLUXER_YOUTUBE_API_KEY", "FLUXER_S3_SESSION_TOKEN", "FLUXER_POSTGRES_URL",
}
var envNoFileVars = []string{
"BUILD_VERSION",
"FLUXER_API_PORT",
"FLUXER_CLIENT_IP_HEADER_NAME",
"FLUXER_DISABLE_RATE_LIMITS",
"FLUXER_ENV",
"FLUXER_ERLANG_DIRTY_CPU_SCHEDULERS",
"FLUXER_ERLANG_DIRTY_IO_SCHEDULERS",
"FLUXER_ERLANG_DIST_PORT",
"FLUXER_ERLANG_NODE_NAME",
"FLUXER_ERLANG_NODE_NAME_PREFIX",
"FLUXER_ERLANG_SCHEDULERS",
"FLUXER_ERLANG_SCHEDULERS_MAX",
"FLUXER_ERLANG_SCHEDULERS_MIN",
"FLUXER_OPERATOR_SOCKET",
"HOSTNAME",
"LOG_LEVEL",
"POD_NAME",
"RELX_REPLACE_OS_VARS",
}
var envVars = []envVar{
{"FLUXER_SETTINGS_LOADED", "required", "Leave it set to `true`. Docker Compose won't start without it."},
{"FLUXER_DOMAIN", "required", ""},
{"FLUXER_SETUP_TOKEN", "admin", "The token the setup wizard asks for before it creates the first admin account. Use 32 to 256 printable characters, such as the output of `openssl rand -hex 32`. When it's empty, the API generates one on its first start and writes it to its log once. With Docker Compose, `docker compose logs api` shows it."},
{"POSTGRES_PASSWORD", "secrets", "The Postgres password. Docker Compose passes it to Fluxer as FLUXER_POSTGRES_PASSWORD and to the bundled Postgres, which sets it only on its first start with an empty data directory."},
{"MEILI_MASTER_KEY", "secrets", "The Meilisearch master key. Docker Compose passes it to the bundled Meilisearch and to Fluxer as FLUXER_SEARCH_API_KEY."},
{"FLUXER_S3_ACCESS_KEY", "secrets", "Keep the default for the bundled object store, or set the access key of your own store."},
{"FLUXER_S3_SECRET_KEY", "secrets", "For your own object store, set its secret key, and update it when you rotate the key at the store."},
{"LIVEKIT_API_KEY", "secrets", "The LiveKit API key. Docker Compose passes it to the bundled LiveKit as its API key and webhook key, and to Fluxer as FLUXER_LIVEKIT_API_KEY."},
{"LIVEKIT_API_SECRET", "secrets", "The LiveKit API secret that goes with LIVEKIT_API_KEY, at least 32 characters. Docker Compose passes it to the bundled LiveKit and to Fluxer as FLUXER_LIVEKIT_API_SECRET."},
{"FLUXER_SUDO_MODE_SECRET", "secrets", "The key Fluxer signs sudo mode tokens with and derives a few other internal signing keys from. Changing it ends every active sudo mode session, voids codes already emailed and makes every remembered device count as new."},
{"FLUXER_CONNECTION_INITIATION_SECRET", "secrets", "The key that signs connection initiation tokens, data export links and admin download links. Changing it breaks tokens not yet verified and download links already sent."},
{"FLUXER_PROFILE_PSEUDONYM_SECRET", "secrets", "The key Fluxer uses to derive the placeholder name and tag that others see while an account's profile is hidden. The api, worker and users services must have the same value. Changing it gives every hidden profile a new placeholder."},
{"FLUXER_VAPID_PUBLIC_KEY", "secrets", "The public half of the VAPID key pair for browser push notifications, as unpadded base64url of the 65-byte uncompressed P-256 point. The value is 87 characters long."},
{"FLUXER_VAPID_PRIVATE_KEY", "secrets", "The private half of the VAPID key pair for browser push notifications, as unpadded base64url of the 32-byte P-256 private key. The value is 43 characters long. It must match FLUXER_VAPID_PUBLIC_KEY."},
{"FLUXER_GATEWAY_RPC_AUTH_TOKEN", "secrets", "The token the api, worker, gateway and push services use to authenticate internal calls to each other. Every service must have the same value."},
{"FLUXER_MEDIA_PROXY_SECRET_KEY", "secrets", "The key that signs the `/external/` URLs for third-party media, such as link preview images and GIF results. The API also uses it to call the media proxy's internal endpoints. It doesn't sign uploaded attachments, which use FLUXER_MEDIA_PROXY_ATTACHMENT_URL_SECRETS_BASE64. The api, worker, media-proxy, gifs and unfurl services must have the same value, so change it on all of them and restart them together. Changing it doesn't affect anything stored, but proxy URLs that were already handed out stop working, such as link preview images in clients that are already open, until they reload."},
{"FLUXER_MEDIA_PROXY_UPLOAD_RELAY_SECRET_BASE64", "secrets", "The key that signs upload relay tokens, as standard base64 that decodes to at least 32 bytes. The api, worker and media-proxy services must have the same value."},
{"FLUXER_ADMIN_SECRET_KEY_BASE", "secrets", "The key the admin panel signs its sessions, CSRF tokens and OAuth state with. Changing it signs everyone out of the admin panel."},
{"FLUXER_ADMIN_OAUTH_CLIENT_SECRET", "secrets", "The OAuth2 client secret the admin panel uses to sign in through the API. The api and admin services must have the same value."},
{"FLUXER_ERLANG_COOKIE", "secrets", "The shared secret for Erlang distribution in the gateway. Anyone who can connect to the distribution port with this value can run code in the gateway. Keep the value secret and the port private."},
{"FLUXER_ACTIVITYPUB_SIGNING_KEY_BASE64", "secrets", "The RSA private key the unfurl service signs ActivityPub requests with when it builds link previews for fediverse posts. Use base64 DER in PKCS#8 or PKCS#1 form. When it's empty, the unfurl service makes those requests unsigned."},
{"COMPOSE_FILE", "compose", "The compose files Docker Compose uses, with docker-compose.yml first. Separate them with colons, or with semicolons on Windows. rexctl takeover uses the value in your shell first and then the one in .env. Leave it commented out to use docker-compose.yml and, if there is one, docker-compose.override.yml. An empty value stops Docker Compose from finding any file."},
{"COMPOSE_PATH_SEPARATOR", "compose", "The separator between the files in COMPOSE_FILE. When it's empty, Docker Compose and rexctl use a colon, or a semicolon on Windows."},
{"COMPOSE_PROJECT_NAME", "compose", "The Docker Compose project name, which Docker Compose puts in front of every container and volume name. When it's empty, Docker Compose uses `fluxer` from docker-compose.yml. rexctl eject writes the project name rexctl ran the instance under. Keep that value, or Docker Compose starts new containers with new, empty volumes. rexctl takeover uses the value in your shell first and then the one in .env."},
{"FLUXER_PUBLIC_SCHEME", "address", "The scheme browsers use to open the instance. Use `https` or `http`. Fluxer builds public addresses from it and FLUXER_DOMAIN when FLUXER_PUBLIC_ORIGIN is empty. With `http`, also set FLUXER_PUBLIC_PORT, usually to `80`. Without rexctl, the edge also uses it for its default site address."},
{"FLUXER_PUBLIC_ORIGIN", "address", "The origin browsers use to open the instance, as a scheme, host and optional port with no path or trailing slash, such as https://chat.example.com:8443. When it's set, the default public addresses of the api, worker and other services come from it. Keep FLUXER_DOMAIN set to the same host. The edge site address, the passkey relying party ID, the default sender and VAPID contact addresses and the gateway still use FLUXER_DOMAIN."},
{"FLUXER_APP_ORIGIN_ALIASES", "address", "More web app origins, separated by commas, for an instance that serves the web app on more than one hostname. Each must be an http or https origin. The API allows each one through CORS and accepts it for sign-in handoff. For passkeys on these origins, list them and the web app origin in FLUXER_PASSKEY_ADDITIONAL_ALLOWED_ORIGINS."},
{"FLUXER_API_ENDPOINT", "address", "The public base URL of the API. When it's empty, Fluxer uses the public origin followed by /api."},
{"FLUXER_API_CLIENT_ENDPOINT", "address", "The API base URL Fluxer hands to clients. When it's empty, Fluxer uses the public origin followed by /api."},
{"FLUXER_API_DISCOVERY_PUBLIC_ENDPOINT", "address", "The public API base URL Fluxer lists in instance discovery as `api_public`. The ActivityPub actor and its key ID use the same address, so its host must serve /.well-known/webfinger, and changing it on an instance with a signing key gives remote servers a new actor. When it's empty, Fluxer uses FLUXER_API_ENDPOINT. Webhooks, signed links and Bluesky sign-in always use FLUXER_API_ENDPOINT."},
{"FLUXER_APP_ENDPOINT", "address", "The address of the web app, which Fluxer allows through CORS and uses in links. When it's empty, Fluxer uses the public origin."},
{"FLUXER_GATEWAY_ENDPOINT", "address", "The public WebSocket URL of the gateway, starting with `ws` or `wss`. When it's empty, Fluxer uses `wss` on the public host followed by /gateway, or `ws` when the public scheme is `http`."},
{"FLUXER_MEDIA_ENDPOINT", "address", "The public address of the media proxy. When it's empty, Fluxer uses the public origin followed by /media."},
{"FLUXER_MEDIA_PROXY_PUBLIC_ENDPOINT", "address", "The public media proxy address that the gifs, unfurl and media-proxy services use when they build media links. When it's empty, they use FLUXER_MEDIA_ENDPOINT, or the public origin followed by /media."},
{"FLUXER_STATIC_CDN_ENDPOINT", "address", "The origin Fluxer serves static assets such as the favicon and app icons from. When it's empty, the api and worker services derive it from FLUXER_STATIC_CDN_DOMAIN or the public origin, and the admin and gateway services use the public origin. The app-proxy service uses it only when it's set, and serves its own copies of the web app files otherwise."},
{"FLUXER_ADMIN_ENDPOINT", "address", "The public address of the admin panel. When it's empty, Fluxer uses the public origin followed by FLUXER_ADMIN_BASE_PATH. The admin sign-in redirect is this address followed by /oauth2_callback, the single sign-on redirect is this address followed by /sso/callback, and the admin panel uses secure cookies when the address starts with `https`."},
{"FLUXER_MARKETING_ENDPOINT", "address", "The address of the marketing site, which Fluxer allows through CORS and uses in some links. When it's empty, Fluxer uses the public origin."},
{"FLUXER_INVITE_ENDPOINT", "address", "The base URL of invite links. When it's empty, Fluxer uses FLUXER_INVITE_DOMAIN or the public host, followed by /invite."},
{"FLUXER_GIFT_ENDPOINT", "address", "The base URL of gift links. When it's empty, Fluxer uses FLUXER_GIFT_DOMAIN or the public host, followed by /gift."},
{"FLUXER_STATIC_CDN_DOMAIN", "address", "A separate hostname for static assets, with no scheme, port or path. When it's set, the default static address of the api and worker services is `https://` followed by this host."},
{"FLUXER_INVITE_DOMAIN", "address", "A separate hostname for invite links, with no scheme, port or path. When it's set, the default invite address uses this host."},
{"FLUXER_GIFT_DOMAIN", "address", "A separate hostname for gift links, with no scheme, port or path. When it's set, the default gift address uses this host."},
{"FLUXER_PUBLIC_PORT", "edge", ""},
{"FLUXER_HTTP_PORT", "edge", "docker-compose.proxy.yml and tunnel.compose.yml ignore it and use FLUXER_EDGE_BIND."},
{"FLUXER_HTTPS_PORT", "edge", "If people connect to this port directly, set FLUXER_PUBLIC_PORT to the same port. docker-compose.proxy.yml and tunnel.compose.yml ignore it and use FLUXER_EDGE_BIND."},
{"FLUXER_EDGE_BIND", "edge", ""},
{"FLUXER_EDGE_LISTEN_ADDRESS", "edge", "Write an IPv6 address without brackets. docker-compose.proxy.yml and tunnel.compose.yml ignore it and use FLUXER_EDGE_BIND."},
{"FLUXER_ADMIN_BASE_PATH", "edge", "The path the admin panel is served under, with a leading slash and no trailing slash, such as /panel. The edge serves the admin panel under this path, the admin service builds its links with it, and the default FLUXER_ADMIN_ENDPOINT follows it."},
{"FLUXER_EDGE_SITE_ADDRESS", "edge", "The site address the edge serves in its Caddyfile, including the scheme. When it's empty, Docker Compose uses FLUXER_CADDY_SITE_ADDRESS, or FLUXER_PUBLIC_SCHEME followed by `://` and FLUXER_DOMAIN. docker-compose.proxy.yml and tunnel.compose.yml set their own value."},
{"FLUXER_CADDY_SITE_ADDRESS", "edge", "The old name for FLUXER_EDGE_SITE_ADDRESS. Docker Compose uses it only without rexctl and when FLUXER_EDGE_SITE_ADDRESS is empty. rexctl takeover and rexctl upgrade move it to FLUXER_EDGE_SITE_ADDRESS."},
{"FLUXER_EDGE_TRUSTED_PROXIES", "edge", ""},
{"FLUXER_EDGE_ENCODE", "edge", "The response compression the edge offers, written as the arguments of the Caddy encode directive, such as `gzip` alone."},
{"FLUXER_EDGE_PROTOCOLS", "edge", "The HTTP versions the edge serves, as the arguments of the Caddy protocols option, such as `h1 h2` to turn off HTTP/3."},
{"FLUXER_EDGE_GLOBAL_OPTIONS", "edge", "Extra Caddy global options on one line, added to the global block of the edge Caddyfile, such as `email [email protected]` for the certificate account. An empty value adds nothing."},
{"FLUXER_EDGE_TLS", "edge", "The arguments of a Caddy tls directive for the edge, such as `internal` for a certificate from Caddy's own local CA, or a certificate and key path under /certs. When it's empty, the edge adds no tls line and Caddy gets certificates on its own. docker-compose.proxy.yml and tunnel.compose.yml ignore it."},
{"FLUXER_LIVEKIT_ENABLED", "voice", "Whether voice and video calls are turned on. Use `true` or `false`."},
{"FLUXER_LIVEKIT_INTERNAL_URL", "voice", "The URL the API uses for the LiveKit control API of the bundled LiveKit, the first server in the default voice region. Servers added in the admin panel use their own address. Fluxer ignores it when FLUXER_LIVEKIT_BUNDLED is `false`."},
{"FLUXER_LIVEKIT_BUNDLED", "voice", "Use `true` or `false`. The bundled LiveKit is the first server in the default voice region. With `false`, Fluxer creates the default region with no server in it, removes the server it made for the bundled LiveKit and keeps calls on the servers you add with `rexctl voice add`, `rexctl voice join` or the admin panel. With Docker Compose, also add external-voice.compose.yml to COMPOSE_FILE."},
{"FLUXER_LIVEKIT_DEFAULT_REGION", "voice", "The voice region Fluxer creates when no voice regions exist yet, as a JSON object with `id`, `name`, `emoji`, `latitude` and `longitude`."},
{"FLUXER_LIVEKIT_URL", "voice", "The URL browsers and apps use for voice signalling. When it's empty, Fluxer uses the public origin, or FLUXER_PUBLIC_SCHEME, FLUXER_DOMAIN and FLUXER_PUBLIC_PORT, followed by /livekit. Set it only when LiveKit runs on another host."},
{"FLUXER_VOICE_P2P_STUN_URLS", "voice", "STUN URLs for peer-to-peer calls, separated by commas, such as `stun:stun.example.com:3478`. When it's empty, peer-to-peer calls work only between devices with a direct route to each other, such as on one local network."},
{"FLUXER_VOICE_JOIN_ALLOW_PRIVATE_ENDPOINTS", "voice", "Whether the API accepts a voice server joining with an endpoint that resolves to a private address. Use `true` or `false`. Set it to `true` only for tests and private networks."},
{"FLUXER_VOICE_HEALTH_INTERVAL_MS", "voice", "How often each API node checks every active voice server, in milliseconds. A server that fails two checks in a row gets no new calls until a check passes. Set it to `0` to turn the checks off. When it's empty, the API checks every 15 seconds."},
{"FLUXER_VOICE_PARTICIPANT_SWEEP_ENABLED", "voice", "Whether a worker compares each voice server's call participants with the gateway's call state every minute and disconnects connections the gateway has not known for two minutes. Use `true` or `false`. When it's empty, the check runs."},
{"FLUXER_VOICE_PARTICIPANT_SWEEP_DRY_RUN", "voice", "Whether the voice participant check from FLUXER_VOICE_PARTICIPANT_SWEEP_ENABLED only logs the connections it would disconnect. Use `true` or `false`. When it's empty, the check only logs them."},
{"FLUXER_LIVEKIT_TCP_PORT", "voice", ""},
{"FLUXER_LIVEKIT_UDP_PORT", "voice", ""},
{"FLUXER_LIVEKIT_NODE_IP", "voice", "Set FLUXER_LIVEKIT_USE_EXTERNAL_IP to `false` with it."},
{"FLUXER_LIVEKIT_USE_EXTERNAL_IP", "voice", "Whether LiveKit finds its public IP address through STUN. Use `true` or `false`. Set it to `false` when you set FLUXER_LIVEKIT_NODE_IP."},
{"FLUXER_LIVEKIT_STUN_PRIMARY", "voice", "The first STUN host LiveKit asks to find its public IP address, as `host:port`. Point it at another STUN host to avoid contacting Google."},
{"FLUXER_LIVEKIT_STUN_SECONDARY", "voice", "The second STUN host LiveKit asks to find its public IP address, as `host:port`."},
{"FLUXER_LIVEKIT_TURN_SERVERS", "voice", "TURN servers that browsers and apps get when they join a call, as a JSON array of objects with `host`, `port` and `protocol`, and either `username` and `credential` or `secret` with an optional `ttl`, such as `[{\"host\":\"turn.example.com\",\"port\":3478,\"protocol\":\"udp\",\"secret\":\"a-long-random-secret\"}]`. Use `udp`, `tcp` or `tls` for `protocol`, and a hostname or an IPv4 address for `host`. With `secret`, LiveKit makes short-lived credentials for each participant in the form coturn checks with `use-auth-secret`, and `ttl`, a whole number from 1, sets how many seconds they last. The bundled voice server and the servers you add with rexctl voice add give these to clients, and rexctl restarts the added servers one at a time when the list changes. A server that joined with rexctl voice join gets the list when it joins and on each rexctl upgrade in its voice folder, unless the instance runs an older release than the rexctl there. Set it when callers can't connect to a voice server directly, such as from networks that allow only port 443. When it's empty, clients get no TURN server. A value the API can't read stops it from starting, and rexctl config set refuses one."},
{"FLUXER_VOICE_ID", "voice-server", "The ID of the voice server, such as `fra-server-2`. Use lowercase letters, digits and dashes. The container uses `voice-` followed by this ID as its host name on the voice network, and the edge routes `/livekit-` followed by this ID to it."},
{"FLUXER_VOICE_API_KEY", "voice-server", "The LiveKit API key of this server. Every voice server of an instance needs its own key, such as `fluxer-` followed by the server ID."},
{"FLUXER_VOICE_API_SECRET", "voice-server", "The LiveKit API secret that goes with FLUXER_VOICE_API_KEY, at least 32 characters, such as the output of `openssl rand -hex 32`."},
{"FLUXER_VOICE_WEBHOOK_URL", "voice-server", "The URL LiveKit sends its webhooks to. On the Fluxer machine it's `http://api:8080/webhooks/livekit`. On another machine it's the public API address followed by /webhooks/livekit."},
{"FLUXER_VOICE_TCP_PORT", "voice-server", "The TCP port for media on this host. LiveKit listens on the same port inside the container, and each server on a host needs its own."},
{"FLUXER_VOICE_UDP_PORT", "voice-server", "The UDP port for media on this host. LiveKit listens on the same port inside the container, and each server on a host needs its own."},
{"FLUXER_VOICE_NODE_IP", "voice-server", "The public addresses LiveKit gives to clients. Give an IPv4 address, an IPv6 address, or both with a comma between them, such as `203.0.113.7,2001:db8::7`. Set FLUXER_VOICE_USE_EXTERNAL_IP to `false` with it. LiveKit offers an IPv6 address only when the server's Docker network has IPv6."},
{"FLUXER_VOICE_ICE_IPS", "voice-server", "The address ranges LiveKit may offer to clients, as a JSON array of ranges such as `[\"::/0\"]`. rexctl sets it to the families in FLUXER_VOICE_NODE_IP, and a server with only IPv6 then offers no private IPv4 address of its container. Use `[]` to offer every address."},
{"FLUXER_VOICE_USE_EXTERNAL_IP", "voice-server", "Whether LiveKit finds its public IP address through STUN. Use `true` or `false`."},
{"FLUXER_VOICE_BIND_IP", "voice-server", "The host address the media ports are published on, for a host with more than one public address. When it's empty, Docker publishes them on every address."},
{"FLUXER_VOICE_HTTP_PORT", "voice-server", "The port that voice-http.compose.yml publishes LiveKit's HTTP and WebSocket port on, for your own proxy."},
{"FLUXER_VOICE_HTTP_BIND", "voice-server", "The host address that voice-http.compose.yml publishes FLUXER_VOICE_HTTP_PORT on. The default is `127.0.0.1`. Use another address of the host, or `0.0.0.0` for every address, when your proxy runs in another network. Write an IPv6 address in brackets, such as `[2001:db8::5]`. The port has no TLS of its own. Let only your proxy's network connect to it in your firewall."},
{"FLUXER_VOICE_NETWORK", "voice-server", "The Docker network the server joins. On a voice machine it's the network of the voice edge. On the Fluxer machine it's the network of the instance, such as `fluxer_fluxer`, and Fluxer's own edge routes to the server."},
{"FLUXER_VOICE_MEMORY_LIMIT", "voice-server", "The memory limit for the server's container."},
{"FLUXER_VOICE_GOMEMLIMIT", "voice-server", "The soft memory limit of the Go runtime in LiveKit. Keep it at about 85% of FLUXER_VOICE_MEMORY_LIMIT."},
{"FLUXER_VOICE_STOP_GRACE", "voice-server", "How long Docker waits for the calls on the server to end when it stops or replaces the container, before it stops LiveKit anyway."},
{"FLUXER_VOICE_EDGE_IP", "voice-edge", "The public IPv4 address of the voice machine, when an endpoint uses that address and not a hostname. The edge then gives clients that send no server name the certificate for that address, which browsers need."},
{"FLUXER_VOICE_NETWORK_IPV6", "voice-edge", "Whether the voice network gets IPv6. Use `true` or `false`. rexctl sets it to `true` when it creates the network on a machine with a public IPv6 address. Docker can't add IPv6 to a network that already exists."},
{"FLUXER_VOICE_EDGE_EMAIL", "voice-edge", "The email address the voice edge gives Let's Encrypt for notices about its certificates. When it's empty, the edge gets certificates without one."},
{"FLUXER_S3_ENDPOINT", "storage", ""},
{"FLUXER_S3_PUBLIC_ENDPOINT", "storage", "When it's empty, the api and worker use FLUXER_S3_ENDPOINT, and the web app doesn't let browsers upload to the object store."},
{"FLUXER_S3_REGION", "storage", ""},
{"FLUXER_S3_FORCE_PATH_STYLE", "storage", "Use `true` or `false`."},
{"FLUXER_S3_SESSION_TOKEN", "storage", "A temporary S3 session token the media proxy sends with its object store requests. When it's empty, the media proxy sends none."},
{"FLUXER_S3_BUCKET_CDN", "storage", "The bucket for processed media such as avatars and other served assets. The bundled object store creates it, and an outside store needs it to exist already."},
{"FLUXER_S3_BUCKET_UPLOADS", "storage", "The bucket for raw uploads. The bundled object store creates it, and an outside store needs it to exist already."},
{"FLUXER_S3_BUCKET_REPORTS", "storage", "The bucket for abuse report evidence. The bundled object store creates it, and an outside store needs it to exist already."},
{"FLUXER_S3_BUCKET_HARVESTS", "storage", "The bucket for data export archives. The bundled object store creates it, and an outside store needs it to exist already."},
{"FLUXER_S3_READ_ENDPOINT", "storage", "A separate http or https address, with no credentials, that the media proxy fetches objects in FLUXER_S3_READ_BUCKET from. When it's empty, the media proxy fetches everything through FLUXER_S3_ENDPOINT."},
{"FLUXER_S3_READ_BUCKET", "storage", "The bucket the media proxy fetches through FLUXER_S3_READ_ENDPOINT. When it's empty, the media proxy uses FLUXER_S3_BUCKET_CDN."},
{"FLUXER_S3_READ_BUCKET_STYLE", "storage", "How the bucket appears in URLs to FLUXER_S3_READ_ENDPOINT. Use `path`, `virtual` or `root`. When it's empty, the media proxy uses `path` when FLUXER_S3_FORCE_PATH_STYLE is on and `virtual` when it's off."},
{"FLUXER_S3_READ_SIGNED", "storage", "Whether the media proxy signs its requests to FLUXER_S3_READ_ENDPOINT. Use `true` or `false`. Use `false` only for a bucket that allows anonymous downloads."},
{"FLUXER_API_PRESIGNED_ATTACHMENT_UPLOADS_ENABLED", "storage", "Whether the API hands clients upload URLs that let them upload attachments before they send the message. Use `true` or `false`."},
{"FLUXER_API_PRESIGNED_HARVEST_DOWNLOADS_ENABLED", "storage", "Whether data export and admin download links are presigned URLs to the object store. Use `true` or `false`. With `false`, the API serves those downloads itself. Turn it on only once browsers can connect to FLUXER_S3_PUBLIC_ENDPOINT."},
{"FLUXER_API_STORAGE_CHANGE_FEED_ENABLED", "storage", "Whether the api and worker services publish a record of each object store write and delete they make to a NATS JetStream stream. Uploads written by the media proxy relay or sent directly to the store by clients are not in it. Use `true` or `false`. When it's empty, the feed is off."},
{"FLUXER_API_STORAGE_CHANGE_FEED_STREAM", "storage", "The JetStream stream the storage change feed publishes to, in letters, digits, underscores or hyphens. When it's empty, Fluxer uses STORAGE_CHANGES."},
{"FLUXER_API_STORAGE_CHANGE_FEED_SKIP_BUCKETS", "storage", "Buckets the storage change feed leaves out, separated by commas, or `none` to leave out no bucket. When it's empty, the feed leaves out the uploads bucket."},
{"FLUXER_SEAWEEDFS_INIT_ATTEMPTS", "storage", "How many rounds, about two seconds apart, the bundled object store's setup job tries to create the buckets and set up access before it gives up."},
{"FLUXER_SEAWEEDFS_UPLOADS_TTL", "storage", "How long the bundled object store keeps files in the uploads bucket before it deletes them, such as `1d` or `12h`. Use `off` to keep them. A new value applies to uploads written after the next start, and files already stored keep their old expiry."},
{"FLUXER_POSTGRES_HOST", "database", "The hostname or address of the Postgres database. Set it when Postgres runs outside the stack."},
{"FLUXER_POSTGRES_PORT", "database", "The Postgres port, from 1 to 65535. When it's empty, Fluxer uses `5432`."},
{"FLUXER_POSTGRES_DATABASE", "database", "The Postgres database name. When it's empty, Fluxer uses `fluxer`. The bundled Postgres creates this database only on its first start with an empty data directory."},
{"FLUXER_POSTGRES_USERNAME", "database", "The Postgres role Fluxer connects as. When it's empty, Fluxer uses `fluxer`. The bundled Postgres creates this role only on its first start with an empty data directory."},
{"FLUXER_POSTGRES_URL", "database", "A full Postgres connection URL, such as postgres://fluxer:[email protected]:5432/fluxer. When it's set, Fluxer connects with it and ignores the host, port, database, username and password settings. An `sslmode` in the URL can turn TLS on when FLUXER_POSTGRES_SSL isn't `true`. For the api and worker, it also wins over FLUXER_POSTGRES_SSL."},
{"FLUXER_POSTGRES_SSL", "database", "Whether Fluxer connects to Postgres over TLS. Use `true` or `false`. When it isn't `true` and FLUXER_POSTGRES_URL has no `sslmode`, the api and worker follow `PGSSLMODE` and the other services connect without TLS."},
{"FLUXER_POSTGRES_SSL_CA", "database", "A CA certificate in PEM form that Fluxer trusts for the Postgres TLS connection, with `\\n` for line breaks. The Rust services use it whenever the connection uses TLS. The api and worker use it only when FLUXER_POSTGRES_SSL is `true` and FLUXER_POSTGRES_URL has no `sslmode`."},
{"FLUXER_POSTGRES_PREPARED_STATEMENTS", "database", "Whether Fluxer uses Postgres prepared statements. Use `true` or `false`. When it's empty, Fluxer uses them. Set it to `false` behind a transaction-pooling pooler such as PgBouncer."},
{"FLUXER_POSTGRES_KV_TABLE", "database", "The Postgres table for Fluxer's key-value data, a plain identifier of letters, digits and underscores that starts with a letter or an underscore. When it's empty, Fluxer uses `fluxer_kv`."},
{"FLUXER_KV_URL", "services", "The Valkey or Redis URL Fluxer uses for its cache, rate limits and other short-lived data."},
{"FLUXER_KV_MODE", "services", "How Fluxer connects to the key-value store. Use `standalone` for a single Valkey or Redis node or `cluster` for a Redis-compatible cluster. When it's empty, Fluxer uses `standalone`."},
{"FLUXER_NATS_URL", "services", "The core NATS address the api, worker and gateway services use, including for requests to the internal services and the push service. The internal services and JetStream follow it unless FLUXER_SVC_NATS_URL or FLUXER_NATS_JETSTREAM_URL is set."},
{"FLUXER_NATS_JETSTREAM_URL", "services", "The NATS address the api and worker services use for JetStream. When it's empty, they use FLUXER_NATS_URL."},
{"FLUXER_NATS_AUTH_TOKEN", "services", "The token every service sends when it connects to NATS. When it's empty, services connect without a token. The bundled NATS needs none."},
{"FLUXER_SVC_NATS_URL", "services", "The NATS address the internal services and the push service listen on. When it's empty, they use FLUXER_NATS_URL. The api and worker send their requests to these services over FLUXER_NATS_URL, and both addresses must lead to the same NATS cluster."},
{"FLUXER_SVC_MAX_CONCURRENT_REQUESTS", "services", "How many requests each internal service handles at once before it turns new ones away. When it's empty, the messages service uses `192`, the snowflakes service `320` and the others `64`. One value you set applies to all of them. rexctl takeover and rexctl upgrade remove a value under `320`."},
{"FLUXER_SVC_CACHE_MAX_ENTRIES", "services", "The most entries each internal service process keeps in its cache. When it's empty, the internal services use `100000`."},
{"FLUXER_SVC_CACHE_TTL_MS", "services", "How long the internal services keep cached entries, in milliseconds. When it's empty, they use `30000`."},
{"FLUXER_GIF_SERVICE_NATS_CLIENT_NAME", "services", "The client name the API gives its NATS connection to the gifs service, which shows in NATS monitoring. When it's empty, the API uses `fluxer-api-gifs`."},
{"FLUXER_GIF_SERVICE_TIMEOUT_MS", "services", "How long the API waits for gifs service requests such as searches, in milliseconds. When it's empty, the API uses `12000`. Recording a share uses FLUXER_GIF_SERVICE_REGISTER_SHARE_TIMEOUT_MS."},
{"FLUXER_GIF_SERVICE_REGISTER_SHARE_TIMEOUT_MS", "services", "How long the API waits for the gifs service to record that someone shared a GIF, in milliseconds. When it's empty, the API uses `3000`."},
{"FLUXER_USERS_SERVICE_NATS_CLIENT_NAME", "services", "The client name the API gives its NATS connection to the users service, which shows in NATS monitoring. When it's empty, the API uses `fluxer-api-users`."},
{"FLUXER_USERS_SERVICE_TIMEOUT_MS", "services", "How long the API waits for the users service, in milliseconds. When it's empty, the API uses `6000`."},
{"FLUXER_USERS_SERVICE_INFLIGHT_MAX_ENTRIES", "services", "How many user lookups the API tracks in flight, which lets requests for the same user share one call to the users service. Lookups past this limit go to the service on their own. When it's empty, the API uses `10000`."},
{"FLUXER_SNOWFLAKE_SERVICE_NATS_CLIENT_NAME", "services", "The client name the API gives its NATS connection to the snowflakes service, which shows in NATS monitoring. When it's empty, the API uses `fluxer-api-snowflakes`."},
{"FLUXER_SNOWFLAKE_SERVICE_BATCH_SIZE", "services", "How many IDs the API fetches from the snowflakes service at a time, from 1 to 512. When it's empty, the API uses `128`."},
{"FLUXER_SNOWFLAKE_SERVICE_LOW_WATERMARK", "services", "The number of unused IDs at which the API fetches a new batch, from 0 to one less than the batch size. When it's empty, the API uses `32`, or one less than the batch size if that's smaller."},
{"FLUXER_SNOWFLAKE_SERVICE_MAX_BUFFER_AGE_MS", "services", "How long the API keeps a fetched batch of IDs before it throws the rest away, in milliseconds from 1 to 60000. When it's empty, the API uses `5000`."},
{"FLUXER_SNOWFLAKE_SERVICE_REQUEST_TIMEOUT_MS", "services", "How long the API waits for the snowflakes service, in milliseconds from 1 to 60000. When it's empty, the API uses `6000`."},
{"FLUXER_SEARCH_ENGINE", "services", "Which search engine Fluxer uses. Use `meilisearch` or `elasticsearch`, or `none` to turn search off. With `elasticsearch`, set MEILI_MASTER_KEY to your Elasticsearch API key. Docker Compose passes it to Fluxer as FLUXER_SEARCH_API_KEY."},
{"FLUXER_SEARCH_URL", "services", "The address of the search engine."},
{"FLUXER_SEARCH_USERNAME", "services", "The basic auth username for Elasticsearch. Fluxer uses it only when FLUXER_SEARCH_API_KEY is empty. Docker Compose always sets that key from MEILI_MASTER_KEY. To use basic auth, set FLUXER_SEARCH_API_KEY to an empty value for the api and worker in a compose file of your own."},
{"FLUXER_SEARCH_PASSWORD", "services", "The basic auth password for Elasticsearch. Fluxer uses it only when FLUXER_SEARCH_API_KEY is empty, the same as FLUXER_SEARCH_USERNAME."},
{"FLUXER_SEARCH_TLS_REJECT_UNAUTHORIZED", "services", "Whether Fluxer checks the Elasticsearch TLS certificate. Use `true` or `false`. When it's empty, Fluxer checks it. Meilisearch connections don't use it."},
{"HTTP_PROXY", "network", "The api, worker and gateway don't use it."},
{"HTTPS_PROXY", "network", "The api, worker and gateway don't use it."},
{"NO_PROXY", "network", ""},
{"FLUXER_NODE_EXTRA_CA_CERTS", "network", "The path of a PEM file of CA certificates that the api and worker trust for outgoing TLS on top of Node's built-in ones. Use it when your email server has a certificate from your own CA. The path is inside their containers. With Docker Compose they see the ca folder of your instance at /etc/fluxer/ca, and nothing else from the instance folder. A file you set replaces the system bundle. Node's built-in CAs still apply, and the file can have only your own CA. The Rust services don't use it and take their CA certificates from SSL_CERT_FILE."},
{"FLUXER_SSO_ALLOW_PRIVATE_ADDRESSES", "sso", "Use `true` or `false`. When it's empty, Fluxer uses `false`."},
{"FLUXER_PASSKEY_RP_ID", "sso", "The relying party ID that passkeys are tied to, a domain such as `chat.example.com`. When it's empty, Fluxer uses FLUXER_DOMAIN. Changing it makes every passkey registered against the old value stop working."},
{"FLUXER_PASSKEY_RP_NAME", "sso", "The title browsers show for Fluxer when someone creates or uses a passkey. When it's empty, browsers show `Fluxer`."},
{"FLUXER_PASSKEY_ADDITIONAL_ALLOWED_ORIGINS", "sso", "Every origin where passkeys work, separated by commas. When it's empty, Docker Compose uses FLUXER_PUBLIC_ORIGIN, or FLUXER_PUBLIC_SCHEME followed by `://` and FLUXER_DOMAIN. A list you set replaces it and must include the web app origin. Set a list when FLUXER_APP_ENDPOINT is on another origin. Each entry is an http or https origin or an Android app, written as `android:apk-key-hash:` followed by its signing certificate's SHA-256 hash in unpadded base64url."},
{"FLUXER_ADMIN_SSO_ISSUER", "sso", "The HTTPS issuer URL of an OpenID Connect provider that staff can also use to sign in to the admin panel. The issuer must not contain credentials, a query or a fragment. Discovery and token endpoints must serve responses directly without redirects. Admin single sign-on is on when FLUXER_ADMIN_SSO_ISSUER, FLUXER_ADMIN_SSO_CLIENT_ID and FLUXER_ADMIN_SSO_CLIENT_SECRET are all set. The admin service won't start when only some of them are set. The api and admin services must have the same issuer and client ID. The provider's ID token must have a `fluxer_id` claim with the ID of the Fluxer account, and access still comes from the admin ACLs of that account. Only trusted provider administrators may set this claim; users must not be able to change it."},
{"FLUXER_ADMIN_SSO_CLIENT_ID", "sso", "The client ID of the admin panel at the provider in FLUXER_ADMIN_SSO_ISSUER. Register the admin address followed by /sso/callback as its redirect URL."},
{"FLUXER_ADMIN_SSO_CLIENT_SECRET", "sso", "The client secret that goes with FLUXER_ADMIN_SSO_CLIENT_ID. Only the admin service uses it."},
{"FLUXER_ADMIN_SSO_DISPLAY_NAME", "sso", "The provider name on the single sign-on button of the admin panel. With `Ferret`, the button says `Sign in with Ferret`. When it's empty, the button says `Sign in with single sign-on`."},
{"FLUXER_ADMIN_SSO_ONLY", "sso", "Whether staff can sign in to the admin panel only with single sign-on. Use `true` or `false`. With `true`, the login page hides the button for signing in with a Fluxer account, and the admin panel refuses new sign-ins that way. Staff who are already signed in stay signed in. It needs FLUXER_ADMIN_SSO_ISSUER, FLUXER_ADMIN_SSO_CLIENT_ID and FLUXER_ADMIN_SSO_CLIENT_SECRET, and the admin service won't start without them. When it's empty, it's `false`."},
{"FLUXER_EMAIL_ENABLED", "email", "The older way to turn email on. Use FLUXER_EMAIL_DELIVERY."},
{"FLUXER_EMAIL_PROVIDER", "email", "The older way to pick the email transport, which takes `smtp` or `none`. Use FLUXER_EMAIL_DELIVERY."},
{"FLUXER_EMAIL_DELIVERY", "email", "How Fluxer sends email. Use `smtp` or `off`. When it's empty, FLUXER_EMAIL_ENABLED and FLUXER_EMAIL_PROVIDER decide, and email is off when those are empty too."},
{"FLUXER_EMAIL_FROM_EMAIL", "email", "The address Fluxer sends email from. When it's empty, Fluxer uses `noreply@` followed by FLUXER_DOMAIN."},
{"FLUXER_EMAIL_FROM_NAME", "email", "The sender name on email from Fluxer. When it's empty, Fluxer uses the product name of the instance."},
{"FLUXER_EMAIL_REPLY_TO_EMAIL", "email", "The address replies go to, sent as the Reply-To header on every email, such as `[email protected]`. When it's empty, Fluxer sends no Reply-To header."},
{"FLUXER_EMAIL_APP_BASE_URL", "email", "The base URL Fluxer uses for links in emails, an http or https URL with no credentials, query or fragment. When it's empty, Fluxer uses FLUXER_APP_ENDPOINT."},
{"FLUXER_EMAIL_WEBHOOK_SECRET", "email", "The base64 secret Fluxer uses to check the signature on bounce and complaint webhooks from the Sweego email service. When it's empty, Fluxer turns those webhooks away."},
{"FLUXER_EMAIL_SMTP_HOST", "email", "The hostname of your SMTP server."},
{"FLUXER_EMAIL_SMTP_PORT", "email", "The port of your SMTP server. When it's empty, Fluxer uses `587`."},
{"FLUXER_EMAIL_SMTP_USERNAME", "email", "The username Fluxer signs in to your SMTP server with."},
{"FLUXER_EMAIL_SMTP_PASSWORD", "email", "The password Fluxer signs in to your SMTP server with."},
{"FLUXER_EMAIL_SMTP_TLS_MODE", "email", "How the SMTP connection is encrypted. Use `implicit` for TLS from the start, usually on port 465, `starttls` to upgrade before signing in, usually on port 587, `opportunistic` to upgrade when the server offers it, or `none`. When it's empty, FLUXER_EMAIL_SMTP_SECURE decides. When both are empty, Fluxer uses `implicit` on port 465 and `starttls` on any other port."},
{"FLUXER_EMAIL_SMTP_SECURE", "email", "The older way to set FLUXER_EMAIL_SMTP_TLS_MODE, used only while that is empty. Use `true` for `implicit` on port 465 and `starttls` on any other port, or `false` for `opportunistic`."},
{"FLUXER_EMAIL_FALLBACK_DOMAINS", "email", "Recipient domains, separated by commas, whose mail goes through the fallback SMTP provider, such as `gmail.com,googlemail.com`. Only exact domain matches count, and `*` alone sends all mail through the fallback provider."},
{"FLUXER_EMAIL_FALLBACK_SMTP_HOST", "email", "The hostname of the fallback SMTP provider."},
{"FLUXER_EMAIL_FALLBACK_SMTP_PORT", "email", "The port of the fallback SMTP provider, from 1 to 65535. When it's empty, Fluxer uses `587`."},
{"FLUXER_EMAIL_FALLBACK_SMTP_USERNAME", "email", "The username Fluxer signs in to the fallback SMTP provider with. Fluxer doesn't start when a fallback provider is set without it."},
{"FLUXER_EMAIL_FALLBACK_SMTP_PASSWORD", "email", "The password Fluxer signs in to the fallback SMTP provider with. Fluxer doesn't start when a fallback provider is set without it."},
{"FLUXER_EMAIL_FALLBACK_SMTP_TLS_MODE", "email", "How Fluxer encrypts the connection to the fallback provider. Use `implicit`, `starttls`, `opportunistic` or `none`. When it's empty, Fluxer uses `implicit` on port 465 and `starttls` on any other port."},
{"FLUXER_EMAIL_FALLBACK_SMTP_HEADERS", "email", "Extra headers added to every message sent through the fallback provider, as a JSON object that maps header names to string values. Core headers such as From, To, Subject and Reply-To can't be set here."},
{"FLUXER_PUSH_APNS_ENABLED", "push", "Whether the push service sends mobile notifications through Apple Push Notification service with your own credentials. Use `true` or `false`. When it's empty, APNs is off."},
{"FLUXER_PUSH_APNS_TEAM_ID", "push", "Your Apple developer team ID."},
{"FLUXER_PUSH_APNS_KEY_ID", "push", "The ID of your APNs signing key, from your Apple developer account."},
{"FLUXER_PUSH_APNS_PRIVATE_KEY", "push", "Your APNs signing key as PEM text. Set this or FLUXER_PUSH_APNS_PRIVATE_KEY_PATH, and this one wins when both are set."},
{"FLUXER_PUSH_APNS_PRIVATE_KEY_PATH", "push", "The path to your APNs signing key file inside the push container."},
{"FLUXER_PUSH_APNS_APPS", "push", "The apps the push service sends to through APNs, as a JSON array of objects. Each object has an `app_id` and a `topic` with the app's bundle ID, and can have an `environment` of `production` or `development`. APNs sends fail for an app that isn't listed or has no topic. A push relay with APNs on doesn't start until this lists at least one app."},
{"FLUXER_PUSH_APNS_DEFAULT_ENVIRONMENT", "push", "The APNs environment the push service uses for a device that registered without one. Use `production` or `development`. When it's empty, it uses `production`."},
{"FLUXER_PUSH_FCM_ENABLED", "push", "Whether the push service sends mobile notifications through Firebase Cloud Messaging with your own credentials. Use `true` or `false`. When it's empty, FCM is off."},
{"FLUXER_PUSH_FCM_PROJECT_ID", "push", "Your Firebase project ID. When it's empty, the push service uses the one in FLUXER_PUSH_FCM_SERVICE_ACCOUNT_JSON_PATH."},
{"FLUXER_PUSH_FCM_CLIENT_EMAIL", "push", "The client email of your Firebase service account. When it's empty, the push service uses the one in FLUXER_PUSH_FCM_SERVICE_ACCOUNT_JSON_PATH."},
{"FLUXER_PUSH_FCM_PRIVATE_KEY", "push", "The private key of your Firebase service account as PEM text. When it's empty, the push service uses FLUXER_PUSH_FCM_PRIVATE_KEY_PATH or the key in the service account JSON."},
{"FLUXER_PUSH_FCM_PRIVATE_KEY_PATH", "push", "The path to your Firebase service account private key inside the push container. The push service uses it when FLUXER_PUSH_FCM_PRIVATE_KEY is empty."},
{"FLUXER_PUSH_FCM_SERVICE_ACCOUNT_JSON_PATH", "push", "The path to your Firebase service account JSON file inside the push container. The push service loads the project ID, client email and private key from it when those settings are empty."},
{"FLUXER_PUSH_FCM_TOKEN_URI", "push", "The OAuth token URL the push service uses for FCM. When it's empty, it uses https://oauth2.googleapis.com/token. Change it only for a proxy or a test double."},
{"FLUXER_PUSH_FCM_APPS", "push", "The apps the push service sends to through FCM, as a JSON array of objects that each have an `app_id` and can have a `project_id`. An app with no entry or no `project_id` uses FLUXER_PUSH_FCM_PROJECT_ID. A push relay with FCM on doesn't start until this lists at least one app."},
{"FLUXER_VAPID_EMAIL", "push", "The contact email Fluxer sends to browser push services with its VAPID key. When it's empty, Fluxer uses `admin@` followed by FLUXER_DOMAIN. Set it if that mailbox doesn't exist."},
{"FLUXER_PUSH_SERVICE_QUEUE_CAPACITY", "push", "How many notification jobs the push service queues at once, from 1 to 1000000. When it's empty, it uses `10000`."},
{"FLUXER_PUSH_SERVICE_SEND_CONCURRENCY", "push", "How many provider requests the push service sends at once across all jobs, from 1 to 65536. When it's empty, it uses `256`."},
{"FLUXER_PUSH_SERVICE_APNS_BASE_URL", "push", "A URL that replaces the APNs host in both environments, for a test double only. When it's empty, the push service uses Apple's own hosts."},
{"FLUXER_PUSH_SERVICE_FCM_BASE_URL", "push", "The FCM host the push service sends to. When it's empty, it uses https://fcm.googleapis.com. Change it only for a proxy or a test double."},
{"FLUXER_PUSH_SERVICE_MANAGED_RELAY_HOSTS", "push", "Hostnames, separated by commas, of the push relay that Fluxer runs. When it's empty, the push service uses `push.fluxer.com`. It sends to these hosts only once relay consent is accepted."},
{"FLUXER_PUSH_SERVICE_OWN_RELAY_HOSTS", "push", "Hostnames, separated by commas, of a push relay your instance runs itself. The push service sends mobile app notifications addressed to these hosts directly to APNs or FCM with its own credentials."},
{"FLUXER_PUSH_SERVICE_PRIVATE_HOSTS", "push", "Hostnames, separated by commas, that push endpoints may use even when they resolve to private or loopback addresses, such as a ntfy service on your own network. The push service refuses every other such endpoint."},
{"FLUXER_PUSH_SERVICE_RELAY_CONSENT_ACCEPTED", "push", "Whether this push service accepts the push relay privacy notice, which lets it send through the relay Fluxer runs. Use `true`, `1` or `yes` to accept. With `false`, `0`, `no` or an empty value, the push relay setting of the instance decides."},
{"FLUXER_CLAMAV_ENABLED", "media", "Whether Fluxer scans uploads for viruses with ClamAV. Use `true` or `false`. When it's empty, Fluxer uses `false`. No ClamAV container ships with the stack. Point FLUXER_CLAMAV_HOST at your own."},
{"FLUXER_CLAMAV_HOST", "media", "The hostname or address of your ClamAV scanner. When it's empty, Fluxer uses `127.0.0.1`."},
{"FLUXER_CLAMAV_PORT", "media", "The port of your ClamAV scanner. When it's empty, Fluxer uses `3310`."},
{"FLUXER_CLAMAV_FAIL_OPEN", "media", "Whether uploads go through when a ClamAV scan fails, such as when Fluxer can't connect to the scanner or gets no usable answer. Use `true` or `false`. When it's empty, Fluxer rejects the upload."},
{"FLUXER_MEDIA_PROXY_ATTACHMENT_URL_SECRETS_BASE64", "media", "Keys that sign attachment URLs, separated by commas. Each is standard base64 that decodes to at least 32 bytes. The first entry signs and every entry verifies. To rotate keys, add the new key last and restart the stack. Then move it first and restart again. Every process can then verify the new key before any process signs with it. Remove the old key 24 hours later. Removing a key ends the data package links it signed. When it's empty, Fluxer returns unsigned attachment URLs."},
{"FLUXER_MEDIA_PROXY_UPLOAD_RELAY_ENDPOINT", "media", "The upload relay URL the API hands to clients. When it's empty, the API uses the public origin followed by /media."},
{"FLUXER_MEDIA_PROXY_UPLOAD_RELAY_MAX_BODY_BYTES", "media", "The largest single request body the relay accepts, which is one object or one part of a multipart upload, in bytes from 1 to 5 GiB. It can't be more than FLUXER_MEDIA_PROXY_UPLOAD_RELAY_SPOOL_MAX_TOTAL_BYTES. When it's empty, the relay uses `524288000`, which is 500 MiB."},
{"FLUXER_MEDIA_PROXY_UPLOAD_RELAY_TOKEN_TTL_SECS", "media", "How long an upload relay token stays valid, in seconds. When it's empty, the API uses `900`."},
{"FLUXER_MEDIA_PROXY_UPLOAD_RELAY_KEEP_DIRECT_COUNTRIES", "media", "Two-letter country codes, separated by commas, whose clients upload to the object store directly and skip the relay. It needs the GeoIP database in FLUXER_GEOIP_DB_PATH, and browsers can only upload directly when FLUXER_S3_PUBLIC_ENDPOINT is set. When it's empty or there's no GeoIP database, every client uses the relay and browsers never see the internal store address."},
{"FLUXER_MEDIA_PROXY_CORS_MODE", "media", "Whether the media proxy checks the Origin of media requests. Use `off`, `report` or `enforce`. When it's empty, it's off. With `report`, the media proxy logs requests it would refuse, and with `enforce` it refuses them. A request with no Origin header is always served."},
{"FLUXER_MEDIA_PROXY_CORS_ALLOWED_ORIGINS", "media", "The web origins, separated by commas, that may load media through CORS when FLUXER_MEDIA_PROXY_CORS_MODE is `report` or `enforce`. When it's empty, the media proxy uses the public origin. The desktop app is always allowed."},
{"FLUXER_MEDIA_PROXY_ATTACHMENT_SIGNATURE_MODE", "media", "Use `off`, `report` or `enforce`. When it's empty, it's off. With `report`, the media proxy logs downloads it would refuse, and with `enforce` it refuses them. Both need FLUXER_MEDIA_PROXY_ATTACHMENT_URL_SECRETS_BASE64, and rexctl makes a key the first time you turn it on if that's empty."},
{"FLUXER_MEDIA_PROXY_READ_ONLY", "media", "Whether the media proxy refuses to write to storage. Use `true` or `false`. When it's empty, it writes as usual."},
{"FLUXER_MEDIA_PROXY_NSFW_THRESHOLD", "media", "The NSFW classifier score, from 0.0 to 1.0, that the media proxy uses as its cutoff. When it's empty, it uses `0.85`."},
{"FLUXER_NSFW_SERVICE_ENDPOINT", "media", "The URL of an outside NSFW classifier the media proxy calls. No such service ships with the stack. When it's empty, the media proxy calls none."},
{"FLUXER_MEDIA_PROXY_MAX_NATIVE_TRANSFORMS", "media", "How many image transforms the media proxy runs at once, from 1 to 128. When it's empty, it uses the number of CPU cores, kept between 2 and 8."},
{"FLUXER_MEDIA_PROXY_WORKER_QUEUE_CAPACITY", "media", "How many transforms may wait in the media proxy's queue, from 1 to 8192. When it's empty, it uses eight times FLUXER_MEDIA_PROXY_MAX_NATIVE_TRANSFORMS."},
{"FLUXER_MEDIA_PROXY_MAX_ENCODE_DURATION_MS", "media", "The longest animation the media proxy encodes, in milliseconds from 100 to 600000. When it's empty, it uses `30000`."},
{"FLUXER_MEDIA_PROXY_MAX_ENCODE_FRAMES", "media", "The most frames the media proxy encodes in one animation, from 1 to 100000. When it's empty, it uses `20000`."},
{"FLUXER_MEDIA_PROXY_TRANSFORM_TIMEOUT_MS", "media", "How long one media transform may take, in milliseconds from 1000 to 120000. When it's empty, the media proxy uses `15000`."},
{"FLUXER_MEDIA_PROXY_TRANSFORM_CACHE_BYTES", "media", "How much memory the media proxy's transform cache may use, in bytes from 0 to 4 GiB. When it's empty, it uses `268435456`, which is 256 MiB."},
{"FLUXER_MEDIA_PROXY_TRANSFORM_CACHE_MAX_ENTRY_BYTES", "media", "The largest transform result the media proxy caches, in bytes from 0 to 512 MiB. When it's empty, it uses `67108864`, which is 64 MiB."},
{"FLUXER_MEDIA_PROXY_TRANSFORM_CACHE_TTL_MS", "media", "How long the media proxy keeps a transform result in its cache, in milliseconds from 0 to 3600000. When it's empty, it uses `120000`."},
{"FLUXER_MEDIA_PROXY_SOCKET_IO_TIMEOUT_MS", "media", "How long the media proxy waits on socket input and output, in milliseconds from 0 to 300000. When it's empty, it uses `30000`."},
{"FLUXER_MEDIA_PROXY_SHUTDOWN_GRACE_MS", "media", "How long the media proxy waits for open requests and transforms to finish when it stops, in milliseconds from 0 to 300000. When it's empty, it uses `30000`."},
{"FLUXER_MEDIA_PROXY_UPLOAD_RELAY_S3_TIMEOUT_MS", "media", "How long the relay waits for an upload's write to the object store, in milliseconds from 1000 to 3600000. When it's empty, it uses `900000`."},
{"FLUXER_MEDIA_PROXY_UPLOAD_RELAY_BUFFERED_RETRY_BYTES", "media", "The largest upload the relay keeps in memory so it can retry the object store write, in bytes from 0 to 256 MiB. Larger uploads stream to the store without a retry. When it's empty, the relay uses `33554432`, which is 32 MiB."},
{"FLUXER_MEDIA_PROXY_UPLOAD_RELAY_BUFFERED_RETRY_TOTAL_BYTES", "media", "How much memory all buffered relay uploads may use together, in bytes from 0 to 8 GiB. An upload that would go past it streams without a retry. When it's empty, the relay uses `536870912`, which is 512 MiB."},
{"FLUXER_MEDIA_PROXY_UPLOAD_RELAY_SPOOL_DIR", "media", "The directory where the relay spools upload bodies and the media proxy keeps copies of large audio and video files it inspects. It must be writable. When it's empty, the media proxy uses the system temporary directory."},
{"FLUXER_MEDIA_PROXY_UPLOAD_RELAY_SPOOL_CHUNK_BYTES", "media", "The chunk size the relay uses when it writes upload bodies to its spool on disk, in bytes from 64 KiB to 64 MiB. When it's empty, it uses `1048576`, which is 1 MiB."},
{"FLUXER_MEDIA_PROXY_UPLOAD_RELAY_SPOOL_MAX_TOTAL_BYTES", "media", "The most disk space the spool may use at once, in bytes from 0 to 256 GiB, shared by relay uploads and copies of large audio and video files. It must be at least FLUXER_MEDIA_PROXY_UPLOAD_RELAY_MAX_BODY_BYTES."},
{"FLUXER_CACHE_PURGE_ADAPTER", "media", "How Fluxer purges cached copies of deleted or replaced media from your CDN or caching proxy. Use `none`, `http` or `controller`. When it's empty, Fluxer uses `none` and sends no purges."},
{"FLUXER_CACHE_PURGE_HTTP_ENDPOINT", "media", "The URL the worker posts purge requests to when FLUXER_CACHE_PURGE_ADAPTER is `http`, as an absolute http or https URL without credentials. Your endpoint then purges the listed media URL prefixes from every cache in front of the media."},
{"FLUXER_CACHE_PURGE_HTTP_TOKEN", "media", "The bearer token Fluxer sends in the Authorization header of each purge request to FLUXER_CACHE_PURGE_HTTP_ENDPOINT, in visible ASCII characters with no spaces."},
{"FLUXER_CACHE_PURGE_HTTP_TIMEOUT_MS", "media", "How long each purge request to FLUXER_CACHE_PURGE_HTTP_ENDPOINT may take, in milliseconds from 1000 to 10000. When it's empty, Fluxer uses `10000`."},
{"FLUXER_CACHE_PURGE_CONTROLLER_ENDPOINT", "media", "The purge URL of the Controller edge site that serves your media, as an absolute https URL without credentials. Fluxer uses it when FLUXER_CACHE_PURGE_ADAPTER is `controller`."},
{"FLUXER_CACHE_PURGE_CONTROLLER_TOKEN", "media", "The Controller API key Fluxer sends as a bearer token with each purge request, in visible ASCII characters with no spaces."},
{"FLUXER_CACHE_PURGE_CONTROLLER_TIMEOUT_MS", "media", "How long each Controller purge request may take, in milliseconds from 1000 to 10000. When it's empty, Fluxer uses `10000`."},
{"FLUXER_GATEWAY_MEDIA_PROXY_ENDPOINT", "gateway", "The public media URL the gateway uses to build avatar links in push notifications. When it's empty, the gateway uses FLUXER_MEDIA_ENDPOINT, or the public origin followed by /media."},
{"FLUXER_GATEWAY_STATIC_CDN_ENDPOINT", "gateway", "The public static file URL the gateway uses to build default avatar links in push notifications. When it's empty, the gateway uses FLUXER_STATIC_CDN_ENDPOINT, or the public origin."},
{"FLUXER_GATEWAY_PUSH_ENABLED", "gateway", "Whether the gateway sends push notifications through the push service. Use `true` or `false`. When it's empty, the gateway uses `true`."},
{"FLUXER_GATEWAY_PUSH_ENROLLED_CLEAR_NOTIFICATIONS_ENABLED", "gateway", "Whether the gateway asks the push service to clear a channel's push notifications once the user has caught up on that channel. Use `true` or `false`. When it's empty, the gateway uses `true`."},
{"FLUXER_GATEWAY_PUSH_OUTBOX_REQUEST_TIMEOUT_MS", "gateway", "How long the gateway waits for the push service to respond to one push request, in milliseconds. When it's empty, the gateway uses `100000`."},
{"FLUXER_GATEWAY_PRESENCE_PUSH_BUFFER_MAX_ENTRIES", "gateway", "The most push notifications the gateway keeps back for one user while one of their sessions is active, dropping the oldest first. A value of `0` keeps none. When it's empty, the gateway uses `128`."},
{"FLUXER_GATEWAY_PRESENCE_PUSH_BUFFER_MAX_BYTES", "gateway", "The most bytes of push notifications the gateway keeps back for one user while one of their sessions is active. A value of `0` turns off this limit. When it's empty, the gateway uses `1048576`, which is 1 MiB."},
{"FLUXER_GATEWAY_HTTP_RPC_MAX_CONCURRENCY", "gateway", "How many HTTP requests the gateway can have open to the API at once. When it's empty, the gateway uses `512`."},
{"FLUXER_GATEWAY_NATS_RPC_MAX_HANDLERS", "gateway", "How many NATS RPC requests the gateway works on at once. When it's empty, the gateway uses `512`."},
{"FLUXER_GATEWAY_ZSTD_WINDOW_LOG", "gateway", "The base 2 logarithm of the zstd window the gateway compresses websocket traffic with, from 10 to 21. Values outside that range count as the nearest end. Larger values compress better and use more memory per connection. When it's empty, the gateway uses `17`."},
{"FLUXER_GATEWAY_IDENTIFY_TOKEN_LIMIT_PER_MINUTE", "gateway", "The most times one token can identify on one gateway node in a minute. The gateway does not answer identifies over the limit. A value of `0` turns off this limit. When it's empty, the gateway uses `0`."},
{"FLUXER_GATEWAY_HTTP_FAILURE_THRESHOLD", "gateway", "How many failed requests from the gateway to the API in 10 seconds open its circuit breaker, when at least 80 percent of the requests in that time failed. The breaker then stops further requests for a while. When it's empty, the gateway uses `6`."},
{"FLUXER_GATEWAY_HTTP_RECOVERY_TIMEOUT_MS", "gateway", "How long the circuit breaker for gateway requests to the API stays open before it tries again, in milliseconds. When it's empty, the gateway uses `15000`."},
{"FLUXER_GATEWAY_GUILD_VISITOR_SESSIONS_MAX", "gateway", "The most visitor sessions one community allows, however many members it has. A visitor views a community without joining it. When it's empty, the gateway uses `10000`."},
{"FLUXER_GATEWAY_GUILD_VISITOR_SESSIONS_FLOOR", "gateway", "The fewest visitor sessions one community allows, however few members it has. When it's empty, the gateway uses `500`."},
{"FLUXER_GATEWAY_GUILD_VISITOR_SESSIONS_PER_MEMBER", "gateway", "How many visitor sessions a community allows for each of its members, kept between the floor and the maximum. When it's empty, the gateway uses `2`."},
{"FLUXER_GATEWAY_GUILD_VISITOR_SESSIONS_PER_USER", "gateway", "How many visitor sessions one account can have in a single community at once. When it's empty, the gateway uses `5`."},
{"FLUXER_GATEWAY_GUILD_VISITOR_SESSIONS_PER_IP", "gateway", "How many visitor sessions one IPv4 address or one IPv6 /64 network can have in a single community at once. When it's empty, the gateway uses `20`."},
{"DISCOVERY_REFRESH_INTERVAL_MS", "app", "How often the app-proxy service fetches the discovery document, in milliseconds. The document has the branding saved in the admin panel, such as the product name, icons and custom CSS. Values under 1 second count as 1 second. A failed fetch is retried with a growing delay of up to five minutes."},
{"FLUXER_APP_PROXY_INDEX_UPSTREAM_URL", "app", "An http or https URL that the app-proxy service fetches the web app's index.html from. When it's empty, the app-proxy service serves the index.html built into its image."},
{"FLUXER_APP_PROXY_SAME_ORIGIN_HOSTS", "app", "Extra hostnames that serve the web app, separated by commas or spaces, with no scheme, port or path. On these hostnames, the web app uses the same hostname for the API and for the gateway and media endpoints that share the API's host. Each one must route /api, /gateway and /media like the main one."},
{"FLUXER_APP_PROXY_MANIFEST_SCOPE_EXTENSIONS", "app", "HTTPS origins with no path, separated by commas or spaces, that the app-proxy service adds to the `scope_extensions` list of the web app manifest. An installed web app keeps them inside its window. Each origin must serve /.well-known/web-app-origin-association for this web app. Invalid entries are logged and dropped."},
{"FLUXER_CSP_EXTRA_DEFAULT_SRC", "app", "Extra sources the app-proxy service adds to the default-src directive of the web app's Content-Security-Policy, separated by commas or spaces. Set one only when a browser must connect to an origin the built-in policy doesn't cover."},
{"FLUXER_CSP_EXTRA_CONNECT_SRC", "app", "Extra sources the app-proxy service adds to the connect-src directive of the web app's Content-Security-Policy, separated by commas or spaces, such as wss://livekit.example.com. A ws or wss source also allows the matching http or https source."},
{"FLUXER_CSP_EXTRA_IMG_SRC", "app", "Extra sources the app-proxy service adds to the img-src directive of the web app's Content-Security-Policy, separated by commas or spaces, such as https://cdn.example.com."},
{"FLUXER_CSP_EXTRA_MEDIA_SRC", "app", "Extra sources the app-proxy service adds to the media-src directive of the web app's Content-Security-Policy, separated by commas or spaces."},
{"FLUXER_CSP_EXTRA_FONT_SRC", "app", "Extra sources the app-proxy service adds to the font-src directive of the web app's Content-Security-Policy, separated by commas or spaces."},
{"FLUXER_CSP_EXTRA_SCRIPT_SRC", "app", "Extra sources the app-proxy service adds to the script-src directive of the web app's Content-Security-Policy, separated by commas or spaces, such as https://analytics.example.com."},
{"FLUXER_CSP_EXTRA_STYLE_SRC", "app", "Extra sources the app-proxy service adds to the style-src directive of the web app's Content-Security-Policy, separated by commas or spaces."},
{"FLUXER_CSP_EXTRA_FRAME_SRC", "app", "Extra sources the app-proxy service adds to the frame-src directive of the web app's Content-Security-Policy, separated by commas or spaces."},
{"FLUXER_CSP_EXTRA_WORKER_SRC", "app", "Extra sources the app-proxy service adds to the worker-src directive of the web app's Content-Security-Policy, separated by commas or spaces."},
{"FLUXER_CSP_EXTRA_MANIFEST_SRC", "app", "Extra sources the app-proxy service adds to the manifest-src directive of the web app's Content-Security-Policy, separated by commas or spaces."},
{"FLUXER_CSP_REPORT_URI", "app", "One http or https URL that browsers send Content-Security-Policy violation reports to. When it's empty, the policy has no report-uri."},
{"FLUXER_API_HEADERS_TIMEOUT_MS", "api", "How long a client may take to send the request line and headers to the API, in milliseconds from 1000 to 3600000. It is capped at FLUXER_API_REQUEST_TIMEOUT_MS. When it's empty, the API uses `30000`."},
{"FLUXER_API_REQUEST_TIMEOUT_MS", "api", "How long a client may take over a whole request to the API, in milliseconds from 1000 to 3600000. Raise it for large uploads or slow links. When it's empty, the API uses `120000`."},
{"FLUXER_API_MAX_INFLIGHT_REQUESTS", "api", "How many requests the API handles at once before it responds to new ones with 503 and a Retry-After header, from 1 to 100000. When it's empty, the API uses `512`."},
{"FLUXER_API_MAX_CONCURRENT_FORM_UPLOADS", "api", "How many attachment files sent as multipart form data the API streams to the object store at once, from 1 to 10000. Each one can use up to about 25 MiB of memory. A file that waits more than 10 seconds for a turn gets 503 with a Retry-After header. When it's empty, the API uses `16`."},
{"FLUXER_TRUST_CLIENT_IP_HEADER", "api", "Whether Fluxer trusts the client address in the FLUXER_CLIENT_IP_HEADER_NAME header. Use `true` or `false`. The api, worker, admin and gateway services and the push relay use it. With `false`, they use the address of the connection, which behind the edge is the edge itself. Outside Docker Compose, the services use `false` when it's empty."},
{"FLUXER_CLIENT_IP_HEADER_NAME", "api", "The request header that has the client's IP address. When it's empty, the api, worker, admin and gateway services and the push relay use `x-forwarded-for`, the header the edge sets."},
{"FLUXER_API_IP_BAN_EXEMPT_IPS", "api", "IP addresses and CIDR ranges, separated by commas, that IP bans never apply to, such as `203.0.113.7,2001:db8::/56`. The API refuses to start when an entry doesn't parse."},
{"FLUXER_IP_BAN_REFRESH_INTERVAL_MS", "api", "How often the API reloads its IP ban list, in milliseconds. When it's empty, the API uses `300000`. A value of `0` turns the periodic reload off."},
{"FLUXER_API_DONATION_PROXY_KEY", "api", "An older way to add one trusted caller that may pass the client address for the donation and purchase rate limits. Fluxer's marketing site uses it. It must be at least 32 characters. Your own instance can leave it empty."},
{"FLUXER_API_TRUSTED_CALLERS", "api", "A JSON array of trusted callers, such as a front end that calls the API for its own visitors. Each entry is an object with a `name`, a `key` of at least 32 characters and `buckets`, a non-empty list of the rate limit buckets the caller may pass a client address for. The caller sends its key in the `X-Fluxer-Internal-Key` header and the client address in the `X-Fluxer-Client-IP` header."},
{"FLUXER_API_WORKER_LANE_CONCURRENCY_OVERRIDES", "api", "How many jobs each worker lane runs at once, as a JSON object that maps each lane to a whole number of at least 1. The lanes are `realtime`, `unfurl`, `lifecycle`, `batch` and `crosspost`. Lanes left out use 10, 20, 8, 12 and 8 in that order, scaled down on machines with fewer than 4 CPU cores."},
{"FLUXER_APP_PRODUCT_NAME", "instance", "The product name the apps show and Fluxer uses in emails and system messages. When it's empty or set to `Fluxer` on a self-hosted instance, Fluxer uses the hostname of the web app."},
{"FLUXER_APP_ICON_URL", "instance", "The URL of the app icon."},
{"FLUXER_APP_SYMBOL_URL", "instance", "The URL of the symbol mark."},
{"FLUXER_APP_LOGO_URL", "instance", "The URL of the logo."},
{"FLUXER_APP_WORDMARK_URL", "instance", "The URL of the wordmark."},
{"FLUXER_APP_FAVICON_URL", "instance", "The URL of the favicon."},
{"FLUXER_APP_FAVICON_DARK_URL", "instance", "The URL of the favicon for browsers in dark mode."},
{"FLUXER_APP_SIGN_IN_BACKDROP_URL", "instance", "The URL of the image behind the sign-in screen."},
{"FLUXER_APP_THEME_COLOR", "instance", "The brand colour of the web app and the browser theme colour, as a hex value such as `#4641d9`."},
{"FLUXER_APP_STATUS_PAGE_URL", "instance", "The URL of your public status page. The web app links to it when loading takes a long time. Fluxer checks whether it is an Instatus page. If it is, the web app also reads its current incidents and maintenance automatically."},
{"FLUXER_APP_STATUS_PAGE_INCIDENT_HISTORY_URL", "instance", "The URL of the incident history on your status page. The apps don't use it yet."},
{"FLUXER_INSTANCE_SETUP_CONFIGURED", "instance", "Whether a new instance starts as already set up. Use `true` or `false`. With `true`, the setup wizard is skipped and registration opens without making the first account an admin. Once a setup state is saved, this has no effect. When it's empty, Fluxer uses `false`."},
{"FLUXER_APP_ATTEST_APP_IDS", "instance", "The iOS apps whose age reports the users service accepts through Apple App Attest, separated by commas. Each entry is a team ID, a dot and a bundle ID, such as `ABCDE12345.com.example.app`. When it's empty, App Attest is off and its API endpoints respond that the feature isn't available. The users service doesn't start when an entry isn't in that form."},
{"FLUXER_APP_ATTEST_ALLOW_DEVELOPMENT", "instance", "Whether the users service also accepts App Attest keys from development builds of the apps in FLUXER_APP_ATTEST_APP_IDS. Use `true` or `false`. When it's empty, it uses `false`, so only App Store, TestFlight and other production builds are accepted."},
{"FLUXER_PLAY_INTEGRITY_PACKAGE_NAMES", "instance", "The Android apps whose age reports the users service accepts through the Google Play Integrity API, separated by commas, such as `com.example.app`. When it's empty, Play Integrity is off and its API endpoints respond that the feature isn't available. When it's set, FLUXER_PLAY_INTEGRITY_CERT_SHA256 and FLUXER_PLAY_INTEGRITY_SERVICE_ACCOUNT_JSON_PATH are required, and the users service doesn't start without them."},
{"FLUXER_PLAY_INTEGRITY_CERT_SHA256", "instance", "The SHA-256 fingerprints of the app signing certificates that Google Play uses for the apps in FLUXER_PLAY_INTEGRITY_PACKAGE_NAMES, separated by commas. Each entry is the hex fingerprint the Play Console shows under app signing, with or without colons, or the same digest as base64url."},
{"FLUXER_PLAY_INTEGRITY_SERVICE_ACCOUNT_JSON_PATH", "instance", "The path to a Google Cloud service account JSON key file inside the users container. The users service uses it to ask Google Play to decode integrity tokens. The service account must belong to the Cloud project linked to the apps in the Play Console."},
{"FLUXER_PLAY_INTEGRITY_DEVICE_INTEGRITY", "instance", "The device check an Android device must pass. Use `device` to need MEETS_DEVICE_INTEGRITY, or `strong` to need MEETS_STRONG_INTEGRITY, which you must turn on in the Play Console first. When it's empty, it uses `device`."},
{"FLUXER_ACCOUNT_IDENTITY", "instance", "How people sign in on a new instance. Use `username` or `email`. Fluxer uses it only on the first start with no saved sign-in method. When it's empty, Fluxer uses `email` if email delivery is set up and `username` otherwise. When FLUXER_INSTANCE_SETUP_CONFIGURED is `true` or any account exists, Fluxer uses email sign-in with random tags and ignores this. Otherwise the setup wizard asks again, and its answer replaces this value."},
{"FLUXER_TAG_STYLE", "instance", "How usernames are tagged on a new instance that signs in by email. Use `none` for unique usernames with no tag or `random` for a random tag on every account. Username sign-in always uses `none`. Fluxer reads this setting only on the first start. When it's empty, Fluxer uses `none`. When FLUXER_INSTANCE_SETUP_CONFIGURED is `true` or any account exists, Fluxer uses random tags and ignores this. Otherwise the setup wizard asks again, and its answer replaces this value."},
{"FLUXER_AUTO_JOIN_INVITE_CODE", "instance", "One or more invite codes, separated by commas or spaces. A new account that signs up without an invite of its own joins the communities these invites lead to."},
{"FLUXER_DISCOVERY_ENABLED", "instance", "Whether community discovery is on. Use `true` or `false`. With `false`, discovery search, joining from discovery and discovery applications are turned off. When it's empty, Fluxer uses `true`."},
{"FLUXER_DISCOVERY_MIN_MEMBER_COUNT", "instance", "How many members a community needs before it can be listed in discovery. When it's empty, Fluxer uses `1`."},
{"FLUXER_DELETION_GRACE_PERIOD_HOURS", "instance", "How many hours a deleted account can still be recovered before Fluxer removes it. When it's empty, Fluxer uses `336`, which is 14 days."},
{"FLUXER_REPORT_RETENTION_DAYS", "instance", "How many days the daily retention job keeps a resolved report, from 1 to 36500. It then deletes the report, its evidence copies and its search entry. A child safety report is kept for at least 365 days after it's resolved, and a report with an enforcement decision for at least 365 days after the decision. The job never deletes a pending report or a report under a legal hold. When it's empty, the worker uses `365`."},
{"FLUXER_REPORT_RETENTION_DRY_RUN", "instance", "Whether the report retention job only counts what it would delete and changes nothing. Use `true` or `false`. When it's empty, the worker uses `false`."},
{"FLUXER_AGE_POLICY_ENABLED", "instance", "Whether the apps need an age check before they show mature content to people in the regions in FLUXER_AGE_POLICY_RESTRICTED_REGIONS. Use `true` or `false`. When it's empty, the age check is on only when FLUXER_AGE_POLICY_RESTRICTED_REGIONS is set."},
{"FLUXER_AGE_POLICY_RESTRICTED_REGIONS", "instance", "The regions where the apps need an age check before they show mature content, separated by commas. Use a country code such as `GB` or a country and region code such as `US-MS`. When it's empty and FLUXER_AGE_POLICY_ENABLED is `true`, Fluxer uses `GB` and `BR`."},
{"FLUXER_STRIPE_ENABLED", "billing", "Whether Fluxer sells subscriptions through Stripe. Use `true` or `false`. When it's empty, Fluxer uses `false`."},
{"FLUXER_STRIPE_SECRET_KEY", "billing", "Your Stripe secret API key."},
{"FLUXER_STRIPE_WEBHOOK_SECRET", "billing", "The signing secret of your Stripe webhook."},
{"FLUXER_STRIPE_PRICES", "billing", "Your Stripe price IDs as one JSON object, keyed by plan and currency such as `monthly_usd`."},
{"FLUXER_STRIPE_LEGACY_PRICES", "billing", "Stripe price IDs you have retired, as a JSON object with the same keys as FLUXER_STRIPE_PRICES and a list of IDs for each. Subscriptions on these prices keep renewing."},
{"FLUXER_VISIONARIES_GUILD_ID", "billing", "The ID of the community that people who buy Visionary are added to. When it's empty on a self-hosted instance, nobody is added."},
{"FLUXER_VISIONARIES_GUILD_VISIONARY_ROLE_ID", "billing", "The ID of the role Fluxer gives Visionary buyers in the community set by FLUXER_VISIONARIES_GUILD_ID. Set it whenever FLUXER_VISIONARIES_GUILD_ID is set."},
{"FLUXER_BREACHED_PASSWORD_CHECK_ENABLED", "integrations", "Whether Fluxer rejects passwords found in known data breaches, by sending the first five characters of the password's SHA-1 hash to `api.pwnedpasswords.com`. Use `true` or `false`. When it's empty, this is off on a self-hosted instance."},
{"FLUXER_BLOCKLIST_FEEDS_ENABLED", "integrations", "Whether the worker downloads the URLhaus and PhishTank link lists every six hours and the MalwareBazaar file hashes every twelve hours, and checks posted links and uploads against them. Use `true` or `false`. When it's empty, this is off on a self-hosted instance."},
{"FLUXER_GEOIP_DB_PATH", "integrations", "Where the api and worker load the MaxMind GeoIP database from, as a file path or an `s3://bucket/key` URL. An s3 URL needs a `download_path` query parameter with an absolute path."},
{"FLUXER_KLIPY_API_KEY", "integrations", "The Klipy API key for GIF search and Klipy link previews. A key saved in the admin panel is used first. GIF search is off when neither is set."},
{"FLUXER_YOUTUBE_API_KEY", "integrations", "The YouTube Data API key Fluxer uses for YouTube link previews. A key saved in the admin panel is used first. The unfurl service calls the API from your server. The key needs YouTube Data API v3 enabled, a daily quota above 0, and an application restriction of None or IP addresses. A key restricted to websites (HTTP referrers) always fails. When Google rejects the key, the unfurl logs show the reason it gives, such as `quotaExceeded` or `API_KEY_HTTP_REFERRER_BLOCKED`."},
{"FLUXER_API_UNFURL_IGNORED_HOSTS", "integrations", "Hostnames, separated by commas, that Fluxer never makes link previews for. A link matches only when its host is exactly one of these."},
{"FLUXER_AUTH_BLUESKY_ENABLED", "integrations", "Whether people can link a Bluesky account to their profile. Use `true` or `false`. It needs FLUXER_AUTH_BLUESKY_KEYS. When it's empty, Fluxer uses `false`."},
{"FLUXER_AUTH_BLUESKY_CLIENT_NAME", "integrations", "The app name Bluesky shows when someone links their account. When it's empty, Bluesky shows `Fluxer`, even when FLUXER_APP_PRODUCT_NAME is set."},
{"FLUXER_AUTH_BLUESKY_CLIENT_URI", "integrations", "Fluxer doesn't use this value. Bluesky shows the API address as the home page of your instance."},
{"FLUXER_AUTH_BLUESKY_LOGO_URI", "integrations", "The logo URL Bluesky shows for your instance."},
{"FLUXER_AUTH_BLUESKY_TOS_URI", "integrations", "The terms of service URL Bluesky shows for your instance."},
{"FLUXER_AUTH_BLUESKY_POLICY_URI", "integrations", "The privacy policy URL Bluesky shows for your instance."},
{"FLUXER_AUTH_BLUESKY_KEYS", "integrations", "The keys Fluxer signs Bluesky account linking requests with, as a JSON array of objects with a `kid` and a `private_key` or a `private_key_path`, which is an absolute path inside the api and worker containers. Keys saved in the admin panel replace these."},
{"FLUXER_TOKIO_WORKER_THREADS", "tuning", "How many worker threads the async runtime uses in the app-proxy, push, admin, snowflakes, users, gifs, messages and unfurl containers, set as their TOKIO_WORKER_THREADS."},
{"FLUXER_MALLOC_ARENA_MAX", "tuning", "How many memory arenas the glibc allocator may create in the push, admin, snowflakes, users, gifs, messages and unfurl containers, set as their MALLOC_ARENA_MAX. Lower values use less memory."},
{"FLUXER_CADDY_MEMORY_LIMIT", "tuning", "The memory limit for the edge container, which runs Caddy."},
{"FLUXER_POSTGRES_MEMORY_LIMIT", "tuning", "The memory limit for the postgres container. Keep it at or above FLUXER_POSTGRES_MEMORY_RESERVATION."},
{"FLUXER_POSTGRES_MEMORY_RESERVATION", "tuning", "The memory reservation for the postgres container, the amount Docker tries to keep for it when the machine runs low. Keep it at or below FLUXER_POSTGRES_MEMORY_LIMIT."},
{"FLUXER_POSTGRES_SERVER_MAX_CONNECTIONS", "tuning", "Postgres `max_connections`, how many connections the database accepts in total. Keep it above the sum of all pool sizes, counting each worker replica."},
{"FLUXER_POSTGRES_SHARED_BUFFERS", "tuning", "Postgres `shared_buffers`, the memory Postgres uses for its own cache."},
{"FLUXER_POSTGRES_EFFECTIVE_CACHE_SIZE", "tuning", "Postgres `effective_cache_size`, how much disk cache the query planner assumes there is. It allocates no memory."},
{"FLUXER_POSTGRES_WORK_MEM", "tuning", "Postgres `work_mem`, the memory each sort or hash step in a query can use before it spills to disk."},
{"FLUXER_POSTGRES_MAINTENANCE_WORK_MEM", "tuning", "Postgres `maintenance_work_mem`, the memory one VACUUM, CREATE INDEX or ALTER TABLE can use."},
{"FLUXER_POSTGRES_AUTOVACUUM_WORK_MEM", "tuning", "Postgres `autovacuum_work_mem`, the memory each autovacuum worker can use."},
{"FLUXER_POSTGRES_RANDOM_PAGE_COST", "tuning", "Postgres `random_page_cost`, how costly the query planner thinks fetching a random disk page is next to a sequential one. Values near 1 suit SSDs."},
{"FLUXER_POSTGRES_EFFECTIVE_IO_CONCURRENCY", "tuning", "Postgres `effective_io_concurrency`, how many disk requests Postgres may have in flight at once. High values suit SSDs."},
{"FLUXER_POSTGRES_DEFAULT_STATISTICS_TARGET", "tuning", "Postgres `default_statistics_target`, how much detail the query planner's table statistics have. Higher values give better plans and a slower ANALYZE."},
{"FLUXER_POSTGRES_JIT", "tuning", "Postgres `jit`, whether Postgres compiles parts of queries with JIT. Use `on` or `off`."},
{"FLUXER_POSTGRES_MIN_WAL_SIZE", "tuning", "Postgres `min_wal_size`, the write-ahead log space Postgres keeps for reuse after a checkpoint."},
{"FLUXER_POSTGRES_MAX_WAL_SIZE", "tuning", "Postgres `max_wal_size`, how large the write-ahead log may grow before Postgres starts a checkpoint."},
{"FLUXER_POSTGRES_CHECKPOINT_COMPLETION_TARGET", "tuning", "Postgres `checkpoint_completion_target`, how much of the time between checkpoints a checkpoint spreads its writes over, as a fraction."},
{"FLUXER_POSTGRES_WAL_BUFFERS", "tuning", "Postgres `wal_buffers`, the memory for write-ahead log data not yet written to disk."},
{"FLUXER_POSTGRES_WAL_COMPRESSION", "tuning", "Postgres `wal_compression`, how full-page images in the write-ahead log are compressed, such as `lz4`, `pglz` or `off`."},
{"FLUXER_POSTGRES_BGWRITER_DELAY", "tuning", "Postgres `bgwriter_delay`, how long the background writer sleeps between rounds, such as `200ms`."},
{"FLUXER_POSTGRES_BGWRITER_LRU_MAXPAGES", "tuning", "Postgres `bgwriter_lru_maxpages`, the most buffers the background writer writes to disk in one round."},
{"FLUXER_POSTGRES_AUTOVACUUM_VACUUM_SCALE_FACTOR", "tuning", "Postgres `autovacuum_vacuum_scale_factor`, the share of a table's rows that must be updated or deleted before autovacuum vacuums it, as a fraction such as `0.1`."},
{"FLUXER_POSTGRES_AUTOVACUUM_ANALYZE_SCALE_FACTOR", "tuning", "Postgres `autovacuum_analyze_scale_factor`, the share of a table's rows that must change before autovacuum analyses it again, as a fraction such as `0.05`."},
{"FLUXER_POSTGRES_AUTOVACUUM_VACUUM_COST_LIMIT", "tuning", "Postgres `autovacuum_vacuum_cost_limit`, how much disk work autovacuum may do before it pauses. Higher values let it finish sooner."},
{"FLUXER_POSTGRES_AUTOVACUUM_MAX_WORKERS", "tuning", "Postgres `autovacuum_max_workers`, how many autovacuum processes can run at once."},
{"FLUXER_POSTGRES_MAX_PARALLEL_WORKERS_PER_GATHER", "tuning", "Postgres `max_parallel_workers_per_gather`, how many parallel workers one step of a query can use."},
{"FLUXER_POSTGRES_MAX_PARALLEL_WORKERS", "tuning", "Postgres `max_parallel_workers`, how many parallel query workers can run at once across the database. Postgres caps it at `max_worker_processes`, and the stack leaves that at 8."},
{"FLUXER_POSTGRES_TRACK_IO_TIMING", "tuning", "Postgres `track_io_timing`, whether Postgres times its disk I/O for its statistics. Use `on` or `off`."},
{"FLUXER_POSTGRES_SHARED_PRELOAD_LIBRARIES", "tuning", "Postgres `shared_preload_libraries`, the extensions Postgres loads at start, separated by commas. Keep `pg_stat_statements` in the list. The api turns it on at start."},
{"FLUXER_POSTGRES_SHM_SIZE", "tuning", "The shared memory size of the postgres container, used by parallel queries and parallel maintenance. Keep it well above FLUXER_POSTGRES_MAINTENANCE_WORK_MEM."},
{"FLUXER_VALKEY_MEMORY_LIMIT", "tuning", "The memory limit for the valkey container. Keep it above FLUXER_VALKEY_MAXMEMORY."},
{"FLUXER_VALKEY_MAXMEMORY", "tuning", "Valkey `maxmemory`, the most memory Valkey may use for stored data. The append-only file buffer and memory fragmentation come on top. Keep it below FLUXER_VALKEY_MEMORY_LIMIT."},
{"FLUXER_VALKEY_MAXMEMORY_POLICY", "tuning", "Valkey `maxmemory-policy`, what Valkey does when its data grows to FLUXER_VALKEY_MAXMEMORY. With `noeviction`, writes fail when Valkey is full and no data is dropped."},
{"FLUXER_NATS_MEMORY_LIMIT", "tuning", "The memory limit for the nats container."},
{"FLUXER_NATS_GOMEMLIMIT", "tuning", "The soft memory limit of the Go runtime in NATS, set as its `GOMEMLIMIT`. Keep it below FLUXER_NATS_MEMORY_LIMIT."},
{"FLUXER_NATS_MAX_MEMORY_STORE", "tuning", "NATS JetStream `max_memory_store`, the most memory JetStream may use for streams kept in memory, such as `128MB`."},
{"FLUXER_NATS_MAX_FILE_STORE", "tuning", "NATS JetStream `max_file_store`, the most disk space JetStream may use for its streams, such as `20GB`."},
{"FLUXER_MEILISEARCH_MEMORY_LIMIT", "tuning", "The memory limit for the meilisearch container."},
{"FLUXER_MEILISEARCH_MAX_INDEXING_MEMORY", "tuning", "The memory Meilisearch aims to stay under while indexing, set as its MEILI_MAX_INDEXING_MEMORY, such as `512mb`. Meilisearch can go a little over it. Keep it well below FLUXER_MEILISEARCH_MEMORY_LIMIT."},
{"FLUXER_MEILISEARCH_MAX_INDEXING_THREADS", "tuning", "The most threads Meilisearch may use for indexing, set as its MEILI_MAX_INDEXING_THREADS."},
{"FLUXER_SEAWEEDFS_MEMORY_LIMIT", "tuning", "The memory limit for the seaweedfs container."},
{"FLUXER_SEAWEEDFS_GOMEMLIMIT", "tuning", "The soft memory limit of the Go runtime in SeaweedFS, set as its `GOMEMLIMIT`. Go can't see the container limit. Keep this at 75 to 85 percent of FLUXER_SEAWEEDFS_MEMORY_LIMIT and raise both together."},
{"FLUXER_SEAWEEDFS_VOLUME_GROWTH", "tuning", "How many volumes SeaweedFS creates at once when a bucket has no writable volume left, set as its WEED_MASTER_VOLUME_GROWTH_COPY_1."},
{"FLUXER_SEAWEEDFS_VOLUME_SIZE_LIMIT_MB", "tuning", "The size in MB a volume can grow to before SeaweedFS stops writing to it, set as its `-master.volumeSizeLimitMB`."},
{"FLUXER_SEAWEEDFS_GARBAGE_THRESHOLD", "tuning", "The share of deleted space in a volume that makes SeaweedFS compact it, as a fraction, set as its `-master.garbageThreshold`."},
{"FLUXER_SEAWEEDFS_S3_CONCURRENT_UPLOADS", "tuning", "How many uploads the bundled object store writes at once, set as its `-s3.concurrentFileUploadLimit`. More uploads wait for a free slot. Each upload in progress uses up to 32 MB of memory in SeaweedFS. Raise FLUXER_SEAWEEDFS_MEMORY_LIMIT before you raise this."},
{"FLUXER_SEAWEEDFS_VOLUME_MAX", "tuning", "The most volumes the SeaweedFS volume store may have, set as its `-volume.max`."},
{"FLUXER_SEAWEEDFS_INIT_MEMORY_LIMIT", "tuning", "The memory limit for the seaweedfs-init container, which creates the buckets, sets up the S3 key and the expiry of the uploads bucket, and then exits."},
{"FLUXER_LIVEKIT_MEMORY_LIMIT", "tuning", "The memory limit for the livekit container."},
{"FLUXER_LIVEKIT_GOMEMLIMIT", "tuning", "The soft memory limit of the Go runtime in LiveKit, set as its `GOMEMLIMIT`. Keep it below FLUXER_LIVEKIT_MEMORY_LIMIT."},
{"FLUXER_API_MEMORY_LIMIT", "tuning", "The memory limit for the api container."},
{"FLUXER_API_MEMORY_RESERVATION", "tuning", "The memory reservation for the api container, the amount Docker tries to keep for it when the machine runs low. Keep it at or below FLUXER_API_MEMORY_LIMIT."},
{"FLUXER_API_NODE_HEAP_MB", "tuning", "The Node heap limit of the api container, in MB, set as `--max-old-space-size`. When it's empty, Node uses 60 percent of the memory available to the container. A value above FLUXER_API_MEMORY_LIMIT lets the heap grow until Docker kills the container for running out of memory."},
{"FLUXER_API_NODE_OPTIONS", "tuning", "Extra Node flags for the api container, added to the end of NODE_OPTIONS, such as `--dns-result-order=ipv4first`. Set the heap with FLUXER_API_NODE_HEAP_MB. While that is empty, a `--max-old-space-size` flag here has no effect."},
{"FLUXER_API_POSTGRES_MAX_CONNECTIONS", "tuning", "The size of the Postgres connection pool of the api container, from 1 to 1000."},
{"FLUXER_API_EMBEDDED_WORKER", "tuning", "Whether the api container also runs the background worker jobs inside the api process. Use `true` or `false`. With `true`, rexctl sets FLUXER_WORKER_REPLICAS to 0 and gives the api container more memory. Without rexctl, set FLUXER_WORKER_REPLICAS to 0 yourself."},
{"FLUXER_WORKER_REPLICAS", "tuning", "How many worker containers Docker runs. With FLUXER_API_EMBEDDED_WORKER set to `true`, rexctl sets it to 0. Without rexctl, set it to 0 yourself."},
{"FLUXER_WORKER_MEMORY_LIMIT", "tuning", "The memory limit for each worker container."},
{"FLUXER_WORKER_MEMORY_RESERVATION", "tuning", "The memory reservation for each worker container, the amount Docker tries to keep for it when the machine runs low. Keep it at or below FLUXER_WORKER_MEMORY_LIMIT."},
{"FLUXER_WORKER_NODE_HEAP_MB", "tuning", "The Node heap limit of each worker container, in MB, set as `--max-old-space-size`. When it's empty, Node uses 55 percent of the memory available to the container. A value above FLUXER_WORKER_MEMORY_LIMIT lets the heap grow until Docker kills the container for running out of memory."},
{"FLUXER_WORKER_NODE_OPTIONS", "tuning", "Extra Node flags for each worker container, added to the end of NODE_OPTIONS, such as `--dns-result-order=ipv4first`. Set the heap with FLUXER_WORKER_NODE_HEAP_MB. While that is empty, a `--max-old-space-size` flag here has no effect."},
{"FLUXER_WORKER_POSTGRES_MAX_CONNECTIONS", "tuning", "The size of the Postgres connection pool of each worker container, from 1 to 1000. It has no effect when FLUXER_API_EMBEDDED_WORKER is `true`."},
{"FLUXER_WORKER_POSTGRES_SYNCHRONOUS_COMMIT", "tuning", "Postgres `synchronous_commit` for the database connections of each worker container. Use `on`, `off`, `local`, `remote_write` or `remote_apply`. When it's empty, the worker uses `off`, and a Postgres crash can lose the worker's most recent writes. It has no effect when FLUXER_API_EMBEDDED_WORKER is `true`."},
{"FLUXER_GATEWAY_MEMORY_LIMIT", "tuning", "The memory limit for the gateway container."},
{"FLUXER_GATEWAY_MEMORY_RESERVATION", "tuning", "The memory reservation for the gateway container, the amount Docker tries to keep for it when the machine runs low. Keep it at or below FLUXER_GATEWAY_MEMORY_LIMIT."},
{"FLUXER_ERLANG_SCHEDULERS", "tuning", "How many normal schedulers the Erlang VM of the gateway runs, a positive whole number. When it's empty, the gateway uses the container's CPU count kept between FLUXER_ERLANG_SCHEDULERS_MIN and FLUXER_ERLANG_SCHEDULERS_MAX."},
{"FLUXER_ERLANG_SCHEDULERS_MIN", "tuning", "The lowest scheduler count the gateway picks from the CPU count when FLUXER_ERLANG_SCHEDULERS is empty. When it's empty, the gateway uses `2`."},
{"FLUXER_ERLANG_SCHEDULERS_MAX", "tuning", "The highest scheduler count the gateway picks from the CPU count when FLUXER_ERLANG_SCHEDULERS is empty. When it's empty, the gateway uses `16`."},
{"FLUXER_ERLANG_DIRTY_CPU_SCHEDULERS", "tuning", "How many dirty CPU schedulers the Erlang VM of the gateway runs, a positive whole number. When it's empty, the gateway uses half the normal scheduler count, and at least `1`."},
{"FLUXER_ERLANG_DIRTY_IO_SCHEDULERS", "tuning", "How many dirty I/O schedulers the Erlang VM of the gateway runs, a positive whole number. When it's empty, the gateway uses the normal scheduler count kept between 2 and 4."},
{"FLUXER_MEDIA_PROXY_MEMORY_LIMIT", "tuning", "The memory limit for the media-proxy container."},
{"FLUXER_MEDIA_PROXY_TOKIO_WORKER_THREADS", "tuning", "How many worker threads the async runtime of the media proxy uses, set as its TOKIO_WORKER_THREADS."},
{"FLUXER_PUSH_MEMORY_LIMIT", "tuning", "The memory limit for the push container."},
{"FLUXER_STATIC_PROXY_MEMORY_LIMIT", "tuning", "The memory limit for the static-proxy container."},
{"FLUXER_APP_PROXY_MEMORY_LIMIT", "tuning", "The memory limit for the app-proxy container."},
{"FLUXER_SNOWFLAKES_MEMORY_LIMIT", "tuning", "The memory limit for the snowflakes container."},
{"FLUXER_USERS_MEMORY_LIMIT", "tuning", "The memory limit for the users container."},
{"FLUXER_USERS_POSTGRES_MAX_CONNECTIONS", "tuning", "The size of the Postgres connection pool of the users container."},
{"FLUXER_GIFS_MEMORY_LIMIT", "tuning", "The memory limit for the gifs container."},
{"FLUXER_GIFS_SHARD_CACHE_MAX_BYTES", "tuning", "How many bytes the gifs service may use for its cache, at least `16777216`, which is 16 MiB. Keep it below FLUXER_GIFS_MEMORY_LIMIT."},
{"FLUXER_MESSAGES_MEMORY_LIMIT", "tuning", "The memory limit for the messages container."},
{"FLUXER_MESSAGES_POSTGRES_MAX_CONNECTIONS", "tuning", "The size of the Postgres connection pool of the messages container."},
{"FLUXER_UNFURL_MEMORY_LIMIT", "tuning", "The memory limit for the unfurl container."},
{"FLUXER_ADMIN_MEMORY_LIMIT", "tuning", "The memory limit for the admin container."},
{"FLUXER_VALKEY_APPENDFSYNC", "bundled", "Valkey `appendfsync`, how often Valkey flushes its append-only file to disk. Use `always`, `everysec` or `no`. With `everysec`, a crash can lose the last second of writes."},
{"FLUXER_VALKEY_SAVE", "bundled", "Valkey `save`, when Valkey writes RDB snapshots, as pairs of seconds and changes such as `3600 1 300 100`. When it's empty, snapshots are off and Valkey keeps its data in the append-only file alone."},
{"FLUXER_MEILISEARCH_ENV", "bundled", "The Meilisearch environment, set as its MEILI_ENV. Use `production` or `development`. With `production`, Meilisearch refuses to start without a master key of at least 16 bytes and turns off its search preview."},
{"FLUXER_MEILISEARCH_NO_ANALYTICS", "bundled", "Whether Meilisearch stops sending usage data to the Meilisearch team, set as its MEILI_NO_ANALYTICS. Use `true` or `false`."},
{"FLUXER_SEAWEEDFS_TELEMETRY", "bundled", "Whether SeaweedFS sends usage data to the SeaweedFS project, set as its `-master.telemetry`. Use `true` or `false`."},
{"LOG_LEVEL", "operations", "How much the api and worker log. Use `trace`, `debug`, `info`, `warn`, `error` or `fatal`. An empty or unknown value gives `info`."},
{"RUST_LOG", "operations", "The log filter of media-proxy, app-proxy, admin, push, snowflakes, users, gifs, messages and unfurl, in tracing EnvFilter format such as `debug` or `off`. An empty or invalid filter gives `info`."},
{"FLUXER_GATEWAY_LOGGER_LEVEL", "operations", "The gateway log level. Use `debug`, `info`, `notice`, `warning`, `error`, `critical`, `alert` or `emergency`. An empty or unknown value gives `info`. LOGGER_LEVEL wins over this one."},
{"LOGGER_LEVEL", "operations", "The gateway log level, which wins over FLUXER_GATEWAY_LOGGER_LEVEL and takes the same levels. An empty or unknown value falls back to FLUXER_GATEWAY_LOGGER_LEVEL."},
{"FLUXER_MEILISEARCH_LOG_LEVEL", "operations", "How much Meilisearch logs, set as its MEILI_LOG_LEVEL. Use `OFF`, `ERROR`, `WARN`, `INFO`, `DEBUG` or `TRACE`."},
{"FLUXER_LIVEKIT_LOG_LEVEL", "operations", "How much LiveKit logs. Use `debug`, `info`, `warn` or `error`."},
{"FLUXER_LOG_MAX_SIZE", "operations", "How large the log file of a container grows before Docker rotates it, such as `50m`."},
{"FLUXER_LOG_MAX_FILE", "operations", "How many log files Docker keeps for each container when it rotates logs."},
{"FLUXER_RESTART_POLICY", "operations", "The Docker restart policy of every long-running service, such as `always`, `on-failure` or `no`."},
{"FLUXER_HEALTHCHECK_INTERVAL", "operations", "How often Docker runs the health check of each service, such as `30s`. The media-proxy and app-proxy containers have their own interval settings."},
{"FLUXER_MEDIA_PROXY_HEALTHCHECK_INTERVAL", "operations", "How often Docker runs the health check of the media-proxy container."},
{"FLUXER_APP_PROXY_HEALTHCHECK_INTERVAL", "operations", "How often Docker runs the health check of the app-proxy container."},
{"FLUXER_HEALTHCHECK_TIMEOUT", "operations", "How long one health check may run before Docker counts it as failed."},
{"FLUXER_HEALTHCHECK_RETRIES", "operations", "How many failed health checks in a row mark the edge, postgres, valkey, nats, meilisearch, livekit, media-proxy, static-proxy and app-proxy containers as unhealthy."},
{"FLUXER_HEALTHCHECK_START_PERIOD", "operations", "How long the edge, postgres, valkey, nats, meilisearch, livekit, media-proxy, static-proxy and app-proxy containers get to start before failed health checks count."},
{"FLUXER_HEALTHCHECK_START_INTERVAL", "operations", "How often Docker runs each health check while a service is still in its start period."},
{"FLUXER_APP_HEALTHCHECK_RETRIES", "operations", "How many failed health checks in a row mark the api, gateway, push, admin, snowflakes, users, gifs, messages and unfurl containers as unhealthy."},
{"FLUXER_APP_HEALTHCHECK_START_PERIOD", "operations", "How long the api, worker and gateway containers get to start before failed health checks count, such as `120s`."},
{"FLUXER_SVC_HEALTHCHECK_START_PERIOD", "operations", "How long the push, admin, snowflakes, users, gifs, messages and unfurl containers get to start before failed health checks count."},
{"FLUXER_SEAWEEDFS_HEALTHCHECK_RETRIES", "operations", "How many failed health checks in a row mark the seaweedfs container as unhealthy."},
{"FLUXER_SEAWEEDFS_HEALTHCHECK_START_PERIOD", "operations", "How long the seaweedfs container gets to start before failed health checks count."},
{"FLUXER_WORKER_HEALTHCHECK_RETRIES", "operations", "How many failed health checks in a row mark a worker container as unhealthy. The check passes while the worker has updated its heartbeat file in the last 30 seconds."},
{"FLUXER_CADDY_IMAGE", "images", ""},
{"FLUXER_POSTGRES_IMAGE", "images", ""},
{"FLUXER_VALKEY_IMAGE", "images", ""},
{"FLUXER_NATS_IMAGE", "images", ""},
{"FLUXER_MEILISEARCH_IMAGE", "images", ""},
{"FLUXER_SEAWEEDFS_IMAGE", "images", ""},
{"FLUXER_LIVEKIT_IMAGE", "images", ""},
{"FLUXER_REGISTRY", "images", "The registry of Fluxer's own images in the docker-compose.yml of the Fluxer repository. When it's empty, that file uses `ghcr.io/` followed by FLUXER_REGISTRY_OWNER. The compose bundle pins every Fluxer image to the release."},
{"FLUXER_REGISTRY_OWNER", "images", "The owner of Fluxer's own images on `ghcr.io`, in the docker-compose.yml of the Fluxer repository. The compose bundle pins every Fluxer image to the release."},
{"FLUXER_IMAGE_TAG", "images", "The tag of Fluxer's own images in the docker-compose.yml of the Fluxer repository. The compose bundle pins every Fluxer image to the release. `rexctl upgrade --check` reads it to find the release a Docker Compose install runs, and uses `v1` when it's empty."},
{"FLUXER_VOICE_JOIN_TOKEN", "rexctl", "The join token for `rexctl voice join` when the command line doesn't have one. Other accounts on the machine can't see it in the process list."},
{"REXCTL_RELEASE_URL", "rexctl", "The URL of the release index that rexctl and its install scripts download releases from. When it's empty, they use https://fluxer.dev/rexctl/release.json. Another server must respond to the same queries as that address, including `version` and `format=sh`."},
{"REXCTL_IMAGE_SET", "rexctl", "The path of an image set JSON file with a release and its image list, which rexctl uses for its built-in images. Only tests use it."},
{"VISUAL", "rexctl", "The editor `rexctl config edit` opens. When it's empty, rexctl uses `EDITOR`."},
{"EDITOR", "rexctl", "The editor `rexctl config edit` opens when `VISUAL` is empty. When both are empty, rexctl uses Notepad on Windows and nano or vi elsewhere."},
{"NO_COLOR", "rexctl", "Set it to any value to turn off colour in rexctl and its install scripts. A `TERM` of `dumb` turns colour off too."},
{"ACCESSIBLE", "rexctl", "Set it to any value to make rexctl ask questions as plain text prompts and print steps as plain lines for screen readers."},
{"DOCKER_HOST", "rexctl", "The engine address rexctl tries first, such as `unix:///run/user/1000/podman/podman.sock`. rexctl reads it for install, takeover and restore, and when the engine an instance uses doesn't respond. When it's empty, rexctl uses the current Docker context and then looks for a Docker or Podman socket."},
{"DOCKER_CONTEXT", "rexctl", "The Docker context rexctl tries first when DOCKER_HOST is empty. rexctl reads it for install, takeover and restore, and when the engine an instance uses doesn't respond. When it's empty, rexctl uses the current context of the Docker CLI."},
{"DOCKER_CONFIG", "rexctl", "The directory of the Docker CLI configuration, which has the current Docker context. When it's empty, rexctl uses `.docker` in your home directory."},
{"DISCOVERY_UPSTREAM_URL", "stack", "Where app-proxy loads the instance discovery document from."},
{"FLUXER_ADMIN_PORT", "stack", "The port the admin service listens on inside its container."},
{"FLUXER_API_PORT", "stack", "The port the api service listens on inside its container."},
{"FLUXER_API_PUBLIC_ENDPOINT", "stack", "The public API address the admin panel allows images from, set from FLUXER_API_ENDPOINT."},
{"FLUXER_API_WORKER_ENABLE_CRON_SCHEDULER", "stack", "Whether the worker runs the scheduled jobs."},
{"FLUXER_API_WORKER_MODE", "stack", "Which job lanes the worker runs."},
{"FLUXER_APP_PROXY_PORT", "stack", "The port the app-proxy service listens on inside its container."},
{"FLUXER_BASE_DOMAIN", "stack", "The domain the services build their addresses from, set from FLUXER_DOMAIN."},
{"FLUXER_DATABASE_BACKEND", "stack", "The database the services use."},
{"FLUXER_EDGE_TLS_DIRECTIVE", "stack", "The tls line of the edge Caddyfile, set from FLUXER_EDGE_TLS."},
{"FLUXER_ENV", "stack", "The environment the services run in."},
{"FLUXER_GATEWAY_PORT", "stack", "The port the gateway listens on inside its container."},
{"FLUXER_INTERNAL_API_ENDPOINT", "stack", "The address the services use to call the api service inside the stack."},
{"FLUXER_INTERNAL_MEDIA_PROXY_ENDPOINT", "stack", "The address the services use to call the media proxy inside the stack."},
{"FLUXER_LIVEKIT_API_KEY", "stack", "The LiveKit API key the services use, set from LIVEKIT_API_KEY."},
{"FLUXER_LIVEKIT_API_SECRET", "stack", "The LiveKit API secret the services use, set from LIVEKIT_API_SECRET."},
{"FLUXER_MEDIA_PROXY_ENDPOINT", "stack", "The address the unfurl service uses to call the media proxy. The api and worker also read it when FLUXER_INTERNAL_MEDIA_PROXY_ENDPOINT is empty."},
{"FLUXER_MEDIA_PROXY_MODE", "stack", "How the media proxy runs."},
{"FLUXER_MEDIA_PROXY_PORT", "stack", "The port the media proxy listens on inside its container."},
{"FLUXER_MEDIA_PROXY_STORAGE_BACKEND", "stack", "Where the media proxy keeps files."},
{"FLUXER_POSTGRES_MAX_CONNECTIONS", "stack", "The size of each service's Postgres connection pool, set from FLUXER_API_POSTGRES_MAX_CONNECTIONS, FLUXER_WORKER_POSTGRES_MAX_CONNECTIONS, FLUXER_USERS_POSTGRES_MAX_CONNECTIONS or FLUXER_MESSAGES_POSTGRES_MAX_CONNECTIONS."},
{"FLUXER_POSTGRES_PASSWORD", "stack", "The Postgres password the services use, set from POSTGRES_PASSWORD."},
{"FLUXER_S3_ACCESS_KEY_ID", "stack", "The object store access key the services use, set from FLUXER_S3_ACCESS_KEY."},
{"FLUXER_S3_SECRET_ACCESS_KEY", "stack", "The object store secret key the services use, set from FLUXER_S3_SECRET_KEY."},
{"FLUXER_SEARCH_API_KEY", "stack", "The search API key the services use, set from MEILI_MASTER_KEY."},
{"FLUXER_SELF_HOSTED", "stack", "Whether the services run as a self-hosted instance."},
{"FLUXER_SVC_MODE", "stack", "How the snowflakes, users, gifs, messages and unfurl services run."},
{"FLUXER_SVC_NAME", "stack", "The service name the internal services use to pick their default for FLUXER_SVC_MAX_CONCURRENT_REQUESTS. Each image always runs its own service. Docker Compose sets it to the name of each service, such as `users`."},
{"FLUXER_SVC_SHARD_COUNT", "stack", "How many shards each internal service has."},
{"GOMEMLIMIT", "stack", "The soft memory limit of the Go runtime in NATS, LiveKit and SeaweedFS, set from FLUXER_NATS_GOMEMLIMIT, FLUXER_LIVEKIT_GOMEMLIMIT and FLUXER_SEAWEEDFS_GOMEMLIMIT."},
{"LIVEKIT_CONFIG", "stack", "The LiveKit config in YAML, built from the voice and video settings and LIVEKIT_API_KEY."},
{"LIVEKIT_KEYS", "stack", "The LiveKit API key and secret pair, set from LIVEKIT_API_KEY and LIVEKIT_API_SECRET."},
{"MALLOC_ARENA_MAX", "stack", "The glibc memory arena limit of the push, admin, snowflakes, users, gifs, messages and unfurl services, set from FLUXER_MALLOC_ARENA_MAX."},
{"MEILI_ENV", "stack", "The Meilisearch environment, set from FLUXER_MEILISEARCH_ENV."},
{"MEILI_LOG_LEVEL", "stack", "The Meilisearch log level, set from FLUXER_MEILISEARCH_LOG_LEVEL."},
{"MEILI_MAX_INDEXING_MEMORY", "stack", "The memory Meilisearch aims to stay under while indexing, set from FLUXER_MEILISEARCH_MAX_INDEXING_MEMORY."},
{"MEILI_MAX_INDEXING_THREADS", "stack", "The most threads Meilisearch may use for indexing, set from FLUXER_MEILISEARCH_MAX_INDEXING_THREADS."},
{"MEILI_NO_ANALYTICS", "stack", "Whether Meilisearch stops sending usage data, set from FLUXER_MEILISEARCH_NO_ANALYTICS."},
{"MEILI_UPGRADE_DB", "stack", "Whether Meilisearch upgrades its database on start after a version change."},
{"NODE_EXTRA_CA_CERTS", "stack", "The extra CA certificates Node trusts in the api and worker services, set from FLUXER_NODE_EXTRA_CA_CERTS."},
{"NODE_OPTIONS", "stack", "The Node options of the api and worker services, built from FLUXER_API_NODE_HEAP_MB, FLUXER_API_NODE_OPTIONS, FLUXER_WORKER_NODE_HEAP_MB and FLUXER_WORKER_NODE_OPTIONS."},
{"POSTGRES_DB", "stack", "The database the bundled Postgres creates on its first start, set from FLUXER_POSTGRES_DATABASE."},
{"POSTGRES_USER", "stack", "The role the bundled Postgres creates on its first start, set from FLUXER_POSTGRES_USERNAME."},
{"TOKIO_WORKER_THREADS", "stack", "How many async worker threads the Rust services use, set from FLUXER_TOKIO_WORKER_THREADS or FLUXER_MEDIA_PROXY_TOKIO_WORKER_THREADS."},
{"WEED_MASTER_VOLUME_GROWTH_COPY_1", "stack", "How many volumes SeaweedFS creates at once, set from FLUXER_SEAWEEDFS_VOLUME_GROWTH."},
{"http_proxy", "stack", "Docker Compose also sets `http_proxy` to this value for tools that only look up the lowercase name."},
{"https_proxy", "stack", "Docker Compose also sets `https_proxy` to this value for tools that only look up the lowercase name."},
{"no_proxy", "stack", "Docker Compose also sets `no_proxy` to this value for tools that only look up the lowercase name."},
{"ALL_PROXY", "internal", "The proxy the Rust services use for HTTP and HTTPS requests when HTTP_PROXY or HTTPS_PROXY is empty. They also take the lowercase `all_proxy`."},
{"BUILD_VERSION", "internal", "The build version a service reports. Each image sets its own."},
{"FLUXER_ADMIN_HOST", "internal", "The address the admin service listens on. When it's empty, it listens on `0.0.0.0`."},
{"FLUXER_ADMIN_OAUTH_CLIENT_ID", "internal", "The OAuth2 client ID the admin panel signs in with. The stack uses the built-in client ID of the admin service."},
{"FLUXER_ADMIN_OAUTH_REDIRECT_URI", "internal", "The OAuth2 redirect URL of the admin panel. The admin service works it out from its own address."},
{"FLUXER_ADMIN_SSO_REDIRECT_URI", "internal", "The single sign-on redirect URL of the admin panel. The admin service works it out from its own address."},
{"FLUXER_API_AUTOMATED_MESSAGE_DELETION_DELAY_DAYS", "hosted", "The delay before automated account actions delete messages, in days."},
{"FLUXER_API_WORKER_LANE", "internal", "The job lane a worker runs when FLUXER_API_WORKER_MODE is `single_lane`. Each worker container in the stack runs every lane."},
{"FLUXER_API_WORKER_METRICS_PORT", "internal", "The port the worker serves its metrics on. The stack doesn't collect worker metrics."},
{"FLUXER_API_WORKER_TASK", "internal", "The one task a worker runs when FLUXER_API_WORKER_MODE is `single_task`. Each worker container in the stack runs every lane."},
{"FLUXER_APP_PROXY_HOST", "internal", "The address the app-proxy service listens on. When it's empty, it listens on `0.0.0.0`."},
{"FLUXER_APP_STORE_APPS", "hosted", "The App Store apps Fluxer sells in."},
{"FLUXER_APP_STORE_ENABLED", "hosted", "Whether App Store purchases are on."},
{"FLUXER_APP_STORE_ISSUER_ID", "hosted", "The App Store Connect issuer ID."},
{"FLUXER_APP_STORE_KEY_ID", "hosted", "The App Store Connect key ID."},
{"FLUXER_APP_STORE_PRIVATE_KEY", "hosted", "The App Store Connect private key."},
{"FLUXER_APP_STORE_PRIVATE_KEY_PATH", "hosted", "The path to the App Store Connect private key."},
{"FLUXER_APP_STORE_PRODUCTS", "hosted", "The App Store products and what they grant."},
{"FLUXER_BUILD_VERSION", "internal", "The older name for BUILD_VERSION, which only the admin and app-proxy services read when BUILD_VERSION is empty. Their images set BUILD_VERSION."},
{"FLUXER_CASSANDRA_HOSTS", "cassandra", "The Cassandra hosts."},
{"FLUXER_CASSANDRA_KEYSPACE", "cassandra", "The Cassandra keyspace."},
{"FLUXER_CASSANDRA_LOCAL_DC", "cassandra", "The local Cassandra data centre."},
{"FLUXER_CASSANDRA_PASSWORD", "cassandra", "The Cassandra password."},
{"FLUXER_CASSANDRA_PORT", "cassandra", "The Cassandra port."},
{"FLUXER_CASSANDRA_USERNAME", "cassandra", "The Cassandra username."},
{"FLUXER_DISABLE_RATE_LIMITS", "dev", "Whether rate limits are off."},
{"FLUXER_DOCS_ENDPOINT", "docs", "The public address of the docs site."},
{"FLUXER_DOCS_LISTEN_HOST", "docs", "The address the docs site listens on."},
{"FLUXER_DOCS_LISTEN_PORT", "docs", "The port the docs site listens on."},
{"FLUXER_DOCS_SEARCH_INDEXING", "docs", "Whether search engines may index the docs site."},
{"FLUXER_ERLANG_COOKIE_FILE", "internal", "A file that has the gateway's Erlang cookie. The stack passes FLUXER_ERLANG_COOKIE itself."},
{"FLUXER_ERLANG_DIST_PORT", "cluster", "The Erlang distribution port of the gateway."},
{"FLUXER_ERLANG_NODE_NAME", "cluster", "The Erlang node name of the gateway."},
{"FLUXER_ERLANG_NODE_NAME_PREFIX", "cluster", "A prefix that gives each gateway node a unique Erlang node name."},
{"FLUXER_GATEWAY_API_RPC_ENDPOINT", "internal", "The URL the gateway sends API RPC requests to. When it's empty, the gateway uses FLUXER_INTERNAL_API_ENDPOINT followed by `/internal/rpc`."},
{"FLUXER_GATEWAY_CLUSTER_DISCOVERY_DNS_NAME", "cluster", "The DNS name gateway nodes find each other through."},
{"FLUXER_GATEWAY_CLUSTER_DISCOVERY_NODE_BASENAME", "cluster", "The node name gateway nodes use when they find each other through DNS."},
{"FLUXER_GATEWAY_CLUSTER_DISCOVERY_POLL_INTERVAL_MS", "cluster", "How often gateway nodes look for each other, in milliseconds."},
{"FLUXER_GATEWAY_CLUSTER_ENABLED", "cluster", "Whether the gateway runs as a cluster."},
{"FLUXER_GATEWAY_CLUSTER_STATIC_PEERS", "cluster", "A fixed list of the other gateway nodes."},
{"FLUXER_GATEWAY_GUILD_PIN_KEEPER_BASE_MD5S", "cluster", "The module MD5s a node may have before the gateway patches it."},
{"FLUXER_GATEWAY_GUILD_PIN_KEEPER_BEAM", "cluster", "The path of the BEAM file the gateway loads onto other nodes to pin communities."},
{"FLUXER_GATEWAY_GUILD_PIN_KEEPER_BEAM_MD5", "cluster", "The MD5 that the FLUXER_GATEWAY_GUILD_PIN_KEEPER_BEAM file must have."},
{"FLUXER_GATEWAY_NATS_RPC_ENABLED", "internal", "Whether the gateway responds to RPC requests over NATS. The gateway responds to the API only over NATS RPC and must keep it turned on."},
{"FLUXER_GATEWAY_PINNED_GUILD_IDS", "cluster", "The communities the gateway pins to particular nodes."},
{"FLUXER_GATEWAY_ROLE", "cluster", "The role of a gateway node in a cluster."},
{"FLUXER_GIF_SERVICE_SUBJECT", "internal", "The NATS subject the API sends gifs service requests to. The gifs service always listens on `svc.gifs`, and any other value breaks GIF search."},
{"FLUXER_GOOGLE_PLAY_CLIENT_EMAIL", "hosted", "The Google Play service account email."},
{"FLUXER_GOOGLE_PLAY_ENABLED", "hosted", "Whether Google Play purchases are on."},
{"FLUXER_GOOGLE_PLAY_PACKAGES", "hosted", "The Android packages Fluxer sells in."},
{"FLUXER_GOOGLE_PLAY_PRIVATE_KEY", "hosted", "The Google Play service account private key."},
{"FLUXER_GOOGLE_PLAY_PRIVATE_KEY_PATH", "hosted", "The path to the Google Play service account private key."},
{"FLUXER_GOOGLE_PLAY_PRODUCTS", "hosted", "The Google Play products and what they grant."},
{"FLUXER_GOOGLE_PLAY_PUSH_AUDIENCE", "hosted", "The audience the API expects in the token on Google Play billing notifications from Pub/Sub."},
{"FLUXER_GOOGLE_PLAY_PUSH_SERVICE_ACCOUNT_EMAIL", "hosted", "The service account email the API expects in the token on Google Play billing notifications from Pub/Sub."},
{"FLUXER_GOOGLE_PLAY_SELF_SERVICE_REFUNDS", "hosted", "Whether people can request Google Play refunds themselves."},
{"FLUXER_GOOGLE_PLAY_SERVICE_ACCOUNT_JSON_PATH", "hosted", "The path to the Google Play service account JSON file."},
{"FLUXER_GOOGLE_PLAY_TOKEN_URI", "hosted", "The OAuth token URL for Google Play."},
{"FLUXER_MEDIA_PROXY_HOST", "internal", "The address the media proxy listens on. When it's empty, it listens on `0.0.0.0`."},
{"FLUXER_MEDIA_PROXY_STORAGE_ROOT", "internal", "The directory the media proxy keeps files in when it stores them on disk. The stack keeps media in the object store."},
{"FLUXER_NATS_CORE_URL", "internal", "The older name for FLUXER_NATS_URL, which only the api and worker read. Docker Compose passes FLUXER_NATS_URL."},
{"FLUXER_OPERATOR_SOCKET", "dev", "The socket path the operator relay connects to. The api listens on /run/fluxer/operator.sock."},
{"FLUXER_PAYMENT_DISPUTE_CLOSURE_EFFECTIVE_AT", "hosted", "When account closures for payment disputes take effect."},
{"FLUXER_PUSH_RELAY_MAX_BODY_BYTES", "relay", "The largest request the push relay accepts, in bytes."},
{"FLUXER_PUSH_RELAY_MAX_CONCURRENT", "relay", "How many requests the push relay handles at once."},
{"FLUXER_PUSH_RELAY_SOURCE_BUCKET_BURST", "relay", "How many requests the push relay allows from one client address in a burst."},
{"FLUXER_PUSH_RELAY_SOURCE_BUCKET_ENABLED", "relay", "Whether the push relay rate limits each client address itself."},
{"FLUXER_PUSH_RELAY_SOURCE_BUCKET_ENTRIES", "relay", "How many client addresses the push relay rate limit tracks."},
{"FLUXER_PUSH_RELAY_SOURCE_BUCKET_PER_MINUTE", "relay", "How many requests a minute the push relay allows from one client address."},
{"FLUXER_PUSH_RELAY_TOKEN_BUCKET_BURST", "relay", "How many requests the push relay allows for one device token in a burst."},
{"FLUXER_PUSH_RELAY_TOKEN_BUCKET_ENTRIES", "relay", "How many device tokens the push relay rate limit tracks."},
{"FLUXER_PUSH_RELAY_TOKEN_BUCKET_PER_MINUTE", "relay", "How many requests a minute the push relay allows for one device token."},
{"FLUXER_PUSH_RELAY_TRUSTED_PROXY_HOPS", "relay", "How many proxies in front of the push relay it trusts."},
{"FLUXER_PUSH_SERVICE_HOST", "internal", "The address the push service listens on. When it's empty, it listens on `0.0.0.0`."},
{"FLUXER_PUSH_SERVICE_PORT", "internal", "The port the push service listens on. When it's empty, it uses `8126`, or `8127` for the push relay."},
{"FLUXER_RELAX_REGISTRATION_RATE_LIMITS", "dev", "Whether registration rate limits are relaxed."},
{"FLUXER_S3_BUCKET_STATIC", "internal", "The bucket the media proxy serves files from when FLUXER_MEDIA_PROXY_MODE is `static`. The stack runs the media proxy in `upload` mode."},
{"FLUXER_SNOWFLAKE_SERVICE_SUBJECT", "internal", "The NATS subject the API sends snowflakes service requests to. The snowflakes service always listens on `svc.snowflakes`, and any other value breaks ID generation."},
{"FLUXER_STATIC_DIR", "internal", "The directory the app-proxy service serves static files from. The app-proxy image has its static files built in."},
{"FLUXER_STORE_BILLING_SANDBOX_ENTITLES_ALL", "hosted", "Whether sandbox store purchases, gifts included, count for every account with no time limit."},
{"FLUXER_STORE_BILLING_SANDBOX_SUBSCRIPTIONS", "hosted", "Whether sandbox App Store and Google Play subscriptions count for every account for 7 days after each purchase. On by default."},
{"FLUXER_STORE_BILLING_SANDBOX_USER_IDS", "hosted", "The accounts whose sandbox store purchases count."},
{"FLUXER_STRIPE_PRICE_GIFT_1_MONTH_BRL", "prices", "The price ID of the one-month gift in BRL."},
{"FLUXER_STRIPE_PRICE_GIFT_1_MONTH_DKK", "prices", "The price ID of the one-month gift in DKK."},
{"FLUXER_STRIPE_PRICE_GIFT_1_MONTH_EUR", "prices", "The price ID of the one-month gift in EUR."},
{"FLUXER_STRIPE_PRICE_GIFT_1_MONTH_INR", "prices", "The price ID of the one-month gift in INR."},
{"FLUXER_STRIPE_PRICE_GIFT_1_MONTH_ISK", "prices", "The price ID of the one-month gift in ISK."},
{"FLUXER_STRIPE_PRICE_GIFT_1_MONTH_NOK", "prices", "The price ID of the one-month gift in NOK."},
{"FLUXER_STRIPE_PRICE_GIFT_1_MONTH_PLN", "prices", "The price ID of the one-month gift in PLN."},
{"FLUXER_STRIPE_PRICE_GIFT_1_MONTH_SEK", "prices", "The price ID of the one-month gift in SEK."},
{"FLUXER_STRIPE_PRICE_GIFT_1_MONTH_TRY", "prices", "The price ID of the one-month gift in TRY."},
{"FLUXER_STRIPE_PRICE_GIFT_1_MONTH_USD", "prices", "The price ID of the one-month gift in USD."},
{"FLUXER_STRIPE_PRICE_GIFT_1_YEAR_BRL", "prices", "The price ID of the one-year gift in BRL."},
{"FLUXER_STRIPE_PRICE_GIFT_1_YEAR_DKK", "prices", "The price ID of the one-year gift in DKK."},
{"FLUXER_STRIPE_PRICE_GIFT_1_YEAR_EUR", "prices", "The price ID of the one-year gift in EUR."},
{"FLUXER_STRIPE_PRICE_GIFT_1_YEAR_INR", "prices", "The price ID of the one-year gift in INR."},
{"FLUXER_STRIPE_PRICE_GIFT_1_YEAR_ISK", "prices", "The price ID of the one-year gift in ISK."},
{"FLUXER_STRIPE_PRICE_GIFT_1_YEAR_NOK", "prices", "The price ID of the one-year gift in NOK."},
{"FLUXER_STRIPE_PRICE_GIFT_1_YEAR_PLN", "prices", "The price ID of the one-year gift in PLN."},
{"FLUXER_STRIPE_PRICE_GIFT_1_YEAR_SEK", "prices", "The price ID of the one-year gift in SEK."},
{"FLUXER_STRIPE_PRICE_GIFT_1_YEAR_TRY", "prices", "The price ID of the one-year gift in TRY."},
{"FLUXER_STRIPE_PRICE_GIFT_1_YEAR_USD", "prices", "The price ID of the one-year gift in USD."},
{"FLUXER_STRIPE_PRICE_MONTHLY_BRL", "prices", "The price ID of the monthly plan in BRL."},
{"FLUXER_STRIPE_PRICE_MONTHLY_DKK", "prices", "The price ID of the monthly plan in DKK."},
{"FLUXER_STRIPE_PRICE_MONTHLY_EUR", "prices", "The price ID of the monthly plan in EUR."},
{"FLUXER_STRIPE_PRICE_MONTHLY_INR", "prices", "The price ID of the monthly plan in INR."},
{"FLUXER_STRIPE_PRICE_MONTHLY_ISK", "prices", "The price ID of the monthly plan in ISK."},
{"FLUXER_STRIPE_PRICE_MONTHLY_NOK", "prices", "The price ID of the monthly plan in NOK."},
{"FLUXER_STRIPE_PRICE_MONTHLY_PLN", "prices", "The price ID of the monthly plan in PLN."},
{"FLUXER_STRIPE_PRICE_MONTHLY_SEK", "prices", "The price ID of the monthly plan in SEK."},
{"FLUXER_STRIPE_PRICE_MONTHLY_TRY", "prices", "The price ID of the monthly plan in TRY."},
{"FLUXER_STRIPE_PRICE_MONTHLY_USD", "prices", "The price ID of the monthly plan in USD."},
{"FLUXER_STRIPE_PRICE_YEARLY_BRL", "prices", "The price ID of the yearly plan in BRL."},
{"FLUXER_STRIPE_PRICE_YEARLY_DKK", "prices", "The price ID of the yearly plan in DKK."},
{"FLUXER_STRIPE_PRICE_YEARLY_EUR", "prices", "The price ID of the yearly plan in EUR."},
{"FLUXER_STRIPE_PRICE_YEARLY_INR", "prices", "The price ID of the yearly plan in INR."},
{"FLUXER_STRIPE_PRICE_YEARLY_ISK", "prices", "The price ID of the yearly plan in ISK."},
{"FLUXER_STRIPE_PRICE_YEARLY_NOK", "prices", "The price ID of the yearly plan in NOK."},
{"FLUXER_STRIPE_PRICE_YEARLY_PLN", "prices", "The price ID of the yearly plan in PLN."},
{"FLUXER_STRIPE_PRICE_YEARLY_SEK", "prices", "The price ID of the yearly plan in SEK."},
{"FLUXER_STRIPE_PRICE_YEARLY_TRY", "prices", "The price ID of the yearly plan in TRY."},
{"FLUXER_STRIPE_PRICE_YEARLY_USD", "prices", "The price ID of the yearly plan in USD."},
{"FLUXER_SVC_LISTEN_HOST", "internal", "The address an internal service listens on. When it's empty, it listens on `0.0.0.0`."},
{"FLUXER_SVC_PORT", "internal", "The port an internal service listens on. When it's empty, it uses `8090`."},
{"FLUXER_SVC_SHARD_ID", "internal", "Which shard of an internal service a container runs. When it's empty, the service takes the number at the end of POD_NAME, or `0`. The stack runs one shard of each service."},
{"FLUXER_TEST_HARNESS_TOKEN", "dev", "The token of the test harness."},
{"FLUXER_TEST_MODE_ENABLED", "dev", "Whether test mode is on."},
{"FLUXER_USERS_SERVICE_SUBJECT", "internal", "The NATS subject the API sends users service requests to. The users service always listens on `svc.users`, and any other value breaks user lookups."},
{"FLUXER_VALKEY_PASSWORD", "internal", "The password of the Valkey that the Fluxer Helm chart runs, at least 32 letters and digits. The chart builds FLUXER_KV_URL from it."},
{"FLUXER_VALIDATE_RESPONSES", "dev", "Whether the API checks its responses against their schemas."},
{"G_MESSAGES_DEBUG", "internal", "The GLib log domains whose debug messages libvips prints in the media proxy, or `all`. The media-proxy image sets it to an empty value and GLib prints none."},
{"HOSTNAME", "internal", "The hostname of the container. Docker sets it."},
{"KLIPY_API_KEY", "internal", "The older name for FLUXER_KLIPY_API_KEY, used only by the unfurl service. Docker Compose passes FLUXER_KLIPY_API_KEY."},
{"LD_PRELOAD", "internal", "Libraries the dynamic loader loads before any others. The media-proxy and app-proxy images set it to `libjemalloc.so.2` to use the jemalloc memory allocator."},
{"LIVEKIT_WEBHOOK_URL", "internal", "The address the bundled LiveKit sends its webhooks to. The Fluxer Helm chart sets it on the LiveKit pod and adds it to the LiveKit config."},
{"MALLOC_CONF", "internal", "The jemalloc options of the media proxy and app-proxy. Both images set it to `background_thread:true,metadata_thp:auto,dirty_decay_ms:5000,muzzy_decay_ms:5000`."},
{"NODE_ENV", "internal", "The Node environment that libraries in the api and worker look up. The api image sets it to `production`."},
{"NODE_TLS_REJECT_UNAUTHORIZED", "internal", "With `0`, Node in the api and worker checks no certificates on outgoing TLS connections, except Postgres when FLUXER_POSTGRES_SSL is `true`. To trust your own CA, use FLUXER_NODE_EXTRA_CA_CERTS."},
{"PGDATA", "internal", "The directory the bundled Postgres keeps its data in. The Fluxer Helm chart sets it on the Postgres pod."},
{"PGSSLMODE", "internal", "The libpq TLS mode the api and worker use when FLUXER_POSTGRES_SSL isn't `true` and FLUXER_POSTGRES_URL has no `sslmode`. With `prefer`, `require`, `verify-ca` or `verify-full`, they connect over TLS and check the server certificate. With `no-verify`, they connect over TLS without checking it. The other services don't use it."},
{"POD_IP", "internal", "The IP address of a gateway pod. The Fluxer Helm chart sets it on the gateway pods and builds FLUXER_ERLANG_NODE_NAME from it."},
{"POD_NAME", "internal", "The name of the pod a service runs in. The api and gateway label their RPC timings with it, or with `HOSTNAME` when it's empty, and the gateway reports it in its node details. When FLUXER_SVC_SHARD_ID is empty, an internal service runs the shard numbered at the end of the pod name, such as `2` for `users-2`. The Fluxer Helm chart sets it on the shard pods of the internal services and on the NATS pods."},
{"REDISCLI_AUTH", "internal", "The password of the bundled Valkey. The Fluxer Helm chart sets it on the Valkey pod from FLUXER_VALKEY_PASSWORD and starts Valkey with it."},
{"RELEASE_CHANNEL", "internal", "The release channel the app-proxy service puts in the web app, `stable` or `canary`. The self-hosted app-proxy service serves the stable channel."},
{"RELX_REPLACE_OS_VARS", "internal", "Whether the gateway release scripts fill in environment variables in the gateway config. The gateway entrypoint sets it."},
{"SSL_CERT_DIR", "internal", "Directories of CA certificate files, separated by colons, that the Rust services trust for outgoing TLS. When it or SSL_CERT_FILE is set, they trust only those certificates."},
{"SSL_CERT_FILE", "internal", "A PEM file of CA certificates that the Rust services trust for outgoing TLS, such as to your own object store or Postgres. When it or SSL_CERT_DIR is set, they trust only those certificates. Add your CA to a copy of the system bundle."},
{"VIPS_CONCURRENCY", "internal", "How many threads libvips uses for each image transform. The media proxy always runs libvips with one thread per transform and ignores it. FLUXER_MEDIA_PROXY_MAX_NATIVE_TRANSFORMS sets how many transforms run at once."},
{"VIPS_DISC_THRESHOLD", "internal", "The image size above which libvips in the media proxy decodes an image to a temporary file on disk. The media-proxy image sets it to `1g`."},
{"YOUTUBE_API_KEY", "internal", "The older name for FLUXER_YOUTUBE_API_KEY, used only by the unfurl service. Docker Compose passes FLUXER_YOUTUBE_API_KEY."},
}