Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp
124 KB
Raw Blame
# ============================================================================
#  This is a reference copy. Use the .env.example in the compose bundle of
#  your Fluxer release.
# ============================================================================

# ============================================================================
#  Fluxer settings for the Docker Compose bundle
#
#  Copy this file to .env, fill in the required values and run
#  docker compose up -d. Settings that start with # are optional. To change
#  one, remove the # and set a value.
#
#  If you move this instance to rexctl later with rexctl takeover, the rexctl
#  line under each setting shows the command that changes it.
# ============================================================================


# ============================================================================
#  REQUIRED
#
#  Fill these in before the first start.
# ============================================================================

# Leave it set to true. Docker Compose won't start without it.
FLUXER_SETTINGS_LOADED=true

# The domain Fluxer runs on.
#   example:  chat.example.com
#   rexctl:   rexctl config set domain
FLUXER_DOMAIN=


# ============================================================================
#  FIRST ADMIN ACCOUNT
# ============================================================================

# 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. Keep it secret.
FLUXER_SETUP_TOKEN=


# ============================================================================
#  SECRETS
#
#  Fill these in before the first start, and keep a copy of .env somewhere
#  safe. Only FLUXER_ACTIVITYPUB_SIGNING_KEY_BASE64 may stay empty.
# ============================================================================

# These have fixed values for the bundled services. Keep them as they are
# unless the setting tells you otherwise.

# The object store access key. Keep the default for the bundled object store,
# or set the access key of your own store.
#   rexctl:   rexctl config set storage.access_key
FLUXER_S3_ACCESS_KEY=fluxer

# 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_KEY=fluxer


# Generate each value with this command. Set them once before the first start
# and never change them.
#   openssl rand -hex 32

# 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.
POSTGRES_PASSWORD=

# The Meilisearch master key. Docker Compose passes it to the bundled
# Meilisearch and to Fluxer as FLUXER_SEARCH_API_KEY.
MEILI_MASTER_KEY=

# The object store secret key. For your own object store, set its secret key,
# and update it when you rotate the key at the store.
#   rexctl:   rexctl config set storage.secret_key
FLUXER_S3_SECRET_KEY=

# 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.
LIVEKIT_API_SECRET=


# Generate each value with this command.
#   openssl rand -hex 32

# 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_SUDO_MODE_SECRET=

# 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_CONNECTION_INITIATION_SECRET=

# 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_PROFILE_PSEUDONYM_SECRET=

# 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_GATEWAY_RPC_AUTH_TOKEN=

# 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_ERLANG_COOKIE=

# 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_SECRET_KEY=

# 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_SECRET_KEY_BASE=

# 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_ADMIN_OAUTH_CLIENT_SECRET=


# Generate the value with this command.
#   openssl rand -base64 32

# 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_MEDIA_PROXY_UPLOAD_RELAY_SECRET_BASE64=


# Generate the value with this command.
#   openssl genpkey -algorithm RSA -pkeyopt rsa_keygen_bits:2048 -outform DER |
#     base64 | tr -d '\n'

# 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.
FLUXER_ACTIVITYPUB_SIGNING_KEY_BASE64=


# These commands print the public and then the private key of the VAPID key
# pair for browser push notifications. Set the pair once before the first
# start and never change it.
#   openssl ecparam -name prime256v1 -genkey -noout -out vapid.pem
#   openssl ec -in vapid.pem -pubout -outform DER | tail -c 65 | base64 |
#     tr '/+' '_-' | tr -d '=\n'
#   openssl ec -in vapid.pem -outform DER | tail -c +8 | head -c 32 |
#     base64 | tr '/+' '_-' | tr -d '=\n'
#   rm vapid.pem

# 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_PUBLIC_KEY=

# 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_VAPID_PRIVATE_KEY=


# ============================================================================
#  COMPOSE FILES
#
#  The optional compose files change how Fluxer runs. To use one, list it
#  after docker-compose.yml in COMPOSE_FILE, such as
#  COMPOSE_FILE=docker-compose.yml:docker-compose.proxy.yml.
#
#    docker-compose.proxy.yml           for your own reverse proxy
#    tunnel.compose.yml                 for a tunnel
#    external-object-store.compose.yml  for your own object store
#    ipv6.compose.yml                   for IPv6 on Fluxer's network
#    external-voice.compose.yml         for voice servers of your own without the bundled LiveKit
# ============================================================================

# 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_FILE=

# 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_PATH_SEPARATOR=

# 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.
# COMPOSE_PROJECT_NAME=


# ============================================================================
#  PUBLIC ADDRESS
#
#  Fluxer works out every address from FLUXER_DOMAIN. Set these only when a
#  part of Fluxer runs on another 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. rexctl sets this
# from your domain and edge settings unless you set it.
#   default:  https
#   rexctl:   rexctl config set FLUXER_PUBLIC_SCHEME
# FLUXER_PUBLIC_SCHEME=

# 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. rexctl sets this
# from your domain and edge settings unless you set it.
#   rexctl:   rexctl config set FLUXER_PUBLIC_ORIGIN
# FLUXER_PUBLIC_ORIGIN=

# 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.
#   rexctl:   rexctl config set FLUXER_APP_ORIGIN_ALIASES
# FLUXER_APP_ORIGIN_ALIASES=

# The public base URL of the API. When it's empty, Fluxer uses the public
# origin followed by /api.
#   rexctl:   rexctl config set FLUXER_API_ENDPOINT
# FLUXER_API_ENDPOINT=

# The API base URL Fluxer hands to clients. When it's empty, Fluxer uses the
# public origin followed by /api.
#   rexctl:   rexctl config set FLUXER_API_CLIENT_ENDPOINT
# FLUXER_API_CLIENT_ENDPOINT=

# 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.
#   rexctl:   rexctl config set FLUXER_API_DISCOVERY_PUBLIC_ENDPOINT
# FLUXER_API_DISCOVERY_PUBLIC_ENDPOINT=

# The address of the web app, which Fluxer allows through CORS and uses in
# links. When it's empty, Fluxer uses the public origin.
#   rexctl:   rexctl config set FLUXER_APP_ENDPOINT
# FLUXER_APP_ENDPOINT=

# 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.
#   rexctl:   rexctl config set FLUXER_GATEWAY_ENDPOINT
# FLUXER_GATEWAY_ENDPOINT=

# The public address of the media proxy. When it's empty, Fluxer uses the
# public origin followed by /media.
#   rexctl:   rexctl config set FLUXER_MEDIA_ENDPOINT
# FLUXER_MEDIA_ENDPOINT=

# 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.
#   rexctl:   rexctl config set FLUXER_MEDIA_PROXY_PUBLIC_ENDPOINT
# FLUXER_MEDIA_PROXY_PUBLIC_ENDPOINT=

# 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.
#   rexctl:   rexctl config set FLUXER_STATIC_CDN_ENDPOINT
# FLUXER_STATIC_CDN_ENDPOINT=

# 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.
#   rexctl:   rexctl config set FLUXER_ADMIN_ENDPOINT
# FLUXER_ADMIN_ENDPOINT=

# 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.
#   rexctl:   rexctl config set FLUXER_MARKETING_ENDPOINT
# FLUXER_MARKETING_ENDPOINT=

# The base URL of invite links. When it's empty, Fluxer uses
# FLUXER_INVITE_DOMAIN or the public host, followed by /invite.
#   rexctl:   rexctl config set FLUXER_INVITE_ENDPOINT
# FLUXER_INVITE_ENDPOINT=

# The base URL of gift links. When it's empty, Fluxer uses FLUXER_GIFT_DOMAIN
# or the public host, followed by /gift.
#   rexctl:   rexctl config set FLUXER_GIFT_ENDPOINT
# FLUXER_GIFT_ENDPOINT=

# 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.
#   rexctl:   rexctl config set FLUXER_STATIC_CDN_DOMAIN
# FLUXER_STATIC_CDN_DOMAIN=

# A separate hostname for invite links, with no scheme, port or path. When
# it's set, the default invite address uses this host.
#   rexctl:   rexctl config set FLUXER_INVITE_DOMAIN
# FLUXER_INVITE_DOMAIN=

# A separate hostname for gift links, with no scheme, port or path. When it's
# set, the default gift address uses this host.
#   rexctl:   rexctl config set FLUXER_GIFT_DOMAIN
# FLUXER_GIFT_DOMAIN=


# ============================================================================
#  EDGE AND HTTPS
#
#  By default Fluxer listens on ports 80 and 443 and gets its own HTTPS
#  certificate for your domain.
# ============================================================================

# The port people use in Fluxer's address, when it differs from the one Fluxer
# listens on. rexctl sets this from your domain and edge settings unless you
# set it.
#   default:  443
#   rexctl:   rexctl config set edge.public_port
# FLUXER_PUBLIC_PORT=

# The port Fluxer listens on for HTTP. docker-compose.proxy.yml and
# tunnel.compose.yml ignore it and use FLUXER_EDGE_BIND.
#   default:  80
#   rexctl:   rexctl config set edge.http_port
# FLUXER_HTTP_PORT=

# The port Fluxer listens on for HTTPS. 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.
#   default:  443
#   rexctl:   rexctl config set edge.https_port
# FLUXER_HTTPS_PORT=

# The address your reverse proxy or tunnel connects to.
#   default:  127.0.0.1:8080 with docker-compose.proxy.yml
#             127.0.0.1:80 with tunnel.compose.yml
#   rexctl:   rexctl config set edge.bind
# FLUXER_EDGE_BIND=

# The IP address on this machine that Fluxer listens on for HTTP and HTTPS, or
# empty for every address. Write an IPv6 address without brackets.
# docker-compose.proxy.yml and tunnel.compose.yml ignore it and use
# FLUXER_EDGE_BIND.
#   rexctl:   rexctl config set edge.listen_address
# FLUXER_EDGE_LISTEN_ADDRESS=

# 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.
#   default:  /admin
#   rexctl:   rexctl config set FLUXER_ADMIN_BASE_PATH
# FLUXER_ADMIN_BASE_PATH=

# 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. rexctl
# sets this from your domain and edge settings unless you set it.
#   rexctl:   rexctl config set FLUXER_EDGE_SITE_ADDRESS
# FLUXER_EDGE_SITE_ADDRESS=

# 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_CADDY_SITE_ADDRESS=

# Proxies whose client address headers Fluxer trusts, separated by spaces.
#   default:  127.0.0.1/32
#             private_ranges with docker-compose.proxy.yml or tunnel.compose.yml
#   rexctl:   rexctl config set edge.trusted_proxies
# FLUXER_EDGE_TRUSTED_PROXIES=

# The response compression the edge offers, written as the arguments of the
# Caddy encode directive, such as gzip alone.
#   default:  zstd gzip
#   rexctl:   rexctl config set FLUXER_EDGE_ENCODE
# FLUXER_EDGE_ENCODE=

# The HTTP versions the edge serves, as the arguments of the Caddy protocols
# option, such as h1 h2 to turn off HTTP/3. On a machine with little memory,
# rexctl turns off HTTP/3 unless you set it.
#   default:  h1 h2 h3
#   rexctl:   rexctl config set FLUXER_EDGE_PROTOCOLS
# FLUXER_EDGE_PROTOCOLS=

# 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.
#   rexctl:   rexctl config set FLUXER_EDGE_GLOBAL_OPTIONS
# FLUXER_EDGE_GLOBAL_OPTIONS=

# 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.
#   rexctl:   rexctl config set FLUXER_EDGE_TLS
# FLUXER_EDGE_TLS=


# ============================================================================
#  VOICE AND VIDEO
#
#  Calls connect directly to this machine on FLUXER_LIVEKIT_TCP_PORT and
#  FLUXER_LIVEKIT_UDP_PORT, even when Fluxer is behind your own proxy. To run
#  without the bundled LiveKit, add external-voice.compose.yml to COMPOSE_FILE
#  and set FLUXER_LIVEKIT_BUNDLED to false.
# ============================================================================

# Whether voice and video calls are turned on. Use true or false.
#   default:  true
#   rexctl:   rexctl config set FLUXER_LIVEKIT_ENABLED
# FLUXER_LIVEKIT_ENABLED=

# 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.
#   default:  http://livekit:7880
#   rexctl:   rexctl config set FLUXER_LIVEKIT_INTERNAL_URL
# FLUXER_LIVEKIT_INTERNAL_URL=

