docker-compose.yaml

---
services:
  envoy:
    image: ghcr.io/ar-io/ar-io-envoy:${ENVOY_IMAGE_TAG:-latest}
    build:
      context: envoy/
    restart: unless-stopped
    ports:
      - '${ENVOY_PORT:-3000}:3000'
      #- '9901:9901' # don't expose admin port by default
    environment:
      - LOG_LEVEL=${ENVOY_LOG_LEVEL:-info}
      - TVAL_AR_IO_HOST=core
      - TVAL_AR_IO_PORT=${CORE_PORT:-4000}
      - TVAL_OBSERVER_HOST=observer
      - TVAL_OBSERVER_PORT=${OBSERVER_PORT:-5050}
      - TVAL_TRUSTED_NODE_HOST=${TRUSTED_NODE_HOST:-arweave.net}
      - TVAL_TRUSTED_NODE_PORT=${TRUSTED_NODE_PORT:-443}
      - TVAL_FALLBACK_NODE_HOST=${FALLBACK_NODE_HOST:-peers.arweave.xyz}
      - TVAL_FALLBACK_NODE_PORT=${FALLBACK_NODE_PORT:-1984}
      - TVAL_GRAPHQL_HOST=${GRAPHQL_HOST:-core}
      - TVAL_GRAPHQL_PORT=${GRAPHQL_PORT:-4000}
      - TVAL_GRAPHQL_HOST_HEADER=${GRAPHQL_HOST_HEADER:-}
      - TVAL_DATASETS_HOST=${DATASETS_PROXY_HOST:-core}
      - TVAL_DATASETS_PORT=${DATASETS_PROXY_PORT:-4000}
      # Where https://<gateway>/ar-io/indexes/announce goes: the index-swarm
      # sidecar's tracker listener for proxied announces (never published).
      - TVAL_INDEX_SWARM_TRACKER_HOST=${INDEX_SWARM_TRACKER_PROXY_HOST:-index-swarm}
      - TVAL_INDEX_SWARM_TRACKER_PORT=${INDEX_SWARM_TRACKER_PROXY_PORT:-6970}
      - TVAL_ARNS_ROOT_HOST=${ARNS_ROOT_HOST:-}
      - TVAL_ARWEAVE_POST_DRY_RUN=${ARWEAVE_POST_DRY_RUN:-false}
      - TVAL_ENABLE_ARWEAVE_PEER_EDS=${ENABLE_ARWEAVE_PEER_EDS:-true}
      - TVAL_ARWEAVE_PEER_DNS_RECORDS=${ARWEAVE_PEER_DNS_RECORDS:-peers.arweave.xyz}
      - TVAL_ARWEAVE_PEER_DNS_PORT=${ARWEAVE_PEER_DNS_PORT:-1984}
      - TVAL_ARIO_GATEWAY_UPSTREAM_IDLE_TIMEOUT=${ENVOY_ARIO_GATEWAY_UPSTREAM_IDLE_TIMEOUT:-55s}
      - TVAL_ARIO_GATEWAY_MAX_CONNECTIONS=${ENVOY_ARIO_GATEWAY_MAX_CONNECTIONS:-16384}
      - TVAL_ARIO_GATEWAY_MAX_PENDING_REQUESTS=${ENVOY_ARIO_GATEWAY_MAX_PENDING_REQUESTS:-16384}
      - TVAL_ARIO_GATEWAY_MAX_REQUESTS=${ENVOY_ARIO_GATEWAY_MAX_REQUESTS:-16384}
      - TVAL_ARIO_GATEWAY_RETRY_BUDGET_PERCENT=${ENVOY_ARIO_GATEWAY_RETRY_BUDGET_PERCENT:-20}
    volumes:
      - envoy-eds-data:/data/envoy-eds
    ulimits:
      nofile:
        soft: 65536
        hard: 65536
    networks:
      - ar-io-network
    depends_on:
      - core
      - observer

  core:
    image: ghcr.io/ar-io/ar-io-core:${CORE_IMAGE_TAG:-latest}
    build:
      context: .
    restart: unless-stopped
    ports:
      - ${CORE_PORT:-4000}:4000
    volumes:
      - ${CHUNKS_DATA_PATH:-./data/chunks}:/app/data/chunks
      - ${CONTIGUOUS_DATA_PATH:-./data/contiguous}:/app/data/contiguous
      - ${HEADERS_DATA_PATH:-./data/headers}:/app/data/headers
      - ${SQLITE_DATA_PATH:-./data/sqlite}:/app/data/sqlite
      - ${DUCKDB_DATA_PATH:-./data/duckdb}:/app/data/duckdb
      - ${TEMP_DATA_PATH:-./data/tmp}:/app/data/tmp
      - ${LMDB_DATA_PATH:-./data/lmdb}:/app/data/lmdb
      - ${PARQUET_DATA_PATH:-./data/parquet}:/app/data/parquet
      - ${DATASETS_PATH:-./data/datasets}:/app/data/datasets
      - ${ETL_STAGING_PATH:-./data/etl/staging}:/app/data/etl/staging
      - ${CDB64_ROOT_TX_INDEX_DATA_PATH:-./data/cdb64-root-tx-index}:/app/data/cdb64-root-tx-index
      # Index artifacts the index-swarm sidecar publishes and installs. Read
      # only: core serves published/ and loads installed/, and never writes.
      - ${INDEX_SWARM_DATA_PATH:-./data/indexes}:/app/data/indexes:ro
      - ${KEYS_DATA_PATH:-./data/keys}:/app/data/keys
      - ${WALLETS_PATH:-./wallets}:/app/wallets:ro
      - ${SECRETS_PATH:-./secrets}:/app/secrets:ro
      - envoy-eds-data:/app/data/envoy-eds
    environment:
      - NODE_ENV=${NODE_ENV:-production}
      - LOG_LEVEL=${CORE_LOG_LEVEL:-info}
      - INDEXES_PUBLISHED_DIR=${INDEXES_PUBLISHED_DIR:-}
      - INDEXES_ADVERTISE_FROM_URL=${INDEXES_ADVERTISE_FROM_URL:-}
      - INDEXES_PUBLIC_URL=${INDEXES_PUBLIC_URL:-}
      - INDEXES_TORRENT_WEBSEED=${INDEXES_TORRENT_WEBSEED:-}
      - LOG_FORMAT=${CORE_LOG_FORMAT:-simple}
      - LOG_FILTER=${CORE_LOG_FILTER:-}
      - LOG_ALL_STACKTRACES=${CORE_LOG_ALL_STACKTRACES:-}
      - TRUSTED_NODE_URL=${TRUSTED_NODE_URL:-http://envoy:3000}
      - TRUSTED_GATEWAY_URL=${TRUSTED_GATEWAY_URL:-}
      - TRUSTED_GATEWAYS_URLS=${TRUSTED_GATEWAYS_URLS:-}
      - TRUSTED_GATEWAYS_REQUEST_TIMEOUT_MS=${TRUSTED_GATEWAYS_REQUEST_TIMEOUT_MS:-}
      - GATEWAYS_THROTTLE_BACKOFF_ENABLED=${GATEWAYS_THROTTLE_BACKOFF_ENABLED:-}
      - GATEWAYS_THROTTLE_BACKOFF_DEFAULT_MS=${GATEWAYS_THROTTLE_BACKOFF_DEFAULT_MS:-}
      - GATEWAYS_THROTTLE_BACKOFF_MAX_MS=${GATEWAYS_THROTTLE_BACKOFF_MAX_MS:-}
      - GATEWAY_AGENT_IDLE_SOCKET_TIMEOUT_MS=${GATEWAY_AGENT_IDLE_SOCKET_TIMEOUT_MS:-}
      - GATEWAY_SLOW_SOCKET_ACQUISITION_LOG_THRESHOLD_MS=${GATEWAY_SLOW_SOCKET_ACQUISITION_LOG_THRESHOLD_MS:-}
      - GATEWAY_MAX_SOCKETS_PER_HOST=${GATEWAY_MAX_SOCKETS_PER_HOST:-}
      - GATEWAY_UNTRUSTED_MAX_SOCKETS_PER_HOST=${GATEWAY_UNTRUSTED_MAX_SOCKETS_PER_HOST:-}
      - GATEWAY_MAX_FREE_SOCKETS_PER_HOST=${GATEWAY_MAX_FREE_SOCKETS_PER_HOST:-}
      - OUTBOUND_MAX_SOCKETS_PER_HOST=${OUTBOUND_MAX_SOCKETS_PER_HOST:-}
      - OUTBOUND_MAX_FREE_SOCKETS_PER_HOST=${OUTBOUND_MAX_FREE_SOCKETS_PER_HOST:-}
      - TRUSTED_GATEWAYS_SEND_UNTRUSTED_PARAMS=${TRUSTED_GATEWAYS_SEND_UNTRUSTED_PARAMS:-}
      - TRUSTED_GATEWAYS_BLOCKED_ORIGINS=${TRUSTED_GATEWAYS_BLOCKED_ORIGINS:-}
      - TRUSTED_GATEWAYS_BLOCKED_IPS_AND_CIDRS=${TRUSTED_GATEWAYS_BLOCKED_IPS_AND_CIDRS:-}
      - CACHE_ONLY_CLIENT_IPS_AND_CIDRS=${CACHE_ONLY_CLIENT_IPS_AND_CIDRS:-}
      - BUNDLER_URLS=${BUNDLER_URLS:-}
      - START_HEIGHT=${START_HEIGHT:-}
      - STOP_HEIGHT=${STOP_HEIGHT:-}
      - L1_BAND_IMPORT_ENABLED=${L1_BAND_IMPORT_ENABLED:-}
      - L1_BAND_IMPORT_BANDS_DIR=${L1_BAND_IMPORT_BANDS_DIR:-}
      - L1_BAND_IMPORT_INTERVAL_SECONDS=${L1_BAND_IMPORT_INTERVAL_SECONDS:-}
      - L1_BAND_IMPORT_CACHE_MIB=${L1_BAND_IMPORT_CACHE_MIB:-}
      - SKIP_CACHE=${SKIP_CACHE:-}
      - SKIP_DATA_CACHE=${SKIP_DATA_CACHE:-}
      - SKIP_DATA_CACHE_WRITES=${SKIP_DATA_CACHE_WRITES:-}
      - ENABLE_CONTIGUOUS_DATA_CACHE_TEMP_CLEANUP=${ENABLE_CONTIGUOUS_DATA_CACHE_TEMP_CLEANUP:-}
      - CONTIGUOUS_DATA_CACHE_TEMP_CLEANUP_THRESHOLD=${CONTIGUOUS_DATA_CACHE_TEMP_CLEANUP_THRESHOLD:-}
      - STREAM_STALL_TIMEOUT_MS=${STREAM_STALL_TIMEOUT_MS:-}
      - STREAM_REQUEST_TIMEOUT_MS=${STREAM_REQUEST_TIMEOUT_MS:-}
      - HTTP_KEEP_ALIVE_TIMEOUT_MS=${HTTP_KEEP_ALIVE_TIMEOUT_MS:-}
      - HTTP_HEADERS_TIMEOUT_MS=${HTTP_HEADERS_TIMEOUT_MS:-}
      - DATA_IMPORTER_DOWNLOAD_TIMEOUT_MS=${DATA_IMPORTER_DOWNLOAD_TIMEOUT_MS:-}
      - NEGATIVE_CACHE_ENABLED=${NEGATIVE_CACHE_ENABLED:-}
      - NEGATIVE_CACHE_MAX_SIZE=${NEGATIVE_CACHE_MAX_SIZE:-}
      - NEGATIVE_CACHE_TTL_MS=${NEGATIVE_CACHE_TTL_MS:-}
      - NEGATIVE_CACHE_MISS_THRESHOLD_MS=${NEGATIVE_CACHE_MISS_THRESHOLD_MS:-}
      - NEGATIVE_CACHE_MISS_COUNT_THRESHOLD=${NEGATIVE_CACHE_MISS_COUNT_THRESHOLD:-}
      - NEGATIVE_CACHE_MISS_TRACKER_TTL_MS=${NEGATIVE_CACHE_MISS_TRACKER_TTL_MS:-}
      - NEGATIVE_CACHE_MAX_TTL_MS=${NEGATIVE_CACHE_MAX_TTL_MS:-}
      - NEGATIVE_CACHE_PROMOTION_HISTORY_TTL_MS=${NEGATIVE_CACHE_PROMOTION_HISTORY_TTL_MS:-}
      - NEGATIVE_CACHE_HEALTH_WINDOW_MS=${NEGATIVE_CACHE_HEALTH_WINDOW_MS:-}
      - NEGATIVE_CACHE_UNHEALTHY_THRESHOLD=${NEGATIVE_CACHE_UNHEALTHY_THRESHOLD:-}
      - NEGATIVE_CACHE_HEALTH_MIN_SAMPLE_SIZE=${NEGATIVE_CACHE_HEALTH_MIN_SAMPLE_SIZE:-}
      - SIMULATED_REQUEST_FAILURE_RATE=${SIMULATED_REQUEST_FAILURE_RATE:-}
      - INSTANCE_ID=${INSTANCE_ID:-}
      - AR_IO_WALLET=${AR_IO_WALLET:-}
      - ADMIN_API_KEY=${ADMIN_API_KEY:-}
      - BACKFILL_BUNDLE_RECORDS=${BACKFILL_BUNDLE_RECORDS:-}
      - FILTER_CHANGE_REPROCESS=${FILTER_CHANGE_REPROCESS:-}
      - ANS104_UNBUNDLE_WORKERS=${ANS104_UNBUNDLE_WORKERS:-}
      - ANS104_DOWNLOAD_WORKERS=${ANS104_DOWNLOAD_WORKERS:-}
      - TX_FETCHER_WORKER_COUNT=${TX_FETCHER_WORKER_COUNT:-}
      - CORE_SQLITE_READ_WORKER_COUNT=${CORE_SQLITE_READ_WORKER_COUNT:-}
      - DATA_SQLITE_READ_WORKER_COUNT=${DATA_SQLITE_READ_WORKER_COUNT:-}
      - SQLITE_SLOW_QUERY_LOG_THRESHOLD_MS=${SQLITE_SLOW_QUERY_LOG_THRESHOLD_MS:-}
      - ANS104_UNBUNDLE_FILTER=${ANS104_UNBUNDLE_FILTER:-}
      - ANS104_INDEX_FILTER=${ANS104_INDEX_FILTER:-}
      - ANS104_UNBUNDLE_GET_DATA_TIMEOUT_MS=${ANS104_UNBUNDLE_GET_DATA_TIMEOUT_MS:-}
      - ANS104_UNBUNDLE_STREAM_TOTAL_TIMEOUT_MS=${ANS104_UNBUNDLE_STREAM_TOTAL_TIMEOUT_MS:-}
      - ANS104_PARSE_JOB_TIMEOUT_MS=${ANS104_PARSE_JOB_TIMEOUT_MS:-}
      - ANS104_UNBUNDLE_GET_DATA_WALL_CLOCK_TIMEOUT_MS=${ANS104_UNBUNDLE_GET_DATA_WALL_CLOCK_TIMEOUT_MS:-}
      - DATA_ITEM_FLUSH_COUNT_THRESHOLD=${DATA_ITEM_FLUSH_COUNT_THRESHOLD:-}
      - MAX_FLUSH_INTERVAL_SECONDS=${MAX_FLUSH_INTERVAL_SECONDS:-}
      - PARQUET_EXPORT_DUCKDB_MEMORY_LIMIT=${PARQUET_EXPORT_DUCKDB_MEMORY_LIMIT:-}
      - PARQUET_EXPORT_DUCKDB_MAX_TEMP_DIRECTORY_SIZE=${PARQUET_EXPORT_DUCKDB_MAX_TEMP_DIRECTORY_SIZE:-}
      - PARQUET_EXPORT_DUCKDB_THREADS=${PARQUET_EXPORT_DUCKDB_THREADS:-}
      - ARNS_ROOT_HOST=${ARNS_ROOT_HOST:-}
      - SANDBOX_PROTOCOL=${SANDBOX_PROTOCOL:-}
      - START_WRITERS=${START_WRITERS:-}
      # AR.IO Network backend — reads protocol state from the AR.IO Solana
      # programs identified by ARIO_*_PROGRAM_ID below.
      - SOLANA_RPC_URL=${SOLANA_RPC_URL:-}
      - ARIO_CORE_PROGRAM_ID=${ARIO_CORE_PROGRAM_ID:-73YoECm6NKXpVRoe5f1Q9BcP5DJGPFUjnFy6AxBE5Nvh}
      - ARIO_GAR_PROGRAM_ID=${ARIO_GAR_PROGRAM_ID:-89fNiiwgpFSPHKuqfNUkgYTYjtAJAhyqHjXmgXeppGpf}
      - ARIO_ARNS_PROGRAM_ID=${ARIO_ARNS_PROGRAM_ID:-2yCUx5edFvUrkibYaUa2ZXWyx9kuJkS8CwyzsgHPWdZZ}
      - ARIO_ANT_PROGRAM_ID=${ARIO_ANT_PROGRAM_ID:-2MWexMHfMhGJwMHv9Qm9YAVCqjUFUJwDJAysW4oCUGk5}
      - CHAIN_CACHE_TYPE=${CHAIN_CACHE_TYPE:-redis}
      - REDIS_CACHE_URL=${REDIS_CACHE_URL:-redis://redis:6379}
      - REDIS_USE_TLS=${REDIS_USE_TLS:-}
      - REDIS_CACHE_TTL_SECONDS=${REDIS_CACHE_TTL_SECONDS:-}
      - ENABLE_RATE_LIMITER=${ENABLE_RATE_LIMITER:-}
      - RATE_LIMITER_TYPE=${RATE_LIMITER_TYPE:-redis}
      - RATE_LIMITER_REDIS_ENDPOINT=${RATE_LIMITER_REDIS_ENDPOINT:-redis://redis:6379}
      - RATE_LIMITER_REDIS_USE_TLS=${RATE_LIMITER_REDIS_USE_TLS:-}
      - RATE_LIMITER_REDIS_USE_CLUSTER=${RATE_LIMITER_REDIS_USE_CLUSTER:-}
      - RATE_LIMITER_RESOURCE_TOKENS_PER_BUCKET=${RATE_LIMITER_RESOURCE_TOKENS_PER_BUCKET:-}
      - RATE_LIMITER_RESOURCE_REFILL_PER_SEC=${RATE_LIMITER_RESOURCE_REFILL_PER_SEC:-}
      - RATE_LIMITER_IP_TOKENS_PER_BUCKET=${RATE_LIMITER_IP_TOKENS_PER_BUCKET:-}
      - RATE_LIMITER_IP_REFILL_PER_SEC=${RATE_LIMITER_IP_REFILL_PER_SEC:-}
      - TRUSTED_PROXIES=${TRUSTED_PROXIES:-}
      - RATE_LIMITER_IPS_AND_CIDRS_ALLOWLIST=${RATE_LIMITER_IPS_AND_CIDRS_ALLOWLIST:-}
      - RATE_LIMITER_ARNS_ALLOWLIST=${RATE_LIMITER_ARNS_ALLOWLIST:-}
      - NODE_MAX_OLD_SPACE_SIZE=${NODE_MAX_OLD_SPACE_SIZE:-}
      - ENABLE_FS_HEADER_CACHE_CLEANUP=${ENABLE_FS_HEADER_CACHE_CLEANUP:-}
      - ON_DEMAND_RETRIEVAL_ORDER=${ON_DEMAND_RETRIEVAL_ORDER:-}
      - SKIP_FORWARDING_HEADERS=${SKIP_FORWARDING_HEADERS:-}
      - SKIP_FORWARDING_EMPTY_USER_AGENT=${SKIP_FORWARDING_EMPTY_USER_AGENT:-}
      - SKIP_FORWARDING_USER_AGENTS=${SKIP_FORWARDING_USER_AGENTS:-}
      - BACKGROUND_RETRIEVAL_ORDER=${BACKGROUND_RETRIEVAL_ORDER:-}
      - CHUNK_DATA_RETRIEVAL_ORDER=${CHUNK_DATA_RETRIEVAL_ORDER:-}
      - CHUNK_METADATA_RETRIEVAL_ORDER=${CHUNK_METADATA_RETRIEVAL_ORDER:-}
      - CHUNK_DATA_SOURCE_PARALLELISM=${CHUNK_DATA_SOURCE_PARALLELISM:-}
      - CHUNK_METADATA_SOURCE_PARALLELISM=${CHUNK_METADATA_SOURCE_PARALLELISM:-}
      - CHUNK_METADATA_ANCHOR_ENABLED=${CHUNK_METADATA_ANCHOR_ENABLED:-}
      - CHUNK_METADATA_ANCHOR_REQUEST_TIMEOUT_MS=${CHUNK_METADATA_ANCHOR_REQUEST_TIMEOUT_MS:-}
      - CHUNK_METADATA_ANCHOR_TX_CACHE_SIZE=${CHUNK_METADATA_ANCHOR_TX_CACHE_SIZE:-}
      - CHUNK_METADATA_ANCHOR_TX_CACHE_TTL_SECONDS=${CHUNK_METADATA_ANCHOR_TX_CACHE_TTL_SECONDS:-}
      - CHUNK_METADATA_ANCHOR_MISS_CACHE_TTL_SECONDS=${CHUNK_METADATA_ANCHOR_MISS_CACHE_TTL_SECONDS:-}
      - CHUNK_REQUEST_CONCURRENCY=${CHUNK_REQUEST_CONCURRENCY:-}
      - CHUNK_FIRST_DATA_TIMEOUT_MS=${CHUNK_FIRST_DATA_TIMEOUT_MS:-}
      - TX_CHUNKS_GEOMETRY_DB_ENABLED=${TX_CHUNKS_GEOMETRY_DB_ENABLED:-}
      - TX_CHUNKS_GEOMETRY_CACHE_SIZE=${TX_CHUNKS_GEOMETRY_CACHE_SIZE:-}
      - CHUNK_SERVE_DEADLINE_MS=${CHUNK_SERVE_DEADLINE_MS:-}
      - CHUNK_PEER_ORIGIN_MODE=${CHUNK_PEER_ORIGIN_MODE:-}
      - CHUNK_GET_BASE64_SIZE_BYTES=${CHUNK_GET_BASE64_SIZE_BYTES:-}
      - CHUNK_METADATA_CACHE_TYPE=${CHUNK_METADATA_CACHE_TYPE:-redis}
      - CONTIGUOUS_METADATA_CACHE_TYPE=${CONTIGUOUS_METADATA_CACHE_TYPE:-}
      - CHUNK_OFFSET_CHAIN_FALLBACK_ENABLED=${CHUNK_OFFSET_CHAIN_FALLBACK_ENABLED:-}
      - CHUNK_OFFSET_CHAIN_FALLBACK_CONCURRENCY=${CHUNK_OFFSET_CHAIN_FALLBACK_CONCURRENCY:-}
      - CHUNK_OFFSET_CHAIN_FALLBACK_BLOCK_CACHE_SIZE=${CHUNK_OFFSET_CHAIN_FALLBACK_BLOCK_CACHE_SIZE:-}
      - CHUNK_OFFSET_CHAIN_FALLBACK_BLOCK_CACHE_TTL_MS=${CHUNK_OFFSET_CHAIN_FALLBACK_BLOCK_CACHE_TTL_MS:-}
      - CHUNK_OFFSET_CHAIN_FALLBACK_TX_DATA_CACHE_SIZE=${CHUNK_OFFSET_CHAIN_FALLBACK_TX_DATA_CACHE_SIZE:-}
      - CHUNK_OFFSET_CHAIN_FALLBACK_TX_DATA_CACHE_TTL_MS=${CHUNK_OFFSET_CHAIN_FALLBACK_TX_DATA_CACHE_TTL_MS:-}
      - CHUNK_OFFSET_CHAIN_FALLBACK_TX_OFFSET_CACHE_SIZE=${CHUNK_OFFSET_CHAIN_FALLBACK_TX_OFFSET_CACHE_SIZE:-}
      - CHUNK_OFFSET_CHAIN_FALLBACK_TX_OFFSET_CACHE_TTL_MS=${CHUNK_OFFSET_CHAIN_FALLBACK_TX_OFFSET_CACHE_TTL_MS:-}
      - ARWEAVE_PEER_CHUNK_GET_MAX_PEER_ATTEMPT_COUNT=${ARWEAVE_PEER_CHUNK_GET_MAX_PEER_ATTEMPT_COUNT:-}
      - ARWEAVE_PEER_CHUNK_GET_PEER_SELECTION_COUNT=${ARWEAVE_PEER_CHUNK_GET_PEER_SELECTION_COUNT:-}
      - ARWEAVE_CHUNK_GET_GEOMETRY_TIMEOUT_MS=${ARWEAVE_CHUNK_GET_GEOMETRY_TIMEOUT_MS:-}
      - ARWEAVE_CHUNK_GET_GEOMETRY_RETRY_COUNT=${ARWEAVE_CHUNK_GET_GEOMETRY_RETRY_COUNT:-}
      - WEBHOOK_TARGET_SERVERS=${WEBHOOK_TARGET_SERVERS:-}
      - WEBHOOK_INDEX_FILTER=${WEBHOOK_INDEX_FILTER:-}
      - WEBHOOK_BLOCK_FILTER=${WEBHOOK_BLOCK_FILTER:-}
      - WEBHOOK_EMIT_DATA_CACHED_EVENTS=${WEBHOOK_EMIT_DATA_CACHED_EVENTS:-}
      - CONTIGUOUS_DATA_CACHE_CLEANUP_THRESHOLD=${CONTIGUOUS_DATA_CACHE_CLEANUP_THRESHOLD:-}
      - CONTIGUOUS_DATA_CACHE_CLEANUP_INITIAL_DELAY=${CONTIGUOUS_DATA_CACHE_CLEANUP_INITIAL_DELAY:-}
      - CONTIGUOUS_DATA_CACHE_LOW_WATERMARK_PERCENT=${CONTIGUOUS_DATA_CACHE_LOW_WATERMARK_PERCENT:-}
      - CONTIGUOUS_DATA_CACHE_HIGH_WATERMARK_PERCENT=${CONTIGUOUS_DATA_CACHE_HIGH_WATERMARK_PERCENT:-}
      - CONTIGUOUS_DATA_CACHE_MIN_FREE_BYTES=${CONTIGUOUS_DATA_CACHE_MIN_FREE_BYTES:-}
      - CONTIGUOUS_DATA_CACHE_AGGRESSIVE_MIN_AGE_SECONDS=${CONTIGUOUS_DATA_CACHE_AGGRESSIVE_MIN_AGE_SECONDS:-}
      - ENABLE_CONTIGUOUS_DATA_CACHE_INDEX=${ENABLE_CONTIGUOUS_DATA_CACHE_INDEX:-}
      - CONTIGUOUS_DATA_CACHE_INDEX_EVICTION_INTERVAL_MS=${CONTIGUOUS_DATA_CACHE_INDEX_EVICTION_INTERVAL_MS:-}
      - CONTIGUOUS_DATA_CACHE_INDEX_EVICTION_BATCH_SIZE=${CONTIGUOUS_DATA_CACHE_INDEX_EVICTION_BATCH_SIZE:-}
      - CONTIGUOUS_DATA_CACHE_INDEX_UPDATE_ON_READ=${CONTIGUOUS_DATA_CACHE_INDEX_UPDATE_ON_READ:-}
      - ENABLE_CONTIGUOUS_DATA_CACHE_INDEX_BACKFILL=${ENABLE_CONTIGUOUS_DATA_CACHE_INDEX_BACKFILL:-}
      - CONTIGUOUS_DATA_CACHE_INDEX_BACKFILL_BATCH_SIZE=${CONTIGUOUS_DATA_CACHE_INDEX_BACKFILL_BATCH_SIZE:-}
      - ENABLE_CHUNK_DATA_CACHE_INDEX=${ENABLE_CHUNK_DATA_CACHE_INDEX:-}
      - CHUNK_DATA_CACHE_INDEX_EVICTION_INTERVAL_MS=${CHUNK_DATA_CACHE_INDEX_EVICTION_INTERVAL_MS:-}
      - CHUNK_DATA_CACHE_INDEX_EVICTION_BATCH_SIZE=${CHUNK_DATA_CACHE_INDEX_EVICTION_BATCH_SIZE:-}
      - CHUNK_DATA_CACHE_INDEX_UNLINK_CONCURRENCY=${CHUNK_DATA_CACHE_INDEX_UNLINK_CONCURRENCY:-}
      - CHUNK_DATA_CACHE_INDEX_EVICTION_TARGET_BYTES=${CHUNK_DATA_CACHE_INDEX_EVICTION_TARGET_BYTES:-}
      - CHUNK_DATA_CACHE_INDEX_UPDATE_ON_READ=${CHUNK_DATA_CACHE_INDEX_UPDATE_ON_READ:-}
      - ENABLE_CHUNK_DATA_CACHE_INDEX_BACKFILL=${ENABLE_CHUNK_DATA_CACHE_INDEX_BACKFILL:-}
      - CHUNK_DATA_CACHE_INDEX_BACKFILL_BATCH_SIZE=${CHUNK_DATA_CACHE_INDEX_BACKFILL_BATCH_SIZE:-}
      - ENABLE_CHUNK_DATA_CACHE_INDEX_HYBRID_TAIL=${ENABLE_CHUNK_DATA_CACHE_INDEX_HYBRID_TAIL:-}
      - CHUNK_DATA_CACHE_INDEX_HYBRID_TAIL_CHUNK_THRESHOLD=${CHUNK_DATA_CACHE_INDEX_HYBRID_TAIL_CHUNK_THRESHOLD:-}
      # Node.js libuv threadpool size (fs/dns/crypto). Default 4; raising it
      # reduces contention for the filesystem cache-cleanup walk under load.
      - UV_THREADPOOL_SIZE=${UV_THREADPOOL_SIZE:-}
      - CHUNK_DATA_CACHE_CLEANUP_THRESHOLD=${CHUNK_DATA_CACHE_CLEANUP_THRESHOLD:-}
      - CHUNK_DATA_CACHE_LOW_WATERMARK_PERCENT=${CHUNK_DATA_CACHE_LOW_WATERMARK_PERCENT:-}
      - CHUNK_DATA_CACHE_HIGH_WATERMARK_PERCENT=${CHUNK_DATA_CACHE_HIGH_WATERMARK_PERCENT:-}
      - CHUNK_DATA_CACHE_MIN_FREE_BYTES=${CHUNK_DATA_CACHE_MIN_FREE_BYTES:-}
      - CHUNK_DATA_CACHE_AGGRESSIVE_MIN_AGE_SECONDS=${CHUNK_DATA_CACHE_AGGRESSIVE_MIN_AGE_SECONDS:-}
      - ENABLE_CHUNK_DATA_CACHE_CLEANUP=${ENABLE_CHUNK_DATA_CACHE_CLEANUP:-}
      - BACKGROUND_CACHE_RANGE_MAX_SIZE=${BACKGROUND_CACHE_RANGE_MAX_SIZE:-}
      - BACKGROUND_CACHE_RANGE_CONCURRENCY=${BACKGROUND_CACHE_RANGE_CONCURRENCY:-}
      - FOREGROUND_CACHE_MAX_SIZE=${FOREGROUND_CACHE_MAX_SIZE:-}
      - FOREGROUND_CACHE_CONCURRENCY=${FOREGROUND_CACHE_CONCURRENCY:-}
      - FOREGROUND_CACHE_COALESCE_TIMEOUT_MS=${FOREGROUND_CACHE_COALESCE_TIMEOUT_MS:-}
      - FOREGROUND_CACHE_COALESCE_MIN_SIZE=${FOREGROUND_CACHE_COALESCE_MIN_SIZE:-}
      - FOREGROUND_CACHE_COALESCE_MAX_ATTEMPTS=${FOREGROUND_CACHE_COALESCE_MAX_ATTEMPTS:-}
      - CACHE_DEFAULT_MAX_AGE=${CACHE_DEFAULT_MAX_AGE:-}
      - CACHE_STABLE_MAX_AGE=${CACHE_STABLE_MAX_AGE:-}
      - CACHE_UNSTABLE_TRUSTED_MAX_AGE=${CACHE_UNSTABLE_TRUSTED_MAX_AGE:-}
      - CACHE_UNSTABLE_MAX_AGE=${CACHE_UNSTABLE_MAX_AGE:-}
      - CACHE_NOT_FOUND_MAX_AGE=${CACHE_NOT_FOUND_MAX_AGE:-}
      - CACHE_BLOCKED_MAX_AGE=${CACHE_BLOCKED_MAX_AGE:-}
      - CACHE_APEX_MAX_AGE=${CACHE_APEX_MAX_AGE:-}
      - CACHE_PRIVATE_CONTENT_TYPES=${CACHE_PRIVATE_CONTENT_TYPES:-}
      - CACHE_PRIVATE_SIZE_THRESHOLD=${CACHE_PRIVATE_SIZE_THRESHOLD:-}
      - TRUSTED_CACHE_RETRY_RATE=${TRUSTED_CACHE_RETRY_RATE:-}
      - UNTRUSTED_CACHE_RETRY_RATE=${UNTRUSTED_CACHE_RETRY_RATE:-}
      - TRUSTED_ARNS_GATEWAY_URL=${TRUSTED_ARNS_GATEWAY_URL:-}
      - TRUSTED_ARNS_RESOLVER_HOST_HEADER=${TRUSTED_ARNS_RESOLVER_HOST_HEADER:-}
      - AR_IO_SDK_LOG_LEVEL=${AR_IO_SDK_LOG_LEVEL:-none}
      - ARNS_RESOLVER_PRIORITY_ORDER=${ARNS_RESOLVER_PRIORITY_ORDER:-}
      - ARNS_COMPOSITE_RESOLVER_TIMEOUT_MS=${ARNS_COMPOSITE_RESOLVER_TIMEOUT_MS:-}
      - ARNS_COMPOSITE_LAST_RESOLVER_TIMEOUT_MS=${ARNS_COMPOSITE_LAST_RESOLVER_TIMEOUT_MS:-}
      - ARNS_CACHED_RESOLUTION_FALLBACK_TIMEOUT_MS=${ARNS_CACHED_RESOLUTION_FALLBACK_TIMEOUT_MS:-}
      - ARNS_RESOLVER_ENFORCE_UNDERNAME_LIMIT=${ARNS_RESOLVER_ENFORCE_UNDERNAME_LIMIT:-}
      - ARNS_RESOLVER_OVERRIDE_TTL_SECONDS=${ARNS_RESOLVER_OVERRIDE_TTL_SECONDS:-}
      - ARWEAVE_NODE_IGNORE_URLS=${ARWEAVE_NODE_IGNORE_URLS:-}
      - ARNS_CACHE_TTL_SECONDS=${ARNS_CACHE_TTL_SECONDS:-}
      - ARNS_CACHE_MAX_KEYS=${ARNS_CACHE_MAX_KEYS:-10000}
      - MANIFEST_RESOLUTION_CACHE_SIZE=${MANIFEST_RESOLUTION_CACHE_SIZE:-}
      - ARNS_CACHE_TYPE=${ARNS_CACHE_TYPE:-redis}
      - ARNS_NAMES_CACHE_TTL_SECONDS=${ARNS_NAMES_CACHE_TTL_SECONDS:-}
      - ARNS_MAX_CONCURRENT_RESOLUTIONS=${ARNS_MAX_CONCURRENT_RESOLUTIONS:-}
      - ARNS_NAME_LIST_CACHE_HIT_REFRESH_INTERVAL_SECONDS=${ARNS_NAME_LIST_CACHE_HIT_REFRESH_INTERVAL_SECONDS:-}
      - ARNS_NAME_LIST_CACHE_MISS_REFRESH_INTERVAL_SECONDS=${ARNS_NAME_LIST_CACHE_MISS_REFRESH_INTERVAL_SECONDS:-}
      - ARNS_NAME_LIST_PAGE_SIZE=${ARNS_NAME_LIST_PAGE_SIZE:-}
      - ARNS_NAME_LIST_MAX_RETRIES=${ARNS_NAME_LIST_MAX_RETRIES:-}
      - ARNS_ANT_STATE_CACHE_HIT_REFRESH_WINDOW_SECONDS=${ARNS_ANT_STATE_CACHE_HIT_REFRESH_WINDOW_SECONDS:-}
      - ARIO_PROCESS_DEFAULT_CIRCUIT_BREAKER_TIMEOUT_MS=${ARIO_PROCESS_DEFAULT_CIRCUIT_BREAKER_TIMEOUT_MS:-}
      - ARIO_PROCESS_DEFAULT_CIRCUIT_BREAKER_ERROR_THRESHOLD_PERCENTAGE=${ARIO_PROCESS_DEFAULT_CIRCUIT_BREAKER_ERROR_THRESHOLD_PERCENTAGE:-}
      - ARIO_PROCESS_DEFAULT_CIRCUIT_BREAKER_ROLLING_COUNT_TIMEOUT_MS=${ARIO_PROCESS_DEFAULT_CIRCUIT_BREAKER_ROLLING_COUNT_TIMEOUT_MS:-}
      - ARIO_PROCESS_DEFAULT_CIRCUIT_BREAKER_RESET_TIMEOUT_MS=${ARIO_PROCESS_DEFAULT_CIRCUIT_BREAKER_RESET_TIMEOUT_MS:-}
      - ENABLE_MEMPOOL_WATCHER=${ENABLE_MEMPOOL_WATCHER:-}
      - ENABLE_DATASETS_ENDPOINT=${ENABLE_DATASETS_ENDPOINT:-}
      - MEMPOOL_POLLING_INTERVAL_MS=${MEMPOOL_POLLING_INTERVAL_MS:-}
      - AWS_ACCESS_KEY_ID=${AWS_ACCESS_KEY_ID:-}
      - AWS_SECRET_ACCESS_KEY=${AWS_SECRET_ACCESS_KEY:-}
      - AWS_REGION=${AWS_REGION:-}
      - AWS_ENDPOINT=${AWS_ENDPOINT:-}
      - TURBO_AWS_REGION=${TURBO_AWS_REGION:-}
      - TURBO_AWS_ENDPOINT=${TURBO_AWS_ENDPOINT:-}
      - TURBO_AWS_ACCESS_KEY_ID=${TURBO_AWS_ACCESS_KEY_ID:-}
      - TURBO_AWS_SECRET_ACCESS_KEY=${TURBO_AWS_SECRET_ACCESS_KEY:-}
      - TURBO_AWS_SESSION_TOKEN=${TURBO_AWS_SESSION_TOKEN:-}
      - AWS_S3_CONTIGUOUS_DATA_BUCKET=${AWS_S3_CONTIGUOUS_DATA_BUCKET:-}
      - AWS_S3_CONTIGUOUS_DATA_PREFIX=${AWS_S3_CONTIGUOUS_DATA_PREFIX:-}
      - AWS_S3_TURBO_CONTIGUOUS_DATA_BUCKET=${AWS_S3_TURBO_CONTIGUOUS_DATA_BUCKET:-}
      - AWS_S3_TURBO_CONTIGUOUS_DATA_PREFIX=${AWS_S3_TURBO_CONTIGUOUS_DATA_PREFIX:-}
      - AWS_SESSION_TOKEN=${AWS_SESSION_TOKEN:-}
      - LEGACY_AWS_S3_CHUNK_DATA_BUCKET=${LEGACY_AWS_S3_CHUNK_DATA_BUCKET:-}
      - LEGACY_AWS_S3_CHUNK_DATA_PREFIX=${LEGACY_AWS_S3_CHUNK_DATA_PREFIX:-}
      - LEGACY_AWS_S3_ACCESS_KEY_ID=${LEGACY_AWS_S3_ACCESS_KEY_ID:-}
      - LEGACY_AWS_S3_SECRET_ACCESS_KEY=${LEGACY_AWS_S3_SECRET_ACCESS_KEY:-}
      - LEGACY_AWS_S3_REGION=${LEGACY_AWS_S3_REGION:-}
      - LEGACY_AWS_S3_ENDPOINT=${LEGACY_AWS_S3_ENDPOINT:-}
      - LEGACY_PSQL_CONNECTION_STRING=${LEGACY_PSQL_CONNECTION_STRING:-}
      - LEGACY_PSQL_PASSWORD_FILE=${LEGACY_PSQL_PASSWORD_FILE:-}
      - LEGACY_PSQL_SSL_REJECT_UNAUTHORIZED=${LEGACY_PSQL_SSL_REJECT_UNAUTHORIZED:-}
      - LEGACY_PSQL_MAX_CONNECTIONS=${LEGACY_PSQL_MAX_CONNECTIONS:-}
      - LEGACY_PSQL_IDLE_TIMEOUT_SECONDS=${LEGACY_PSQL_IDLE_TIMEOUT_SECONDS:-}
      - LEGACY_PSQL_CONNECT_TIMEOUT_SECONDS=${LEGACY_PSQL_CONNECT_TIMEOUT_SECONDS:-}
      - LEGACY_PSQL_MAX_LIFETIME_SECONDS=${LEGACY_PSQL_MAX_LIFETIME_SECONDS:-}
      - LEGACY_PSQL_STATEMENT_TIMEOUT_MS=${LEGACY_PSQL_STATEMENT_TIMEOUT_MS:-}
      - LEGACY_PSQL_IDLE_IN_TRANSACTION_TIMEOUT_MS=${LEGACY_PSQL_IDLE_IN_TRANSACTION_TIMEOUT_MS:-}
      - AWS_DYNAMODB_TURBO_REGION=${AWS_DYNAMODB_TURBO_REGION:-}
      - AWS_DYNAMODB_TURBO_ENDPOINT=${AWS_DYNAMODB_TURBO_ENDPOINT:-}
      - AWS_DYNAMODB_TURBO_ASSUME_ROLE_ARN=${AWS_DYNAMODB_TURBO_ASSUME_ROLE_ARN:-}
      - AWS_DYNAMODB_TURBO_DATA_ITEM_TABLE=${AWS_DYNAMODB_TURBO_DATA_ITEM_TABLE:-}
      - AWS_DYNAMODB_TURBO_OFFSETS_TABLE=${AWS_DYNAMODB_TURBO_OFFSETS_TABLE:-}
      - AWS_ELASTICACHE_TURBO_HOST=${AWS_ELASTICACHE_TURBO_HOST:-}
      - AWS_ELASTICACHE_TURBO_USE_TLS=${AWS_ELASTICACHE_TURBO_USE_TLS:-}
      - AWS_ELASTICACHE_TURBO_PORT=${AWS_ELASTICACHE_TURBO_PORT:-}
      - AR_IO_NODE_RELEASE=${AR_IO_NODE_RELEASE:-86-pre}
      - CHUNK_POST_MIN_SUCCESS_COUNT=${CHUNK_POST_MIN_SUCCESS_COUNT:-}
      - CHUNK_POST_MIN_PREFERRED_SUCCESS_COUNT=${CHUNK_POST_MIN_PREFERRED_SUCCESS_COUNT:-}
      - CHUNK_POST_MAX_CONSECUTIVE_FAILURES=${CHUNK_POST_MAX_CONSECUTIVE_FAILURES:-}
      - CHUNK_POST_CONTINUE_PAST_THRESHOLD=${CHUNK_POST_CONTINUE_PAST_THRESHOLD:-}
      - CHUNK_POST_SORTED_PEERS_CACHE_DURATION_MS=${CHUNK_POST_SORTED_PEERS_CACHE_DURATION_MS:-}
      - CHUNK_POST_RESPONSE_TIMEOUT_MS=${CHUNK_POST_RESPONSE_TIMEOUT_MS:-}
      - CHUNK_POST_ABORT_TIMEOUT_MS=${CHUNK_POST_ABORT_TIMEOUT_MS:-}
      - CHUNK_INGEST_CACHE_ENABLED=${CHUNK_INGEST_CACHE_ENABLED:-}
      - CHUNK_INGEST_CACHE_ALLOWLIST=${CHUNK_INGEST_CACHE_ALLOWLIST:-}
      - CHUNK_INGEST_CONFIRMATION_TIMEOUT_SECONDS=${CHUNK_INGEST_CONFIRMATION_TIMEOUT_SECONDS:-}
      - CHUNK_INGEST_ALLOWLIST_CONFIRMATION_TIMEOUT_SECONDS=${CHUNK_INGEST_ALLOWLIST_CONFIRMATION_TIMEOUT_SECONDS:-}
      - CHUNK_INGEST_MAX_PENDING_BYTES=${CHUNK_INGEST_MAX_PENDING_BYTES:-}
      - CHUNK_INGEST_GC_INTERVAL_MS=${CHUNK_INGEST_GC_INTERVAL_MS:-}
      - CHUNK_INGEST_GC_BATCH_SIZE=${CHUNK_INGEST_GC_BATCH_SIZE:-}
      - CHUNK_INGEST_CONFIRMED_ROOT_RETENTION_SECONDS=${CHUNK_INGEST_CONFIRMED_ROOT_RETENTION_SECONDS:-}
      - CHUNK_REBROADCAST_SOURCES=${CHUNK_REBROADCAST_SOURCES:-}
      - CHUNK_REBROADCAST_RATE_LIMIT_TOKENS=${CHUNK_REBROADCAST_RATE_LIMIT_TOKENS:-}
      - CHUNK_REBROADCAST_RATE_LIMIT_INTERVAL=${CHUNK_REBROADCAST_RATE_LIMIT_INTERVAL:-}
      - CHUNK_REBROADCAST_MAX_CONCURRENT=${CHUNK_REBROADCAST_MAX_CONCURRENT:-}
      - CHUNK_REBROADCAST_DEDUP_TTL_SECONDS=${CHUNK_REBROADCAST_DEDUP_TTL_SECONDS:-}
      - CHUNK_REBROADCAST_MIN_SUCCESS_COUNT=${CHUNK_REBROADCAST_MIN_SUCCESS_COUNT:-}
      - WRITE_ANS104_DATA_ITEM_DB_SIGNATURES=${WRITE_ANS104_DATA_ITEM_DB_SIGNATURES:-}
      - WRITE_TRANSACTION_DB_SIGNATURES=${WRITE_TRANSACTION_DB_SIGNATURES:-}
      - OPTIMISTIC_TX_INDEXING_ENABLED=${OPTIMISTIC_TX_INDEXING_ENABLED:-}
      - OPTIMISTIC_TX_CLEANUP_WAIT_SECONDS=${OPTIMISTIC_TX_CLEANUP_WAIT_SECONDS:-}
      - OPTIMISTIC_TX_MAX_BATCH_SIZE=${OPTIMISTIC_TX_MAX_BATCH_SIZE:-}
      - ENABLE_DATA_DB_WAL_CLEANUP=${ENABLE_DATA_DB_WAL_CLEANUP:-}
      - MAX_DATA_ITEM_QUEUE_SIZE=${MAX_DATA_ITEM_QUEUE_SIZE:-}
      - DATA_ITEM_INDEXER_QUEUE_SIZE=${DATA_ITEM_INDEXER_QUEUE_SIZE:-}
      - DATA_ITEM_INDEXER_WORKER_COUNT=${DATA_ITEM_INDEXER_WORKER_COUNT:-}
      - QUEUE_DATA_ITEM_MAX_BATCH_SIZE=${QUEUE_DATA_ITEM_MAX_BATCH_SIZE:-}
      - QUEUE_DATA_ITEM_BACKPRESSURE_DEPTH=${QUEUE_DATA_ITEM_BACKPRESSURE_DEPTH:-}
      - ANS104_DATA_INDEXER_QUEUE_SIZE=${ANS104_DATA_INDEXER_QUEUE_SIZE:-}
      - GRAPHQL_RESOLVER_DEADLINE_MS=${GRAPHQL_RESOLVER_DEADLINE_MS:-}
      - BUNDLE_DATA_ITEM_DRAIN_BATCH=${BUNDLE_DATA_ITEM_DRAIN_BATCH:-}
      - TAG_SELECTIVITY=${TAG_SELECTIVITY:-}
      - GET_DEBUG_INFO_CACHE_TTL_MS=${GET_DEBUG_INFO_CACHE_TTL_MS:-}
      - MAX_EXPECTED_DATA_ITEM_INDEXING_INTERVAL_SECONDS=${MAX_EXPECTED_DATA_ITEM_INDEXING_INTERVAL_SECONDS:-}
      - ENABLE_BACKGROUND_DATA_VERIFICATION=${ENABLE_BACKGROUND_DATA_VERIFICATION:-}
      - MIN_DATA_VERIFICATION_PRIORITY=${MIN_DATA_VERIFICATION_PRIORITY:-}
      - BACKGROUND_DATA_VERIFICATION_INTERVAL_SECONDS=${BACKGROUND_DATA_VERIFICATION_INTERVAL_SECONDS:-}
      - BACKGROUND_DATA_VERIFICATION_STREAM_TIMEOUT_MS=${BACKGROUND_DATA_VERIFICATION_STREAM_TIMEOUT_MS:-}
      - BACKGROUND_DATA_VERIFICATION_WORKER_COUNT=${BACKGROUND_DATA_VERIFICATION_WORKER_COUNT:-}
      - MAX_VERIFICATION_RETRIES=${MAX_VERIFICATION_RETRIES:-}
      - VERIFICATION_DATA_IMPORTER_QUEUE_SIZE=${VERIFICATION_DATA_IMPORTER_QUEUE_SIZE:-}
      - ENABLE_DATA_ITEM_ROOT_TX_SEARCH=${ENABLE_DATA_ITEM_ROOT_TX_SEARCH:-}
      - ROOT_TX_LOOKUP_ORDER=${ROOT_TX_LOOKUP_ORDER:-}
      - ROOT_TX_CACHE_MAX_SIZE=${ROOT_TX_CACHE_MAX_SIZE:-}
      - ROOT_TX_CACHE_TTL_MS=${ROOT_TX_CACHE_TTL_MS:-}
      - ROOT_TX_INDEX_CIRCUIT_BREAKER_FAILURE_THRESHOLD=${ROOT_TX_INDEX_CIRCUIT_BREAKER_FAILURE_THRESHOLD:-}
      - ROOT_TX_INDEX_CIRCUIT_BREAKER_SUCCESS_THRESHOLD=${ROOT_TX_INDEX_CIRCUIT_BREAKER_SUCCESS_THRESHOLD:-}
      - ROOT_TX_INDEX_CIRCUIT_BREAKER_TIMEOUT_MS=${ROOT_TX_INDEX_CIRCUIT_BREAKER_TIMEOUT_MS:-}
      - CIRCUIT_BREAKER_FAILURE_THRESHOLD=${CIRCUIT_BREAKER_FAILURE_THRESHOLD:-}
      - CIRCUIT_BREAKER_SUCCESS_THRESHOLD=${CIRCUIT_BREAKER_SUCCESS_THRESHOLD:-}
      - CIRCUIT_BREAKER_TIMEOUT_MS=${CIRCUIT_BREAKER_TIMEOUT_MS:-}
      - GET_DATA_CIRCUIT_BREAKER_TIMEOUT_MS=${GET_DATA_CIRCUIT_BREAKER_TIMEOUT_MS:-}
      - TX_METADATA_RESOLVE_CONCURRENCY=${TX_METADATA_RESOLVE_CONCURRENCY:-}
      - TURBO_ENDPOINT=${TURBO_ENDPOINT:-}
      - TURBO_REQUEST_TIMEOUT_MS=${TURBO_REQUEST_TIMEOUT_MS:-}
      - TURBO_REQUEST_RETRY_COUNT=${TURBO_REQUEST_RETRY_COUNT:-}
      - TURBO_ROOT_TX_RATE_LIMIT_BURST_SIZE=${TURBO_ROOT_TX_RATE_LIMIT_BURST_SIZE:-}
      - TURBO_ROOT_TX_RATE_LIMIT_TOKENS_PER_INTERVAL=${TURBO_ROOT_TX_RATE_LIMIT_TOKENS_PER_INTERVAL:-}
      - TURBO_ROOT_TX_RATE_LIMIT_INTERVAL=${TURBO_ROOT_TX_RATE_LIMIT_INTERVAL:-}
      - GATEWAYS_ROOT_TX_URLS=${GATEWAYS_ROOT_TX_URLS:-}
      - GATEWAYS_ROOT_TX_REQUEST_TIMEOUT_MS=${GATEWAYS_ROOT_TX_REQUEST_TIMEOUT_MS:-}
      - GATEWAYS_ROOT_TX_RATE_LIMIT_BURST_SIZE=${GATEWAYS_ROOT_TX_RATE_LIMIT_BURST_SIZE:-}
      - GATEWAYS_ROOT_TX_RATE_LIMIT_TOKENS_PER_INTERVAL=${GATEWAYS_ROOT_TX_RATE_LIMIT_TOKENS_PER_INTERVAL:-}
      - GATEWAYS_ROOT_TX_RATE_LIMIT_INTERVAL=${GATEWAYS_ROOT_TX_RATE_LIMIT_INTERVAL:-}
      - PEERS_ROOT_TX_URLS=${PEERS_ROOT_TX_URLS:-}
      - PEERS_ROOT_TX_REQUEST_TIMEOUT_MS=${PEERS_ROOT_TX_REQUEST_TIMEOUT_MS:-}
      - PEERS_ROOT_TX_RATE_LIMIT_BURST_SIZE=${PEERS_ROOT_TX_RATE_LIMIT_BURST_SIZE:-}
      - PEERS_ROOT_TX_RATE_LIMIT_TOKENS_PER_INTERVAL=${PEERS_ROOT_TX_RATE_LIMIT_TOKENS_PER_INTERVAL:-}
      - PEERS_ROOT_TX_RATE_LIMIT_INTERVAL=${PEERS_ROOT_TX_RATE_LIMIT_INTERVAL:-}
      - GRAPHQL_ON_DEMAND_RESOLUTION_ENABLED=${GRAPHQL_ON_DEMAND_RESOLUTION_ENABLED:-}
      - GRAPHQL_ON_DEMAND_RESOLUTION_MAX_CONCURRENT=${GRAPHQL_ON_DEMAND_RESOLUTION_MAX_CONCURRENT:-}
      - GRAPHQL_ON_DEMAND_RESOLUTION_TIMEOUT_MS=${GRAPHQL_ON_DEMAND_RESOLUTION_TIMEOUT_MS:-}
      - GRAPHQL_ROOT_TX_GATEWAYS_URLS=${GRAPHQL_ROOT_TX_GATEWAYS_URLS:-}
      - GRAPHQL_ROOT_TX_RATE_LIMIT_BURST_SIZE=${GRAPHQL_ROOT_TX_RATE_LIMIT_BURST_SIZE:-}
      - GRAPHQL_ROOT_TX_RATE_LIMIT_TOKENS_PER_INTERVAL=${GRAPHQL_ROOT_TX_RATE_LIMIT_TOKENS_PER_INTERVAL:-}
      - GRAPHQL_ROOT_TX_RATE_LIMIT_INTERVAL=${GRAPHQL_ROOT_TX_RATE_LIMIT_INTERVAL:-}
      - GRAPHQL_ROOT_TX_BATCH_ENABLED=${GRAPHQL_ROOT_TX_BATCH_ENABLED:-}
      - GRAPHQL_ROOT_TX_BATCH_WINDOW_MS=${GRAPHQL_ROOT_TX_BATCH_WINDOW_MS:-}
      - GRAPHQL_ROOT_TX_BATCH_MAX_SIZE=${GRAPHQL_ROOT_TX_BATCH_MAX_SIZE:-}
      - GRAPHQL_ROOT_TX_BATCH_MAX_SIZE_BY_URL=${GRAPHQL_ROOT_TX_BATCH_MAX_SIZE_BY_URL:-}
      - GRAPHQL_ROOT_TX_BATCH_MAX_QUEUE_DEPTH=${GRAPHQL_ROOT_TX_BATCH_MAX_QUEUE_DEPTH:-}
      - GRAPHQL_ROOT_TX_BATCH_TOKEN_MAX_WAIT_MS=${GRAPHQL_ROOT_TX_BATCH_TOKEN_MAX_WAIT_MS:-}
      - GATEWAYS_GQL_URLS=${GATEWAYS_GQL_URLS:-}
      - GATEWAYS_GQL_INCLUDE_LOCAL=${GATEWAYS_GQL_INCLUDE_LOCAL:-}
      - GATEWAYS_GQL_REQUEST_TIMEOUT_MS=${GATEWAYS_GQL_REQUEST_TIMEOUT_MS:-}
      - GATEWAYS_GQL_CIRCUIT_BREAKER_TIMEOUT_MS=${GATEWAYS_GQL_CIRCUIT_BREAKER_TIMEOUT_MS:-}
      - GATEWAYS_GQL_CIRCUIT_BREAKER_ERROR_THRESHOLD_PERCENTAGE=${GATEWAYS_GQL_CIRCUIT_BREAKER_ERROR_THRESHOLD_PERCENTAGE:-}
      - GATEWAYS_GQL_CIRCUIT_BREAKER_ROLLING_COUNT_TIMEOUT_MS=${GATEWAYS_GQL_CIRCUIT_BREAKER_ROLLING_COUNT_TIMEOUT_MS:-}
      - GATEWAYS_GQL_CIRCUIT_BREAKER_RESET_TIMEOUT_MS=${GATEWAYS_GQL_CIRCUIT_BREAKER_RESET_TIMEOUT_MS:-}
      - GATEWAYS_GQL_SOFT_DEADLINE_ENABLED=${GATEWAYS_GQL_SOFT_DEADLINE_ENABLED:-}
      - GATEWAYS_GQL_SOFT_DEADLINE_MS=${GATEWAYS_GQL_SOFT_DEADLINE_MS:-}
      - HYPERBEAM_ENDPOINT=${HYPERBEAM_ENDPOINT:-}
      - HYPERBEAM_REQUEST_TIMEOUT_MS=${HYPERBEAM_REQUEST_TIMEOUT_MS:-}
      - HYPERBEAM_ROOT_TX_RATE_LIMIT_BURST_SIZE=${HYPERBEAM_ROOT_TX_RATE_LIMIT_BURST_SIZE:-}
      - HYPERBEAM_ROOT_TX_RATE_LIMIT_TOKENS_PER_INTERVAL=${HYPERBEAM_ROOT_TX_RATE_LIMIT_TOKENS_PER_INTERVAL:-}
      - HYPERBEAM_ROOT_TX_RATE_LIMIT_INTERVAL=${HYPERBEAM_ROOT_TX_RATE_LIMIT_INTERVAL:-}
      - CDB64_ROOT_TX_INDEX_WATCH=${CDB64_ROOT_TX_INDEX_WATCH:-}
      - CDB64_ROOT_TX_INDEX_SOURCES=${CDB64_ROOT_TX_INDEX_SOURCES:-}
      - CDB64_REMOTE_RETRIEVAL_ORDER=${CDB64_REMOTE_RETRIEVAL_ORDER:-}
      - CDB64_REMOTE_CACHE_MAX_REGIONS=${CDB64_REMOTE_CACHE_MAX_REGIONS:-}
      - CDB64_REMOTE_CACHE_TTL_MS=${CDB64_REMOTE_CACHE_TTL_MS:-}
      - CDB64_REMOTE_REQUEST_TIMEOUT_MS=${CDB64_REMOTE_REQUEST_TIMEOUT_MS:-}
      - CDB64_REMOTE_MAX_CONCURRENT_REQUESTS=${CDB64_REMOTE_MAX_CONCURRENT_REQUESTS:-}
      - CDB64_REMOTE_SEMAPHORE_TIMEOUT_MS=${CDB64_REMOTE_SEMAPHORE_TIMEOUT_MS:-}
      - ENABLE_SAMPLING_DATA_SOURCE=${ENABLE_SAMPLING_DATA_SOURCE:-}
      - SAMPLING_DATA_SOURCE=${SAMPLING_DATA_SOURCE:-}
      - SAMPLING_RATE=${SAMPLING_RATE:-}
      - SAMPLING_STRATEGY=${SAMPLING_STRATEGY:-}
      - ENABLE_PASSTHROUGH_WITHOUT_OFFSETS=${ENABLE_PASSTHROUGH_WITHOUT_OFFSETS:-}
      - CLICKHOUSE_URL=${CLICKHOUSE_URL:-}
      - CLICKHOUSE_USER=${CLICKHOUSE_USER:-}
      - CLICKHOUSE_PASSWORD=${CLICKHOUSE_PASSWORD:-}
      - CLICKHOUSE_SQLITE_MIN_HEIGHT_ENABLED=${CLICKHOUSE_SQLITE_MIN_HEIGHT_ENABLED:-}
      - CLICKHOUSE_SQLITE_MIN_HEIGHT_BUFFER=${CLICKHOUSE_SQLITE_MIN_HEIGHT_BUFFER:-}
      - CLICKHOUSE_MAX_HEIGHT_CACHE_TTL_SECONDS=${CLICKHOUSE_MAX_HEIGHT_CACHE_TTL_SECONDS:-}
      - CLICKHOUSE_QUERY_TIMEOUT_SECONDS=${CLICKHOUSE_QUERY_TIMEOUT_SECONDS:-}
      - CLICKHOUSE_GQL_MAX_ROWS_TO_READ=${CLICKHOUSE_GQL_MAX_ROWS_TO_READ:-}
      - CLICKHOUSE_GQL_DEDUPE_HEADROOM=${CLICKHOUSE_GQL_DEDUPE_HEADROOM:-}
      - CLICKHOUSE_GQL_OWNER_PROJECTION_ROUTING_ENABLED=${CLICKHOUSE_GQL_OWNER_PROJECTION_ROUTING_ENABLED:-}
      - CLICKHOUSE_GQL_ID_LOOKUP_ENABLED=${CLICKHOUSE_GQL_ID_LOOKUP_ENABLED:-}
      - CLICKHOUSE_GQL_OWNER_PROJECTION_ENTITY_TYPES=${CLICKHOUSE_GQL_OWNER_PROJECTION_ENTITY_TYPES:-}
      - GQL_L1_ONLY_ROUTING_FILTER=${GQL_L1_ONLY_ROUTING_FILTER:-}
      - CLICKHOUSE_SQLITE_CIRCUIT_BREAKER_TIMEOUT_MS=${CLICKHOUSE_SQLITE_CIRCUIT_BREAKER_TIMEOUT_MS:-}
      - CLICKHOUSE_SQLITE_CIRCUIT_BREAKER_ERROR_THRESHOLD_PERCENTAGE=${CLICKHOUSE_SQLITE_CIRCUIT_BREAKER_ERROR_THRESHOLD_PERCENTAGE:-}
      - CLICKHOUSE_SQLITE_CIRCUIT_BREAKER_ROLLING_COUNT_TIMEOUT_MS=${CLICKHOUSE_SQLITE_CIRCUIT_BREAKER_ROLLING_COUNT_TIMEOUT_MS:-}
      - CLICKHOUSE_SQLITE_CIRCUIT_BREAKER_RESET_TIMEOUT_MS=${CLICKHOUSE_SQLITE_CIRCUIT_BREAKER_RESET_TIMEOUT_MS:-}
      - CLICKHOUSE_STREAMING_ENABLED=${CLICKHOUSE_STREAMING_ENABLED:-}
      - CLICKHOUSE_STREAMER_BATCH_SIZE=${CLICKHOUSE_STREAMER_BATCH_SIZE:-}
      - CLICKHOUSE_STREAMER_FLUSH_INTERVAL_MS=${CLICKHOUSE_STREAMER_FLUSH_INTERVAL_MS:-}
      - CLICKHOUSE_STREAMER_QUEUE_MAX_SIZE=${CLICKHOUSE_STREAMER_QUEUE_MAX_SIZE:-}
      - CLICKHOUSE_GQL_SKIP_SQLITE_READS=${CLICKHOUSE_GQL_SKIP_SQLITE_READS:-}
      - CLICKHOUSE_SQLITE_FALLBACK_CIRCUIT_BREAKER_TIMEOUT_MS=${CLICKHOUSE_SQLITE_FALLBACK_CIRCUIT_BREAKER_TIMEOUT_MS:-}
      - BUNDLE_DATA_IMPORTER_QUEUE_SIZE=${BUNDLE_DATA_IMPORTER_QUEUE_SIZE:-}
      - FS_CLEANUP_WORKER_BATCH_SIZE=${FS_CLEANUP_WORKER_BATCH_SIZE:-}
      - FS_CLEANUP_WORKER_BATCH_PAUSE_DURATION=${FS_CLEANUP_WORKER_BATCH_PAUSE_DURATION:-}
      - FS_CLEANUP_WORKER_RESTART_PAUSE_DURATION=${FS_CLEANUP_WORKER_RESTART_PAUSE_DURATION:-}
      - FS_CLEANUP_WORKER_WALK_CONCURRENCY=${FS_CLEANUP_WORKER_WALK_CONCURRENCY:-}
      - ENABLE_CHUNK_SYMLINK_CLEANUP=${ENABLE_CHUNK_SYMLINK_CLEANUP:-}
      - CHUNK_SYMLINK_CLEANUP_INTERVAL=${CHUNK_SYMLINK_CLEANUP_INTERVAL:-}
      - BUNDLE_REPAIR_RETRY_INTERVAL_SECONDS=${BUNDLE_REPAIR_RETRY_INTERVAL_SECONDS:-}
      - BUNDLE_REPAIR_RETRY_BATCH_SIZE=${BUNDLE_REPAIR_RETRY_BATCH_SIZE:-}
      - BUNDLE_REPAIR_MAX_RETRY_ATTEMPTS=${BUNDLE_REPAIR_MAX_RETRY_ATTEMPTS:-}
      - BUNDLE_REPAIR_RETRY_COOLDOWN_SECONDS=${BUNDLE_REPAIR_RETRY_COOLDOWN_SECONDS:-}
      - BUNDLE_REPAIR_UPDATE_TIMESTAMPS_INTERVAL_SECONDS=${BUNDLE_REPAIR_UPDATE_TIMESTAMPS_INTERVAL_SECONDS:-}
      - BUNDLE_REPAIR_BACKFILL_INTERVAL_SECONDS=${BUNDLE_REPAIR_BACKFILL_INTERVAL_SECONDS:-}
      - BUNDLE_REPAIR_FILTER_REPROCESS_INTERVAL_SECONDS=${BUNDLE_REPAIR_FILTER_REPROCESS_INTERVAL_SECONDS:-}
      - WEIGHTED_PEERS_TEMPERATURE_DELTA=${WEIGHTED_PEERS_TEMPERATURE_DELTA:-}
      - GATEWAY_PEERS_WEIGHTS_CACHE_DURATION_MS=${GATEWAY_PEERS_WEIGHTS_CACHE_DURATION_MS:-}
      - GATEWAY_PEERS_REQUEST_WINDOW_COUNT=${GATEWAY_PEERS_REQUEST_WINDOW_COUNT:-}
      - PEER_MAX_CONCURRENT_OUTBOUND=${PEER_MAX_CONCURRENT_OUTBOUND:-}
      - PEER_CANDIDATE_COUNT=${PEER_CANDIDATE_COUNT:-}
      - PEER_HEDGE_DELAY_MS=${PEER_HEDGE_DELAY_MS:-}
      - PEER_MAX_HEDGED_REQUESTS=${PEER_MAX_HEDGED_REQUESTS:-}
      - PEER_HASH_RING_VIRTUAL_NODES=${PEER_HASH_RING_VIRTUAL_NODES:-}
      - PEER_HASH_RING_HOME_SET_SIZE=${PEER_HASH_RING_HOME_SET_SIZE:-}
      - APEX_TX_ID=${APEX_TX_ID:-}
      - APEX_ARNS_NAME=${APEX_ARNS_NAME:-}
      - ARNS_NOT_FOUND_TX_ID=${ARNS_NOT_FOUND_TX_ID:-}
      - ARNS_NOT_FOUND_ARNS_NAME=${ARNS_NOT_FOUND_ARNS_NAME:-}
      - PREFERRED_ARNS_NAMES=${PREFERRED_ARNS_NAMES:-}
      - PREFERRED_ARNS_BASE_NAMES=${PREFERRED_ARNS_BASE_NAMES:-}
      - PREFERRED_ARNS_CONTIGUOUS_DATA_CACHE_CLEANUP_THRESHOLD=${PREFERRED_ARNS_CONTIGUOUS_DATA_CACHE_CLEANUP_THRESHOLD:-}
      - PREFERRED_CHUNK_GET_NODE_URLS=${PREFERRED_CHUNK_GET_NODE_URLS:-}
      - PREFERRED_CHUNK_POST_NODE_URLS=${PREFERRED_CHUNK_POST_NODE_URLS:-}
      - PREFERRED_CHUNK_NODE_DNS_RESOLUTION_INTERVAL_SECONDS=${PREFERRED_CHUNK_NODE_DNS_RESOLUTION_INTERVAL_SECONDS:-}
      - CHUNK_POST_QUEUE_DEPTH_THRESHOLD=${CHUNK_POST_QUEUE_DEPTH_THRESHOLD:-}
      - CHUNK_POST_PEER_CONCURRENCY=${CHUNK_POST_PEER_CONCURRENCY:-}
      - CHUNK_POST_PER_NODE_CONCURRENCY=${CHUNK_POST_PER_NODE_CONCURRENCY:-}
      - PEER_REFRESH_CONCURRENCY=${PEER_REFRESH_CONCURRENCY:-}
      - PREFERRED_CHUNK_POST_WEIGHT=${PREFERRED_CHUNK_POST_WEIGHT:-}
      - OTEL_BATCH_LOG_PROCESSOR_SCHEDULED_DELAY_MS=${OTEL_BATCH_LOG_PROCESSOR_SCHEDULED_DELAY_MS:-}
      - OTEL_BATCH_LOG_PROCESSOR_MAX_EXPORT_BATCH_SIZE=${OTEL_BATCH_LOG_PROCESSOR_MAX_EXPORT_BATCH_SIZE:-}
      - OTEL_SERVICE_NAME=${OTEL_SERVICE_NAME:-}
      - OTEL_TRACING_SAMPLING_RATE_DENOMINATOR=${OTEL_TRACING_SAMPLING_RATE_DENOMINATOR:-}
      - OTEL_EXPORTER_OTLP_HEADERS_FILE=${OTEL_EXPORTER_OTLP_HEADERS_FILE:-}
      - OTEL_EXPORTER_OTLP_HEADERS=${OTEL_EXPORTER_OTLP_HEADERS:-}
      - OTEL_RESOURCE_ATTRIBUTES=${OTEL_RESOURCE_ATTRIBUTES:-}
      # Set to http://otel-collector:4318 when using --profile otel, or to external endpoint to bypass collector
      - OTEL_EXPORTER_OTLP_ENDPOINT=${OTEL_EXPORTER_OTLP_ENDPOINT:-}
      # x402 USDC Egress
      - ENABLE_X_402_USDC_DATA_EGRESS=${ENABLE_X_402_USDC_DATA_EGRESS:-}
      - X_402_USDC_NETWORK=${X_402_USDC_NETWORK:-}
      - X_402_USDC_WALLET_ADDRESS=${X_402_USDC_WALLET_ADDRESS:-}
      - X_402_USDC_DATA_EGRESS_MIN_PRICE=${X_402_USDC_DATA_EGRESS_MIN_PRICE:-}
      - X_402_USDC_DATA_EGRESS_MAX_PRICE=${X_402_USDC_DATA_EGRESS_MAX_PRICE:-}
      - X_402_USDC_FACILITATOR_URL=${X_402_USDC_FACILITATOR_URL:-}
      - X_402_USDC_PER_BYTE_PRICE=${X_402_USDC_PER_BYTE_PRICE:-}
      - X_402_CDP_CLIENT_KEY=${X_402_CDP_CLIENT_KEY:-}
      - X_402_SESSION_TOKEN_ENDPOINT=${X_402_SESSION_TOKEN_ENDPOINT:-}
      - X_402_RATE_LIMIT_CAPACITY_MULTIPLIER=${X_402_RATE_LIMIT_CAPACITY_MULTIPLIER:-}
      - X_402_USDC_SETTLE_TIMEOUT_MS=${X_402_USDC_SETTLE_TIMEOUT_MS:-}
      - X_402_APP_NAME=${X_402_APP_NAME:-}
      - X_402_APP_LOGO=${X_402_APP_LOGO:-}
      - CDP_API_KEY_ID=${CDP_API_KEY_ID:-}
      - CDP_API_KEY_SECRET=${CDP_API_KEY_SECRET:-}
      - CDP_API_KEY_SECRET_FILE=${CDP_API_KEY_SECRET_FILE:-}
      - ARWEAVE_POST_DRY_RUN=${ARWEAVE_POST_DRY_RUN:-false}
      - ARWEAVE_POST_DRY_RUN_SKIP_VALIDATION=${ARWEAVE_POST_DRY_RUN_SKIP_VALIDATION:-false}
      - ARWEAVE_PEER_DNS_RECORDS=${ARWEAVE_PEER_DNS_RECORDS:-}
      - ARWEAVE_PEER_DNS_PORT=${ARWEAVE_PEER_DNS_PORT:-}
      - ARWEAVE_NODE_MAX_HEIGHT_LAG=${ARWEAVE_NODE_MAX_HEIGHT_LAG:-}
      - ARWEAVE_NODE_MAX_HEIGHT_LEAD=${ARWEAVE_NODE_MAX_HEIGHT_LEAD:-}
      - ARWEAVE_HEIGHT_MIN_CONSENSUS_COUNT=${ARWEAVE_HEIGHT_MIN_CONSENSUS_COUNT:-}
      - ARWEAVE_NODE_FULL_SYNC_THRESHOLD=${ARWEAVE_NODE_FULL_SYNC_THRESHOLD:-}
      - ARWEAVE_PEER_HEALTH_CHECK_INTERVAL_MS=${ARWEAVE_PEER_HEALTH_CHECK_INTERVAL_MS:-}
      - ARWEAVE_TAG_RESPONSE_HEADERS_ENABLED=${ARWEAVE_TAG_RESPONSE_HEADERS_ENABLED:-}
      - ARWEAVE_TAG_RESPONSE_HEADERS_MAX=${ARWEAVE_TAG_RESPONSE_HEADERS_MAX:-}
      - ARWEAVE_TAG_RESPONSE_HEADERS_MAX_BYTES=${ARWEAVE_TAG_RESPONSE_HEADERS_MAX_BYTES:-}
      - HTTPSIG_ENABLED=${HTTPSIG_ENABLED:-}
      - HTTPSIG_KEY_FILE=${HTTPSIG_KEY_FILE:-}
      - HTTPSIG_BIND_REQUEST=${HTTPSIG_BIND_REQUEST:-}
      # Observer Solana keypair for HTTPSIG signing — accept either a
      # JSON-file path or a base58 64-byte secret (Phantom export form).
      # Setting both is rejected at startup as ambiguous.
      - OBSERVER_KEYPAIR_PATH=${OBSERVER_KEYPAIR_PATH:-}
      - OBSERVER_PRIVATE_KEY=${OBSERVER_PRIVATE_KEY:-}
    ulimits:
      nofile:
        soft: 65536
        hard: 65536
    networks:
      - ar-io-network
    depends_on:
      - redis
    labels:
      autoheal: ${RUN_AUTOHEAL:-false}

  redis:
    image: redis:${REDIS_IMAGE_TAG:-7}
    command: redis-server --maxmemory ${REDIS_MAX_MEMORY:-256mb} --maxmemory-policy allkeys-lru ${EXTRA_REDIS_FLAGS:---save "" --appendonly no}
    restart: unless-stopped
    ports:
      - '6379' # don't expose redis externally by default
    volumes:
      - ${REDIS_DATA_PATH:-./data/redis}:/data
    networks:
      - ar-io-network

  otel-collector:
    image: otel/opentelemetry-collector-contrib:${OTEL_COLLECTOR_IMAGE_TAG:-0.119.0}
    profiles:
      - otel
    restart: unless-stopped
    ports:
      - '4317' # gRPC OTLP receiver (don't expose externally by default)
      - '4318' # HTTP OTLP receiver (don't expose externally by default)
    volumes:
      - ./otel/collector-config.yaml:/etc/otel/config.yaml:ro
    environment:
      # Destination endpoint for sampled traces
      - OTEL_COLLECTOR_DESTINATION_ENDPOINT=${OTEL_COLLECTOR_DESTINATION_ENDPOINT:-}
      # Backend API keys (configure ONE based on your telemetry backend)
      - OTEL_COLLECTOR_HONEYCOMB_API_KEY=${OTEL_COLLECTOR_HONEYCOMB_API_KEY:-}
      - OTEL_COLLECTOR_GRAFANA_CLOUD_API_KEY=${OTEL_COLLECTOR_GRAFANA_CLOUD_API_KEY:-}
      - OTEL_COLLECTOR_DATADOG_API_KEY=${OTEL_COLLECTOR_DATADOG_API_KEY:-}
      - OTEL_COLLECTOR_NEW_RELIC_API_KEY=${OTEL_COLLECTOR_NEW_RELIC_API_KEY:-}
      - OTEL_COLLECTOR_ELASTIC_API_KEY=${OTEL_COLLECTOR_ELASTIC_API_KEY:-}
      # Tail sampling configuration
      - OTEL_TAIL_SAMPLING_SUCCESS_RATE=${OTEL_TAIL_SAMPLING_SUCCESS_RATE:-1}
      - OTEL_TAIL_SAMPLING_SLOW_THRESHOLD_MS=${OTEL_TAIL_SAMPLING_SLOW_THRESHOLD_MS:-2000}
      - OTEL_TAIL_SAMPLING_ERROR_RATE=${OTEL_TAIL_SAMPLING_ERROR_RATE:-100}
      - OTEL_TAIL_SAMPLING_SLOW_RATE=${OTEL_TAIL_SAMPLING_SLOW_RATE:-100}
      - OTEL_TAIL_SAMPLING_PAID_TRAFFIC_RATE=${OTEL_TAIL_SAMPLING_PAID_TRAFFIC_RATE:-100}
      - OTEL_TAIL_SAMPLING_PAID_TOKENS_RATE=${OTEL_TAIL_SAMPLING_PAID_TOKENS_RATE:-100}
      - OTEL_TAIL_SAMPLING_NESTED_BUNDLE_RATE=${OTEL_TAIL_SAMPLING_NESTED_BUNDLE_RATE:-5}
      - OTEL_TAIL_SAMPLING_OFFSET_OVERWRITE_RATE=${OTEL_TAIL_SAMPLING_OFFSET_OVERWRITE_RATE:-10}
    command: ['--config=/etc/otel/config.yaml']
    networks:
      - ar-io-network

  clickhouse:
    image: clickhouse/clickhouse-server:${CLICKHOUSE_IMAGE_TAG:-26.3}
    profiles:
      - clickhouse
    # Without this the container defaults to `restart: no`, so a host reboot
    # or a Docker daemon restart brings every other service back and leaves
    # ClickHouse down. With CLICKHOUSE_STREAMING_ENABLED=true that takes the
    # gateway with it: core's boot fails in `clickhouseStreamer.start()` with
    # `getaddrinfo ENOTFOUND clickhouse` before `app.listen()` runs. Core now
    # exits and restart-loops in that case rather than sitting there with no
    # HTTP listener (see `markStartupComplete` in src/system.ts), so this
    # policy is what actually gets the pair back up; without it core just
    # loops against a ClickHouse that is never coming back on its own.
    restart: unless-stopped
    ports:
      - ${CLICKHOUSE_PORT_2:-8123}:8123
      - ${CLICKHOUSE_PORT_3:-8443}:8443
      - ${CLICKHOUSE_PORT:-9000}:9000
    ulimits:
      nofile:
        soft: 262144
        hard: 262144
    volumes:
      - ${CLICKHOUSE_DATA_PATH:-./data/clickhouse}:/var/lib/clickhouse
      - ${CLICKHOUSE_LOGS_PATH:-./logs/clickhouse}:/var/log/clickhouse-server
    environment:
      - CLICKHOUSE_USER=${CLICKHOUSE_USER:-}
      - CLICKHOUSE_PASSWORD=${CLICKHOUSE_PASSWORD:-}
    networks:
      - ar-io-network

  clickhouse-auto-import:
    image: ghcr.io/ar-io/ar-io-clickhouse-auto-import:${CLICKHOUSE_AUTO_IMPORT_IMAGE_TAG:-latest}
    profiles:
      - clickhouse
    build:
      context: .
      dockerfile: Dockerfile.clickhouse-auto-import
    restart: unless-stopped
    volumes:
      - ${PARQUET_DATA_PATH:-./data/parquet}:/app/data/parquet
      - ${SQLITE_DATA_PATH:-./data/sqlite}:/app/data/sqlite:ro
      - ${LOCAL_DATASETS_PATH:-./data/datasets}:/app/data/datasets
      - ${ETL_STAGING_PATH:-./data/etl/staging}:/app/data/etl/staging
      - ${CLICKHOUSE_TTL_RULES_PATH:-./config/clickhouse-ttl-rules.yaml}:/app/config/clickhouse-ttl-rules.yaml:ro
    environment:
      - DEBUG=${CLICKHOUSE_DEBUG:-}
      - AR_IO_HOST=core
      - AR_IO_PORT=4000
      - ADMIN_API_KEY=${ADMIN_API_KEY:-}
      - CLICKHOUSE_HOST=${CLICKHOUSE_HOST:-clickhouse} # defaults to localhost in scripts
      - CLICKHOUSE_PORT=${CLICKHOUSE_PORT:-} # defaults to 9000 in scripts
      - CLICKHOUSE_USER=${CLICKHOUSE_USER:-} # defaults to 'default' in scripts
      - CLICKHOUSE_PASSWORD=${CLICKHOUSE_PASSWORD:-} # must be set, no default
      - LOCAL_DATASETS_PATH=/app/data/datasets
      - ETL_STAGING_PATH=/app/data/etl/staging
      - ARNS_ROOT_HOST=${ARNS_ROOT_HOST:-}
      - CLICKHOUSE_AUTO_IMPORT_SLEEP_INTERVAL=${CLICKHOUSE_AUTO_IMPORT_SLEEP_INTERVAL:-}
      - CLICKHOUSE_AUTO_IMPORT_HEIGHT_INTERVAL=${CLICKHOUSE_AUTO_IMPORT_HEIGHT_INTERVAL:-}
      - CLICKHOUSE_AUTO_IMPORT_MAX_ROWS_PER_FILE=${CLICKHOUSE_AUTO_IMPORT_MAX_ROWS_PER_FILE:-}
      - CLICKHOUSE_AUTO_IMPORT_IDLE_WAIT_TIMEOUT_S=${CLICKHOUSE_AUTO_IMPORT_IDLE_WAIT_TIMEOUT_S:-}
      - CLICKHOUSE_AUTO_IMPORT_EXPORT_MAX_RETRIES=${CLICKHOUSE_AUTO_IMPORT_EXPORT_MAX_RETRIES:-}
      - CLICKHOUSE_AUTO_IMPORT_EXPORT_RETRY_DELAY_S=${CLICKHOUSE_AUTO_IMPORT_EXPORT_RETRY_DELAY_S:-}
      - CLICKHOUSE_AUTO_IMPORT_DEBUG_RETRY_WINDOW_S=${CLICKHOUSE_AUTO_IMPORT_DEBUG_RETRY_WINDOW_S:-}
      - CLICKHOUSE_IMPORT_SKIP_UNCHANGED=${CLICKHOUSE_IMPORT_SKIP_UNCHANGED:-}
      - CLICKHOUSE_TTL_RULES_PATH=/app/config/clickhouse-ttl-rules.yaml
      # Read by scripts/clickhouse-import at schema-render time (not by the
      # gateway runtime), so it lives on this service rather than on core.
      - CLICKHOUSE_NEW_TX_TTL_MINUTES=${CLICKHOUSE_NEW_TX_TTL_MINUTES:-}
    networks:
      - ar-io-network
    depends_on:
      - core
      - clickhouse

  observer:
    image: ghcr.io/ar-io/ar-io-observer:${OBSERVER_IMAGE_TAG:-c5e98ddcf567598358fa73a0852b6be2cbbd42c4}
    restart: unless-stopped
    ports:
      - ${OBSERVER_PORT:-5050}:5050
    volumes:
      - ${TEMP_DATA_PATH:-./data/tmp}:/app/data/tmp
      - ${REPORTS_DATA_PATH:-./data/reports}:/app/data/reports
      - ${WALLETS_PATH:-./wallets}:/app/wallets
      - ${OBSERVER_STATE_PATH:-./data/observer}:/app/data/observer
    environment:
      - LOG_LEVEL=${OBSERVER_LOG_LEVEL:-}
      - OBSERVER_WALLET=${OBSERVER_WALLET:-}
      # AR.IO Network backend — see core service for full docs.
      - SOLANA_RPC_URL=${SOLANA_RPC_URL:-}
      - ARIO_CORE_PROGRAM_ID=${ARIO_CORE_PROGRAM_ID:-73YoECm6NKXpVRoe5f1Q9BcP5DJGPFUjnFy6AxBE5Nvh}
      - ARIO_GAR_PROGRAM_ID=${ARIO_GAR_PROGRAM_ID:-89fNiiwgpFSPHKuqfNUkgYTYjtAJAhyqHjXmgXeppGpf}
      - ARIO_ARNS_PROGRAM_ID=${ARIO_ARNS_PROGRAM_ID:-2yCUx5edFvUrkibYaUa2ZXWyx9kuJkS8CwyzsgHPWdZZ}
      - ARIO_ANT_PROGRAM_ID=${ARIO_ANT_PROGRAM_ID:-2MWexMHfMhGJwMHv9Qm9YAVCqjUFUJwDJAysW4oCUGk5}
      # Cranker (Solana-only). When unset, observer skips cranking.
      - ENABLE_EPOCH_CRANKING=${ENABLE_EPOCH_CRANKING:-}
      - ENABLE_CLEANUP=${ENABLE_CLEANUP:-}
      # Cranker cadence. Both are optional: left empty the observer derives
      # them from the epoch duration (see the observer's
      # `src/epoch/adaptive-intervals.ts`); an explicit value always wins.
      # Empty is safe — the observer's `varOrUndefined` treats a blank env
      # var as unset rather than feeding '' to the positive-integer check.
      - CRANK_POLL_INTERVAL_MS=${CRANK_POLL_INTERVAL_MS:-}
      - CLEANUP_MIN_INTERVAL_MS=${CLEANUP_MIN_INTERVAL_MS:-}
      - CLEANUP_TO_RETURNED_TXS_PER_CYCLE=${CLEANUP_TO_RETURNED_TXS_PER_CYCLE:-}
      - CRANK_BATCH_SIZE=${CRANK_BATCH_SIZE:-}
      - CRANK_CLOSE_EPOCHS=${CRANK_CLOSE_EPOCHS:-}
      - CRANK_EPOCH_RETENTION=${CRANK_EPOCH_RETENTION:-}
      - CRANK_WARN_BALANCE_SOL=${CRANK_WARN_BALANCE_SOL:-}
      - CRANK_CRITICAL_BALANCE_SOL=${CRANK_CRITICAL_BALANCE_SOL:-}
      - CLEANUP_BATCH_SIZE=${CLEANUP_BATCH_SIZE:-}
      - CLEANUP_FAILURE_THRESHOLD=${CLEANUP_FAILURE_THRESHOLD:-}
      - MAX_CLEANUP_TXS_PER_CYCLE=${MAX_CLEANUP_TXS_PER_CYCLE:-}
      - ALT_RECLAIM_SCAN_LIMIT=${ALT_RECLAIM_SCAN_LIMIT:-}
      - OBSERVED_GATEWAY_HOSTS=${OBSERVED_GATEWAY_HOSTS:-}
      # Solana wallet identities (operator/observer/upload). All four
      # supported configurations are documented in the observer's
      # `src/wallet-config.ts`. Each role accepts EITHER a JSON-file path
      # (`*_KEYPAIR_PATH`) OR a base58 64-byte secret (`*_PRIVATE_KEY`,
      # Phantom export form). Setting both for the same role is rejected
      # as ambiguous. Operator key is required in solana mode; the others
      # are optional fallbacks.
      - SOLANA_KEYPAIR_PATH=${SOLANA_KEYPAIR_PATH:-}
      - SOLANA_PRIVATE_KEY=${SOLANA_PRIVATE_KEY:-}
      - OBSERVER_KEYPAIR_PATH=${OBSERVER_KEYPAIR_PATH:-}
      - OBSERVER_PRIVATE_KEY=${OBSERVER_PRIVATE_KEY:-}
      - SOLANA_UPLOAD_KEYPAIR_PATH=${SOLANA_UPLOAD_KEYPAIR_PATH:-}
      - SOLANA_UPLOAD_PRIVATE_KEY=${SOLANA_UPLOAD_PRIVATE_KEY:-}
      - ARWEAVE_UPLOAD_KEY_FILE=${ARWEAVE_UPLOAD_KEY_FILE:-}
      - ARWEAVE_UPLOAD_JWK=${ARWEAVE_UPLOAD_JWK:-}
      # Ethereum upload identity (alternative to Arweave/Solana for
      # signing observation-report bundles before Turbo upload). Either
      # set the FILE path or the inline hex value; setting BOTH chains
      # at once raises a startup error. See wallet-config.ts precedence.
      - ETHEREUM_UPLOAD_PRIVATE_KEY_FILE=${ETHEREUM_UPLOAD_PRIVATE_KEY_FILE:-}
      - ETHEREUM_UPLOAD_PRIVATE_KEY=${ETHEREUM_UPLOAD_PRIVATE_KEY:-}
      - SUBMIT_CONTRACT_INTERACTIONS=${SUBMIT_CONTRACT_INTERACTIONS:-true}
      - NUM_ARNS_NAMES_TO_OBSERVE_PER_GROUP=${NUM_ARNS_NAMES_TO_OBSERVE_PER_GROUP:-8}
      - REPORT_GENERATION_INTERVAL_MS=${REPORT_GENERATION_INTERVAL_MS:-}
      - REPORT_DATA_SINK=${REPORT_DATA_SINK:-}
      - TURBO_UPLOAD_SERVICE_URL=${TURBO_UPLOAD_SERVICE_URL:-}
      - RUN_OBSERVER=${RUN_OBSERVER:-true}
      - MIN_RELEASE_NUMBER=${MIN_RELEASE_NUMBER:-0}
      - AR_IO_NODE_RELEASE=${AR_IO_NODE_RELEASE:-86-pre}
      - AR_IO_SDK_LOG_LEVEL=${AR_IO_SDK_LOG_LEVEL:-none}
      # Reference Gateway Configuration
      # The bundled observer references THIS node's own gateway by default (its
      # ARNS_ROOT_HOST), rather than external gateways. Since the gateway now
      # resolves ArNS on-demand (authoritatively, from chain), self-reference is
      # both authoritative and more decentralized — the observer forms its own
      # chain-derived view and the protocol aggregates observers by majority.
      # Falls back to the observer's own default (turbo/ar-io.net) if neither
      # REFERENCE_GATEWAY_HOSTS nor ARNS_ROOT_HOST is set.
      - REFERENCE_GATEWAY_HOSTS=${REFERENCE_GATEWAY_HOSTS:-${ARNS_ROOT_HOST:-}}
      - REFERENCE_GATEWAY_NETWORK_ONLY=${REFERENCE_GATEWAY_NETWORK_ONLY:-}
      - REFERENCE_GATEWAY_NETWORK_FALLBACK=${REFERENCE_GATEWAY_NETWORK_FALLBACK:-}
      - REFERENCE_GATEWAY_CONSENSUS_SIZE=${REFERENCE_GATEWAY_CONSENSUS_SIZE:-}
      - REFERENCE_GATEWAY_CONSENSUS_THRESHOLD=${REFERENCE_GATEWAY_CONSENSUS_THRESHOLD:-}
      - REFERENCE_GATEWAY_MIN_PASS_RATE=${REFERENCE_GATEWAY_MIN_PASS_RATE:-}
      - REFERENCE_GATEWAY_MIN_CONSECUTIVE_PASSES=${REFERENCE_GATEWAY_MIN_CONSECUTIVE_PASSES:-}
      - REFERENCE_GATEWAY_MIN_EPOCH_COUNT=${REFERENCE_GATEWAY_MIN_EPOCH_COUNT:-}
      - REFERENCE_GATEWAY_MAX_NETWORK_POOL=${REFERENCE_GATEWAY_MAX_NETWORK_POOL:-}
      - REFERENCE_GATEWAY_NETWORK_CACHE_TTL_SECONDS=${REFERENCE_GATEWAY_NETWORK_CACHE_TTL_SECONDS:-}
      - REFERENCE_GATEWAY_CONSENSUS_MAX_ATTEMPTS=${REFERENCE_GATEWAY_CONSENSUS_MAX_ATTEMPTS:-}
      # Continuous Observation Configuration
      - OBSERVATIONS_PER_GATEWAY=${OBSERVATIONS_PER_GATEWAY:-}
      - OBSERVATION_WINDOW_FRACTION=${OBSERVATION_WINDOW_FRACTION:-}
      - OBSERVATION_CYCLE_INTERVAL_MS=${OBSERVATION_CYCLE_INTERVAL_MS:-}
      - MAJORITY_VOTE_THRESHOLD=${MAJORITY_VOTE_THRESHOLD:-}
      # Per-cycle assessment parallelism (gateway + ArNS-name probes). Without
      # these the observer falls back to its built-in defaults regardless of
      # the .env value — see ar-io-observer src/config.ts.
      - GATEWAY_ASSESSMENT_CONCURRENCY=${GATEWAY_ASSESSMENT_CONCURRENCY:-}
      - NAME_ASSESSMENT_CONCURRENCY=${NAME_ASSESSMENT_CONCURRENCY:-}
      # Enable the LogReportSink — logs full per-gateway assessment detail at
      # info level (off by default).
      - ENABLE_LOG_REPORT_SINK=${ENABLE_LOG_REPORT_SINK:-}
      # Epoch-relative submission window (defaults tuned for mainnet's ~24h
      # epochs; shorter-epoch networks like devnet must shrink these or the
      # observer rejects with "Epoch duration too short for configured buffers").
      - OBSERVATION_STABILITY_BUFFER_MS=${OBSERVATION_STABILITY_BUFFER_MS:-}
      - OBSERVATION_SUBMISSION_BUFFER_MS=${OBSERVATION_SUBMISSION_BUFFER_MS:-}
      # Maximum fraction of failed gateways before the report-sink circuit
      # breaker refuses to submit. Default `0.8` is production-safe; on
      # devnet (where most registered gateways are stubs that don't serve
      # HTTP) `1.0` effectively disables the gate so the honest "all-
      # failed" report can still ship — required for a freshly-joined
      # devnet observer to ever increment its observerPerformanceRatio.
      # See ar-io-observer src/config.ts OBSERVER_MAX_GATEWAY_FAILURE_
      # THRESHOLD for context.
      - OBSERVER_MAX_GATEWAY_FAILURE_THRESHOLD=${OBSERVER_MAX_GATEWAY_FAILURE_THRESHOLD:-}
      # Offset (chunk-proof) observation: a sampled share of gateways must
      # serve /chunk/<offset> with a Merkle proof that validates against the
      # chain. Set OFFSET_OBSERVATION_ENFORCEMENT_ENABLED=false to report
      # failures without failing gateways. See docs/envs.md.
      - OFFSET_OBSERVATION_SAMPLE_RATE=${OFFSET_OBSERVATION_SAMPLE_RATE:-}
      - OFFSET_SAMPLE_COUNT=${OFFSET_SAMPLE_COUNT:-}
      - OFFSET_OBSERVATION_ENABLED=${OFFSET_OBSERVATION_ENABLED:-}
      - OFFSET_OBSERVATION_ENFORCEMENT_ENABLED=${OFFSET_OBSERVATION_ENFORCEMENT_ENABLED:-}
    networks:
      - ar-io-network

  litestream:
    image: ghcr.io/ar-io/ar-io-litestream:${LITESTREAM_IMAGE_TAG:-latest}
    build:
      context: litestream/
      dockerfile: Dockerfile
    profiles:
      - litestream
    # Same reason as the clickhouse service above: continuous SQLite
    # replication that does not come back after a reboot is a backup that
    # silently stops, which is only discovered when a restore is needed.
    restart: unless-stopped
    volumes:
      - ${SQLITE_DATA_PATH:-./data/sqlite}:/app/data/sqlite
    environment:
      - TVAL_AR_IO_SQLITE_BACKUP_S3_BUCKET_NAME=${AR_IO_SQLITE_BACKUP_S3_BUCKET_NAME:-}
      - TVAL_AR_IO_SQLITE_BACKUP_S3_BUCKET_REGION=${AR_IO_SQLITE_BACKUP_S3_BUCKET_REGION:-}
      - TVAL_AR_IO_SQLITE_BACKUP_S3_BUCKET_ACCESS_KEY=${AR_IO_SQLITE_BACKUP_S3_BUCKET_ACCESS_KEY:-}
      - TVAL_AR_IO_SQLITE_BACKUP_S3_BUCKET_SECRET_KEY=${AR_IO_SQLITE_BACKUP_S3_BUCKET_SECRET_KEY:-}
      - TVAL_AR_IO_SQLITE_BACKUP_S3_BUCKET_PREFIX=${AR_IO_SQLITE_BACKUP_S3_BUCKET_PREFIX:-}
    networks:
      - ar-io-network

  # Publishes the index artifacts this gateway offers, and subscribes to those
  # published by other gateways, installing and retiring bands under the
  # running node. Runs by default: with INDEX_SWARM_SUBSCRIBE unset it takes
  # the ar.io publisher's root-TX bands (INDEX_SWARM_SUBSCRIBE=[] opts out).
  # The old `--profile index-swarm` flag is still accepted, and does nothing.
  #
  # Runs the core image rather than one of its own: the sidecar is compiled
  # into the same dist/ tree and needs no dependency core does not already
  # have, so a separate image would be roughly a gigabyte of duplicate layers
  # per operator for code that is already present.
  index-swarm:
    image: ghcr.io/ar-io/ar-io-core:${CORE_IMAGE_TAG:-latest}
    build:
      context: .
    entrypoint: ['/nodejs/bin/node', 'dist/index-swarm/main.js']
    restart: unless-stopped
    # Proper PID 1, so signals reach the process and exited children are
    # reaped. Without it a wedged process cannot be stopped without a kill,
    # which is how a band install gets left half-written.
    init: true
    stop_grace_period: 30s
    # Deliberately no depends_on. The sidecar shares only a volume with the
    # gateway and works whether or not it is up, and a dependency here would
    # mean bringing this profile up could start or recreate core.
    # The closed tracker's direct port, which only a publisher of torrents
    # listens on. Published on loopback by default, so a subscriber (the
    # default role) exposes nothing: announces normally reach the tracker
    # through the gateway's HTTPS (/ar-io/indexes/announce, forwarded by Envoy
    # to INDEX_SWARM_TRACKER_PROXY_PORT, which is never published). A
    # publisher whose torrents announce to this port directly sets
    # INDEX_SWARM_TRACKER_HOST_IP=0.0.0.0.
    ports:
      - '${INDEX_SWARM_TRACKER_HOST_IP:-127.0.0.1}:${INDEX_SWARM_TRACKER_PORT:-6969}:${INDEX_SWARM_TRACKER_PORT:-6969}/tcp'
    volumes:
      - ${INDEX_SWARM_DATA_PATH:-./data/indexes}:/app/data/indexes
      # Only the observer keypair, and only when it is kept in a file: the
      # sidecar fetches documents from other gateways, so it sees no other
      # key material (no wallets directory, no report-upload keys). With
      # OBSERVER_PRIVATE_KEY instead, nothing is mounted.
      - ${INDEX_SWARM_OBSERVER_KEYPAIR_FILE:-/dev/null}:/app/keys/observer.json:ro
    environment:
      - NODE_ENV=${NODE_ENV:-production}
      - INDEX_SWARM_LOG_LEVEL=${INDEX_SWARM_LOG_LEVEL:-info}
      - INDEX_SWARM_LOG_FORMAT=${INDEX_SWARM_LOG_FORMAT:-simple}
      - INDEX_SWARM_DATA_DIR=/app/data/indexes
      - INDEX_SWARM_PUBLISH=${INDEX_SWARM_PUBLISH:-}
      - INDEX_SWARM_SUBSCRIBE=${INDEX_SWARM_SUBSCRIBE:-}
      - INDEX_SWARM_TRUSTED_PUBLISHERS=${INDEX_SWARM_TRUSTED_PUBLISHERS:-}
      - INDEX_SWARM_ALLOWED_FILE_ORIGINS=${INDEX_SWARM_ALLOWED_FILE_ORIGINS:-}
      - INDEX_SWARM_PUBLISH_SCAN_INTERVAL_SECONDS=${INDEX_SWARM_PUBLISH_SCAN_INTERVAL_SECONDS:-}
      - INDEX_SWARM_PUBLISH_TTL_SECONDS=${INDEX_SWARM_PUBLISH_TTL_SECONDS:-}
      - INDEX_SWARM_SUPERSEDE_GRACE_SECONDS=${INDEX_SWARM_SUPERSEDE_GRACE_SECONDS:-}
      - INDEX_SWARM_POLL_INTERVAL_SECONDS=${INDEX_SWARM_POLL_INTERVAL_SECONDS:-}
      - INDEX_SWARM_MANIFEST_FETCH_TIMEOUT_MS=${INDEX_SWARM_MANIFEST_FETCH_TIMEOUT_MS:-}
      - INDEX_SWARM_DOWNLOAD_STALL_TIMEOUT_SECONDS=${INDEX_SWARM_DOWNLOAD_STALL_TIMEOUT_SECONDS:-}
      - INDEX_SWARM_DOWNLOAD_CONCURRENCY=${INDEX_SWARM_DOWNLOAD_CONCURRENCY:-}
      # Unset: 64 GiB with the default subscription (INDEX_SWARM_SUBSCRIBE
      # unset), no ceiling with an explicit one (see envs.md); 0 is no ceiling.
      - INDEX_SWARM_MAX_DISK_BYTES=${INDEX_SWARM_MAX_DISK_BYTES:-}
      - INDEX_SWARM_DOWNLOAD_RATE_LIMIT_BYTES_PER_SEC=${INDEX_SWARM_DOWNLOAD_RATE_LIMIT_BYTES_PER_SEC:-}
      - INDEX_SWARM_REGISTRY_CACHE_TTL_SECONDS=${INDEX_SWARM_REGISTRY_CACHE_TTL_SECONDS:-}
      # The swarm tier, on by default: the URL defaults to the compose engine
      # once there is a password, INDEX_SWARM_ENGINE_AUTH or, unset, the one
      # index-swarm-engine-init generates into data/indexes/engine-auth.
      - INDEX_SWARM_ENGINE_URL=${INDEX_SWARM_ENGINE_URL:-}
      - INDEX_SWARM_ENGINE_AUTH=${INDEX_SWARM_ENGINE_AUTH:-}
      - INDEX_SWARM_TRACKERS=${INDEX_SWARM_TRACKERS:-}
      - INDEX_SWARM_ALLOWED_TRACKERS=${INDEX_SWARM_ALLOWED_TRACKERS:-}
      - INDEX_SWARM_ENGINE_BLOCK_PRIVATE=${INDEX_SWARM_ENGINE_BLOCK_PRIVATE:-true}
      - INDEX_SWARM_TRACKER_PORT=${INDEX_SWARM_TRACKER_PORT:-6969}
      # Read only to warn when torrents announce to a port bound to loopback.
      - INDEX_SWARM_TRACKER_HOST_IP=${INDEX_SWARM_TRACKER_HOST_IP:-127.0.0.1}
      - INDEX_SWARM_TRACKER_PROXY_PORT=${INDEX_SWARM_TRACKER_PROXY_PORT:-6970}
      - INDEX_SWARM_TRACKER_TRUSTED_PROXIES=${INDEX_SWARM_TRACKER_TRUSTED_PROXIES:-}
      - INDEX_SWARM_TRACKER_PROXY_TRUSTED_PROXIES=${INDEX_SWARM_TRACKER_PROXY_TRUSTED_PROXIES:-}
      - INDEX_SWARM_ENGINE_PUBLIC_HOST=${INDEX_SWARM_ENGINE_PUBLIC_HOST:-}
      - INDEX_SWARM_ENGINE_PORT=${INDEX_SWARM_ENGINE_PORT:-6881}
      - INDEX_SWARM_UPLOAD_LIMIT_BYTES_PER_SEC=${INDEX_SWARM_UPLOAD_LIMIT_BYTES_PER_SEC:-10000000}
      - INDEX_SWARM_UPLOAD_DAILY_LIMIT_BYTES=${INDEX_SWARM_UPLOAD_DAILY_LIMIT_BYTES:-100000000000}
      - INDEX_SWARM_TORRENT_TIMEOUT_SECONDS=${INDEX_SWARM_TORRENT_TIMEOUT_SECONDS:-}
      - INDEX_SWARM_WEBSEED_AFTER_SECONDS=${INDEX_SWARM_WEBSEED_AFTER_SECONDS:-}
      - INDEX_SWARM_ENGINE_UID=${INDEX_SWARM_ENGINE_UID:-1000}
      - INDEX_SWARM_ENGINE_GID=${INDEX_SWARM_ENGINE_GID:-1000}
      # Identity, shared with the gateway. Registry records come from the
      # gateway's /ar-io/peers, so the sidecar needs no RPC settings.
      - AR_IO_WALLET=${AR_IO_WALLET:-}
      - INDEX_SWARM_METRICS_PORT=${INDEX_SWARM_METRICS_PORT:-9101}
      - INDEX_SWARM_METRICS_HOST=${INDEX_SWARM_METRICS_HOST:-0.0.0.0}
      - INDEX_SWARM_CORE_URL=${INDEX_SWARM_CORE_URL:-http://core:4000}
      - INDEX_SWARM_MIN_CORE_RELEASE=${INDEX_SWARM_MIN_CORE_RELEASE:-}
      - INDEX_SWARM_SHUTDOWN_TIMEOUT_MS=${INDEX_SWARM_SHUTDOWN_TIMEOUT_MS:-}
      # The signing identity is the gateway's registered observer key, read
      # only: the sidecar signs what it publishes and never writes key material.
      # A keypair file comes in through the single-file mount above, so the
      # gateway's own OBSERVER_KEYPAIR_PATH (a path inside its wallets
      # directory) is not used here.
      # Set INDEX_SWARM_OBSERVER_KEYPAIR_FILE or OBSERVER_PRIVATE_KEY, not
      # both: with both, publishing refuses to start.
      - OBSERVER_KEYPAIR_PATH=${INDEX_SWARM_OBSERVER_KEYPAIR_FILE:+/app/keys/observer.json}
      - OBSERVER_PRIVATE_KEY=${OBSERVER_PRIVATE_KEY:-}
    # The runtime image is distroless and carries no shell utilities beyond
    # sh and mkdir, so the check runs through node.
    healthcheck:
      test:
        [
          'CMD',
          '/nodejs/bin/node',
          '-e',
          "fetch('http://127.0.0.1:${INDEX_SWARM_METRICS_PORT:-9101}/healthz').then(r=>process.exit(r.ok?0:1),()=>process.exit(1))",
        ]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 15s
    # Docker's json-file driver is unbounded by default, which on a long-lived
    # gateway quietly fills the disk holding /var/lib/docker. Capped here so a
    # new service cannot reintroduce that.
    logging:
      driver: json-file
      options:
        max-size: '${INDEX_SWARM_LOG_MAX_SIZE:-50m}'
        max-file: '${INDEX_SWARM_LOG_MAX_FILE:-3}'
    networks:
      - ar-io-network
      # Where it reaches the torrent engine's Web API.
      - index-swarm-engine
    labels:
      autoheal: ${RUN_AUTOHEAL:-false}

  # Builds this gateway's root-TX (and, with INDEX_EXPORT_KINDS, L1) index
  # bands from its own index once a day and
  # puts them where the index-swarm sidecar signs and offers them. See
  # "Producing bands" in docs/index-swarm.md.
  index-export:
    # The core image, at its own tag when set: the service can move to a
    # release before core does, and must not run an image that predates it.
    # Like core's, this build tags the core image.
    image: ghcr.io/ar-io/ar-io-core:${INDEX_EXPORT_IMAGE_TAG:-${CORE_IMAGE_TAG:-latest}}
    build:
      context: .
    entrypoint: ['/nodejs/bin/node', 'dist/index-export/main.js']
    profiles:
      - index-export
    restart: unless-stopped
    init: true
    # A run in progress gets a minute to stop; its scratch is cleared at the
    # next start.
    stop_grace_period: 60s
    # Deliberately no depends_on: bringing this profile up must never start or
    # recreate core, ClickHouse or the sidecar. A source that is down makes a
    # run "couldn't check", retried later.
    volumes:
      - ${INDEX_SWARM_DATA_PATH:-./data/indexes}:/app/data/indexes
      # Read-only, for the SQLite source (gateways without ClickHouse), L1
      # bands (core.db) and L2 bands' owners' keys (bundles.db wallets).
      - ${SQLITE_DATA_PATH:-./data/sqlite}:/app/data/sqlite:ro
      # Peers' ClickHouse password files, only when INDEX_EXPORT_SOURCES names
      # a peer; otherwise nothing is mounted.
      - ${INDEX_EXPORT_SECRETS_DIR:-/dev/null}:/run/secrets/index-export:ro
    environment:
      - NODE_ENV=${NODE_ENV:-production}
      - LOG_LEVEL=${LOG_LEVEL:-info}
      - LOG_FORMAT=${LOG_FORMAT:-simple}
      # The publisher: band ids are made unique to it.
      - AR_IO_WALLET=${AR_IO_WALLET:-}
      - CLICKHOUSE_URL=${CLICKHOUSE_URL:-}
      - CLICKHOUSE_USER=${CLICKHOUSE_USER:-}
      - CLICKHOUSE_PASSWORD=${CLICKHOUSE_PASSWORD:-}
      - INDEX_EXPORT_KINDS=${INDEX_EXPORT_KINDS:-root-tx-index}
      - INDEX_EXPORT_CORE_DB=${INDEX_EXPORT_CORE_DB:-}
      - INDEX_EXPORT_SOURCES=${INDEX_EXPORT_SOURCES:-}
      - INDEX_EXPORT_RUN_AT_UTC=${INDEX_EXPORT_RUN_AT_UTC:-04:00}
      - INDEX_EXPORT_RECENT_MAX_BLOCKS=${INDEX_EXPORT_RECENT_MAX_BLOCKS:-100000}
      - INDEX_EXPORT_ROOT_TX_LAYOUT=${INDEX_EXPORT_ROOT_TX_LAYOUT:-legacy}
      - INDEX_EXPORT_ROOT_TX_SETTLE_BLOCKS=${INDEX_EXPORT_ROOT_TX_SETTLE_BLOCKS:-5040}
      - INDEX_EXPORT_ROOT_TX_RESETTLE_INTERVAL_HOURS=${INDEX_EXPORT_ROOT_TX_RESETTLE_INTERVAL_HOURS:-168}
      - INDEX_EXPORT_ROOT_TX_RESETTLE_MAX_CHANGED=${INDEX_EXPORT_ROOT_TX_RESETTLE_MAX_CHANGED:-20000}
      - INDEX_EXPORT_START_HEIGHT=${INDEX_EXPORT_START_HEIGHT:-}
      - INDEX_EXPORT_L1_RUN_BUDGET_MINUTES=${INDEX_EXPORT_L1_RUN_BUDGET_MINUTES:-}
      # parquet-l2: the selections to build, and where from (see envs.md).
      - INDEX_EXPORT_L2_INDEXES=${INDEX_EXPORT_L2_INDEXES:-}
      - INDEX_EXPORT_L2_SOURCE=${INDEX_EXPORT_L2_SOURCE:-}
      - INDEX_EXPORT_L2_SETTLE_BLOCKS=${INDEX_EXPORT_L2_SETTLE_BLOCKS:-}
      - INDEX_EXPORT_L2_WALLETS_DB=${INDEX_EXPORT_L2_WALLETS_DB:-}
      - INDEX_EXPORT_L2_MAX_READS=${INDEX_EXPORT_L2_MAX_READS:-}
      - INDEX_EXPORT_L2_RUN_BUDGET_MINUTES=${INDEX_EXPORT_L2_RUN_BUDGET_MINUTES:-}
      - INDEX_EXPORT_L2_DUCKDB_MEMORY=${INDEX_EXPORT_L2_DUCKDB_MEMORY:-}
      - INDEX_EXPORT_L2_DUCKDB_THREADS=${INDEX_EXPORT_L2_DUCKDB_THREADS:-}
      - INDEX_EXPORT_L2_DUCKDB_SPILL_MAX_GB=${INDEX_EXPORT_L2_DUCKDB_SPILL_MAX_GB:-}
      - INDEX_EXPORT_L2_WINDOW_ITEMS=${INDEX_EXPORT_L2_WINDOW_ITEMS:-}
      - INDEX_EXPORT_L2_RECHECK_UNREADABLE_EVERY=${INDEX_EXPORT_L2_RECHECK_UNREADABLE_EVERY:-}
      - INDEX_EXPORT_HEADER_CHECK_URL=${INDEX_EXPORT_HEADER_CHECK_URL:-}
      - INDEX_EXPORT_HEADER_CHECK_TIMEOUT_MS=${INDEX_EXPORT_HEADER_CHECK_TIMEOUT_MS:-30000}
      - INDEX_EXPORT_METRICS_PORT=${INDEX_EXPORT_METRICS_PORT:-9102}
      # Bounds, so a fold can't crowd the gateway: heap and memory, a larger
      # thread pool so file I/O doesn't starve DNS lookups, and a low share
      # of the disk.
      - NODE_OPTIONS=--max-old-space-size=4096
      - UV_THREADPOOL_SIZE=16
    mem_limit: 6g
    blkio_config:
      weight: 100
    healthcheck:
      test:
        [
          'CMD',
          '/nodejs/bin/node',
          '-e',
          "fetch('http://127.0.0.1:${INDEX_EXPORT_METRICS_PORT:-9102}/healthz').then(r=>process.exit(r.ok?0:1),()=>process.exit(1))",
        ]
      # Sorting a large band's partition holds the event loop for a while:
      # five minutes of failed checks, as /healthz itself allows, before the
      # container counts as unhealthy.
      interval: 30s
      timeout: 30s
      retries: 10
      start_period: 60s
    logging:
      driver: json-file
      options:
        max-size: '${INDEX_SWARM_LOG_MAX_SIZE:-50m}'
        max-file: '${INDEX_SWARM_LOG_MAX_FILE:-3}'
    networks:
      - ar-io-network
    labels:
      autoheal: ${RUN_AUTOHEAL:-false}

  # Writes the settings the swarm depends on into the torrent engine's config
  # before each engine start, then exits. The engine image has no way to take
  # a Web UI password from the environment; without this it would invent one
  # per start that the sidecar could never know. The password is
  # INDEX_SWARM_ENGINE_AUTH when set; else one generated on the first start
  # and kept, root-owned and mode 0600, in data/indexes/engine-auth, which
  # the sidecar reads. Fails, and so keeps the engine down, when it cannot
  # have one: the engine never runs without a password. Runs by default; the
  # old `--profile index-swarm-torrent` flag is still accepted.
  index-swarm-engine-init:
    image: ghcr.io/ar-io/ar-io-core:${CORE_IMAGE_TAG:-latest}
    entrypoint: ['/nodejs/bin/node', 'dist/index-swarm/engine-init.js']
    restart: 'no'
    volumes:
      # Also where the generated password is kept: the sidecar mounts the
      # same directory, the engine does not.
      - ${INDEX_SWARM_DATA_PATH:-./data/indexes}:/app/data/indexes
      - ${INDEX_SWARM_ENGINE_CONFIG_PATH:-./data/index-swarm-engine}:/config
    environment:
      - INDEX_SWARM_LOG_FORMAT=${INDEX_SWARM_LOG_FORMAT:-simple}
      - INDEX_SWARM_ENGINE_AUTH=${INDEX_SWARM_ENGINE_AUTH:-}
      - INDEX_SWARM_UPLOAD_LIMIT_BYTES_PER_SEC=${INDEX_SWARM_UPLOAD_LIMIT_BYTES_PER_SEC:-10000000}
      - INDEX_SWARM_ENGINE_BLOCK_PRIVATE=${INDEX_SWARM_ENGINE_BLOCK_PRIVATE:-true}
      - INDEX_SWARM_ENGINE_UID=${INDEX_SWARM_ENGINE_UID:-1000}
      - INDEX_SWARM_ENGINE_GID=${INDEX_SWARM_ENGINE_GID:-1000}
    logging:
      driver: json-file
      options:
        max-size: '${INDEX_SWARM_LOG_MAX_SIZE:-50m}'
        max-file: '${INDEX_SWARM_LOG_MAX_FILE:-3}'
    network_mode: none

  # The torrent engine: qBittorrent-nox on libtorrent 2, pinned by digest
  # (docs/index-swarm.md#why-qbittorrent). The sidecar drives it over its
  # Web API; nothing else does. It sees the index directories at the same
  # paths as the sidecar, because the sidecar hands it paths.
  index-swarm-engine:
    image: qbittorrentofficial/qbittorrent-nox:5.2.3-lt2-1@sha256:f269c2aae56f1bf8caddd77a59e7ba2a278919d8401213266b8fe154c6ac1043
    restart: unless-stopped
    depends_on:
      index-swarm-engine-init:
        condition: service_completed_successfully
    # The image runs tini itself. The grace period lets it save resume data,
    # which is what spares a restart from rechecking every seeded band.
    stop_grace_period: 30s
    volumes:
      - ${INDEX_SWARM_ENGINE_CONFIG_PATH:-./data/index-swarm-engine}:/config
      # Seeds what this node publishes and what it has installed, and can
      # write neither: the gateway serves and loads those directories. The
      # publisher seeds from published/.seed/, hard links to the blobs.
      - ${INDEX_SWARM_DATA_PATH:-./data/indexes}/published:/app/data/indexes/published:ro
      - ${INDEX_SWARM_DATA_PATH:-./data/indexes}/installed:/app/data/indexes/installed:ro
      # The only place it may write.
      - ${INDEX_SWARM_DATA_PATH:-./data/indexes}/swarm:/app/data/indexes/swarm
    environment:
      - QBT_LEGAL_NOTICE=confirm
      - QBT_TORRENTING_PORT=${INDEX_SWARM_ENGINE_PORT:-6881}
      - PUID=${INDEX_SWARM_ENGINE_UID:-1000}
      - PGID=${INDEX_SWARM_ENGINE_GID:-1000}
      - UMASK=022
    # Only the peer port reaches the host; open it (TCP and UDP) to the
    # internet so peers can connect in. The Web API stays on the engine's
    # own network, where the sidecar reaches it as index-swarm-engine:8080;
    # it must be reached at that same port, because qBittorrent refuses a
    # Host header naming another.
    ports:
      - '${INDEX_SWARM_ENGINE_PORT:-6881}:${INDEX_SWARM_ENGINE_PORT:-6881}/tcp'
      - '${INDEX_SWARM_ENGINE_PORT:-6881}:${INDEX_SWARM_ENGINE_PORT:-6881}/udp'
    healthcheck:
      # Any HTTP answer is healthy: the API asks for a login even on
      # loopback, so a 403 still means the engine is up.
      test: ['CMD', 'curl', '-sS', '-o', '/dev/null', 'http://127.0.0.1:8080/api/v2/app/webapiVersion']
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 20s
    logging:
      driver: json-file
      options:
        max-size: '${INDEX_SWARM_LOG_MAX_SIZE:-50m}'
        max-file: '${INDEX_SWARM_LOG_MAX_FILE:-3}'
    # Its own network, shared only with the sidecar. Trackers, peers and
    # WebSeeds are chosen by other gateways, so the engine must not be able
    # to reach core, the observer or anything else on ar-io-network.
    networks:
      - index-swarm-engine
    labels:
      autoheal: ${RUN_AUTOHEAL:-false}

  autoheal:
    image: willfarrell/autoheal@sha256:fd2c5500ab9210be9fa0d365162301eb0d16923f1d9a36de887f5d1751c6eb8c
    network_mode: none
    restart: always
    environment:
      - AUTOHEAL_CONTAINER_LABEL=autoheal
      - AUTOHEAL_ONLY_MONITOR_RUNNING=false
    volumes:
      - /etc/localtime:/etc/localtime:ro
      - /var/run/docker.sock:/var/run/docker.sock

volumes:
  envoy-eds-data:

networks:
  ar-io-network:
    name: ${DOCKER_NETWORK_NAME:-ar-io-network}
  index-swarm-engine:
    name: ${INDEX_SWARM_ENGINE_NETWORK_NAME:-ar-io-index-swarm-engine}