# Whether Fluxer runs its own LiveKit voice server on this machine. 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.
#   default:  true
#   rexctl:   rexctl config set voice.bundled
# FLUXER_LIVEKIT_BUNDLED=

# The voice region Fluxer creates when no voice regions exist yet, as a JSON
# object with id, name, emoji, latitude and longitude.
#   default:  {"id":"default","name":"Default","emoji":"🌍","latitude":0,"longitude":0}
#   rexctl:   rexctl config set FLUXER_LIVEKIT_DEFAULT_REGION
# FLUXER_LIVEKIT_DEFAULT_REGION=

# 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.
#   rexctl:   rexctl config set FLUXER_LIVEKIT_URL
# FLUXER_LIVEKIT_URL=

# 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.
#   rexctl:   rexctl config set FLUXER_VOICE_P2P_STUN_URLS
# FLUXER_VOICE_P2P_STUN_URLS=

# 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.
#   rexctl:   rexctl config set FLUXER_VOICE_JOIN_ALLOW_PRIVATE_ENDPOINTS
# FLUXER_VOICE_JOIN_ALLOW_PRIVATE_ENDPOINTS=

# 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.
#   rexctl:   rexctl config set FLUXER_VOICE_HEALTH_INTERVAL_MS
# FLUXER_VOICE_HEALTH_INTERVAL_MS=

# 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.
#   rexctl:   rexctl config set FLUXER_VOICE_PARTICIPANT_SWEEP_ENABLED
# FLUXER_VOICE_PARTICIPANT_SWEEP_ENABLED=

# 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.
#   rexctl:   rexctl config set FLUXER_VOICE_PARTICIPANT_SWEEP_DRY_RUN
# FLUXER_VOICE_PARTICIPANT_SWEEP_DRY_RUN=

# The TCP port for voice and video.
#   default:  7881
#   rexctl:   rexctl config set voice.tcp_port
# FLUXER_LIVEKIT_TCP_PORT=

# The UDP port for voice and video.
#   default:  7882
#   rexctl:   rexctl config set voice.udp_port
# FLUXER_LIVEKIT_UDP_PORT=

# The public IP address voice and video use, when Fluxer can't find it by
# itself. Set FLUXER_LIVEKIT_USE_EXTERNAL_IP to false with it.
#   rexctl:   rexctl config set voice.public_ip
# FLUXER_LIVEKIT_NODE_IP=

# Whether LiveKit finds its public IP address through STUN. Use true or false.
# Set it to false when you set FLUXER_LIVEKIT_NODE_IP.
#   default:  true
#   rexctl:   rexctl config set voice.public_ip
# FLUXER_LIVEKIT_USE_EXTERNAL_IP=

# 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.
#   default:  stun.l.google.com:19302
#   rexctl:   rexctl config set FLUXER_LIVEKIT_STUN_PRIMARY
# FLUXER_LIVEKIT_STUN_PRIMARY=

# The second STUN host LiveKit asks to find its public IP address, as
# host:port.
#   default:  stun1.l.google.com:19302
#   rexctl:   rexctl config set FLUXER_LIVEKIT_STUN_SECONDARY
# FLUXER_LIVEKIT_STUN_SECONDARY=

# 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.
#   default:  []
#   rexctl:   rexctl config set FLUXER_LIVEKIT_TURN_SERVERS
# FLUXER_LIVEKIT_TURN_SERVERS=


# ============================================================================
#  OBJECT STORAGE
#
#  By default Fluxer keeps files in the bundled object store. To use your own
#  S3-compatible store, set its address and buckets, add
#  external-object-store.compose.yml to COMPOSE_FILE and put its keys in
#  FLUXER_S3_ACCESS_KEY and FLUXER_S3_SECRET_KEY.
# ============================================================================

# The address of the S3-compatible object store.
#   default:  http://seaweedfs:8333
#   rexctl:   rexctl config set storage.endpoint
# FLUXER_S3_ENDPOINT=

# The object store address browsers use, when it differs from the one Fluxer
# uses. 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.
#   rexctl:   rexctl config set storage.public_endpoint
# FLUXER_S3_PUBLIC_ENDPOINT=

# The object store region.
#   default:  us-east-1
#   rexctl:   rexctl config set storage.region
# FLUXER_S3_REGION=

# Whether the object store needs path-style addresses. Use true or false.
#   default:  true
#   rexctl:   rexctl config set storage.path_style
# FLUXER_S3_FORCE_PATH_STYLE=

# A temporary S3 session token the media proxy sends with its object store
# requests. When it's empty, the media proxy sends none. Keep it secret.
#   rexctl:   rexctl config set FLUXER_S3_SESSION_TOKEN
# FLUXER_S3_SESSION_TOKEN=

# 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.
#   default:  fluxer
#   rexctl:   rexctl config set FLUXER_S3_BUCKET_CDN
# FLUXER_S3_BUCKET_CDN=

# The bucket for raw uploads. The bundled object store creates it, and an
# outside store needs it to exist already.
#   default:  fluxer-uploads
#   rexctl:   rexctl config set FLUXER_S3_BUCKET_UPLOADS
# FLUXER_S3_BUCKET_UPLOADS=

# The bucket for abuse report evidence. The bundled object store creates it,
# and an outside store needs it to exist already.
#   default:  fluxer-reports
#   rexctl:   rexctl config set FLUXER_S3_BUCKET_REPORTS
# FLUXER_S3_BUCKET_REPORTS=

# The bucket for data export archives. The bundled object store creates it,
# and an outside store needs it to exist already.
#   default:  fluxer-harvests
#   rexctl:   rexctl config set FLUXER_S3_BUCKET_HARVESTS
# FLUXER_S3_BUCKET_HARVESTS=

# 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.
#   rexctl:   rexctl config set FLUXER_S3_READ_ENDPOINT
# FLUXER_S3_READ_ENDPOINT=

# The bucket the media proxy fetches through FLUXER_S3_READ_ENDPOINT. When
# it's empty, the media proxy uses FLUXER_S3_BUCKET_CDN.
#   rexctl:   rexctl config set FLUXER_S3_READ_BUCKET
# FLUXER_S3_READ_BUCKET=

# 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.
#   rexctl:   rexctl config set FLUXER_S3_READ_BUCKET_STYLE
# FLUXER_S3_READ_BUCKET_STYLE=

# 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.
#   default:  true
#   rexctl:   rexctl config set FLUXER_S3_READ_SIGNED
# FLUXER_S3_READ_SIGNED=

# Whether the API hands clients upload URLs that let them upload attachments
# before they send the message. Use true or false.
#   default:  true
#   rexctl:   rexctl config set FLUXER_API_PRESIGNED_ATTACHMENT_UPLOADS_ENABLED
# FLUXER_API_PRESIGNED_ATTACHMENT_UPLOADS_ENABLED=

# 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.
#   default:  false
#   rexctl:   rexctl config set FLUXER_API_PRESIGNED_HARVEST_DOWNLOADS_ENABLED
# FLUXER_API_PRESIGNED_HARVEST_DOWNLOADS_ENABLED=

# 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.
#   rexctl:   rexctl config set FLUXER_API_STORAGE_CHANGE_FEED_ENABLED
# FLUXER_API_STORAGE_CHANGE_FEED_ENABLED=

# The JetStream stream the storage change feed publishes to, in letters,
# digits, underscores or hyphens. When it's empty, Fluxer uses
# STORAGE_CHANGES.
#   rexctl:   rexctl config set FLUXER_API_STORAGE_CHANGE_FEED_STREAM
# FLUXER_API_STORAGE_CHANGE_FEED_STREAM=

# 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.
#   rexctl:   rexctl config set FLUXER_API_STORAGE_CHANGE_FEED_SKIP_BUCKETS
# FLUXER_API_STORAGE_CHANGE_FEED_SKIP_BUCKETS=

# 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.
#   default:  60
#   rexctl:   rexctl config set FLUXER_SEAWEEDFS_INIT_ATTEMPTS
# FLUXER_SEAWEEDFS_INIT_ATTEMPTS=

# 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.
#   default:  1d
#   rexctl:   rexctl config set FLUXER_SEAWEEDFS_UPLOADS_TTL
# FLUXER_SEAWEEDFS_UPLOADS_TTL=


# ============================================================================
#  DATABASE
#
#  Leave these unset to use the bundled Postgres.
# ============================================================================

# The hostname or address of the Postgres database. Set it when Postgres runs
# outside the stack.
#   default:  postgres
#   rexctl:   rexctl config set FLUXER_POSTGRES_HOST
# FLUXER_POSTGRES_HOST=

# The Postgres port, from 1 to 65535. When it's empty, Fluxer uses 5432.
#   rexctl:   rexctl config set FLUXER_POSTGRES_PORT
# FLUXER_POSTGRES_PORT=

# 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.
#   rexctl:   rexctl config set FLUXER_POSTGRES_DATABASE
# FLUXER_POSTGRES_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.
#   rexctl:   rexctl config set FLUXER_POSTGRES_USERNAME
# FLUXER_POSTGRES_USERNAME=

# 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.
# Keep it secret.
#   rexctl:   rexctl config set FLUXER_POSTGRES_URL
# FLUXER_POSTGRES_URL=

# 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.
#   rexctl:   rexctl config set FLUXER_POSTGRES_SSL
# FLUXER_POSTGRES_SSL=

# 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.
#   rexctl:   rexctl config set FLUXER_POSTGRES_SSL_CA
# FLUXER_POSTGRES_SSL_CA=

# 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.
#   rexctl:   rexctl config set FLUXER_POSTGRES_PREPARED_STATEMENTS
# FLUXER_POSTGRES_PREPARED_STATEMENTS=

# 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.
#   rexctl:   rexctl config set FLUXER_POSTGRES_KV_TABLE
# FLUXER_POSTGRES_KV_TABLE=


# ============================================================================
#  CACHE, QUEUE AND SEARCH
#
#  Leave these unset to use the bundled Valkey, NATS and Meilisearch.
# ============================================================================

# The Valkey or Redis URL Fluxer uses for its cache, rate limits and other
# short-lived data.
#   default:  redis://valkey:6379/0
#   rexctl:   rexctl config set FLUXER_KV_URL
# FLUXER_KV_URL=

# 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.
#   rexctl:   rexctl config set FLUXER_KV_MODE
# FLUXER_KV_MODE=

# 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.
#   default:  nats://nats:4222
#   rexctl:   rexctl config set FLUXER_NATS_URL
# FLUXER_NATS_URL=

# The NATS address the api and worker services use for JetStream. When it's
# empty, they use FLUXER_NATS_URL.
#   rexctl:   rexctl config set FLUXER_NATS_JETSTREAM_URL
# FLUXER_NATS_JETSTREAM_URL=

# The token every service sends when it connects to NATS. When it's empty,
# services connect without a token. The bundled NATS needs none. Keep it
# secret.
#   rexctl:   rexctl config set FLUXER_NATS_AUTH_TOKEN
# FLUXER_NATS_AUTH_TOKEN=

# 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.
#   rexctl:   rexctl config set FLUXER_SVC_NATS_URL
# FLUXER_SVC_NATS_URL=

# 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.
#   rexctl:   rexctl config set FLUXER_SVC_MAX_CONCURRENT_REQUESTS
# FLUXER_SVC_MAX_CONCURRENT_REQUESTS=

# The most entries each internal service process keeps in its cache. When it's
# empty, the internal services use 100000.
#   rexctl:   rexctl config set FLUXER_SVC_CACHE_MAX_ENTRIES
# FLUXER_SVC_CACHE_MAX_ENTRIES=

# How long the internal services keep cached entries, in milliseconds. When
# it's empty, they use 30000.
#   rexctl:   rexctl config set FLUXER_SVC_CACHE_TTL_MS
# FLUXER_SVC_CACHE_TTL_MS=

# 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.
#   rexctl:   rexctl config set FLUXER_GIF_SERVICE_NATS_CLIENT_NAME
# FLUXER_GIF_SERVICE_NATS_CLIENT_NAME=

# 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.
#   rexctl:   rexctl config set FLUXER_GIF_SERVICE_TIMEOUT_MS
# FLUXER_GIF_SERVICE_TIMEOUT_MS=

# 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.
#   rexctl:   rexctl config set FLUXER_GIF_SERVICE_REGISTER_SHARE_TIMEOUT_MS
# FLUXER_GIF_SERVICE_REGISTER_SHARE_TIMEOUT_MS=

# 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.
#   rexctl:   rexctl config set FLUXER_USERS_SERVICE_NATS_CLIENT_NAME
# FLUXER_USERS_SERVICE_NATS_CLIENT_NAME=

# How long the API waits for the users service, in milliseconds. When it's
# empty, the API uses 6000.
#   rexctl:   rexctl config set FLUXER_USERS_SERVICE_TIMEOUT_MS
# FLUXER_USERS_SERVICE_TIMEOUT_MS=

# 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.
#   rexctl:   rexctl config set FLUXER_USERS_SERVICE_INFLIGHT_MAX_ENTRIES
# FLUXER_USERS_SERVICE_INFLIGHT_MAX_ENTRIES=

# 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.
#   rexctl:   rexctl config set FLUXER_SNOWFLAKE_SERVICE_NATS_CLIENT_NAME
# FLUXER_SNOWFLAKE_SERVICE_NATS_CLIENT_NAME=

# 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.
#   rexctl:   rexctl config set FLUXER_SNOWFLAKE_SERVICE_BATCH_SIZE
# FLUXER_SNOWFLAKE_SERVICE_BATCH_SIZE=

# 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.
#   rexctl:   rexctl config set FLUXER_SNOWFLAKE_SERVICE_LOW_WATERMARK
# FLUXER_SNOWFLAKE_SERVICE_LOW_WATERMARK=

# 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.
#   rexctl:   rexctl config set FLUXER_SNOWFLAKE_SERVICE_MAX_BUFFER_AGE_MS
# FLUXER_SNOWFLAKE_SERVICE_MAX_BUFFER_AGE_MS=

# How long the API waits for the snowflakes service, in milliseconds from 1 to
# 60000. When it's empty, the API uses 6000.
#   rexctl:   rexctl config set FLUXER_SNOWFLAKE_SERVICE_REQUEST_TIMEOUT_MS
# FLUXER_SNOWFLAKE_SERVICE_REQUEST_TIMEOUT_MS=

# 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.
#   default:  meilisearch
#   rexctl:   rexctl config set FLUXER_SEARCH_ENGINE
# FLUXER_SEARCH_ENGINE=

# The address of the search engine.
#   default:  http://meilisearch:7700
#   rexctl:   rexctl config set FLUXER_SEARCH_URL
# FLUXER_SEARCH_URL=

# 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.
#   rexctl:   rexctl config set FLUXER_SEARCH_USERNAME
# FLUXER_SEARCH_USERNAME=

# The basic auth password for Elasticsearch. Fluxer uses it only when
# FLUXER_SEARCH_API_KEY is empty, the same as FLUXER_SEARCH_USERNAME. Keep it
# secret.
#   rexctl:   rexctl config set FLUXER_SEARCH_PASSWORD
# FLUXER_SEARCH_PASSWORD=

# Whether Fluxer checks the Elasticsearch TLS certificate. Use true or false.
# When it's empty, Fluxer checks it. Meilisearch connections don't use it.
#   rexctl:   rexctl config set FLUXER_SEARCH_TLS_REJECT_UNAUTHORIZED
# FLUXER_SEARCH_TLS_REJECT_UNAUTHORIZED=


# ============================================================================
#  OUTGOING PROXY
#
#  These settings are for Fluxer's services. rexctl and the Linux and macOS
#  install script take HTTPS_PROXY, HTTP_PROXY and NO_PROXY from the shell you
#  run them from.
# ============================================================================

# The proxy the Rust services other than the app-proxy use for outgoing HTTP
# requests. The api, worker and gateway don't use it.
#   rexctl:   rexctl config set network.http_proxy
# HTTP_PROXY=

# The proxy the Rust services other than the app-proxy use for outgoing HTTPS
# requests. The api, worker and gateway don't use it.
#   rexctl:   rexctl config set network.https_proxy
# HTTPS_PROXY=

# Hosts the Rust services other than the app-proxy connect to without the
# proxy, separated by commas.
#   rexctl:   rexctl config set network.no_proxy
# NO_PROXY=

# 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.
#   default:  /etc/ssl/certs/ca-certificates.crt
#   rexctl:   rexctl config set FLUXER_NODE_EXTRA_CA_CERTS
# FLUXER_NODE_EXTRA_CA_CERTS=


# ============================================================================
#  SIGN-IN
# ============================================================================

# Whether single sign-on can use a provider on a private or local network
# address. Use true or false. When it's empty, Fluxer uses false.
#   rexctl:   rexctl config set sso.allow_private_addresses
# FLUXER_SSO_ALLOW_PRIVATE_ADDRESSES=

# 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.
#   rexctl:   rexctl config set FLUXER_PASSKEY_RP_ID
# FLUXER_PASSKEY_RP_ID=

# The title browsers show for Fluxer when someone creates or uses a passkey.
# When it's empty, browsers show Fluxer.
#   rexctl:   rexctl config set FLUXER_PASSKEY_RP_NAME
# FLUXER_PASSKEY_RP_NAME=

# 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.
#   rexctl:   rexctl config set FLUXER_PASSKEY_ADDITIONAL_ALLOWED_ORIGINS
# FLUXER_PASSKEY_ADDITIONAL_ALLOWED_ORIGINS=

# 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.
#   rexctl:   rexctl config set FLUXER_ADMIN_SSO_ISSUER
# FLUXER_ADMIN_SSO_ISSUER=

# 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.
#   rexctl:   rexctl config set FLUXER_ADMIN_SSO_CLIENT_ID
# FLUXER_ADMIN_SSO_CLIENT_ID=

# The client secret that goes with FLUXER_ADMIN_SSO_CLIENT_ID. Only the admin
# service uses it. Keep it secret.
#   rexctl:   rexctl config set FLUXER_ADMIN_SSO_CLIENT_SECRET
# FLUXER_ADMIN_SSO_CLIENT_SECRET=

# 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.
#   rexctl:   rexctl config set FLUXER_ADMIN_SSO_DISPLAY_NAME
# FLUXER_ADMIN_SSO_DISPLAY_NAME=

# 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.
#   rexctl:   rexctl config set FLUXER_ADMIN_SSO_ONLY
# FLUXER_ADMIN_SSO_ONLY=


# ============================================================================
#  EMAIL
#
#  The admin panel can also save the delivery mode, the sender and the SMTP
#  server. A value saved there is used first.
# ============================================================================

# The older way to turn email on. Use FLUXER_EMAIL_DELIVERY.
#   rexctl:   rexctl config set integrations.email.delivery
# FLUXER_EMAIL_ENABLED=

# The older way to pick the email transport, which takes smtp or none. Use
# FLUXER_EMAIL_DELIVERY.
#   rexctl:   rexctl config set integrations.email.delivery
# FLUXER_EMAIL_PROVIDER=

# 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.
#   rexctl:   rexctl config set integrations.email.delivery
# FLUXER_EMAIL_DELIVERY=

# The address Fluxer sends email from. When it's empty, Fluxer uses noreply@
# followed by FLUXER_DOMAIN.
#   rexctl:   rexctl config set integrations.email.from_email
# FLUXER_EMAIL_FROM_EMAIL=

# The sender name on email from Fluxer. When it's empty, Fluxer uses the
# product name of the instance.
#   rexctl:   rexctl config set integrations.email.from_name
# FLUXER_EMAIL_FROM_NAME=

# 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.
#   rexctl:   rexctl config set FLUXER_EMAIL_REPLY_TO_EMAIL
# FLUXER_EMAIL_REPLY_TO_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.
#   rexctl:   rexctl config set FLUXER_EMAIL_APP_BASE_URL
# FLUXER_EMAIL_APP_BASE_URL=

# 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. Keep it secret.
#   rexctl:   rexctl config set FLUXER_EMAIL_WEBHOOK_SECRET
# FLUXER_EMAIL_WEBHOOK_SECRET=

# The hostname of your SMTP server.
#   rexctl:   rexctl config set integrations.email.smtp.host
# FLUXER_EMAIL_SMTP_HOST=

# The port of your SMTP server. When it's empty, Fluxer uses 587.
#   rexctl:   rexctl config set integrations.email.smtp.port
# FLUXER_EMAIL_SMTP_PORT=

# The username Fluxer signs in to your SMTP server with.
#   rexctl:   rexctl config set integrations.email.smtp.username
# FLUXER_EMAIL_SMTP_USERNAME=

# The password Fluxer signs in to your SMTP server with. Keep it secret.
#   rexctl:   rexctl config set integrations.email.smtp.password
# FLUXER_EMAIL_SMTP_PASSWORD=

# 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.
#   rexctl:   rexctl config set integrations.email.smtp.tls_mode
# FLUXER_EMAIL_SMTP_TLS_MODE=

# 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.
#   rexctl:   rexctl config set integrations.email.smtp.tls_mode
# FLUXER_EMAIL_SMTP_SECURE=

# 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.
#   rexctl:   rexctl config set FLUXER_EMAIL_FALLBACK_DOMAINS
# FLUXER_EMAIL_FALLBACK_DOMAINS=

# The hostname of the fallback SMTP provider.
#   rexctl:   rexctl config set FLUXER_EMAIL_FALLBACK_SMTP_HOST
# FLUXER_EMAIL_FALLBACK_SMTP_HOST=

# The port of the fallback SMTP provider, from 1 to 65535. When it's empty,
# Fluxer uses 587.
#   rexctl:   rexctl config set FLUXER_EMAIL_FALLBACK_SMTP_PORT
# FLUXER_EMAIL_FALLBACK_SMTP_PORT=

# The username Fluxer signs in to the fallback SMTP provider with. Fluxer
# doesn't start when a fallback provider is set without it.
#   rexctl:   rexctl config set FLUXER_EMAIL_FALLBACK_SMTP_USERNAME
# FLUXER_EMAIL_FALLBACK_SMTP_USERNAME=

# The password Fluxer signs in to the fallback SMTP provider with. Fluxer
# doesn't start when a fallback provider is set without it. Keep it secret.
#   rexctl:   rexctl config set FLUXER_EMAIL_FALLBACK_SMTP_PASSWORD
# FLUXER_EMAIL_FALLBACK_SMTP_PASSWORD=

# 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.
#   rexctl:   rexctl config set FLUXER_EMAIL_FALLBACK_SMTP_TLS_MODE
# FLUXER_EMAIL_FALLBACK_SMTP_TLS_MODE=

# 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.
#   rexctl:   rexctl config set FLUXER_EMAIL_FALLBACK_SMTP_HEADERS
# FLUXER_EMAIL_FALLBACK_SMTP_HEADERS=


# ============================================================================
#  PUSH NOTIFICATIONS
# ============================================================================

# 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.
#   rexctl:   rexctl config set FLUXER_PUSH_APNS_ENABLED
# FLUXER_PUSH_APNS_ENABLED=

# Your Apple developer team ID.
#   rexctl:   rexctl config set FLUXER_PUSH_APNS_TEAM_ID
# FLUXER_PUSH_APNS_TEAM_ID=

# The ID of your APNs signing key, from your Apple developer account.
#   rexctl:   rexctl config set FLUXER_PUSH_APNS_KEY_ID
# FLUXER_PUSH_APNS_KEY_ID=

# Your APNs signing key as PEM text. Set this or
# FLUXER_PUSH_APNS_PRIVATE_KEY_PATH, and this one wins when both are set. Keep
# it secret.
#   rexctl:   rexctl config set FLUXER_PUSH_APNS_PRIVATE_KEY
# FLUXER_PUSH_APNS_PRIVATE_KEY=

# The path to your APNs signing key file inside the push container.
#   rexctl:   rexctl config set FLUXER_PUSH_APNS_PRIVATE_KEY_PATH
# FLUXER_PUSH_APNS_PRIVATE_KEY_PATH=

# 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.
#   rexctl:   rexctl config set FLUXER_PUSH_APNS_APPS
# FLUXER_PUSH_APNS_APPS=

# 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.
#   rexctl:   rexctl config set FLUXER_PUSH_APNS_DEFAULT_ENVIRONMENT
# FLUXER_PUSH_APNS_DEFAULT_ENVIRONMENT=

# 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.
#   rexctl:   rexctl config set FLUXER_PUSH_FCM_ENABLED
# FLUXER_PUSH_FCM_ENABLED=

# Your Firebase project ID. When it's empty, the push service uses the one in
# FLUXER_PUSH_FCM_SERVICE_ACCOUNT_JSON_PATH.
#   rexctl:   rexctl config set FLUXER_PUSH_FCM_PROJECT_ID
# FLUXER_PUSH_FCM_PROJECT_ID=

# 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.
#   rexctl:   rexctl config set FLUXER_PUSH_FCM_CLIENT_EMAIL
# FLUXER_PUSH_FCM_CLIENT_EMAIL=

# 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. Keep it secret.
#   rexctl:   rexctl config set FLUXER_PUSH_FCM_PRIVATE_KEY
# FLUXER_PUSH_FCM_PRIVATE_KEY=

# 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.
#   rexctl:   rexctl config set FLUXER_PUSH_FCM_PRIVATE_KEY_PATH
# FLUXER_PUSH_FCM_PRIVATE_KEY_PATH=

# 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.
#   rexctl:   rexctl config set FLUXER_PUSH_FCM_SERVICE_ACCOUNT_JSON_PATH
# FLUXER_PUSH_FCM_SERVICE_ACCOUNT_JSON_PATH=

# 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.
#   rexctl:   rexctl config set FLUXER_PUSH_FCM_TOKEN_URI
# FLUXER_PUSH_FCM_TOKEN_URI=

# 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.
#   rexctl:   rexctl config set FLUXER_PUSH_FCM_APPS
# FLUXER_PUSH_FCM_APPS=

# 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.
#   rexctl:   rexctl config set FLUXER_VAPID_EMAIL
# FLUXER_VAPID_EMAIL=

# How many notification jobs the push service queues at once, from 1 to
# 1000000. When it's empty, it uses 10000.
#   rexctl:   rexctl config set FLUXER_PUSH_SERVICE_QUEUE_CAPACITY
# FLUXER_PUSH_SERVICE_QUEUE_CAPACITY=

# How many provider requests the push service sends at once across all jobs,
# from 1 to 65536. When it's empty, it uses 256.
#   rexctl:   rexctl config set FLUXER_PUSH_SERVICE_SEND_CONCURRENCY
# FLUXER_PUSH_SERVICE_SEND_CONCURRENCY=

# 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.
#   rexctl:   rexctl config set FLUXER_PUSH_SERVICE_APNS_BASE_URL
# FLUXER_PUSH_SERVICE_APNS_BASE_URL=

# 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.
#   rexctl:   rexctl config set FLUXER_PUSH_SERVICE_FCM_BASE_URL
# FLUXER_PUSH_SERVICE_FCM_BASE_URL=

# 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.
#   rexctl:   rexctl config set FLUXER_PUSH_SERVICE_MANAGED_RELAY_HOSTS
# FLUXER_PUSH_SERVICE_MANAGED_RELAY_HOSTS=

# 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.
#   rexctl:   rexctl config set FLUXER_PUSH_SERVICE_OWN_RELAY_HOSTS
# FLUXER_PUSH_SERVICE_OWN_RELAY_HOSTS=

# 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.
#   rexctl:   rexctl config set FLUXER_PUSH_SERVICE_PRIVATE_HOSTS
# FLUXER_PUSH_SERVICE_PRIVATE_HOSTS=

# 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.
#   rexctl:   rexctl config set FLUXER_PUSH_SERVICE_RELAY_CONSENT_ACCEPTED
# FLUXER_PUSH_SERVICE_RELAY_CONSENT_ACCEPTED=


# ============================================================================
#  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.
#   rexctl:   rexctl config set FLUXER_CLAMAV_ENABLED
# FLUXER_CLAMAV_ENABLED=

# The hostname or address of your ClamAV scanner. When it's empty, Fluxer uses
# 127.0.0.1.
#   rexctl:   rexctl config set FLUXER_CLAMAV_HOST
# FLUXER_CLAMAV_HOST=

# The port of your ClamAV scanner. When it's empty, Fluxer uses 3310.
#   rexctl:   rexctl config set FLUXER_CLAMAV_PORT
# FLUXER_CLAMAV_PORT=

# 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.
#   rexctl:   rexctl config set FLUXER_CLAMAV_FAIL_OPEN
# FLUXER_CLAMAV_FAIL_OPEN=

# 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. Keep it secret.
#   rexctl:   rexctl config set FLUXER_MEDIA_PROXY_ATTACHMENT_URL_SECRETS_BASE64
# FLUXER_MEDIA_PROXY_ATTACHMENT_URL_SECRETS_BASE64=

# The upload relay URL the API hands to clients. When it's empty, the API uses
# the public origin followed by /media.
#   rexctl:   rexctl config set FLUXER_MEDIA_PROXY_UPLOAD_RELAY_ENDPOINT
# FLUXER_MEDIA_PROXY_UPLOAD_RELAY_ENDPOINT=

# 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.
#   rexctl:   rexctl config set FLUXER_MEDIA_PROXY_UPLOAD_RELAY_MAX_BODY_BYTES
# FLUXER_MEDIA_PROXY_UPLOAD_RELAY_MAX_BODY_BYTES=

# How long an upload relay token stays valid, in seconds. When it's empty, the
# API uses 900.
#   rexctl:   rexctl config set FLUXER_MEDIA_PROXY_UPLOAD_RELAY_TOKEN_TTL_SECS
# FLUXER_MEDIA_PROXY_UPLOAD_RELAY_TOKEN_TTL_SECS=

# 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.
#   rexctl:   rexctl config set FLUXER_MEDIA_PROXY_UPLOAD_RELAY_KEEP_DIRECT_COUNTRIES
# FLUXER_MEDIA_PROXY_UPLOAD_RELAY_KEEP_DIRECT_COUNTRIES=

# 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.
#   rexctl:   rexctl config set FLUXER_MEDIA_PROXY_CORS_MODE
# FLUXER_MEDIA_PROXY_CORS_MODE=

# 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.
#   rexctl:   rexctl config set FLUXER_MEDIA_PROXY_CORS_ALLOWED_ORIGINS
# FLUXER_MEDIA_PROXY_CORS_ALLOWED_ORIGINS=

# Whether attachment downloads need a signed link. 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.
#   options:  off, report, enforce
#   rexctl:   rexctl config set media.signed_attachments
# FLUXER_MEDIA_PROXY_ATTACHMENT_SIGNATURE_MODE=

# Whether the media proxy refuses to write to storage. Use true or false. When
# it's empty, it writes as usual.
#   rexctl:   rexctl config set FLUXER_MEDIA_PROXY_READ_ONLY
# FLUXER_MEDIA_PROXY_READ_ONLY=

# 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.
#   rexctl:   rexctl config set FLUXER_MEDIA_PROXY_NSFW_THRESHOLD
# FLUXER_MEDIA_PROXY_NSFW_THRESHOLD=

# 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.
#   rexctl:   rexctl config set FLUXER_NSFW_SERVICE_ENDPOINT
# FLUXER_NSFW_SERVICE_ENDPOINT=

# 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.
#   rexctl:   rexctl config set FLUXER_MEDIA_PROXY_MAX_NATIVE_TRANSFORMS
# FLUXER_MEDIA_PROXY_MAX_NATIVE_TRANSFORMS=

# 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.
#   rexctl:   rexctl config set FLUXER_MEDIA_PROXY_WORKER_QUEUE_CAPACITY
# FLUXER_MEDIA_PROXY_WORKER_QUEUE_CAPACITY=

# The longest animation the media proxy encodes, in milliseconds from 100 to
# 600000. When it's empty, it uses 30000.
#   rexctl:   rexctl config set FLUXER_MEDIA_PROXY_MAX_ENCODE_DURATION_MS
# FLUXER_MEDIA_PROXY_MAX_ENCODE_DURATION_MS=

# The most frames the media proxy encodes in one animation, from 1 to 100000.
# When it's empty, it uses 20000.
#   rexctl:   rexctl config set FLUXER_MEDIA_PROXY_MAX_ENCODE_FRAMES
# FLUXER_MEDIA_PROXY_MAX_ENCODE_FRAMES=

# How long one media transform may take, in milliseconds from 1000 to 120000.
# When it's empty, the media proxy uses 15000.
#   rexctl:   rexctl config set FLUXER_MEDIA_PROXY_TRANSFORM_TIMEOUT_MS
# FLUXER_MEDIA_PROXY_TRANSFORM_TIMEOUT_MS=

# 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. rexctl sizes
# this.
#   rexctl:   rexctl config set FLUXER_MEDIA_PROXY_TRANSFORM_CACHE_BYTES
# FLUXER_MEDIA_PROXY_TRANSFORM_CACHE_BYTES=

# 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.
#   rexctl:   rexctl config set FLUXER_MEDIA_PROXY_TRANSFORM_CACHE_MAX_ENTRY_BYTES
# FLUXER_MEDIA_PROXY_TRANSFORM_CACHE_MAX_ENTRY_BYTES=

# 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.
#   rexctl:   rexctl config set FLUXER_MEDIA_PROXY_TRANSFORM_CACHE_TTL_MS
# FLUXER_MEDIA_PROXY_TRANSFORM_CACHE_TTL_MS=

# How long the media proxy waits on socket input and output, in milliseconds
# from 0 to 300000. When it's empty, it uses 30000.
#   rexctl:   rexctl config set FLUXER_MEDIA_PROXY_SOCKET_IO_TIMEOUT_MS
# FLUXER_MEDIA_PROXY_SOCKET_IO_TIMEOUT_MS=

# 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.
#   rexctl:   rexctl config set FLUXER_MEDIA_PROXY_SHUTDOWN_GRACE_MS
# FLUXER_MEDIA_PROXY_SHUTDOWN_GRACE_MS=

# 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.
#   rexctl:   rexctl config set FLUXER_MEDIA_PROXY_UPLOAD_RELAY_S3_TIMEOUT_MS
# FLUXER_MEDIA_PROXY_UPLOAD_RELAY_S3_TIMEOUT_MS=

# 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.
#   rexctl:   rexctl config set FLUXER_MEDIA_PROXY_UPLOAD_RELAY_BUFFERED_RETRY_BYTES
# FLUXER_MEDIA_PROXY_UPLOAD_RELAY_BUFFERED_RETRY_BYTES=

# 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. rexctl sizes this.
#   rexctl:   rexctl config set FLUXER_MEDIA_PROXY_UPLOAD_RELAY_BUFFERED_RETRY_TOTAL_BYTES
# FLUXER_MEDIA_PROXY_UPLOAD_RELAY_BUFFERED_RETRY_TOTAL_BYTES=

# 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.
#   rexctl:   rexctl config set FLUXER_MEDIA_PROXY_UPLOAD_RELAY_SPOOL_DIR
# FLUXER_MEDIA_PROXY_UPLOAD_RELAY_SPOOL_DIR=

# 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.
#   rexctl:   rexctl config set FLUXER_MEDIA_PROXY_UPLOAD_RELAY_SPOOL_CHUNK_BYTES
# FLUXER_MEDIA_PROXY_UPLOAD_RELAY_SPOOL_CHUNK_BYTES=

# 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. rexctl raises
# this to FLUXER_MEDIA_PROXY_UPLOAD_RELAY_MAX_BODY_BYTES if you set that
# higher. When disk.profile is small, rexctl sets this to 536870912, which is
# 512 MiB, unless you set it.
#   default:  2147483648
#   rexctl:   rexctl config set FLUXER_MEDIA_PROXY_UPLOAD_RELAY_SPOOL_MAX_TOTAL_BYTES
# FLUXER_MEDIA_PROXY_UPLOAD_RELAY_SPOOL_MAX_TOTAL_BYTES=

# 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.
#   rexctl:   rexctl config set FLUXER_CACHE_PURGE_ADAPTER
# FLUXER_CACHE_PURGE_ADAPTER=

# 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.
#   rexctl:   rexctl config set FLUXER_CACHE_PURGE_HTTP_ENDPOINT
# FLUXER_CACHE_PURGE_HTTP_ENDPOINT=

# 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. Keep it secret.
#   rexctl:   rexctl config set FLUXER_CACHE_PURGE_HTTP_TOKEN
# FLUXER_CACHE_PURGE_HTTP_TOKEN=

# 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.
#   rexctl:   rexctl config set FLUXER_CACHE_PURGE_HTTP_TIMEOUT_MS
# FLUXER_CACHE_PURGE_HTTP_TIMEOUT_MS=

# 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.
#   rexctl:   rexctl config set FLUXER_CACHE_PURGE_CONTROLLER_ENDPOINT
# FLUXER_CACHE_PURGE_CONTROLLER_ENDPOINT=

# The Controller API key Fluxer sends as a bearer token with each purge
# request, in visible ASCII characters with no spaces. Keep it secret.
#   rexctl:   rexctl config set FLUXER_CACHE_PURGE_CONTROLLER_TOKEN
# FLUXER_CACHE_PURGE_CONTROLLER_TOKEN=

# How long each Controller purge request may take, in milliseconds from 1000
# to 10000. When it's empty, Fluxer uses 10000.
#   rexctl:   rexctl config set FLUXER_CACHE_PURGE_CONTROLLER_TIMEOUT_MS
# FLUXER_CACHE_PURGE_CONTROLLER_TIMEOUT_MS=


# ============================================================================
#  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.
#   rexctl:   rexctl config set FLUXER_GATEWAY_MEDIA_PROXY_ENDPOINT
# FLUXER_GATEWAY_MEDIA_PROXY_ENDPOINT=

# 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.
#   rexctl:   rexctl config set FLUXER_GATEWAY_STATIC_CDN_ENDPOINT
# FLUXER_GATEWAY_STATIC_CDN_ENDPOINT=

# Whether the gateway sends push notifications through the push service. Use
# true or false. When it's empty, the gateway uses true.
#   rexctl:   rexctl config set FLUXER_GATEWAY_PUSH_ENABLED
# FLUXER_GATEWAY_PUSH_ENABLED=

# 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.
#   rexctl:   rexctl config set FLUXER_GATEWAY_PUSH_ENROLLED_CLEAR_NOTIFICATIONS_ENABLED
# FLUXER_GATEWAY_PUSH_ENROLLED_CLEAR_NOTIFICATIONS_ENABLED=

# 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.
#   rexctl:   rexctl config set FLUXER_GATEWAY_PUSH_OUTBOX_REQUEST_TIMEOUT_MS
# FLUXER_GATEWAY_PUSH_OUTBOX_REQUEST_TIMEOUT_MS=

# 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.
#   rexctl:   rexctl config set FLUXER_GATEWAY_PRESENCE_PUSH_BUFFER_MAX_ENTRIES
# FLUXER_GATEWAY_PRESENCE_PUSH_BUFFER_MAX_ENTRIES=

# 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.
#   rexctl:   rexctl config set FLUXER_GATEWAY_PRESENCE_PUSH_BUFFER_MAX_BYTES
# FLUXER_GATEWAY_PRESENCE_PUSH_BUFFER_MAX_BYTES=

# How many HTTP requests the gateway can have open to the API at once. When
# it's empty, the gateway uses 512.
#   rexctl:   rexctl config set FLUXER_GATEWAY_HTTP_RPC_MAX_CONCURRENCY
# FLUXER_GATEWAY_HTTP_RPC_MAX_CONCURRENCY=

# How many NATS RPC requests the gateway works on at once. When it's empty,
# the gateway uses 512.
#   rexctl:   rexctl config set FLUXER_GATEWAY_NATS_RPC_MAX_HANDLERS
# FLUXER_GATEWAY_NATS_RPC_MAX_HANDLERS=

# 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.
#   rexctl:   rexctl config set FLUXER_GATEWAY_ZSTD_WINDOW_LOG
# FLUXER_GATEWAY_ZSTD_WINDOW_LOG=

# 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.
#   rexctl:   rexctl config set FLUXER_GATEWAY_IDENTIFY_TOKEN_LIMIT_PER_MINUTE
# FLUXER_GATEWAY_IDENTIFY_TOKEN_LIMIT_PER_MINUTE=

# 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.
#   rexctl:   rexctl config set FLUXER_GATEWAY_HTTP_FAILURE_THRESHOLD
# FLUXER_GATEWAY_HTTP_FAILURE_THRESHOLD=

# 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.
#   rexctl:   rexctl config set FLUXER_GATEWAY_HTTP_RECOVERY_TIMEOUT_MS
# FLUXER_GATEWAY_HTTP_RECOVERY_TIMEOUT_MS=

# 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.
#   rexctl:   rexctl config set FLUXER_GATEWAY_GUILD_VISITOR_SESSIONS_MAX
# FLUXER_GATEWAY_GUILD_VISITOR_SESSIONS_MAX=

# The fewest visitor sessions one community allows, however few members it
# has. When it's empty, the gateway uses 500.
#   rexctl:   rexctl config set FLUXER_GATEWAY_GUILD_VISITOR_SESSIONS_FLOOR
# FLUXER_GATEWAY_GUILD_VISITOR_SESSIONS_FLOOR=

# 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.
#   rexctl:   rexctl config set FLUXER_GATEWAY_GUILD_VISITOR_SESSIONS_PER_MEMBER
# FLUXER_GATEWAY_GUILD_VISITOR_SESSIONS_PER_MEMBER=

# How many visitor sessions one account can have in a single community at
# once. When it's empty, the gateway uses 5.
#   rexctl:   rexctl config set FLUXER_GATEWAY_GUILD_VISITOR_SESSIONS_PER_USER
# FLUXER_GATEWAY_GUILD_VISITOR_SESSIONS_PER_USER=

# 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.
#   rexctl:   rexctl config set FLUXER_GATEWAY_GUILD_VISITOR_SESSIONS_PER_IP
# FLUXER_GATEWAY_GUILD_VISITOR_SESSIONS_PER_IP=


# ============================================================================
#  WEB 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.
#   default:  5000
#   rexctl:   rexctl config set DISCOVERY_REFRESH_INTERVAL_MS
# DISCOVERY_REFRESH_INTERVAL_MS=

# 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.
#   rexctl:   rexctl config set FLUXER_APP_PROXY_INDEX_UPSTREAM_URL
# FLUXER_APP_PROXY_INDEX_UPSTREAM_URL=

# 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.
#   rexctl:   rexctl config set FLUXER_APP_PROXY_SAME_ORIGIN_HOSTS
# FLUXER_APP_PROXY_SAME_ORIGIN_HOSTS=

# 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.
#   rexctl:   rexctl config set FLUXER_APP_PROXY_MANIFEST_SCOPE_EXTENSIONS
# FLUXER_APP_PROXY_MANIFEST_SCOPE_EXTENSIONS=

# 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.
#   rexctl:   rexctl config set FLUXER_CSP_EXTRA_DEFAULT_SRC
# FLUXER_CSP_EXTRA_DEFAULT_SRC=

# 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.
#   rexctl:   rexctl config set FLUXER_CSP_EXTRA_CONNECT_SRC
# FLUXER_CSP_EXTRA_CONNECT_SRC=

# 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.
#   rexctl:   rexctl config set FLUXER_CSP_EXTRA_IMG_SRC
# FLUXER_CSP_EXTRA_IMG_SRC=

# 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.
#   rexctl:   rexctl config set FLUXER_CSP_EXTRA_MEDIA_SRC
# FLUXER_CSP_EXTRA_MEDIA_SRC=

# 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.
#   rexctl:   rexctl config set FLUXER_CSP_EXTRA_FONT_SRC
# FLUXER_CSP_EXTRA_FONT_SRC=

# 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.
#   rexctl:   rexctl config set FLUXER_CSP_EXTRA_SCRIPT_SRC
# FLUXER_CSP_EXTRA_SCRIPT_SRC=

# 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.
#   rexctl:   rexctl config set FLUXER_CSP_EXTRA_STYLE_SRC
# FLUXER_CSP_EXTRA_STYLE_SRC=

# 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.
#   rexctl:   rexctl config set FLUXER_CSP_EXTRA_FRAME_SRC
# FLUXER_CSP_EXTRA_FRAME_SRC=

# 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.
#   rexctl:   rexctl config set FLUXER_CSP_EXTRA_WORKER_SRC
# FLUXER_CSP_EXTRA_WORKER_SRC=

# 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.
#   rexctl:   rexctl config set FLUXER_CSP_EXTRA_MANIFEST_SRC
# FLUXER_CSP_EXTRA_MANIFEST_SRC=

# One http or https URL that browsers send Content-Security-Policy violation
# reports to. When it's empty, the policy has no report-uri.
#   rexctl:   rexctl config set FLUXER_CSP_REPORT_URI
# FLUXER_CSP_REPORT_URI=


# ============================================================================
#  API AND WORKER
# ============================================================================

# 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.
#   rexctl:   rexctl config set FLUXER_API_HEADERS_TIMEOUT_MS
# FLUXER_API_HEADERS_TIMEOUT_MS=

# 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.
#   rexctl:   rexctl config set FLUXER_API_REQUEST_TIMEOUT_MS
# FLUXER_API_REQUEST_TIMEOUT_MS=

# 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.
#   rexctl:   rexctl config set FLUXER_API_MAX_INFLIGHT_REQUESTS
# FLUXER_API_MAX_INFLIGHT_REQUESTS=

# 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.
#   rexctl:   rexctl config set FLUXER_API_MAX_CONCURRENT_FORM_UPLOADS
# FLUXER_API_MAX_CONCURRENT_FORM_UPLOADS=

# 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.
#   default:  true
#   rexctl:   rexctl config set FLUXER_TRUST_CLIENT_IP_HEADER
# FLUXER_TRUST_CLIENT_IP_HEADER=

# 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.
#   rexctl:   rexctl config set FLUXER_CLIENT_IP_HEADER_NAME
# FLUXER_CLIENT_IP_HEADER_NAME=

# 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.
#   rexctl:   rexctl config set FLUXER_API_IP_BAN_EXEMPT_IPS
# FLUXER_API_IP_BAN_EXEMPT_IPS=

# 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.
#   rexctl:   rexctl config set FLUXER_IP_BAN_REFRESH_INTERVAL_MS
# FLUXER_IP_BAN_REFRESH_INTERVAL_MS=

# 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. Keep
# it secret.
#   rexctl:   rexctl config set FLUXER_API_DONATION_PROXY_KEY
# FLUXER_API_DONATION_PROXY_KEY=

# 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. Keep it secret.
#   rexctl:   rexctl config set FLUXER_API_TRUSTED_CALLERS
# FLUXER_API_TRUSTED_CALLERS=

# 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.
#   rexctl:   rexctl config set FLUXER_API_WORKER_LANE_CONCURRENCY_OVERRIDES
# FLUXER_API_WORKER_LANE_CONCURRENCY_OVERRIDES=


# ============================================================================
#  INSTANCE AND BRANDING
#
#  Fluxer uses the product name, images, theme colour and status page links
#  set here only until the setup wizard finishes or someone saves branding in
#  the admin panel. After that it uses the saved values and ignores these.
#  Make later changes in the admin panel or with rexctl config set.
# ============================================================================

# 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.
#   rexctl:   rexctl config set app_public.branding.product_name
# FLUXER_APP_PRODUCT_NAME=

# The URL of the app icon.
#   rexctl:   rexctl config set app_public.branding.icon_url
# FLUXER_APP_ICON_URL=

# The URL of the symbol mark.
#   rexctl:   rexctl config set app_public.branding.symbol_url
# FLUXER_APP_SYMBOL_URL=

# The URL of the logo.
#   rexctl:   rexctl config set app_public.branding.logo_url
# FLUXER_APP_LOGO_URL=

# The URL of the wordmark.
#   rexctl:   rexctl config set app_public.branding.wordmark_url
# FLUXER_APP_WORDMARK_URL=

# The URL of the favicon.
#   rexctl:   rexctl config set app_public.branding.favicon_url
# FLUXER_APP_FAVICON_URL=

# The URL of the favicon for browsers in dark mode.
#   rexctl:   rexctl config set app_public.branding.favicon_dark_url
# FLUXER_APP_FAVICON_DARK_URL=

# The URL of the image behind the sign-in screen.
#   rexctl:   rexctl config set app_public.branding.sign_in_backdrop_url
# FLUXER_APP_SIGN_IN_BACKDROP_URL=

# The brand colour of the web app and the browser theme colour, as a hex value
# such as #4641d9.
#   rexctl:   rexctl config set app_public.branding.theme_color
# FLUXER_APP_THEME_COLOR=

# 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.
#   rexctl:   rexctl config set app_public.branding.status_page_url
# FLUXER_APP_STATUS_PAGE_URL=

# The URL of the incident history on your status page. The apps don't use it
# yet.
#   rexctl:   rexctl config set app_public.branding.status_page_incident_history_url
# FLUXER_APP_STATUS_PAGE_INCIDENT_HISTORY_URL=

# 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.
#   rexctl:   rexctl config set FLUXER_INSTANCE_SETUP_CONFIGURED
# FLUXER_INSTANCE_SETUP_CONFIGURED=

# 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.
#   rexctl:   rexctl config set FLUXER_APP_ATTEST_APP_IDS
# FLUXER_APP_ATTEST_APP_IDS=

# 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.
#   rexctl:   rexctl config set FLUXER_APP_ATTEST_ALLOW_DEVELOPMENT
# FLUXER_APP_ATTEST_ALLOW_DEVELOPMENT=

# 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.
#   rexctl:   rexctl config set FLUXER_PLAY_INTEGRITY_PACKAGE_NAMES
# FLUXER_PLAY_INTEGRITY_PACKAGE_NAMES=

# 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.
#   rexctl:   rexctl config set FLUXER_PLAY_INTEGRITY_CERT_SHA256
# FLUXER_PLAY_INTEGRITY_CERT_SHA256=

# 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.
#   rexctl:   rexctl config set FLUXER_PLAY_INTEGRITY_SERVICE_ACCOUNT_JSON_PATH
# FLUXER_PLAY_INTEGRITY_SERVICE_ACCOUNT_JSON_PATH=

# 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.
#   rexctl:   rexctl config set FLUXER_PLAY_INTEGRITY_DEVICE_INTEGRITY
# FLUXER_PLAY_INTEGRITY_DEVICE_INTEGRITY=

# 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.
#   rexctl:   rexctl config set FLUXER_ACCOUNT_IDENTITY
# FLUXER_ACCOUNT_IDENTITY=

# 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.
#   rexctl:   rexctl config set FLUXER_TAG_STYLE
# FLUXER_TAG_STYLE=

# 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.
#   rexctl:   rexctl config set FLUXER_AUTO_JOIN_INVITE_CODE
# FLUXER_AUTO_JOIN_INVITE_CODE=

# 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.
#   rexctl:   rexctl config set FLUXER_DISCOVERY_ENABLED
# FLUXER_DISCOVERY_ENABLED=

# How many members a community needs before it can be listed in discovery.
# When it's empty, Fluxer uses 1.
#   rexctl:   rexctl config set FLUXER_DISCOVERY_MIN_MEMBER_COUNT
# FLUXER_DISCOVERY_MIN_MEMBER_COUNT=

# 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.
#   rexctl:   rexctl config set FLUXER_DELETION_GRACE_PERIOD_HOURS
# FLUXER_DELETION_GRACE_PERIOD_HOURS=

# 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.
#   rexctl:   rexctl config set FLUXER_REPORT_RETENTION_DAYS
# FLUXER_REPORT_RETENTION_DAYS=

# 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.
#   rexctl:   rexctl config set FLUXER_REPORT_RETENTION_DRY_RUN
# FLUXER_REPORT_RETENTION_DRY_RUN=

# 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.
#   rexctl:   rexctl config set FLUXER_AGE_POLICY_ENABLED
# FLUXER_AGE_POLICY_ENABLED=

# 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.
#   rexctl:   rexctl config set FLUXER_AGE_POLICY_RESTRICTED_REGIONS
# FLUXER_AGE_POLICY_RESTRICTED_REGIONS=


# ============================================================================
#  BILLING
#
#  The admin panel can also save whether billing is on, the Stripe keys and
#  the prices. A value saved there is used first, and a saved price list
#  replaces all of FLUXER_STRIPE_PRICES.
# ============================================================================

# Whether Fluxer sells subscriptions through Stripe. Use true or false. When
# it's empty, Fluxer uses false.
#   rexctl:   rexctl config set billing.enabled
# FLUXER_STRIPE_ENABLED=

# Your Stripe secret API key. Keep it secret.
#   rexctl:   rexctl config set billing.stripe_secret_key
# FLUXER_STRIPE_SECRET_KEY=

# The signing secret of your Stripe webhook. Keep it secret.
#   rexctl:   rexctl config set billing.stripe_webhook_secret
# FLUXER_STRIPE_WEBHOOK_SECRET=

# Your Stripe price IDs as one JSON object, keyed by plan and currency such as
# monthly_usd.
#   rexctl:   rexctl config set billing.prices
# FLUXER_STRIPE_PRICES=

# 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.
#   rexctl:   rexctl config set billing.legacy_prices
# FLUXER_STRIPE_LEGACY_PRICES=

# 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.
#   rexctl:   rexctl config set FLUXER_VISIONARIES_GUILD_ID
# FLUXER_VISIONARIES_GUILD_ID=

# 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.
#   rexctl:   rexctl config set FLUXER_VISIONARIES_GUILD_VISIONARY_ROLE_ID
# FLUXER_VISIONARIES_GUILD_VISIONARY_ROLE_ID=


# ============================================================================
#  INTEGRATIONS
#
#  The admin panel can also save the Bluesky settings and keys. A value saved
#  there is used first.
# ============================================================================

# 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.
#   rexctl:   rexctl config set FLUXER_BREACHED_PASSWORD_CHECK_ENABLED
# FLUXER_BREACHED_PASSWORD_CHECK_ENABLED=

# 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.
#   rexctl:   rexctl config set FLUXER_BLOCKLIST_FEEDS_ENABLED
# FLUXER_BLOCKLIST_FEEDS_ENABLED=

# 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.
#   rexctl:   rexctl config set FLUXER_GEOIP_DB_PATH
# FLUXER_GEOIP_DB_PATH=

# 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. Keep it
# secret.
#   rexctl:   rexctl config set integrations.gif.klipy_api_key
# FLUXER_KLIPY_API_KEY=

# 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. Keep it secret.
#   rexctl:   rexctl config set integrations.youtube.api_key
# FLUXER_YOUTUBE_API_KEY=

# Hostnames, separated by commas, that Fluxer never makes link previews for. A
# link matches only when its host is exactly one of these.
#   rexctl:   rexctl config set FLUXER_API_UNFURL_IGNORED_HOSTS
# FLUXER_API_UNFURL_IGNORED_HOSTS=

# 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.
#   rexctl:   rexctl config set integrations.bluesky.enabled
# FLUXER_AUTH_BLUESKY_ENABLED=

# 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.
#   rexctl:   rexctl config set integrations.bluesky.client_name
# FLUXER_AUTH_BLUESKY_CLIENT_NAME=

# Fluxer doesn't use this value. Bluesky shows the API address as the home
# page of your instance.
# FLUXER_AUTH_BLUESKY_CLIENT_URI=

# The logo URL Bluesky shows for your instance.
#   rexctl:   rexctl config set integrations.bluesky.logo_uri
# FLUXER_AUTH_BLUESKY_LOGO_URI=

# The terms of service URL Bluesky shows for your instance.
#   rexctl:   rexctl config set integrations.bluesky.tos_uri
# FLUXER_AUTH_BLUESKY_TOS_URI=

# The privacy policy URL Bluesky shows for your instance.
#   rexctl:   rexctl config set integrations.bluesky.policy_uri
# FLUXER_AUTH_BLUESKY_POLICY_URI=

# 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. Keep it secret.
#   rexctl:   rexctl config set integrations.bluesky.keys
# FLUXER_AUTH_BLUESKY_KEYS=


# ============================================================================
#  MEMORY AND PERFORMANCE
#
#  rexctl sets some of these from the machine's memory and CPU on every start.
#  A value you set wins.
# ============================================================================

# 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. rexctl sizes this.
#   default:  2
#   rexctl:   rexctl config set FLUXER_TOKIO_WORKER_THREADS
# FLUXER_TOKIO_WORKER_THREADS=

# 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. rexctl sizes this.
#   default:  2
#   rexctl:   rexctl config set FLUXER_MALLOC_ARENA_MAX
# FLUXER_MALLOC_ARENA_MAX=

# The memory limit for the edge container, which runs Caddy. rexctl sizes
# this.
#   default:  384mb
#   rexctl:   rexctl config set FLUXER_CADDY_MEMORY_LIMIT
# FLUXER_CADDY_MEMORY_LIMIT=

# The memory limit for the postgres container. Keep it at or above
# FLUXER_POSTGRES_MEMORY_RESERVATION. rexctl sizes this.
#   default:  5gb
#   rexctl:   rexctl config set FLUXER_POSTGRES_MEMORY_LIMIT
# FLUXER_POSTGRES_MEMORY_LIMIT=

# 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. rexctl sizes this.
#   default:  3gb
#   rexctl:   rexctl config set FLUXER_POSTGRES_MEMORY_RESERVATION
# FLUXER_POSTGRES_MEMORY_RESERVATION=

# Postgres max_connections, how many connections the database accepts in
# total. Keep it above the sum of all pool sizes, counting each worker
# replica. rexctl sizes this.
#   default:  150
#   rexctl:   rexctl config set FLUXER_POSTGRES_SERVER_MAX_CONNECTIONS
# FLUXER_POSTGRES_SERVER_MAX_CONNECTIONS=

# Postgres shared_buffers, the memory Postgres uses for its own cache. rexctl
# sizes this.
#   default:  512MB
#   rexctl:   rexctl config set FLUXER_POSTGRES_SHARED_BUFFERS
# FLUXER_POSTGRES_SHARED_BUFFERS=

# Postgres effective_cache_size, how much disk cache the query planner assumes
# there is. It allocates no memory. rexctl sizes this.
#   default:  2GB
#   rexctl:   rexctl config set FLUXER_POSTGRES_EFFECTIVE_CACHE_SIZE
# FLUXER_POSTGRES_EFFECTIVE_CACHE_SIZE=

# Postgres work_mem, the memory each sort or hash step in a query can use
# before it spills to disk. rexctl sizes this.
#   default:  8MB
#   rexctl:   rexctl config set FLUXER_POSTGRES_WORK_MEM
# FLUXER_POSTGRES_WORK_MEM=

# Postgres maintenance_work_mem, the memory one VACUUM, CREATE INDEX or ALTER
# TABLE can use. rexctl sizes this.
#   default:  256MB
#   rexctl:   rexctl config set FLUXER_POSTGRES_MAINTENANCE_WORK_MEM
# FLUXER_POSTGRES_MAINTENANCE_WORK_MEM=

# Postgres autovacuum_work_mem, the memory each autovacuum worker can use.
# rexctl sizes this.
#   default:  128MB
#   rexctl:   rexctl config set FLUXER_POSTGRES_AUTOVACUUM_WORK_MEM
# FLUXER_POSTGRES_AUTOVACUUM_WORK_MEM=

# 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.
#   default:  1.1
#   rexctl:   rexctl config set FLUXER_POSTGRES_RANDOM_PAGE_COST
# FLUXER_POSTGRES_RANDOM_PAGE_COST=

# Postgres effective_io_concurrency, how many disk requests Postgres may have
# in flight at once. High values suit SSDs.
#   default:  200
#   rexctl:   rexctl config set FLUXER_POSTGRES_EFFECTIVE_IO_CONCURRENCY
# FLUXER_POSTGRES_EFFECTIVE_IO_CONCURRENCY=

# Postgres default_statistics_target, how much detail the query planner's
# table statistics have. Higher values give better plans and a slower ANALYZE.
#   default:  200
#   rexctl:   rexctl config set FLUXER_POSTGRES_DEFAULT_STATISTICS_TARGET
# FLUXER_POSTGRES_DEFAULT_STATISTICS_TARGET=

# Postgres jit, whether Postgres compiles parts of queries with JIT. Use on or
# off.
#   default:  off
#   rexctl:   rexctl config set FLUXER_POSTGRES_JIT
# FLUXER_POSTGRES_JIT=

# Postgres min_wal_size, the write-ahead log space Postgres keeps for reuse
# after a checkpoint.
#   default:  80MB
#   rexctl:   rexctl config set FLUXER_POSTGRES_MIN_WAL_SIZE
# FLUXER_POSTGRES_MIN_WAL_SIZE=

# Postgres max_wal_size, how large the write-ahead log may grow before
# Postgres starts a checkpoint. When disk.profile is small, rexctl sets this
# to 512MB unless you set it.
#   default:  2GB
#   rexctl:   rexctl config set FLUXER_POSTGRES_MAX_WAL_SIZE
# FLUXER_POSTGRES_MAX_WAL_SIZE=

# Postgres checkpoint_completion_target, how much of the time between
# checkpoints a checkpoint spreads its writes over, as a fraction.
#   default:  0.9
#   rexctl:   rexctl config set FLUXER_POSTGRES_CHECKPOINT_COMPLETION_TARGET
# FLUXER_POSTGRES_CHECKPOINT_COMPLETION_TARGET=

# Postgres wal_buffers, the memory for write-ahead log data not yet written to
# disk.
#   default:  16MB
#   rexctl:   rexctl config set FLUXER_POSTGRES_WAL_BUFFERS
# FLUXER_POSTGRES_WAL_BUFFERS=

# Postgres wal_compression, how full-page images in the write-ahead log are
# compressed, such as lz4, pglz or off.
#   default:  zstd
#   rexctl:   rexctl config set FLUXER_POSTGRES_WAL_COMPRESSION
# FLUXER_POSTGRES_WAL_COMPRESSION=

# Postgres bgwriter_delay, how long the background writer sleeps between
# rounds, such as 200ms. rexctl sizes this.
#   default:  50ms
#   rexctl:   rexctl config set FLUXER_POSTGRES_BGWRITER_DELAY
# FLUXER_POSTGRES_BGWRITER_DELAY=

# Postgres bgwriter_lru_maxpages, the most buffers the background writer
# writes to disk in one round. rexctl sizes this.
#   default:  1000
#   rexctl:   rexctl config set FLUXER_POSTGRES_BGWRITER_LRU_MAXPAGES
# FLUXER_POSTGRES_BGWRITER_LRU_MAXPAGES=

# 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.
#   default:  0.05
#   rexctl:   rexctl config set FLUXER_POSTGRES_AUTOVACUUM_VACUUM_SCALE_FACTOR
# FLUXER_POSTGRES_AUTOVACUUM_VACUUM_SCALE_FACTOR=

# 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.
#   default:  0.02
#   rexctl:   rexctl config set FLUXER_POSTGRES_AUTOVACUUM_ANALYZE_SCALE_FACTOR
# FLUXER_POSTGRES_AUTOVACUUM_ANALYZE_SCALE_FACTOR=

# Postgres autovacuum_vacuum_cost_limit, how much disk work autovacuum may do
# before it pauses. Higher values let it finish sooner.
#   default:  2000
#   rexctl:   rexctl config set FLUXER_POSTGRES_AUTOVACUUM_VACUUM_COST_LIMIT
# FLUXER_POSTGRES_AUTOVACUUM_VACUUM_COST_LIMIT=

# Postgres autovacuum_max_workers, how many autovacuum processes can run at
# once. rexctl sizes this.
#   default:  3
#   rexctl:   rexctl config set FLUXER_POSTGRES_AUTOVACUUM_MAX_WORKERS
# FLUXER_POSTGRES_AUTOVACUUM_MAX_WORKERS=

# Postgres max_parallel_workers_per_gather, how many parallel workers one step
# of a query can use. rexctl sizes this.
#   default:  2
#   rexctl:   rexctl config set FLUXER_POSTGRES_MAX_PARALLEL_WORKERS_PER_GATHER
# FLUXER_POSTGRES_MAX_PARALLEL_WORKERS_PER_GATHER=

# 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. rexctl sizes this.
#   default:  8
#   rexctl:   rexctl config set FLUXER_POSTGRES_MAX_PARALLEL_WORKERS
# FLUXER_POSTGRES_MAX_PARALLEL_WORKERS=

# Postgres track_io_timing, whether Postgres times its disk I/O for its
# statistics. Use on or off.
#   default:  on
#   rexctl:   rexctl config set FLUXER_POSTGRES_TRACK_IO_TIMING
# FLUXER_POSTGRES_TRACK_IO_TIMING=

# 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.
#   default:  pg_stat_statements
#   rexctl:   rexctl config set FLUXER_POSTGRES_SHARED_PRELOAD_LIBRARIES
# FLUXER_POSTGRES_SHARED_PRELOAD_LIBRARIES=

# The shared memory size of the postgres container, used by parallel queries
# and parallel maintenance. Keep it well above
# FLUXER_POSTGRES_MAINTENANCE_WORK_MEM. rexctl sizes this.
#   default:  1gb
#   rexctl:   rexctl config set FLUXER_POSTGRES_SHM_SIZE
# FLUXER_POSTGRES_SHM_SIZE=

# The memory limit for the valkey container. Keep it above
# FLUXER_VALKEY_MAXMEMORY. rexctl sizes this.
#   default:  256mb
#   rexctl:   rexctl config set FLUXER_VALKEY_MEMORY_LIMIT
# FLUXER_VALKEY_MEMORY_LIMIT=

# 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. rexctl sizes this.
#   default:  192mb
#   rexctl:   rexctl config set FLUXER_VALKEY_MAXMEMORY
# FLUXER_VALKEY_MAXMEMORY=

# 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.
#   default:  noeviction
#   rexctl:   rexctl config set FLUXER_VALKEY_MAXMEMORY_POLICY
# FLUXER_VALKEY_MAXMEMORY_POLICY=

# The memory limit for the nats container. rexctl sizes this.
#   default:  256mb
#   rexctl:   rexctl config set FLUXER_NATS_MEMORY_LIMIT
# FLUXER_NATS_MEMORY_LIMIT=

# The soft memory limit of the Go runtime in NATS, set as its GOMEMLIMIT. Keep
# it below FLUXER_NATS_MEMORY_LIMIT. rexctl sizes this.
#   default:  200MiB
#   rexctl:   rexctl config set FLUXER_NATS_GOMEMLIMIT
# FLUXER_NATS_GOMEMLIMIT=

# NATS JetStream max_memory_store, the most memory JetStream may use for
# streams kept in memory, such as 128MB.
#   default:  64MB
#   rexctl:   rexctl config set FLUXER_NATS_MAX_MEMORY_STORE
# FLUXER_NATS_MAX_MEMORY_STORE=

# NATS JetStream max_file_store, the most disk space JetStream may use for its
# streams, such as 20GB.
#   default:  10GB
#   rexctl:   rexctl config set FLUXER_NATS_MAX_FILE_STORE
# FLUXER_NATS_MAX_FILE_STORE=

# The memory limit for the meilisearch container. rexctl sizes this.
#   default:  1536mb
#   rexctl:   rexctl config set FLUXER_MEILISEARCH_MEMORY_LIMIT
# FLUXER_MEILISEARCH_MEMORY_LIMIT=

# 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. rexctl sizes this.
#   default:  256mb
#   rexctl:   rexctl config set FLUXER_MEILISEARCH_MAX_INDEXING_MEMORY
# FLUXER_MEILISEARCH_MAX_INDEXING_MEMORY=

# The most threads Meilisearch may use for indexing, set as its
# MEILI_MAX_INDEXING_THREADS. rexctl sizes this.
#   default:  2
#   rexctl:   rexctl config set FLUXER_MEILISEARCH_MAX_INDEXING_THREADS
# FLUXER_MEILISEARCH_MAX_INDEXING_THREADS=

# The memory limit for the seaweedfs container. rexctl sizes this.
#   default:  2gb
#   rexctl:   rexctl config set FLUXER_SEAWEEDFS_MEMORY_LIMIT
# FLUXER_SEAWEEDFS_MEMORY_LIMIT=

# 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. rexctl sizes this.
#   default:  1536MiB
#   rexctl:   rexctl config set FLUXER_SEAWEEDFS_GOMEMLIMIT
# FLUXER_SEAWEEDFS_GOMEMLIMIT=

# How many volumes SeaweedFS creates at once when a bucket has no writable
# volume left, set as its WEED_MASTER_VOLUME_GROWTH_COPY_1.
#   default:  1
#   rexctl:   rexctl config set FLUXER_SEAWEEDFS_VOLUME_GROWTH
# FLUXER_SEAWEEDFS_VOLUME_GROWTH=

# The size in MB a volume can grow to before SeaweedFS stops writing to it,
# set as its -master.volumeSizeLimitMB.
#   default:  1024
#   rexctl:   rexctl config set FLUXER_SEAWEEDFS_VOLUME_SIZE_LIMIT_MB
# FLUXER_SEAWEEDFS_VOLUME_SIZE_LIMIT_MB=

# The share of deleted space in a volume that makes SeaweedFS compact it, as a
# fraction, set as its -master.garbageThreshold.
#   default:  0.1
#   rexctl:   rexctl config set FLUXER_SEAWEEDFS_GARBAGE_THRESHOLD
# FLUXER_SEAWEEDFS_GARBAGE_THRESHOLD=

# 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. rexctl sizes this.
#   default:  5
#   rexctl:   rexctl config set FLUXER_SEAWEEDFS_S3_CONCURRENT_UPLOADS
# FLUXER_SEAWEEDFS_S3_CONCURRENT_UPLOADS=

# The most volumes the SeaweedFS volume store may have, set as its
# -volume.max.
#   default:  10000
#   rexctl:   rexctl config set FLUXER_SEAWEEDFS_VOLUME_MAX
# FLUXER_SEAWEEDFS_VOLUME_MAX=

# 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.
#   default:  128mb
#   rexctl:   rexctl config set FLUXER_SEAWEEDFS_INIT_MEMORY_LIMIT
# FLUXER_SEAWEEDFS_INIT_MEMORY_LIMIT=

# The memory limit for the livekit container. rexctl sizes this.
#   default:  512mb
#   rexctl:   rexctl config set FLUXER_LIVEKIT_MEMORY_LIMIT
# FLUXER_LIVEKIT_MEMORY_LIMIT=

# The soft memory limit of the Go runtime in LiveKit, set as its GOMEMLIMIT.
# Keep it below FLUXER_LIVEKIT_MEMORY_LIMIT. rexctl sizes this.
#   default:  435MiB
#   rexctl:   rexctl config set FLUXER_LIVEKIT_GOMEMLIMIT
# FLUXER_LIVEKIT_GOMEMLIMIT=

# The memory limit for the api container. rexctl sizes this.
#   default:  2560mb
#   rexctl:   rexctl config set FLUXER_API_MEMORY_LIMIT
# FLUXER_API_MEMORY_LIMIT=

# 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. rexctl sizes this.
#   default:  1gb
#   rexctl:   rexctl config set FLUXER_API_MEMORY_RESERVATION
# FLUXER_API_MEMORY_RESERVATION=

# 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.
#   rexctl:   rexctl config set FLUXER_API_NODE_HEAP_MB
# FLUXER_API_NODE_HEAP_MB=

# 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.
#   rexctl:   rexctl config set FLUXER_API_NODE_OPTIONS
# FLUXER_API_NODE_OPTIONS=

# The size of the Postgres connection pool of the api container, from 1 to
# 1000. rexctl sizes this.
#   default:  25
#   rexctl:   rexctl config set FLUXER_API_POSTGRES_MAX_CONNECTIONS
# FLUXER_API_POSTGRES_MAX_CONNECTIONS=

# 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.
#   default:  false
#   rexctl:   rexctl config set FLUXER_API_EMBEDDED_WORKER
# FLUXER_API_EMBEDDED_WORKER=

# 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.
#   default:  1
#   rexctl:   rexctl config set FLUXER_WORKER_REPLICAS
# FLUXER_WORKER_REPLICAS=

# The memory limit for each worker container. rexctl sizes this.
#   default:  2560mb
#   rexctl:   rexctl config set FLUXER_WORKER_MEMORY_LIMIT
# FLUXER_WORKER_MEMORY_LIMIT=

# 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. rexctl sizes this.
#   default:  1gb
#   rexctl:   rexctl config set FLUXER_WORKER_MEMORY_RESERVATION
# FLUXER_WORKER_MEMORY_RESERVATION=

# 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.
#   rexctl:   rexctl config set FLUXER_WORKER_NODE_HEAP_MB
# FLUXER_WORKER_NODE_HEAP_MB=

# 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.
#   rexctl:   rexctl config set FLUXER_WORKER_NODE_OPTIONS
# FLUXER_WORKER_NODE_OPTIONS=

# 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. rexctl sizes
# this.
#   default:  25
#   rexctl:   rexctl config set FLUXER_WORKER_POSTGRES_MAX_CONNECTIONS
# FLUXER_WORKER_POSTGRES_MAX_CONNECTIONS=

# 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.
#   rexctl:   rexctl config set FLUXER_WORKER_POSTGRES_SYNCHRONOUS_COMMIT
# FLUXER_WORKER_POSTGRES_SYNCHRONOUS_COMMIT=

# The memory limit for the gateway container. rexctl sizes this.
#   default:  1gb
#   rexctl:   rexctl config set FLUXER_GATEWAY_MEMORY_LIMIT
# FLUXER_GATEWAY_MEMORY_LIMIT=

# 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. rexctl sizes this.
#   default:  384mb
#   rexctl:   rexctl config set FLUXER_GATEWAY_MEMORY_RESERVATION
# FLUXER_GATEWAY_MEMORY_RESERVATION=

# 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.
#   rexctl:   rexctl config set FLUXER_ERLANG_SCHEDULERS
# FLUXER_ERLANG_SCHEDULERS=

# 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.
#   rexctl:   rexctl config set FLUXER_ERLANG_SCHEDULERS_MIN
# FLUXER_ERLANG_SCHEDULERS_MIN=

# 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.
#   rexctl:   rexctl config set FLUXER_ERLANG_SCHEDULERS_MAX
# FLUXER_ERLANG_SCHEDULERS_MAX=

# 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.
#   rexctl:   rexctl config set FLUXER_ERLANG_DIRTY_CPU_SCHEDULERS
# FLUXER_ERLANG_DIRTY_CPU_SCHEDULERS=

# 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.
#   rexctl:   rexctl config set FLUXER_ERLANG_DIRTY_IO_SCHEDULERS
# FLUXER_ERLANG_DIRTY_IO_SCHEDULERS=

# The memory limit for the media-proxy container. rexctl sizes this.
#   default:  1gb
#   rexctl:   rexctl config set FLUXER_MEDIA_PROXY_MEMORY_LIMIT
# FLUXER_MEDIA_PROXY_MEMORY_LIMIT=

# How many worker threads the async runtime of the media proxy uses, set as
# its TOKIO_WORKER_THREADS. rexctl sizes this.
#   default:  4
#   rexctl:   rexctl config set FLUXER_MEDIA_PROXY_TOKIO_WORKER_THREADS
# FLUXER_MEDIA_PROXY_TOKIO_WORKER_THREADS=

# The memory limit for the push container.
#   default:  256mb
#   rexctl:   rexctl config set FLUXER_PUSH_MEMORY_LIMIT
# FLUXER_PUSH_MEMORY_LIMIT=

# The memory limit for the static-proxy container.
#   default:  256mb
#   rexctl:   rexctl config set FLUXER_STATIC_PROXY_MEMORY_LIMIT
# FLUXER_STATIC_PROXY_MEMORY_LIMIT=

# The memory limit for the app-proxy container.
#   default:  256mb
#   rexctl:   rexctl config set FLUXER_APP_PROXY_MEMORY_LIMIT
# FLUXER_APP_PROXY_MEMORY_LIMIT=

# The memory limit for the snowflakes container.
#   default:  256mb
#   rexctl:   rexctl config set FLUXER_SNOWFLAKES_MEMORY_LIMIT
# FLUXER_SNOWFLAKES_MEMORY_LIMIT=

# The memory limit for the users container.
#   default:  256mb
#   rexctl:   rexctl config set FLUXER_USERS_MEMORY_LIMIT
# FLUXER_USERS_MEMORY_LIMIT=

# The size of the Postgres connection pool of the users container. rexctl
# sizes this.
#   default:  20
#   rexctl:   rexctl config set FLUXER_USERS_POSTGRES_MAX_CONNECTIONS
# FLUXER_USERS_POSTGRES_MAX_CONNECTIONS=

# The memory limit for the gifs container.
#   default:  256mb
#   rexctl:   rexctl config set FLUXER_GIFS_MEMORY_LIMIT
# FLUXER_GIFS_MEMORY_LIMIT=

# 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. rexctl sizes this.
#   default:  134217728
#   rexctl:   rexctl config set FLUXER_GIFS_SHARD_CACHE_MAX_BYTES
# FLUXER_GIFS_SHARD_CACHE_MAX_BYTES=

# The memory limit for the messages container.
#   default:  256mb
#   rexctl:   rexctl config set FLUXER_MESSAGES_MEMORY_LIMIT
# FLUXER_MESSAGES_MEMORY_LIMIT=

# The size of the Postgres connection pool of the messages container. rexctl
# sizes this.
#   default:  20
#   rexctl:   rexctl config set FLUXER_MESSAGES_POSTGRES_MAX_CONNECTIONS
# FLUXER_MESSAGES_POSTGRES_MAX_CONNECTIONS=

# The memory limit for the unfurl container.
#   default:  256mb
#   rexctl:   rexctl config set FLUXER_UNFURL_MEMORY_LIMIT
# FLUXER_UNFURL_MEMORY_LIMIT=

# The memory limit for the admin container.
#   default:  256mb
#   rexctl:   rexctl config set FLUXER_ADMIN_MEMORY_LIMIT
# FLUXER_ADMIN_MEMORY_LIMIT=


# ============================================================================
#  BUNDLED SERVICES
#
#  These change how the bundled Valkey, Meilisearch and SeaweedFS run.
# ============================================================================

# 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.
#   default:  everysec
#   rexctl:   rexctl config set FLUXER_VALKEY_APPENDFSYNC
# FLUXER_VALKEY_APPENDFSYNC=

# 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.
#   rexctl:   rexctl config set FLUXER_VALKEY_SAVE
# FLUXER_VALKEY_SAVE=

# 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.
#   default:  production
#   rexctl:   rexctl config set FLUXER_MEILISEARCH_ENV
# FLUXER_MEILISEARCH_ENV=

# Whether Meilisearch stops sending usage data to the Meilisearch team, set as
# its MEILI_NO_ANALYTICS. Use true or false.
#   default:  true
#   rexctl:   rexctl config set FLUXER_MEILISEARCH_NO_ANALYTICS
# FLUXER_MEILISEARCH_NO_ANALYTICS=

# Whether SeaweedFS sends usage data to the SeaweedFS project, set as its
# -master.telemetry. Use true or false.
#   default:  false
#   rexctl:   rexctl config set FLUXER_SEAWEEDFS_TELEMETRY
# FLUXER_SEAWEEDFS_TELEMETRY=


# ============================================================================
#  LOGS AND HEALTH CHECKS
# ============================================================================

# How much the api and worker log. Use trace, debug, info, warn, error or
# fatal. An empty or unknown value gives info.
#   rexctl:   rexctl config set LOG_LEVEL
# LOG_LEVEL=

# 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.
#   rexctl:   rexctl config set RUST_LOG
# RUST_LOG=

# 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.
#   rexctl:   rexctl config set FLUXER_GATEWAY_LOGGER_LEVEL
# FLUXER_GATEWAY_LOGGER_LEVEL=

# 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.
#   rexctl:   rexctl config set LOGGER_LEVEL
# LOGGER_LEVEL=

# How much Meilisearch logs, set as its MEILI_LOG_LEVEL. Use OFF, ERROR, WARN,
# INFO, DEBUG or TRACE.
#   default:  WARN
#   rexctl:   rexctl config set FLUXER_MEILISEARCH_LOG_LEVEL
# FLUXER_MEILISEARCH_LOG_LEVEL=

# How much LiveKit logs. Use debug, info, warn or error.
#   default:  info
#   rexctl:   rexctl config set FLUXER_LIVEKIT_LOG_LEVEL
# FLUXER_LIVEKIT_LOG_LEVEL=

# How large the log file of a container grows before Docker rotates it, such
# as 50m. When disk.profile is small, rexctl sets this to 5m unless you set
# it.
#   default:  10m
#   rexctl:   rexctl config set FLUXER_LOG_MAX_SIZE
# FLUXER_LOG_MAX_SIZE=

# How many log files Docker keeps for each container when it rotates logs.
# When disk.profile is small, rexctl sets this to 2 unless you set it.
#   default:  3
#   rexctl:   rexctl config set FLUXER_LOG_MAX_FILE
# FLUXER_LOG_MAX_FILE=

# The Docker restart policy of every long-running service, such as always,
# on-failure or no.
#   default:  unless-stopped
#   rexctl:   rexctl config set FLUXER_RESTART_POLICY
# FLUXER_RESTART_POLICY=

# 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.
#   default:  10s
#   rexctl:   rexctl config set FLUXER_HEALTHCHECK_INTERVAL
# FLUXER_HEALTHCHECK_INTERVAL=

# How often Docker runs the health check of the media-proxy container.
#   default:  30s
#   rexctl:   rexctl config set FLUXER_MEDIA_PROXY_HEALTHCHECK_INTERVAL
# FLUXER_MEDIA_PROXY_HEALTHCHECK_INTERVAL=

# How often Docker runs the health check of the app-proxy container.
#   default:  30s
#   rexctl:   rexctl config set FLUXER_APP_PROXY_HEALTHCHECK_INTERVAL
# FLUXER_APP_PROXY_HEALTHCHECK_INTERVAL=

# How long one health check may run before Docker counts it as failed.
#   default:  5s
#   rexctl:   rexctl config set FLUXER_HEALTHCHECK_TIMEOUT
# FLUXER_HEALTHCHECK_TIMEOUT=

# 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.
#   default:  10
#   rexctl:   rexctl config set FLUXER_HEALTHCHECK_RETRIES
# FLUXER_HEALTHCHECK_RETRIES=

# 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.
#   default:  60s
#   rexctl:   rexctl config set FLUXER_HEALTHCHECK_START_PERIOD
# FLUXER_HEALTHCHECK_START_PERIOD=

# How often Docker runs each health check while a service is still in its
# start period.
#   default:  1s
#   rexctl:   rexctl config set FLUXER_HEALTHCHECK_START_INTERVAL
# FLUXER_HEALTHCHECK_START_INTERVAL=

# How many failed health checks in a row mark the api, gateway, push, admin,
# snowflakes, users, gifs, messages and unfurl containers as unhealthy.
#   default:  30
#   rexctl:   rexctl config set FLUXER_APP_HEALTHCHECK_RETRIES
# FLUXER_APP_HEALTHCHECK_RETRIES=

# How long the api, worker and gateway containers get to start before failed
# health checks count, such as 120s.
#   default:  90s
#   rexctl:   rexctl config set FLUXER_APP_HEALTHCHECK_START_PERIOD
# FLUXER_APP_HEALTHCHECK_START_PERIOD=

# How long the push, admin, snowflakes, users, gifs, messages and unfurl
# containers get to start before failed health checks count.
#   default:  60s
#   rexctl:   rexctl config set FLUXER_SVC_HEALTHCHECK_START_PERIOD
# FLUXER_SVC_HEALTHCHECK_START_PERIOD=

# How many failed health checks in a row mark the seaweedfs container as
# unhealthy.
#   default:  20
#   rexctl:   rexctl config set FLUXER_SEAWEEDFS_HEALTHCHECK_RETRIES
# FLUXER_SEAWEEDFS_HEALTHCHECK_RETRIES=

# How long the seaweedfs container gets to start before failed health checks
# count.
#   default:  60s
#   rexctl:   rexctl config set FLUXER_SEAWEEDFS_HEALTHCHECK_START_PERIOD
# FLUXER_SEAWEEDFS_HEALTHCHECK_START_PERIOD=

# 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.
#   default:  3
#   rexctl:   rexctl config set FLUXER_WORKER_HEALTHCHECK_RETRIES
# FLUXER_WORKER_HEALTHCHECK_RETRIES=


# ============================================================================
#  IMAGES
#
#  Set one to use your own mirror or another version. Fluxer's own images are
#  pinned to the release in docker-compose.yml.
# ============================================================================

# The image the edge container runs.
#   default:  caddy:2.11-alpine
#   rexctl:   rexctl config set images.edge
# FLUXER_CADDY_IMAGE=

# The image the postgres container runs.
#   default:  postgres:16-alpine
#   rexctl:   rexctl config set images.postgres
# FLUXER_POSTGRES_IMAGE=

# The image the valkey container runs.
#   default:  valkey/valkey:9.1-alpine
#   rexctl:   rexctl config set images.valkey
# FLUXER_VALKEY_IMAGE=

# The image the nats container runs.
#   default:  nats:2.14-alpine
#   rexctl:   rexctl config set images.nats
# FLUXER_NATS_IMAGE=

# The image the meilisearch container runs.
#   default:  getmeili/meilisearch:v1.53
#   rexctl:   rexctl config set images.meilisearch
# FLUXER_MEILISEARCH_IMAGE=

# The image the seaweedfs and seaweedfs-init containers run.
#   default:  chrislusf/seaweedfs:4.52
#   rexctl:   rexctl config set images.seaweedfs
# FLUXER_SEAWEEDFS_IMAGE=

# The image the livekit container runs.
#   default:  livekit/livekit-server:v1.12.0
#   rexctl:   rexctl config set images.livekit
# FLUXER_LIVEKIT_IMAGE=