Merge remote-tracking branch 'origin/main'

2026-10-09 20:22:11 +09:00 · 2026-09-27 21:29:29 +00:00 · 2026-09-27 19:22:45 +00:00 · 2026-09-27 19:19:37 +00:00 · 2026-09-27 19:15:35 +00:00 · 2026-09-27 19:03:44 +00:00
2861 changed files with 182933 additions and 371550 deletions
@@ -23,6 +23,7 @@ services:
      FLUXER_S3_PUBLIC_ENDPOINT: "http://localhost:${FLUXER_DEV_PROXY_PORT:-8088}"
      FLUXER_LIVEKIT_URL: "ws://localhost:${FLUXER_DEV_PROXY_PORT:-8088}/livekit"
      FLUXER_LIVEKIT_INTERNAL_URL: "http://livekit:7880"
+      FLUXER_LIVEKIT_WEBHOOK_URL: "http://localhost:${FLUXER_DEV_PROXY_PORT:-8088}/api/webhooks/livekit"
      FLUXER_MEDIA_PROXY_UPLOAD_RELAY_ENDPOINT: "http://localhost:${FLUXER_DEV_PROXY_PORT:-8088}/media"
      FLUXER_GATEWAY_MEDIA_PROXY_ENDPOINT: "http://localhost:${FLUXER_DEV_PROXY_PORT:-8088}/media"
      FLUXER_GATEWAY_STATIC_CDN_ENDPOINT: "http://localhost:${FLUXER_DEV_PROXY_PORT:-8088}"
@@ -201,6 +202,11 @@ services:
        target: /workspaces/fluxer/fluxer_api/pkgs/rate_limit/node_modules
        volume:
          nocopy: true
+      - type: volume
+        source: fluxer-api-sms-node-modules
+        target: /workspaces/fluxer/fluxer_api/pkgs/sms/node_modules
+        volume:
+          nocopy: true
      - type: volume
        source: fluxer-api-virus-scan-node-modules
        target: /workspaces/fluxer/fluxer_api/pkgs/virus_scan/node_modules
@@ -378,6 +384,7 @@ volumes:
  fluxer-api-mime-utils-node-modules:
  fluxer-api-nats-node-modules:
  fluxer-api-rate-limit-node-modules:
+  fluxer-api-sms-node-modules:
  fluxer-api-virus-scan-node-modules:
  fluxer-api-worker-node-modules:
  fluxer-app-list-utils-node-modules:
@@ -2,5 +2,3 @@
 fluxer_static/** -text -diff
 fluxer_static/**/*.md text diff
 packages/fonts/files/** -text -diff
-fluxer_app/src/features/voice/utils/noise_suppression/deepfilternet3/*.wasm -text -diff
-fluxer_app/src/features/voice/utils/noise_suppression/deepfilternet3/*.tar.gz -text -diff
@@ -1,24 +1,24 @@
 # Contributing to Fluxer

-This policy applies to all commits and pull requests.
+This policy applies to all issues, discussions, commits and pull requests.

 ## Scope

 To prevent spam, only approved contributors may submit pull requests.

-To request approval, comment on the [feedback.fluxer.com](https://feedback.fluxer.com) post you want to implement and ask to work on it. For work that extends beyond a defect fix, post a feature request there first.
+To request approval, comment on an existing issue and ask to implement it. For work that extends beyond a defect fix, open a [discussion](https://github.com/orgs/fluxerapp/discussions) first.

 Every pull request must:

 - Target the repository's default branch.
- Link each feedback.fluxer.com post it resolves.
+- Include a closing reference for each repository issue it resolves.
 - Receive approval from a maintainer before it is merged.

-Place each link on a separate line:
+Place each closing reference on a separate line:

 ```text
-Resolves https://feedback.fluxer.com/p/123
-Resolves https://feedback.fluxer.com/p/456
+Closes #123
+Closes #456
 ```

 ## Authorship
@@ -78,11 +78,11 @@ Complete every section of the pull request template. Clearly describe:

 ## Reports and other contributions

-Report bugs and request features at [feedback.fluxer.com](https://feedback.fluxer.com).
+Use the [bug report form](https://github.com/fluxerapp/fluxer/issues/new?template=bug-report.yaml) to report reproducible defects.

-Report security vulnerabilities privately through [fluxer.app/security](https://fluxer.app/security). Never post them publicly.
+Report security vulnerabilities privately through the channels specified in the [security policy](https://github.com/fluxerapp/fluxer/blob/main/.github/SECURITY.md). Do not report vulnerabilities in public issues or discussions.

-Read the [operator documentation](https://fluxer.dev) for self-hosting questions.
+Use [discussions](https://github.com/orgs/fluxerapp/discussions) for feature proposals and self-hosting questions.

 Submit translations through [Weblate](https://weblate.fluxer.tools), not through pull requests.

@@ -0,0 +1,41 @@
+# yaml-language-server: $schema=https://www.schemastore.org/github-discussion.json
+
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Search existing discussions before posting a feature proposal.
+
+        Report vulnerabilities through the [private form](https://github.com/fluxerapp/fluxer/security/advisories/new) or <[email protected]>.
+
+  - type: textarea
+    id: problem
+    attributes:
+      label: Current problem
+      description: State what you are trying to do and what prevents it.
+    validations:
+      required: true
+
+  - type: textarea
+    id: proposal
+    attributes:
+      label: Proposed change
+      description: State the expected behaviour.
+    validations:
+      required: true
+
+  - type: textarea
+    id: notes
+    attributes:
+      label: Additional information
+      description: Optional. Include constraints, trade-offs, related discussions, screenshots or mockups.
+    validations:
+      required: false
+
+  - type: checkboxes
+    id: checks
+    attributes:
+      label: Acknowledgements
+      options:
+        - label: I searched existing discussions.
+          required: true
@@ -16,10 +16,4 @@ Every commit made by a contributor must include the [Developer Certificate of Or

 ## Name and marks

-Fluxer and the Fluxer logo are trademarks of Fluxer Platform AB. Neither the AGPL nor the CC BY-SA 4.0 licence on Fluxer artwork grants trademark rights. Fluxer Platform AB grants everyone the following permissions.
-
- You may distribute unmodified builds of Fluxer, or builds with light patches, under the Fluxer name and logo. Light patches are changes for packaging, portability, security and bug fixes, configuration defaults and translations. Linux distributions, nixpkgs, Flathub and container images are all covered.
- A self-hosted instance running such a build may show the Fluxer name and logo under the instance's own name and domain, as long as it does not imply affiliation with or endorsement by Fluxer Platform AB.
- You may refer to Fluxer by name to describe compatibility, for example "works with Fluxer".
-
-Forks with substantive functional changes must use their own name and logo. Any other use needs permission from Fluxer Platform AB. Contact support@fluxer.com.
+The AGPL does not grant permission to use the Fluxer name, logo or other branding. Forks must use a distinct name and branding unless Fluxer Platform AB grants permission otherwise.
@@ -0,0 +1,83 @@
+# yaml-language-server: $schema=https://www.schemastore.org/github-issue-forms.json
+name: Bug report
+description: Report a reproducible defect in Fluxer.
+type: Bug
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Search [open and closed issues](https://github.com/fluxerapp/fluxer/issues?q=is%3Aissue) before filing a report.
+
+        Report vulnerabilities through the [private form](https://github.com/fluxerapp/fluxer/security/advisories/new) or <[email protected]>. Send account and billing requests to <[email protected]>.
+
+  - type: textarea
+    id: summary
+    attributes:
+      label: Observed behaviour
+      description: State what happened and what you expected.
+    validations:
+      required: true
+
+  - type: textarea
+    id: steps
+    attributes:
+      label: Reproduction steps
+      description: Give numbered steps starting from a fresh app or session.
+      placeholder: |
+        1. Go to ...
+        2. Select ...
+        3. Observe ...
+    validations:
+      required: true
+
+  - type: input
+    id: build
+    attributes:
+      label: Build information
+      description: >-
+        Open User Settings, scroll to the bottom of the left sidebar, and select
+        the build information. Fluxer copies it to the clipboard.
+    validations:
+      required: true
+
+  - type: dropdown
+    id: surface
+    attributes:
+      label: Affected surface
+      multiple: true
+      options:
+        - Desktop app
+        - Web app
+        - Voice, video, or Go Live
+        - Self-hosted instance
+        - HTTP API or Gateway
+        - Documentation site
+    validations:
+      required: true
+
+  - type: input
+    id: instance
+    attributes:
+      label: Instance
+      description: For a self-hosted instance, include the release tag and database backend.
+      placeholder: fluxer.app
+    validations:
+      required: false
+
+  - type: textarea
+    id: evidence
+    attributes:
+      label: Evidence
+      description: Attach relevant logs, screenshots or recordings. Remove tokens, keys, private messages and other personal data. Configuration files may contain secrets.
+    validations:
+      required: false
+
+  - type: checkboxes
+    id: checks
+    attributes:
+      label: Acknowledgements
+      options:
+        - label: I searched open and closed issues.
+          required: true
+        - label: I removed secrets and unrelated personal data from the report.
+          required: true
@@ -0,0 +1,18 @@
+# yaml-language-server: $schema=https://www.schemastore.org/github-issue-config.json
+blank_issues_enabled: false
+contact_links:
+  - name: Mobile client bugs
+    url: https://github.com/fluxerapp/flutter_client#bug-reporting
+    about: Read the reporting instructions for the Fluxer mobile client.
+  - name: Account and billing support
+    url: https://fluxer.app/help
+    about: Find account help and support contact details.
+  - name: Feature proposals
+    url: https://github.com/orgs/fluxerapp/discussions
+    about: Propose a feature in a discussion.
+  - name: Translations
+    url: https://weblate.fluxer.tools
+    about: Improve an existing locale or start a new one.
+  - name: Self-hosting support
+    url: https://fluxer.dev
+    about: Read the operator documentation, then open a discussion if the problem remains.
@@ -0,0 +1,44 @@
+# yaml-language-server: $schema=https://www.schemastore.org/github-issue-forms.json
+name: Documentation
+description: Report incorrect, missing or unclear documentation.
+type: Task
+labels:
+  - docs
+body:
+  - type: markdown
+    attributes:
+      value: |
+        This form covers <https://fluxer.dev> and operator documentation.
+
+  - type: textarea
+    id: issue
+    attributes:
+      label: Documentation defect
+      description: State what the page says and what is correct. For missing content, state what information you needed.
+    validations:
+      required: true
+
+  - type: input
+    id: location
+    attributes:
+      label: Location
+      description: Provide the page URL or file path and heading.
+      placeholder: https://fluxer.dev/gateway/overview/
+    validations:
+      required: false
+
+  - type: textarea
+    id: suggestion
+    attributes:
+      label: Proposed wording
+      description: Optional.
+    validations:
+      required: false
+
+  - type: checkboxes
+    id: checks
+    attributes:
+      label: Acknowledgements
+      options:
+        - label: I searched open and closed issues.
+          required: true
@@ -1,7 +1,7 @@
 # Security policy

-Do not report a vulnerability in a pull request, on feedback.fluxer.com, in a Fluxer community, or in a direct message to staff.
+Do not report a vulnerability in an issue, pull request, or discussion.

-Submit a report through <https://fluxer.app/security> or email <security@fluxer.com>. Include the affected component, impact, reproduction steps, and supporting evidence. Remove unrelated personal data and secrets.
+Submit a report through [GitHub private vulnerability reporting](https://github.com/fluxerapp/fluxer/security/advisories/new) or email <security@fluxer.com>. Include the affected component, impact, reproduction steps, and supporting evidence. Remove unrelated personal data and secrets.

 The programme scope, testing rules, safe harbour, disclosure process, and reward terms are published at <https://fluxer.app/security>. That page is authoritative.
@@ -1,6 +1,6 @@
-Resolves https://feedback.fluxer.com/p/
+Closes #

-<!-- Repeat this line for each feedback.fluxer.com post this resolves, up to 20. Remove the placeholder only if no post is resolved and the approval gate does not apply. -->
+<!-- Repeat this line for each resolved issue, up to 20. Remove the placeholder only if no issue is resolved and the approval gate does not apply. -->

 ## Summary

@@ -336,9 +336,6 @@ jobs:
          restore-keys: |
            rebar3-${{ runner.os }}-otp28-rebar3.27.0-

-      - name: Drop restored gateway build output
-        run: rm -rf fluxer_gateway/_build/default/lib/fluxer_gateway fluxer_gateway/_build/test/lib/fluxer_gateway
-
      - name: Check formatting
        run: |
          "$FLUXER_CI_BIN" ci --step gateway_fmt
@@ -1785,10 +1785,8 @@ name = "fluxer-gifs"
 version = "0.1.0"
 dependencies = [
 "anyhow",
- "axum",
 "fluxer-svc",
 "fluxer_common",
- "futures",
 "hmac 0.13.0",
 "moka",
 "reqwest",
@@ -1825,7 +1823,6 @@ dependencies = [
 "cc",
 "clap",
 "criterion",
- "flate2",
 "fluxer_common",
 "futures-util",
 "hex",
@@ -1853,7 +1850,6 @@ dependencies = [
 "tokio",
 "tokio-util",
 "tower",
- "tower-http 0.7.1",
 "tracing",
 "tracing-subscriber",
 "url",
@@ -1908,6 +1904,7 @@ dependencies = [
 "thiserror",
 "tokio",
 "tracing",
+ "tracing-subscriber",
 "url",
 ]

@@ -1986,13 +1983,11 @@ dependencies = [
 "fluxer-svc",
 "fluxer_common",
 "futures",
- "hmac 0.13.0",
 "moka",
 "rmp-serde",
 "scylla",
 "serde",
 "serde_json",
- "sha2 0.11.0",
 "tokio",
 "tracing",
 ]
@@ -2044,7 +2039,6 @@ dependencies = [
 "reqwest",
 "serde",
 "serde_json",
- "sha2 0.11.0",
 "tokio",
 "tokio-util",
 "tower",
@@ -2073,7 +2067,6 @@ dependencies = [
 "thiserror",
 "time",
 "tracing",
- "tracing-subscriber",
 "url",
 "urlencoding",
 ]
@@ -5837,9 +5830,9 @@ dependencies = [

 [[package]]
 name = "yoke-derive"
-version = "0.8.4"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec8ebde2db3681e8c9980cc27822030e68752690ddfa9473e739aeb4dbde6d71"
+checksum = "33811428bee40dbceb6d545e95754741d17a6aef9a4849f0fd62e2ba4f412a78"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -23,13 +23,10 @@

 # Fluxer

-> [!IMPORTANT]
-> Bug reports and feature requests have moved to [feedback.fluxer.com](https://feedback.fluxer.com). Sign in with your Fluxer account to post, vote and follow updates. GitHub Issues and Discussions are closed. Report security vulnerabilities privately through [fluxer.app/security](https://fluxer.app/security).
-
 Fluxer is a free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

 <p align="center">
-  <img src="https://fluxer.app/static/img/screenshots-desktop-readme-1920w.70cb6ce340007e0a.png" alt="Fluxer running side by side on a desktop monitor and a phone" width="640">
+  <img src="./fluxer_static/marketing/screenshots/desktop-readme-1920w.png" alt="Fluxer running side by side on a desktop monitor and a phone" width="640">
 </p>

 ## Download
@@ -146,13 +143,14 @@ Full setup notes, including canary, are in the [Linux repositories documentation

 The source is licensed under the [AGPL-3.0-or-later](./LICENSE) license.

-Fluxer artwork, such as the logo, icons, badges and default avatars, is
-licensed under [CC BY-SA 4.0](./fluxer_static/LICENSE). Third-party material
-keeps its own terms, listed in
+Fluxer branding, icons, default avatars, badge artwork, screenshots and marketing
+imagery are copyright Fluxer, all rights reserved, as set out in
+[fluxer_static/LICENSE](./fluxer_static/LICENSE). Third-party material keeps its own
+terms, listed in
 [fluxer_static/THIRD_PARTY_LICENSES.md](./fluxer_static/THIRD_PARTY_LICENSES.md).

-Use of the Fluxer name and logo is covered by the
-[name and marks policy](./.github/GOVERNANCE.md#name-and-marks).
+Public availability of this repository does not grant trademark, brand, or
+endorsement rights.

 [win-setup-x64]: https://pkgs.fluxer.com/desktop/stable/win32/x64/latest/setup
 [win-setup-arm64]: https://pkgs.fluxer.com/desktop/stable/win32/arm64/latest/setup
@@ -143,10 +143,6 @@
 			],
 			"linter": {"rules": {"style": {"noRestrictedImports": "off"}}}
 		},
-		{
-			"includes": ["fluxer_app/src/**/*.worklet.js"],
-			"javascript": {"globals": ["AudioWorkletProcessor", "registerProcessor", "sampleRate", "currentTime"]}
-		},
 		{
 			"includes": ["**/*.astro"],
 			"linter": {"rules": {"correctness": {"noUnusedImports": "off", "noUnusedVariables": "off"}}},
@@ -34,6 +34,7 @@ FLUXER_KV_URL=redis://valkey:6379/0
 FLUXER_NATS_URL=nats://nats:4222
 FLUXER_NATS_JETSTREAM_URL=nats://nats:4222
 FLUXER_INTERNAL_API_ENDPOINT=http://127.0.0.1:8080
+FLUXER_INTERNAL_GATEWAY_ENDPOINT=http://127.0.0.1:8771
 FLUXER_INTERNAL_MEDIA_PROXY_ENDPOINT=http://127.0.0.1:8082
 FLUXER_MEDIA_PROXY_ENDPOINT=http://127.0.0.1:8082
 FLUXER_MEDIA_PROXY_PUBLIC_ENDPOINT=http://localhost:8088/media
@@ -41,6 +42,7 @@ FLUXER_MEDIA_PROXY_PUBLIC_ENDPOINT=http://localhost:8088/media
 FLUXER_SVC_NATS_URL=nats://nats:4222
 FLUXER_SVC_SHARD_COUNT=1
 FLUXER_SVC_CACHE_TTL_MS=30000
+FLUXER_SVC_CACHE_HARD_TTL_MS=600000

 FLUXER_S3_ENDPOINT=http://127.0.0.1:8333
 FLUXER_S3_PUBLIC_ENDPOINT=http://localhost:8088
@@ -59,6 +61,7 @@ FLUXER_LIVEKIT_URL=ws://localhost:8088/livekit
 FLUXER_LIVEKIT_INTERNAL_URL=http://localhost:7880
 FLUXER_LIVEKIT_API_KEY=devkey
 FLUXER_LIVEKIT_API_SECRET=fluxer-livekit-development-secret
+FLUXER_LIVEKIT_WEBHOOK_URL=http://localhost:8088/api/webhooks/livekit
 FLUXER_LIVEKIT_DEFAULT_REGION={"id":"local","name":"Local","emoji":"LC","latitude":59.3293,"longitude":18.0686}

 FLUXER_API_PORT=8080
@@ -89,7 +92,6 @@ FLUXER_ADMIN_OAUTH_REDIRECT_URI=http://localhost:8088/admin/oauth2_callback

 FLUXER_SUDO_MODE_SECRET=dev-sudo-secret
 FLUXER_CONNECTION_INITIATION_SECRET=dev-connection-initiation-secret
-FLUXER_PROFILE_PSEUDONYM_SECRET=fluxer-dev-profile-pseudonym-secret
 FLUXER_VAPID_PUBLIC_KEY=BHIbdKs24FdPkOQS7hbeg3adceLS0IqlKsn71ywEe6kbeopeFFiG3lkvJac7BVqkuk7mxwEa555O2FXV3HLt56w
 FLUXER_VAPID_PRIVATE_KEY=cs24JvXSxHiqJQgkJNocJFAdzJpPmpfU9xD-fDpn3tw
 FLUXER_VAPID_EMAIL=dev@localhost
@@ -105,6 +107,9 @@ FLUXER_EMAIL_SMTP_PORT=1025
 FLUXER_EMAIL_SMTP_USERNAME=dev
 FLUXER_EMAIL_SMTP_PASSWORD=dev
 FLUXER_EMAIL_SMTP_SECURE=false
+FLUXER_SMS_ENABLED=false
+FLUXER_CAPTCHA_ENABLED=false
+FLUXER_CAPTCHA_PROVIDER=none
 FLUXER_SEARCH_ENGINE=meilisearch
 FLUXER_SEARCH_URL=http://meilisearch:7700
 FLUXER_SEARCH_API_KEY=fluxer-dev-meilisearch
@@ -126,3 +131,6 @@ PUBLIC_BOOTSTRAP_API_PUBLIC_ENDPOINT=http://localhost:8088/api
 FLUXER_MEDIA_PROXY_UPLOAD_RELAY_SECRET_BASE64=Zmx1eGVyLWRldi11cGxvYWQtcmVsYXktc2VjcmV0LTAwMDA=
 FLUXER_MEDIA_PROXY_ATTACHMENT_URL_SECRETS_BASE64=Zmx1eGVyLWRldi1hdHRhY2htZW50LXVybC1zZWNyZXQ=
 AWS_EC2_METADATA_DISABLED=true
+AWS_ACCESS_KEY_ID=fluxer
+AWS_SECRET_ACCESS_KEY=fluxer-secret
+AWS_DEFAULT_REGION=us-east-1
@@ -1,6 +0,0 @@
-apiVersion: v2
-name: fluxer-api
-description: Fluxer HTTP API and background job workers
-type: application
-version: 0.1.0
-appVersion: "v1"
@@ -1,244 +0,0 @@
-{{- define "fluxer-api.chart" -}}
-{{- printf "%s-%s" .Chart.Name .Chart.Version | replace "+" "_" | trunc 63 | trimSuffix "-" -}}
-{{- end }}
-
-{{- define "fluxer-api.selectorLabels" -}}
-app.kubernetes.io/name: {{ .name }}
-app.kubernetes.io/instance: {{ .root.Release.Name }}
-{{- end }}
-
-{{- define "fluxer-api.labels" -}}
-{{ include "fluxer-api.selectorLabels" . }}
-app.kubernetes.io/component: {{ .component }}
-app.kubernetes.io/part-of: fluxer
-app.kubernetes.io/managed-by: {{ .root.Release.Service }}
-helm.sh/chart: {{ include "fluxer-api.chart" .root }}
-{{- end }}
-
-{{- define "fluxer-api.image" -}}
-{{- $g := .root.Values.image | default dict -}}
-{{- $i := .w.image | default dict -}}
-{{- $repo := $i.repository -}}
-{{- if not $repo -}}
-{{- $repo = printf "%s/%s" (required "image.registry is required" $g.registry) ($i.name | default "fluxer-api") -}}
-{{- end -}}
-{{- $tag := required "image.tag is required" ($i.tag | default $g.tag) -}}
-{{- if $i.digest -}}
-{{- printf "%s:%s@%s" $repo $tag $i.digest | quote -}}
-{{- else -}}
-{{- printf "%s:%s" $repo $tag | quote -}}
-{{- end -}}
-{{- end }}
-
-{{- define "fluxer-api.pick" -}}
-{{- $v := ternary (get .w .key) (get .root.Values .key) (hasKey .w .key) -}}
-{{- if $v }}
-{{- toYaml $v }}
-{{- end }}
-{{- end }}
-
-{{- define "fluxer-api.str" -}}
-{{- if and (kindIs "float64" .) (eq . (floor .)) -}}
-{{- int64 . | toString | quote -}}
-{{- else -}}
-{{- toString . | quote -}}
-{{- end -}}
-{{- end }}
-
-{{- define "fluxer-api.env" -}}
-{{- $env := dict -}}
-{{- range $k, $val := .root.Values.env | default dict }}
-{{- $_ := set $env $k $val }}
-{{- end }}
-{{- range $k, $val := .w.env | default dict }}
-{{- $_ := set $env $k $val }}
-{{- end }}
-{{- range $k, $val := $env }}
-{{- if not (kindIs "invalid" $val) }}
- name: {{ $k }}
-  value: {{ include "fluxer-api.str" $val }}
-{{- end }}
-{{- end }}
-{{- with .w.buildVersion }}
- name: BUILD_VERSION
-  value: {{ include "fluxer-api.str" . }}
-{{- end }}
-{{- with concat (.root.Values.extraEnv | default list) (.w.extraEnv | default list) }}
-{{ toYaml . }}
-{{- end }}
-{{- end }}
-
-{{- define "fluxer-api.topologySpread" -}}
-{{- $tscs := ternary .w.topologySpreadConstraints .root.Values.topologySpreadConstraints (hasKey .w "topologySpreadConstraints") -}}
-{{- range $tscs }}
-{{- $c := deepCopy . }}
-{{- if not $c.labelSelector }}
-{{- $_ := set $c "labelSelector" (dict "matchLabels" (include "fluxer-api.selectorLabels" $ | fromYaml)) }}
-{{- end }}
- {{- toYaml $c | nindent 2 }}
-{{- end }}
-{{- end }}
-
-{{- define "fluxer-api.pdb" -}}
-{{- with .w.pdb }}
---
-apiVersion: policy/v1
-kind: PodDisruptionBudget
-metadata:
-  name: {{ $.name }}-pdb
-  namespace: {{ $.root.Release.Namespace }}
-  labels:
-    {{- include "fluxer-api.labels" $ | nindent 4 }}
-spec:
-  {{- toYaml . | nindent 2 }}
-  selector:
-    matchLabels:
-      {{- include "fluxer-api.selectorLabels" $ | nindent 6 }}
-{{- end }}
-{{- end }}
-
-{{- define "fluxer-api.hpa" -}}
-{{- with .w.hpa }}
---
-apiVersion: autoscaling/v2
-kind: HorizontalPodAutoscaler
-metadata:
-  name: {{ $.name }}
-  namespace: {{ $.root.Release.Namespace }}
-  labels:
-    {{- include "fluxer-api.labels" $ | nindent 4 }}
-spec:
-  scaleTargetRef:
-    apiVersion: apps/v1
-    kind: Deployment
-    name: {{ $.name }}
-  minReplicas: {{ required (printf "%s.hpa.minReplicas is required" $.name) .minReplicas }}
-  maxReplicas: {{ required (printf "%s.hpa.maxReplicas is required" $.name) .maxReplicas }}
-  {{- with .targetCPUUtilizationPercentage }}
-  metrics:
-    - type: Resource
-      resource:
-        name: cpu
-        target:
-          type: Utilization
-          averageUtilization: {{ . }}
-  {{- end }}
-  {{- with .behavior }}
-  behavior:
-    {{- toYaml . | nindent 4 }}
-  {{- end }}
-{{- end }}
-{{- end }}
-
-{{- define "fluxer-api.deployment" -}}
-{{- $root := .root -}}
-{{- $v := $root.Values -}}
-{{- $w := .w -}}
-{{- $envFrom := concat ($v.envFrom | default list) ($w.envFrom | default list) -}}
-{{- $podAnnotations := merge (dict) ($w.podAnnotations | default dict) ($v.podAnnotations | default dict) -}}
-{{- $wProbes := $w.probes | default dict -}}
-{{- $gProbes := .probes | default dict -}}
---
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: {{ .name }}
-  namespace: {{ $root.Release.Namespace }}
-  labels:
-    {{- include "fluxer-api.labels" . | nindent 4 }}
-spec:
-  {{- if not $w.hpa }}
-  replicas: {{ if kindIs "invalid" $w.replicas }}1{{ else }}{{ int $w.replicas }}{{ end }}
-  {{- end }}
-  {{- if not (kindIs "invalid" $w.minReadySeconds) }}
-  minReadySeconds: {{ int $w.minReadySeconds }}
-  {{- end }}
-  selector:
-    matchLabels:
-      {{- include "fluxer-api.selectorLabels" . | nindent 6 }}
-  {{- with include "fluxer-api.pick" (dict "root" $root "w" $w "key" "strategy") }}
-  strategy:
-    {{- . | nindent 4 }}
-  {{- end }}
-  template:
-    metadata:
-      labels:
-        {{- include "fluxer-api.labels" . | nindent 8 }}
-      {{- with $podAnnotations }}
-      annotations:
-        {{- toYaml . | nindent 8 }}
-      {{- end }}
-    spec:
-      {{- with include "fluxer-api.pick" (dict "root" $root "w" $w "key" "imagePullSecrets") }}
-      imagePullSecrets:
-        {{- . | nindent 8 }}
-      {{- end }}
-      {{- with include "fluxer-api.pick" (dict "root" $root "w" $w "key" "podSecurityContext") }}
-      securityContext:
-        {{- . | nindent 8 }}
-      {{- end }}
-      {{- if not (kindIs "invalid" $w.terminationGracePeriodSeconds) }}
-      terminationGracePeriodSeconds: {{ int $w.terminationGracePeriodSeconds }}
-      {{- end }}
-      {{- with include "fluxer-api.pick" (dict "root" $root "w" $w "key" "nodeSelector") }}
-      nodeSelector:
-        {{- . | nindent 8 }}
-      {{- end }}
-      {{- with include "fluxer-api.pick" (dict "root" $root "w" $w "key" "affinity") }}
-      affinity:
-        {{- . | nindent 8 }}
-      {{- end }}
-      {{- with include "fluxer-api.pick" (dict "root" $root "w" $w "key" "tolerations") }}
-      tolerations:
-        {{- . | nindent 8 }}
-      {{- end }}
-      {{- with include "fluxer-api.topologySpread" . | trim }}
-      topologySpreadConstraints:
-        {{- . | nindent 8 }}
-      {{- end }}
-      containers:
-        - name: {{ .name }}
-          image: {{ include "fluxer-api.image" . }}
-          imagePullPolicy: {{ ($w.image | default dict).pullPolicy | default ($v.image | default dict).pullPolicy | default "IfNotPresent" }}
-          {{- with .command }}
-          command:
-            {{- toYaml . | nindent 12 }}
-          {{- end }}
-          {{- with include "fluxer-api.env" . | trim }}
-          env:
-            {{- . | nindent 12 }}
-          {{- end }}
-          {{- with $envFrom }}
-          envFrom:
-            {{- toYaml . | nindent 12 }}
-          {{- end }}
-          ports:
-            - name: http
-              containerPort: 8080
-          {{- with $w.lifecycle }}
-          lifecycle:
-            {{- toYaml . | nindent 12 }}
-          {{- end }}
-          {{- range $probe := list "startup" "liveness" "readiness" }}
-          {{- with hasKey $wProbes $probe | ternary (get $wProbes $probe) (get $gProbes $probe) }}
-          {{ $probe }}Probe:
-            {{- toYaml . | nindent 12 }}
-          {{- end }}
-          {{- end }}
-          {{- with $w.resources }}
-          resources:
-            {{- toYaml . | nindent 12 }}
-          {{- end }}
-          {{- with include "fluxer-api.pick" (dict "root" $root "w" $w "key" "securityContext") }}
-          securityContext:
-            {{- . | nindent 12 }}
-          {{- end }}
-          {{- with $w.extraVolumeMounts }}
-          volumeMounts:
-            {{- toYaml . | nindent 12 }}
-          {{- end }}
-      {{- with $w.extraVolumes }}
-      volumes:
-        {{- toYaml . | nindent 8 }}
-      {{- end }}
-{{- end }}
@@ -1,24 +0,0 @@
-{{- range $name, $w := .Values.api }}
-{{- if not (kindIs "invalid" $w) }}
-{{- $ctx := dict "root" $ "name" $name "w" $w "component" "api" "probes" ($.Values.probes | default dict) }}
-{{ include "fluxer-api.deployment" $ctx }}
-{{ include "fluxer-api.hpa" $ctx }}
-{{ include "fluxer-api.pdb" $ctx }}
---
-apiVersion: v1
-kind: Service
-metadata:
-  name: {{ $name }}
-  namespace: {{ $.Release.Namespace }}
-  labels:
-    {{- include "fluxer-api.labels" $ctx | nindent 4 }}
-spec:
-  type: ClusterIP
-  selector:
-    {{- include "fluxer-api.selectorLabels" $ctx | nindent 4 }}
-  ports:
-    - name: http
-      port: 8080
-      targetPort: http
-{{- end }}
-{{- end }}
@@ -1,8 +0,0 @@
-{{- range $name, $w := .Values.workers }}
-{{- if not (kindIs "invalid" $w) }}
-{{- $ctx := dict "root" $ "name" $name "w" $w "component" "worker" "command" (list "node" "dist/WorkerEntrypoint.js") "probes" (dict) }}
-{{ include "fluxer-api.deployment" $ctx }}
-{{ include "fluxer-api.hpa" $ctx }}
-{{ include "fluxer-api.pdb" $ctx }}
-{{- end }}
-{{- end }}
@@ -1,86 +0,0 @@
-image:
-  registry: ghcr.io/fluxerapp
-  tag: v1
-  pullPolicy: IfNotPresent
-
-imagePullSecrets: []
-
-env:
-  NODE_ENV: production
-  FLUXER_ENV: production
-  FLUXER_PUBLIC_ORIGIN: https://web.example.com
-  FLUXER_API_ENDPOINT: https://api.example.com
-  FLUXER_GATEWAY_ENDPOINT: wss://gateway.example.com
-  FLUXER_MEDIA_ENDPOINT: https://media.example.com
-  FLUXER_ADMIN_ENDPOINT: https://admin.example.com
-  FLUXER_MEDIA_PROXY_UPLOAD_RELAY_ENDPOINT: https://uploads.example.com
-  FLUXER_INTERNAL_MEDIA_PROXY_ENDPOINT: http://media-proxy:8080
-  FLUXER_KV_URL: redis://valkey:6379/0
-  FLUXER_NATS_URL: nats://nats:4222
-  FLUXER_NATS_JETSTREAM_URL: nats://nats:4222
-
-extraEnv: []
-
-envFrom:
-  - secretRef:
-      name: fluxer-env
-
-podAnnotations: {}
-
-podSecurityContext:
-  runAsNonRoot: true
-  seccompProfile:
-    type: RuntimeDefault
-
-securityContext:
-  allowPrivilegeEscalation: false
-
-probes:
-  startup:
-    httpGet:
-      path: /_health
-      port: http
-    periodSeconds: 10
-    failureThreshold: 30
-  liveness:
-    httpGet:
-      path: /_health
-      port: http
-  readiness:
-    httpGet:
-      path: /_health
-      port: http
-
-strategy:
-  type: RollingUpdate
-
-topologySpreadConstraints: []
-
-nodeSelector: {}
-
-tolerations: []
-
-affinity: {}
-
-api:
-  api:
-    replicas: 1
-    resources:
-      requests:
-        cpu: 250m
-        memory: 1Gi
-      limits:
-        memory: 2560Mi
-
-workers:
-  worker:
-    replicas: 1
-    env:
-      FLUXER_API_WORKER_MODE: all_lanes
-      FLUXER_API_WORKER_ENABLE_CRON_SCHEDULER: "true"
-    resources:
-      requests:
-        cpu: 250m
-        memory: 1Gi
-      limits:
-        memory: 2560Mi
@@ -1,6 +0,0 @@
-apiVersion: v2
-name: fluxer-gateway
-description: A Helm chart for the Fluxer realtime gateway.
-type: application
-version: 0.1.0
-appVersion: "v1"
@@ -1,280 +0,0 @@
-{{- define "gateway.selectorLabels" -}}
-app.kubernetes.io/name: {{ .name }}
-app.kubernetes.io/instance: {{ .root.Release.Name }}
-{{- end }}
-
-{{- define "gateway.labels" -}}
-{{ include "gateway.selectorLabels" . }}
-{{- with .component }}
-app.kubernetes.io/component: {{ . }}
-{{- end }}
-app.kubernetes.io/part-of: fluxer
-app.kubernetes.io/managed-by: {{ .root.Release.Service }}
-helm.sh/chart: {{ printf "%s-%s" .root.Chart.Name .root.Chart.Version | replace "+" "_" }}
-{{- end }}
-
-{{- define "gateway.headlessName" -}}
-{{ printf "%s-headless" .Release.Name }}
-{{- end }}
-
-{{- define "gateway.pick" -}}
-{{- $v := get .root.Values .key }}
-{{- if hasKey .w .key }}
-{{- $v = get .w .key }}
-{{- end }}
-{{- with $v }}
-{{- toYaml . }}
-{{- end }}
-{{- end }}
-
-{{- define "gateway.string" -}}
-{{- if and (kindIs "float64" .) (eq . (float64 (int64 .))) }}
-{{- int64 . | toString }}
-{{- else }}
-{{- toString . }}
-{{- end }}
-{{- end }}
-
-{{- define "gateway.envList" -}}
-{{- $env := deepCopy (.root.Values.env | default dict) }}
-{{- range $k, $v := .w.env | default dict }}
-{{- if kindIs "invalid" $v }}
-{{- $_ := unset $env $k }}
-{{- else }}
-{{- $_ := set $env $k $v }}
-{{- end }}
-{{- end }}
-{{- range $k, $v := $env }}
-{{- if not (kindIs "invalid" $v) }}
- name: {{ $k }}
-  value: {{ include "gateway.string" $v | quote }}
-{{- end }}
-{{- end }}
-{{- with concat (.root.Values.extraEnv | default list) (.w.extraEnv | default list) }}
-{{ toYaml . }}
-{{- end }}
-{{- end }}
-
-{{- define "gateway.envFrom" -}}
-{{- with concat (.root.Values.envFrom | default list) (.w.envFrom | default list) }}
-{{- toYaml . }}
-{{- end }}
-{{- end }}
-
-{{- define "gateway.podAnnotations" -}}
-{{- with merge (deepCopy (.w.podAnnotations | default dict)) (deepCopy (.root.Values.podAnnotations | default dict)) }}
-{{- toYaml . }}
-{{- end }}
-{{- end }}
-
-{{- define "gateway.probes" -}}
-{{- $global := .root.Values.probes | default dict }}
-{{- $own := .w.probes | default dict }}
-{{- range $probe := list "startup" "liveness" "readiness" }}
-{{- $p := get $global $probe }}
-{{- if hasKey $own $probe }}
-{{- $p = get $own $probe }}
-{{- end }}
-{{- with $p }}
-{{ $probe }}Probe:
-  {{- toYaml . | nindent 2 }}
-{{- end }}
-{{- end }}
-{{- end }}
-
-{{- define "gateway.topologySpreadConstraints" -}}
-{{- $out := list }}
-{{- range include "gateway.pick" (dict "root" .root "w" .w "key" "topologySpreadConstraints") | fromYamlArray }}
-{{- $c := deepCopy . }}
-{{- if not (hasKey $c "labelSelector") }}
-{{- $_ := set $c "labelSelector" (dict "matchLabels" (include "gateway.selectorLabels" $ | fromYaml)) }}
-{{- end }}
-{{- $out = append $out $c }}
-{{- end }}
-{{- with $out }}
-{{- toYaml . }}
-{{- end }}
-{{- end }}
-
-{{- define "gateway.image" -}}
-{{- $img := .w.image | default dict }}
-{{- $v := .root.Values.image }}
-{{- $repo := $img.repository | default (printf "%s/%s" $v.registry ($img.name | default "fluxer-gateway")) }}
-{{- $ref := printf "%s:%s" $repo ($img.tag | default $v.tag) }}
-{{- with $img.digest }}
-{{- $ref = printf "%s@%s" $ref . }}
-{{- end }}
-{{- $ref | quote }}
-{{- end }}
-
-{{- define "gateway.replicas" -}}
-{{- if kindIs "invalid" .w.replicas }}1{{ else }}{{ .w.replicas }}{{ end }}
-{{- end }}
-
-{{- define "gateway.env" -}}
-{{- $root := .root }}
-{{- $w := .w -}}
-{{- with $w.role }}
- name: FLUXER_GATEWAY_ROLE
-  value: {{ . | quote }}
-{{- end }}
-{{- if not (kindIs "invalid" $w.buildVersion) }}
- name: BUILD_VERSION
-  value: {{ include "gateway.string" $w.buildVersion | quote }}
-{{- end }}
- name: POD_IP
-  valueFrom:
-    fieldRef:
-      apiVersion: v1
-      fieldPath: status.podIP
- name: FLUXER_ERLANG_NODE_NAME
-  value: fluxer_gateway@$(POD_IP)
- name: FLUXER_ERLANG_DIST_PORT
-  value: "8081"
- name: FLUXER_GATEWAY_CLUSTER_ENABLED
-  value: "true"
- name: FLUXER_GATEWAY_CLUSTER_DISCOVERY_DNS_NAME
-  value: {{ printf "%s.%s.svc.%s" (include "gateway.headlessName" $root) $root.Release.Namespace $root.Values.clusterDomain | quote }}
- name: FLUXER_GATEWAY_CLUSTER_DISCOVERY_NODE_BASENAME
-  value: fluxer_gateway
-{{- include "gateway.envList" . }}
-{{- end }}
-
-{{- define "gateway.pod" -}}
-{{- $root := .root }}
-{{- $w := .w -}}
-metadata:
-  labels:
-    {{- include "gateway.labels" . | nindent 4 }}
-  {{- with include "gateway.podAnnotations" . }}
-  annotations:
-    {{- . | nindent 4 }}
-  {{- end }}
-spec:
-  {{- with include "gateway.pick" (dict "root" $root "w" $w "key" "affinity") }}
-  affinity:
-    {{- . | nindent 4 }}
-  {{- end }}
-  {{- with include "gateway.pick" (dict "root" $root "w" $w "key" "imagePullSecrets") }}
-  imagePullSecrets:
-    {{- . | nindent 4 }}
-  {{- end }}
-  {{- with include "gateway.pick" (dict "root" $root "w" $w "key" "nodeSelector") }}
-  nodeSelector:
-    {{- . | nindent 4 }}
-  {{- end }}
-  {{- with include "gateway.pick" (dict "root" $root "w" $w "key" "tolerations") }}
-  tolerations:
-    {{- . | nindent 4 }}
-  {{- end }}
-  {{- with include "gateway.topologySpreadConstraints" . }}
-  topologySpreadConstraints:
-    {{- . | nindent 4 }}
-  {{- end }}
-  {{- with include "gateway.pick" (dict "root" $root "w" $w "key" "podSecurityContext") }}
-  securityContext:
-    {{- . | nindent 4 }}
-  {{- end }}
-  {{- if not (kindIs "invalid" $w.terminationGracePeriodSeconds) }}
-  terminationGracePeriodSeconds: {{ $w.terminationGracePeriodSeconds }}
-  {{- end }}
-  containers:
-  - name: gateway
-    image: {{ include "gateway.image" . }}
-    imagePullPolicy: {{ ($w.image | default dict).pullPolicy | default $root.Values.image.pullPolicy }}
-    env:
-      {{- include "gateway.env" . | trim | nindent 6 }}
-    {{- with include "gateway.envFrom" . }}
-    envFrom:
-      {{- . | nindent 6 }}
-    {{- end }}
-    {{- with $w.lifecycle }}
-    lifecycle:
-      {{- toYaml . | nindent 6 }}
-    {{- end }}
-    ports:
-    - name: http
-      containerPort: 8080
-      protocol: TCP
-    - name: epmd
-      containerPort: 4369
-      protocol: TCP
-    - name: erl-dist
-      containerPort: 8081
-      protocol: TCP
-    {{- with include "gateway.probes" . | trim }}
-    {{- . | nindent 4 }}
-    {{- end }}
-    {{- with $w.resources }}
-    resources:
-      {{- toYaml . | nindent 6 }}
-    {{- end }}
-    {{- with include "gateway.pick" (dict "root" $root "w" $w "key" "securityContext") }}
-    securityContext:
-      {{- . | nindent 6 }}
-    {{- end }}
-    {{- with $w.extraVolumeMounts }}
-    volumeMounts:
-      {{- toYaml . | nindent 6 }}
-    {{- end }}
-  {{- with $w.extraVolumes }}
-  volumes:
-    {{- toYaml . | nindent 4 }}
-  {{- end }}
-{{- end }}
-
-{{- define "gateway.pdb" -}}
-{{- with .w.pdb }}
---
-apiVersion: policy/v1
-kind: PodDisruptionBudget
-metadata:
-  name: {{ $.name }}-pdb
-  namespace: {{ $.root.Release.Namespace }}
-  labels:
-    {{- include "gateway.labels" $ | nindent 4 }}
-spec:
-  {{- if not (kindIs "invalid" .minAvailable) }}
-  minAvailable: {{ .minAvailable }}
-  {{- end }}
-  {{- if not (kindIs "invalid" .maxUnavailable) }}
-  maxUnavailable: {{ .maxUnavailable }}
-  {{- end }}
-  selector:
-    matchLabels:
-      {{- include "gateway.selectorLabels" $ | nindent 6 }}
-{{- end }}
-{{- end }}
-
-{{- define "gateway.hpa" -}}
-{{- with .w.hpa }}
---
-apiVersion: autoscaling/v2
-kind: HorizontalPodAutoscaler
-metadata:
-  name: {{ $.name }}
-  namespace: {{ $.root.Release.Namespace }}
-  labels:
-    {{- include "gateway.labels" $ | nindent 4 }}
-spec:
-  scaleTargetRef:
-    apiVersion: apps/v1
-    kind: Deployment
-    name: {{ $.name }}
-  minReplicas: {{ required (printf "%s.hpa.minReplicas is required" $.name) .minReplicas }}
-  maxReplicas: {{ required (printf "%s.hpa.maxReplicas is required" $.name) .maxReplicas }}
-  {{- if not (kindIs "invalid" .targetCPUUtilizationPercentage) }}
-  metrics:
-  - type: Resource
-    resource:
-      name: cpu
-      target:
-        type: Utilization
-        averageUtilization: {{ .targetCPUUtilizationPercentage }}
-  {{- end }}
-  {{- with .behavior }}
-  behavior:
-    {{- toYaml . | nindent 4 }}
-  {{- end }}
-{{- end }}
-{{- end }}
@@ -1,48 +0,0 @@
-{{- range $name, $w := .Values.deployments }}
-{{- if not (kindIs "invalid" $w) }}
-{{- $ctx := dict "root" $ "name" $name "component" $w.role "w" $w }}
---
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: {{ $name }}
-  namespace: {{ $.Release.Namespace }}
-  labels:
-    {{- include "gateway.labels" $ctx | nindent 4 }}
-spec:
-  {{- if not $w.hpa }}
-  replicas: {{ include "gateway.replicas" $ctx }}
-  {{- end }}
-  {{- if not (kindIs "invalid" $w.minReadySeconds) }}
-  minReadySeconds: {{ $w.minReadySeconds }}
-  {{- end }}
-  selector:
-    matchLabels:
-      {{- include "gateway.selectorLabels" $ctx | nindent 6 }}
-  {{- with include "gateway.pick" (dict "root" $ "w" $w "key" "strategy") }}
-  strategy:
-    {{- . | nindent 4 }}
-  {{- end }}
-  template:
-    {{- include "gateway.pod" $ctx | nindent 4 }}
---
-apiVersion: v1
-kind: Service
-metadata:
-  name: {{ $name }}
-  namespace: {{ $.Release.Namespace }}
-  labels:
-    {{- include "gateway.labels" $ctx | nindent 4 }}
-spec:
-  type: ClusterIP
-  ports:
-  - name: http
-    port: 8080
-    protocol: TCP
-    targetPort: http
-  selector:
-    {{- include "gateway.selectorLabels" $ctx | nindent 4 }}
-{{- include "gateway.hpa" $ctx }}
-{{- include "gateway.pdb" $ctx }}
-{{- end }}
-{{- end }}
@@ -1,26 +0,0 @@
-apiVersion: v1
-kind: Service
-metadata:
-  name: {{ include "gateway.headlessName" . }}
-  namespace: {{ .Release.Namespace }}
-  labels:
-    {{- include "gateway.labels" (dict "root" . "name" "gateway" "component" "discovery") | nindent 4 }}
-spec:
-  type: ClusterIP
-  clusterIP: None
-  ports:
-  - name: http
-    port: 8080
-    protocol: TCP
-    targetPort: http
-  - name: epmd
-    port: 4369
-    protocol: TCP
-    targetPort: epmd
-  - name: erl-dist
-    port: 8081
-    protocol: TCP
-    targetPort: erl-dist
-  selector:
-    app.kubernetes.io/instance: {{ .Release.Name }}
-    app.kubernetes.io/part-of: fluxer
@@ -1,53 +0,0 @@
-{{- $np := .Values.networkPolicy | default dict }}
-{{- if $np.enabled }}
-apiVersion: networking.k8s.io/v1
-kind: NetworkPolicy
-metadata:
-  name: gateway
-  namespace: {{ .Release.Namespace }}
-  labels:
-    {{- include "gateway.labels" (dict "root" . "name" "gateway") | nindent 4 }}
-spec:
-  podSelector:
-    matchLabels:
-      app.kubernetes.io/instance: {{ .Release.Name }}
-      app.kubernetes.io/part-of: fluxer
-  policyTypes:
-  - Ingress
-  - Egress
-  egress:
-  - {}
-  ingress:
-  {{- with $np.ingressNamespace }}
-  - from:
-    - namespaceSelector:
-        matchLabels:
-          kubernetes.io/metadata.name: {{ . }}
-    ports:
-    - port: 8080
-      protocol: TCP
-  {{- end }}
-  {{- with $np.clients }}
-  - from:
-    {{- range . }}
-    - podSelector:
-        matchLabels:
-          {{- toYaml . | nindent 10 }}
-    {{- end }}
-    ports:
-    - port: 8080
-      protocol: TCP
-  {{- end }}
-  - from:
-    - podSelector:
-        matchLabels:
-          app.kubernetes.io/instance: {{ .Release.Name }}
-          app.kubernetes.io/part-of: fluxer
-    ports:
-    - port: 8080
-      protocol: TCP
-    - port: 4369
-      protocol: TCP
-    - port: 8081
-      protocol: TCP
-{{- end }}
@@ -1,29 +0,0 @@
-{{- range $name, $w := .Values.statefulsets }}
-{{- if not (kindIs "invalid" $w) }}
-{{- $ctx := dict "root" $ "name" $name "component" $w.role "w" $w }}
---
-apiVersion: apps/v1
-kind: StatefulSet
-metadata:
-  name: {{ $name }}
-  namespace: {{ $.Release.Namespace }}
-  labels:
-    {{- include "gateway.labels" $ctx | nindent 4 }}
-spec:
-  replicas: {{ include "gateway.replicas" $ctx }}
-  {{- if not (kindIs "invalid" $w.minReadySeconds) }}
-  minReadySeconds: {{ $w.minReadySeconds }}
-  {{- end }}
-  serviceName: {{ include "gateway.headlessName" $ }}
-  selector:
-    matchLabels:
-      {{- include "gateway.selectorLabels" $ctx | nindent 6 }}
-  {{- with include "gateway.pick" (dict "root" $ "w" $w "key" "updateStrategy") }}
-  updateStrategy:
-    {{- . | nindent 4 }}
-  {{- end }}
-  template:
-    {{- include "gateway.pod" $ctx | nindent 4 }}
-{{- include "gateway.pdb" $ctx }}
-{{- end }}
-{{- end }}
@@ -1,86 +0,0 @@
-image:
-  registry: ghcr.io/fluxerapp
-  tag: v1
-  pullPolicy: IfNotPresent
-
-imagePullSecrets: []
-
-clusterDomain: cluster.local
-
-env:
-  FLUXER_ENV: production
-  FLUXER_GATEWAY_PORT: "8080"
-  FLUXER_GATEWAY_MEDIA_PROXY_ENDPOINT: https://media.example.com
-  FLUXER_INTERNAL_API_ENDPOINT: http://api:8080
-
-extraEnv: []
-
-envFrom:
- secretRef:
-    name: fluxer-env
-
-podAnnotations: {}
-
-podSecurityContext:
-  runAsNonRoot: true
-  seccompProfile:
-    type: RuntimeDefault
-
-securityContext:
-  allowPrivilegeEscalation: false
-
-probes:
-  startup:
-    httpGet:
-      path: /_health
-      port: http
-    failureThreshold: 30
-  liveness:
-    httpGet:
-      path: /_health
-      port: http
-  readiness:
-    exec:
-      command:
-      - curl
-      - -fsS
-      - -o
-      - /dev/null
-      - --max-time
-      - "2"
-      - http://127.0.0.1:8080/_health/ready
-    timeoutSeconds: 3
-
-strategy: {}
-updateStrategy: {}
-
-topologySpreadConstraints: []
-nodeSelector: {}
-tolerations: []
-affinity: {}
-
-networkPolicy:
-  enabled: false
-  ingressNamespace: ingress-nginx
-  clients:
-  - app.kubernetes.io/part-of: fluxer
-
-deployments:
-  gateway:
-    role: all
-    replicas: 1
-    lifecycle:
-      preStop:
-        exec:
-          command:
-          - /bin/sh
-          - -c
-          - curl -fsS -o /dev/null --max-time 2 http://127.0.0.1:8080/_health/drain; sleep 5
-    resources:
-      requests:
-        cpu: 100m
-        memory: 384Mi
-      limits:
-        memory: 1Gi
-
-statefulsets: {}
@@ -1,6 +0,0 @@
-apiVersion: v2
-name: fluxer-infra
-description: NATS and Valkey for a Fluxer installation.
-type: application
-version: 0.1.0
-appVersion: "v1"
@@ -1,282 +0,0 @@
-{{- define "fluxer-infra.chart" -}}
-{{- printf "%s-%s" .Chart.Name .Chart.Version | replace "+" "_" | trunc 63 | trimSuffix "-" -}}
-{{- end }}
-
-{{- define "fluxer-infra.selectorLabels" -}}
-app.kubernetes.io/name: {{ .name }}
-app.kubernetes.io/instance: {{ .root.Release.Name }}
-{{- end }}
-
-{{- define "fluxer-infra.labels" -}}
-{{ include "fluxer-infra.selectorLabels" . }}
-app.kubernetes.io/component: {{ .component }}
-app.kubernetes.io/part-of: fluxer
-app.kubernetes.io/managed-by: {{ .root.Release.Service }}
-helm.sh/chart: {{ include "fluxer-infra.chart" .root }}
-{{- end }}
-
-{{- define "fluxer-infra.pick" -}}
-{{- $v := get .root.Values .key }}
-{{- if hasKey .w .key }}
-{{- $v = get .w .key }}
-{{- end }}
-{{- with $v }}
-{{- toYaml . }}
-{{- end }}
-{{- end }}
-
-{{- define "fluxer-infra.string" -}}
-{{- if and (kindIs "float64" .) (eq . (float64 (int64 .))) }}
-{{- int64 . | toString }}
-{{- else }}
-{{- toString . }}
-{{- end }}
-{{- end }}
-
-{{- define "fluxer-infra.envList" -}}
-{{- $env := deepCopy (.root.Values.env | default dict) }}
-{{- range $k, $v := .w.env | default dict }}
-{{- if kindIs "invalid" $v }}
-{{- $_ := unset $env $k }}
-{{- else }}
-{{- $_ := set $env $k $v }}
-{{- end }}
-{{- end }}
-{{- range $k, $v := $env }}
-{{- if not (kindIs "invalid" $v) }}
- name: {{ $k }}
-  value: {{ include "fluxer-infra.string" $v | quote }}
-{{- end }}
-{{- end }}
-{{- with concat (.root.Values.extraEnv | default list) (.w.extraEnv | default list) }}
-{{ toYaml . }}
-{{- end }}
-{{- end }}
-
-{{- define "fluxer-infra.envFrom" -}}
-{{- with concat (.root.Values.envFrom | default list) (.w.envFrom | default list) }}
-{{- toYaml . }}
-{{- end }}
-{{- end }}
-
-{{- define "fluxer-infra.probes" -}}
-{{- $global := .root.Values.probes | default dict }}
-{{- $own := .w.probes | default dict }}
-{{- range $probe := list "startup" "liveness" "readiness" }}
-{{- $p := get $global $probe }}
-{{- if hasKey $own $probe }}
-{{- $p = get $own $probe }}
-{{- end }}
-{{- with $p }}
-{{ $probe }}Probe:
-  {{- toYaml . | nindent 2 }}
-{{- end }}
-{{- end }}
-{{- end }}
-
-{{- define "fluxer-infra.topologySpreadConstraints" -}}
-{{- $out := list }}
-{{- range include "fluxer-infra.pick" (dict "root" .root "w" .w "key" "topologySpreadConstraints") | fromYamlArray }}
-{{- $c := deepCopy . }}
-{{- if not (hasKey $c "labelSelector") }}
-{{- $_ := set $c "labelSelector" (dict "matchLabels" (include "fluxer-infra.selectorLabels" $ | fromYaml)) }}
-{{- end }}
-{{- $out = append $out $c }}
-{{- end }}
-{{- with $out }}
-{{- toYaml . }}
-{{- end }}
-{{- end }}
-
-{{- define "fluxer-infra.replicas" -}}
-{{- if kindIs "invalid" .w.replicas }}1{{ else }}{{ .w.replicas }}{{ end }}
-{{- end }}
-
-{{- define "fluxer-infra.image" -}}
-{{- $ref := printf "%s:%s" .repository .tag }}
-{{- with .digest }}
-{{- $ref = printf "%s@%s" $ref . }}
-{{- end }}
-{{- $ref | quote }}
-{{- end }}
-
-{{- define "fluxer-infra.podAnnotations" -}}
-{{- with merge (deepCopy (.extra | default dict)) (deepCopy (.w.podAnnotations | default dict)) (deepCopy (.root.Values.podAnnotations | default dict)) }}
-annotations:
-  {{- toYaml . | nindent 2 }}
-{{- end }}
-{{- end }}
-
-{{- define "fluxer-infra.podSpec" -}}
-{{- $root := .root }}
-{{- $w := .w }}
-{{- with include "fluxer-infra.pick" (dict "root" $root "w" $w "key" "affinity") }}
-affinity:
-  {{- . | nindent 2 }}
-{{- end }}
-{{- with include "fluxer-infra.pick" (dict "root" $root "w" $w "key" "imagePullSecrets") }}
-imagePullSecrets:
-  {{- . | nindent 2 }}
-{{- end }}
-{{- with include "fluxer-infra.pick" (dict "root" $root "w" $w "key" "nodeSelector") }}
-nodeSelector:
-  {{- . | nindent 2 }}
-{{- end }}
-{{- with include "fluxer-infra.pick" (dict "root" $root "w" $w "key" "tolerations") }}
-tolerations:
-  {{- . | nindent 2 }}
-{{- end }}
-{{- with include "fluxer-infra.topologySpreadConstraints" . }}
-topologySpreadConstraints:
-  {{- . | nindent 2 }}
-{{- end }}
-{{- with include "fluxer-infra.pick" (dict "root" $root "w" $w "key" "podSecurityContext") }}
-securityContext:
-  {{- . | nindent 2 }}
-{{- end }}
-{{- if not (kindIs "invalid" $w.terminationGracePeriodSeconds) }}
-terminationGracePeriodSeconds: {{ $w.terminationGracePeriodSeconds }}
-{{- end }}
-{{- end }}
-
-{{- define "fluxer-infra.containerCommon" -}}
-{{- $root := .root }}
-{{- $w := .w }}
-{{- $img := $w.image | default dict }}
-image: {{ include "fluxer-infra.image" $img }}
-imagePullPolicy: {{ $img.pullPolicy }}
-{{- $env := include "fluxer-infra.envList" . | trim }}
-{{- if or .env $env }}
-env:
-{{- with .env }}
-  {{- toYaml . | nindent 2 }}
-{{- end }}
-{{- with $env }}
-  {{- . | nindent 2 }}
-{{- end }}
-{{- end }}
-{{- with include "fluxer-infra.envFrom" . }}
-envFrom:
-  {{- . | nindent 2 }}
-{{- end }}
-{{- with $w.lifecycle }}
-lifecycle:
-  {{- toYaml . | nindent 2 }}
-{{- end }}
-{{- include "fluxer-infra.probes" . }}
-{{- with $w.resources }}
-resources:
-  {{- toYaml . | nindent 2 }}
-{{- end }}
-{{- with include "fluxer-infra.pick" (dict "root" $root "w" $w "key" "securityContext") }}
-securityContext:
-  {{- . | nindent 2 }}
-{{- end }}
-{{- with concat .mounts ($w.extraVolumeMounts | default list) }}
-volumeMounts:
-  {{- toYaml . | nindent 2 }}
-{{- end }}
-{{- end }}
-
-{{- define "fluxer-infra.statefulSetSpec" -}}
-{{- $w := .w }}
-{{- with include "fluxer-infra.pick" (dict "root" .root "w" $w "key" "updateStrategy") }}
-updateStrategy:
-  {{- . | nindent 2 }}
-{{- end }}
-{{- if not (kindIs "invalid" $w.minReadySeconds) }}
-minReadySeconds: {{ $w.minReadySeconds }}
-{{- end }}
-{{- end }}
-
-{{- define "fluxer-infra.volumeClaim" -}}
- metadata:
-    name: data
-  spec:
-    accessModes:
-      - ReadWriteOnce
-    {{- with .storageClassName }}
-    storageClassName: {{ . | quote }}
-    {{- end }}
-    resources:
-      requests:
-        storage: {{ .size }}
-{{- end }}
-
-{{- define "fluxer-infra.pdb" -}}
-{{- with .w.pdb }}
---
-apiVersion: policy/v1
-kind: PodDisruptionBudget
-metadata:
-  name: {{ $.name }}-pdb
-  namespace: {{ $.root.Release.Namespace }}
-  labels:
-    {{- include "fluxer-infra.labels" $ | nindent 4 }}
-spec:
-  {{- if not (kindIs "invalid" .minAvailable) }}
-  minAvailable: {{ .minAvailable }}
-  {{- end }}
-  {{- if not (kindIs "invalid" .maxUnavailable) }}
-  maxUnavailable: {{ .maxUnavailable }}
-  {{- end }}
-  selector:
-    matchLabels:
-      {{- include "fluxer-infra.selectorLabels" $ | nindent 6 }}
-{{- end }}
-{{- end }}
-
-{{- define "fluxer-infra.service" }}
---
-apiVersion: v1
-kind: Service
-metadata:
-  name: {{ .svcName }}
-  namespace: {{ .root.Release.Namespace }}
-  labels:
-    {{- include "fluxer-infra.labels" . | nindent 4 }}
-spec:
-  {{- if .headless }}
-  clusterIP: None
-  {{- end }}
-  {{- if .publishNotReady }}
-  publishNotReadyAddresses: true
-  {{- end }}
-  selector:
-    {{- include "fluxer-infra.selectorLabels" . | nindent 4 }}
-  ports:
-    {{- range .ports }}
-    - name: {{ index . 0 }}
-      port: {{ index . 1 }}
-      targetPort: {{ index . 0 }}
-    {{- end }}
-{{- end }}
-
-{{- define "fluxer-infra.natsConf" -}}
-{{- $w := .Values.nats -}}
-{{- with $w.config -}}
-listen: 0.0.0.0:4222
-http: 0.0.0.0:8222
-max_payload: {{ .maxPayload }}
-max_pending: {{ .maxPending }}
-max_connections: {{ .maxConnections }}
-{{- if $w.jetstream.enabled }}
-server_name: $POD_NAME
-
-jetstream {
-  store_dir: /data
-}
-{{- end }}
-
-cluster {
-  name: {{ .clusterName }}
-  listen: 0.0.0.0:6222
-
-  routes = [
-{{- range $i := until (int (include "fluxer-infra.replicas" (dict "w" $w))) }}
-    nats-route://nats-{{ $i }}.nats-headless.{{ $.Release.Namespace }}.svc.{{ $.Values.clusterDomain }}:6222
-{{- end }}
-  ]
-}
-{{ end }}
-{{- end }}
@@ -1,71 +0,0 @@
-{{- with .Values.nats }}
-{{- $ctx := dict "root" $ "w" . "name" "nats" "component" "messaging" }}
-apiVersion: v1
-kind: ConfigMap
-metadata:
-  name: nats-config
-  namespace: {{ $.Release.Namespace }}
-  labels:
-    {{- include "fluxer-infra.labels" $ctx | nindent 4 }}
-data:
-  nats.conf: {{ include "fluxer-infra.natsConf" $ | toJson }}
-{{- include "fluxer-infra.pdb" $ctx }}
-{{- include "fluxer-infra.service" (merge (dict "svcName" "nats" "ports" (list (list "client" 4222))) $ctx) }}
-{{- include "fluxer-infra.service" (merge (dict "svcName" "nats-headless" "headless" true "ports" (list (list "client" 4222) (list "cluster" 6222) (list "monitor" 8222))) $ctx) }}
-{{- $mounts := list (dict "name" "config" "mountPath" "/etc/nats") }}
-{{- $env := list }}
-{{- if .jetstream.enabled }}
-{{- $mounts = append $mounts (dict "name" "data" "mountPath" "/data") }}
-{{- $env = append $env (dict "name" "POD_NAME" "valueFrom" (dict "fieldRef" (dict "fieldPath" "metadata.name"))) }}
-{{- end }}
---
-apiVersion: apps/v1
-kind: StatefulSet
-metadata:
-  name: nats
-  namespace: {{ $.Release.Namespace }}
-  labels:
-    {{- include "fluxer-infra.labels" $ctx | nindent 4 }}
-spec:
-  replicas: {{ include "fluxer-infra.replicas" $ctx }}
-  serviceName: nats-headless
-  {{- with include "fluxer-infra.statefulSetSpec" $ctx | trim }}
-  {{- . | nindent 2 }}
-  {{- end }}
-  selector:
-    matchLabels:
-      {{- include "fluxer-infra.selectorLabels" $ctx | nindent 6 }}
-  template:
-    metadata:
-      labels:
-        {{- include "fluxer-infra.labels" $ctx | nindent 8 }}
-      {{- with include "fluxer-infra.podAnnotations" (merge (dict "extra" (dict "checksum/config" (include "fluxer-infra.natsConf" $ | sha256sum))) $ctx) | trim }}
-      {{- . | nindent 6 }}
-      {{- end }}
-    spec:
-      {{- include "fluxer-infra.podSpec" $ctx | trim | nindent 6 }}
-      containers:
-        - name: nats
-          {{- include "fluxer-infra.containerCommon" (merge (dict "env" $env "mounts" $mounts) $ctx) | trim | nindent 10 }}
-          args:
-            - -c
-            - /etc/nats/nats.conf
-          ports:
-            - name: client
-              containerPort: 4222
-            - name: cluster
-              containerPort: 6222
-            - name: monitor
-              containerPort: 8222
-      volumes:
-        - name: config
-          configMap:
-            name: nats-config
-        {{- with .extraVolumes }}
-        {{- toYaml . | nindent 8 }}
-        {{- end }}
-  {{- if .jetstream.enabled }}
-  volumeClaimTemplates:
-    {{- include "fluxer-infra.volumeClaim" .jetstream.storage | nindent 4 }}
-  {{- end }}
-{{- end }}
@@ -1,67 +0,0 @@
-{{- with .Values.valkey }}
-{{- $ctx := dict "root" $ "w" . "name" "valkey" "component" "cache" }}
-{{- include "fluxer-infra.pdb" $ctx }}
-{{- include "fluxer-infra.service" (merge (dict "svcName" "valkey" "ports" (list (list "valkey" 6379))) $ctx) }}
-{{- include "fluxer-infra.service" (merge (dict "svcName" "valkey-headless" "headless" true "publishNotReady" true "ports" (list (list "valkey" 6379))) $ctx) }}
-{{- $mounts := list }}
-{{- if .persistence.enabled }}
-{{- $mounts = append $mounts (dict "name" "data" "mountPath" "/data") }}
-{{- end }}
---
-apiVersion: apps/v1
-kind: StatefulSet
-metadata:
-  name: valkey
-  namespace: {{ $.Release.Namespace }}
-  labels:
-    {{- include "fluxer-infra.labels" $ctx | nindent 4 }}
-spec:
-  replicas: 1
-  serviceName: valkey-headless
-  {{- with include "fluxer-infra.statefulSetSpec" $ctx | trim }}
-  {{- . | nindent 2 }}
-  {{- end }}
-  selector:
-    matchLabels:
-      {{- include "fluxer-infra.selectorLabels" $ctx | nindent 6 }}
-  template:
-    metadata:
-      labels:
-        {{- include "fluxer-infra.labels" $ctx | nindent 8 }}
-      {{- with include "fluxer-infra.podAnnotations" $ctx | trim }}
-      {{- . | nindent 6 }}
-      {{- end }}
-    spec:
-      {{- include "fluxer-infra.podSpec" $ctx | trim | nindent 6 }}
-      containers:
-        - name: valkey
-          {{- include "fluxer-infra.containerCommon" (merge (dict "env" list "mounts" $mounts) $ctx) | trim | nindent 10 }}
-          command:
-            - valkey-server
-            {{- if .persistence.enabled }}
-            - --appendonly
-            - "yes"
-            - --dir
-            - /data
-            {{- else }}
-            - --save
-            - ""
-            - --appendonly
-            - "no"
-            {{- end }}
-            - --maxmemory
-            - {{ .maxmemory | quote }}
-            - --maxmemory-policy
-            - {{ .maxmemoryPolicy | quote }}
-          ports:
-            - name: valkey
-              containerPort: 6379
-      {{- with .extraVolumes }}
-      volumes:
-        {{- toYaml . | nindent 8 }}
-      {{- end }}
-  {{- if .persistence.enabled }}
-  volumeClaimTemplates:
-    {{- include "fluxer-infra.volumeClaim" .persistence | nindent 4 }}
-  {{- end }}
-{{- end }}
@@ -1,108 +0,0 @@
-imagePullSecrets: []
-
-clusterDomain: cluster.local
-
-env: {}
-
-extraEnv: []
-
-envFrom: []
-
-podAnnotations: {}
-
-podSecurityContext:
-  runAsNonRoot: true
-  seccompProfile:
-    type: RuntimeDefault
-
-securityContext:
-  allowPrivilegeEscalation: false
-
-probes: {}
-
-updateStrategy: {}
-
-topologySpreadConstraints: []
-
-nodeSelector: {}
-
-tolerations: []
-
-affinity: {}
-
-nats:
-  image:
-    repository: nats
-    tag: 2.14-alpine
-    pullPolicy: IfNotPresent
-  replicas: 3
-  config:
-    clusterName: nats
-    maxPayload: 1MB
-    maxPending: 64MB
-    maxConnections: 65536
-  jetstream:
-    enabled: true
-    storage:
-      size: 10Gi
-      storageClassName: ""
-  podSecurityContext:
-    fsGroup: 65534
-    runAsGroup: 65534
-    runAsNonRoot: true
-    runAsUser: 65534
-    seccompProfile:
-      type: RuntimeDefault
-  probes:
-    liveness:
-      httpGet:
-        path: /healthz
-        port: monitor
-      initialDelaySeconds: 10
-    readiness:
-      httpGet:
-        path: /healthz?js-enabled-only=true
-        port: monitor
-  resources:
-    requests:
-      cpu: 50m
-      memory: 128Mi
-    limits:
-      memory: 512Mi
-
-valkey:
-  image:
-    repository: valkey/valkey
-    tag: 9.1-alpine
-    pullPolicy: IfNotPresent
-  maxmemory: 192mb
-  maxmemoryPolicy: noeviction
-  persistence:
-    enabled: true
-    size: 1Gi
-    storageClassName: ""
-  podSecurityContext:
-    fsGroup: 999
-    runAsGroup: 999
-    runAsNonRoot: true
-    runAsUser: 999
-    seccompProfile:
-      type: RuntimeDefault
-  probes:
-    liveness:
-      exec:
-        command:
-          - valkey-cli
-          - ping
-      initialDelaySeconds: 10
-    readiness:
-      exec:
-        command:
-          - valkey-cli
-          - ping
-  resources:
-    requests:
-      cpu: 50m
-      memory: 64Mi
-    limits:
-      memory: 256Mi
@@ -1,6 +0,0 @@
-apiVersion: v2
-name: fluxer-ingress
-description: Ingress routing for the public Fluxer endpoints.
-type: application
-version: 0.1.0
-appVersion: "v1"
@@ -1,27 +0,0 @@
-{{- define "fluxer-ingress.chart" -}}
-{{- printf "%s-%s" .Chart.Name .Chart.Version | replace "+" "_" | trunc 63 | trimSuffix "-" -}}
-{{- end }}
-
-{{- define "fluxer-ingress.labels" -}}
-app.kubernetes.io/name: {{ .Chart.Name }}
-app.kubernetes.io/instance: {{ .Release.Name }}
-app.kubernetes.io/part-of: fluxer
-app.kubernetes.io/managed-by: {{ .Release.Service }}
-helm.sh/chart: {{ include "fluxer-ingress.chart" . }}
-{{- end }}
-
-{{- define "fluxer-ingress.annotationKey" -}}
-{{- if or (contains "/" .key) (not .prefix) -}}
-{{- .key -}}
-{{- else -}}
-{{- printf "%s/%s" .prefix .key -}}
-{{- end -}}
-{{- end }}
-
-{{- define "fluxer-ingress.string" -}}
-{{- if and (kindIs "float64" .) (eq . (floor .)) -}}
-{{- . | int64 | toString -}}
-{{- else -}}
-{{- . | toString -}}
-{{- end -}}
-{{- end }}
@@ -1,20 +0,0 @@
-{{- with .Values.clusterIssuer }}
-{{- if .enabled }}
-apiVersion: cert-manager.io/v1
-kind: ClusterIssuer
-metadata:
-  name: {{ required "clusterIssuer.name is required" .name }}
-  labels:
-    {{- include "fluxer-ingress.labels" $ | nindent 4 }}
-spec:
-  acme:
-    email: {{ required "clusterIssuer.email is required" .email | quote }}
-    privateKeySecretRef:
-      name: {{ required "clusterIssuer.privateKeySecretName is required" .privateKeySecretName }}
-    server: {{ required "clusterIssuer.server is required" .server }}
-    solvers:
-      - http01:
-          ingress:
-            class: {{ required "clusterIssuer.solverIngressClass is required" .solverIngressClass }}
-{{- end }}
-{{- end }}
@@ -1,58 +0,0 @@
-{{- $v := .Values }}
-{{- $presets := $v.annotationPresets | default dict }}
-{{- $issuer := $v.clusterIssuer | default dict }}
-{{- range $name, $spec := ($v.ingresses | default dict) }}
-{{- if not (kindIs "invalid" $spec) }}
-{{- $ann := deepCopy ($v.commonAnnotations | default dict) }}
-{{- range ($spec.presets | default list) }}
-{{- $ann = mergeOverwrite $ann (deepCopy (required (printf "unknown annotation preset %s" .) (index $presets .))) }}
-{{- end }}
-{{- if and $spec.tls $issuer.enabled }}
-{{- $_ := set $ann "cert-manager.io/cluster-issuer" (required "clusterIssuer.name is required" $issuer.name) }}
-{{- end }}
-{{- $ann = mergeOverwrite $ann (deepCopy ($spec.annotations | default dict)) }}
-{{- range $k, $val := $ann }}
-{{- if kindIs "invalid" $val }}
-{{- $_ := unset $ann $k }}
-{{- end }}
-{{- end }}
---
-apiVersion: networking.k8s.io/v1
-kind: Ingress
-metadata:
-  name: {{ $name }}
-  namespace: {{ $.Release.Namespace }}
-  labels:
-    {{- include "fluxer-ingress.labels" $ | nindent 4 }}
-  {{- with $ann }}
-  annotations:
-    {{- range $k, $val := . }}
-    {{ include "fluxer-ingress.annotationKey" (dict "key" $k "prefix" $v.annotationPrefix) }}: {{ include "fluxer-ingress.string" $val | quote }}
-    {{- end }}
-  {{- end }}
-spec:
-  {{- with $spec.ingressClassName | default $v.ingressClassName }}
-  ingressClassName: {{ . }}
-  {{- end }}
-  {{- with $spec.tls }}
-  tls:
-    {{- toYaml . | nindent 4 }}
-  {{- end }}
-  rules:
-    {{- range $rule := required (printf "ingress %s needs rules" $name) $spec.rules }}
-    - host: {{ required (printf "ingress %s has a rule without a host" $name) $rule.host | quote }}
-      http:
-        paths:
-          {{- range $p := $rule.paths | default (list dict) }}
-          {{- $p = $p | default dict }}
-          - path: {{ $p.path | default "/" | quote }}
-            pathType: {{ $p.pathType | default "Prefix" }}
-            backend:
-              service:
-                name: {{ required (printf "ingress %s host %s needs a service" $name $rule.host) ($p.service | default $rule.service) }}
-                port:
-                  number: {{ required (printf "ingress %s host %s needs a port or servicePort" $name $rule.host) ($p.port | default $rule.port | default $v.servicePort) | int64 }}
-          {{- end }}
-    {{- end }}
-{{- end }}
-{{- end }}
@@ -1,53 +0,0 @@
-ingressClassName: nginx
-annotationPrefix: nginx.ingress.kubernetes.io
-servicePort: 8080
-
-commonAnnotations: {}
-
-annotationPresets:
-  websocket:
-    proxy-read-timeout: "3600"
-    proxy-send-timeout: "3600"
-  stripPrefix:
-    use-regex: "true"
-    rewrite-target: /$2
-
-ingresses:
-  fluxer:
-    rules:
-      - host: web.example.com
-        service: app-proxy
-      - host: api.example.com
-        service: api
-      - host: admin.example.com
-        service: admin
-      - host: media.example.com
-        service: media-proxy
-  fluxer-web-api:
-    presets: [stripPrefix]
-    rules:
-      - host: web.example.com
-        service: api
-        paths:
-          - path: /api(/(.*))?$
-            pathType: ImplementationSpecific
-  fluxer-gateway:
-    presets: [websocket]
-    rules:
-      - host: gateway.example.com
-        service: gateway
-  fluxer-uploads:
-    annotations:
-      proxy-body-size: 100m
-      proxy-request-buffering: "off"
-    rules:
-      - host: uploads.example.com
-        service: uploads
-
-clusterIssuer:
-  enabled: false
-  name: letsencrypt
-  email: ""
-  server: https://acme-v02.api.letsencrypt.org/directory
-  privateKeySecretName: letsencrypt-account-key
-  solverIngressClass: nginx
@@ -1,6 +0,0 @@
-apiVersion: v2
-name: fluxer-media-proxy
-description: Fluxer media proxy and upload relay workloads.
-type: application
-version: 0.1.0
-appVersion: "v1"
@@ -1,87 +0,0 @@
-{{- define "fluxer-media-proxy.chart" -}}
-{{- printf "%s-%s" .Chart.Name .Chart.Version | replace "+" "_" | trunc 63 | trimSuffix "-" -}}
-{{- end }}
-
-{{- define "fluxer-media-proxy.selectorLabels" -}}
-app.kubernetes.io/name: {{ .name }}
-app.kubernetes.io/instance: {{ .root.Release.Name }}
-{{- end }}
-
-{{- define "fluxer-media-proxy.labels" -}}
-{{ include "fluxer-media-proxy.selectorLabels" . }}
-app.kubernetes.io/component: {{ include "fluxer-media-proxy.mode" . }}
-app.kubernetes.io/part-of: fluxer
-app.kubernetes.io/managed-by: {{ .root.Release.Service }}
-helm.sh/chart: {{ include "fluxer-media-proxy.chart" .root }}
-{{- end }}
-
-{{- define "fluxer-media-proxy.image" -}}
-{{- $g := .root.Values.image -}}
-{{- $i := .w.image | default dict -}}
-{{- $repo := $i.repository | default (printf "%s/%s" $g.registry ($i.name | default "fluxer-media-proxy")) -}}
-{{- $tag := $i.tag | default $g.tag -}}
-{{- if $i.digest -}}
-{{- printf "%s:%s@%s" $repo $tag $i.digest | quote -}}
-{{- else -}}
-{{- printf "%s:%s" $repo $tag | quote -}}
-{{- end -}}
-{{- end }}
-
-{{- define "fluxer-media-proxy.pick" -}}
-{{- $v := ternary (get .w .key) (get .root.Values .key) (hasKey .w .key) -}}
-{{- if $v }}
-{{- toYaml $v }}
-{{- end }}
-{{- end }}
-
-{{- define "fluxer-media-proxy.mode" -}}
-{{- $mode := required (printf "workloads.%s.mode is required" .name) .w.mode -}}
-{{- if not (has $mode (list "mp" "static" "upload" "relay")) -}}
-{{- fail (printf "workloads.%s.mode must be mp, static, upload or relay" .name) -}}
-{{- end -}}
-{{- $mode -}}
-{{- end }}
-
-{{- define "fluxer-media-proxy.envValue" -}}
-{{- if and (kindIs "float64" .) (eq . (float64 (int64 .))) -}}
-{{- int64 . | toString -}}
-{{- else -}}
-{{- toString . -}}
-{{- end -}}
-{{- end }}
-
-{{- define "fluxer-media-proxy.mergeEnv" -}}
-{{- $out := dict -}}
-{{- range $layer := . -}}
-{{- range $k, $v := ($layer | default dict) -}}
-{{- if kindIs "invalid" $v -}}
-{{- $_ := unset $out $k -}}
-{{- else -}}
-{{- $_ := set $out $k $v -}}
-{{- end -}}
-{{- end -}}
-{{- end -}}
-{{- toYaml $out -}}
-{{- end }}
-
-{{- define "fluxer-media-proxy.topologySpreadConstraints" -}}
-{{- $out := list -}}
-{{- range .constraints -}}
-{{- if .labelSelector -}}
-{{- $out = append $out . -}}
-{{- else -}}
-{{- $out = append $out (merge (dict "labelSelector" (dict "matchLabels" $.selector)) .) -}}
-{{- end -}}
-{{- end -}}
-{{- toYaml $out -}}
-{{- end }}
-
-{{- define "fluxer-media-proxy.pdb" -}}
-{{- $out := dict -}}
-{{- range $k := list "minAvailable" "maxUnavailable" -}}
-{{- if and (hasKey $ $k) (not (kindIs "invalid" (index $ $k))) -}}
-{{- $_ := set $out $k (index $ $k) -}}
-{{- end -}}
-{{- end -}}
-{{- toYaml $out -}}
-{{- end }}
@@ -1,191 +0,0 @@
-{{- range $name, $w := .Values.workloads }}
-{{- if not (kindIs "invalid" $w) }}
-{{- $ctx := dict "root" $ "name" $name "w" $w }}
-{{- $mode := include "fluxer-media-proxy.mode" $ctx }}
-{{- $sel := include "fluxer-media-proxy.selectorLabels" $ctx | fromYaml }}
-{{- $env := include "fluxer-media-proxy.mergeEnv" (list $.Values.env $w.env) | fromYaml }}
-{{- $extraEnv := concat ($.Values.extraEnv | default list) ($w.extraEnv | default list) }}
-{{- $envFrom := concat ($.Values.envFrom | default list) ($w.envFrom | default list) }}
-{{- $podAnnotations := merge (dict) ($w.podAnnotations | default dict) ($.Values.podAnnotations | default dict) }}
-{{- $probes := dict }}
-{{- range $k, $v := ($.Values.probes | default dict) }}
-{{- $_ := set $probes $k $v }}
-{{- end }}
-{{- range $k, $v := ($w.probes | default dict) }}
-{{- $_ := set $probes $k $v }}
-{{- end }}
-{{- $pick := dict "root" $ "w" $w }}
---
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: {{ $name }}
-  namespace: {{ $.Release.Namespace }}
-  labels:
-    {{- include "fluxer-media-proxy.labels" $ctx | nindent 4 }}
-spec:
-  {{- if not $w.hpa }}
-  replicas: {{ ternary $w.replicas 1 (hasKey $w "replicas") | int64 }}
-  {{- end }}
-  {{- if not (kindIs "invalid" $w.minReadySeconds) }}
-  minReadySeconds: {{ $w.minReadySeconds | int64 }}
-  {{- end }}
-  selector:
-    matchLabels:
-      {{- toYaml $sel | nindent 6 }}
-  {{- with include "fluxer-media-proxy.pick" (set (deepCopy $pick) "key" "strategy") }}
-  strategy:
-    {{- . | nindent 4 }}
-  {{- end }}
-  template:
-    metadata:
-      {{- with $podAnnotations }}
-      annotations:
-        {{- toYaml . | nindent 8 }}
-      {{- end }}
-      labels:
-        {{- include "fluxer-media-proxy.labels" $ctx | nindent 8 }}
-    spec:
-      {{- with include "fluxer-media-proxy.pick" (set (deepCopy $pick) "key" "imagePullSecrets") }}
-      imagePullSecrets:
-        {{- . | nindent 8 }}
-      {{- end }}
-      {{- with include "fluxer-media-proxy.pick" (set (deepCopy $pick) "key" "podSecurityContext") }}
-      securityContext:
-        {{- . | nindent 8 }}
-      {{- end }}
-      {{- if not (kindIs "invalid" $w.terminationGracePeriodSeconds) }}
-      terminationGracePeriodSeconds: {{ $w.terminationGracePeriodSeconds | int64 }}
-      {{- end }}
-      {{- with include "fluxer-media-proxy.pick" (set (deepCopy $pick) "key" "nodeSelector") }}
-      nodeSelector:
-        {{- . | nindent 8 }}
-      {{- end }}
-      {{- with include "fluxer-media-proxy.pick" (set (deepCopy $pick) "key" "tolerations") }}
-      tolerations:
-        {{- . | nindent 8 }}
-      {{- end }}
-      {{- with include "fluxer-media-proxy.pick" (set (deepCopy $pick) "key" "affinity") }}
-      affinity:
-        {{- . | nindent 8 }}
-      {{- end }}
-      {{- with include "fluxer-media-proxy.pick" (set (deepCopy $pick) "key" "topologySpreadConstraints") | fromYamlArray }}
-      topologySpreadConstraints:
-        {{- include "fluxer-media-proxy.topologySpreadConstraints" (dict "constraints" . "selector" $sel) | nindent 8 }}
-      {{- end }}
-      containers:
-        - name: {{ $name }}
-          image: {{ include "fluxer-media-proxy.image" $ctx }}
-          imagePullPolicy: {{ ($w.image | default dict).pullPolicy | default $.Values.image.pullPolicy }}
-          env:
-            {{- if not (kindIs "invalid" $w.buildVersion) }}
-            - name: BUILD_VERSION
-              value: {{ include "fluxer-media-proxy.envValue" $w.buildVersion | quote }}
-            {{- end }}
-            - name: FLUXER_MEDIA_PROXY_MODE
-              value: {{ $mode | quote }}
-            {{- range $k, $v := $env }}
-            - name: {{ $k }}
-              value: {{ include "fluxer-media-proxy.envValue" $v | quote }}
-            {{- end }}
-            {{- with $extraEnv }}
-            {{- toYaml . | nindent 12 }}
-            {{- end }}
-          {{- with $envFrom }}
-          envFrom:
-            {{- toYaml . | nindent 12 }}
-          {{- end }}
-          ports:
-            - name: http
-              containerPort: 8080
-              protocol: TCP
-          {{- with $w.lifecycle }}
-          lifecycle:
-            {{- toYaml . | nindent 12 }}
-          {{- end }}
-          {{- range $k := list "startup" "liveness" "readiness" }}
-          {{- with get $probes $k }}
-          {{ $k }}Probe:
-            {{- toYaml . | nindent 12 }}
-          {{- end }}
-          {{- end }}
-          {{- with $w.resources }}
-          resources:
-            {{- toYaml . | nindent 12 }}
-          {{- end }}
-          {{- with include "fluxer-media-proxy.pick" (set (deepCopy $pick) "key" "securityContext") }}
-          securityContext:
-            {{- . | nindent 12 }}
-          {{- end }}
-          {{- with $w.extraVolumeMounts }}
-          volumeMounts:
-            {{- toYaml . | nindent 12 }}
-          {{- end }}
-      {{- with $w.extraVolumes }}
-      volumes:
-        {{- toYaml . | nindent 8 }}
-      {{- end }}
---
-apiVersion: v1
-kind: Service
-metadata:
-  name: {{ $name }}
-  namespace: {{ $.Release.Namespace }}
-  labels:
-    {{- include "fluxer-media-proxy.labels" $ctx | nindent 4 }}
-spec:
-  type: ClusterIP
-  selector:
-    {{- toYaml $sel | nindent 4 }}
-  ports:
-    - name: http
-      port: 8080
-      targetPort: http
-      protocol: TCP
-{{- with include "fluxer-media-proxy.pdb" ($w.pdb | default dict) | fromYaml }}
---
-apiVersion: policy/v1
-kind: PodDisruptionBudget
-metadata:
-  name: {{ $name }}-pdb
-  namespace: {{ $.Release.Namespace }}
-  labels:
-    {{- include "fluxer-media-proxy.labels" $ctx | nindent 4 }}
-spec:
-  {{- toYaml . | nindent 2 }}
-  selector:
-    matchLabels:
-      {{- toYaml $sel | nindent 6 }}
-{{- end }}
-{{- with $w.hpa }}
---
-apiVersion: autoscaling/v2
-kind: HorizontalPodAutoscaler
-metadata:
-  name: {{ $name }}
-  namespace: {{ $.Release.Namespace }}
-  labels:
-    {{- include "fluxer-media-proxy.labels" $ctx | nindent 4 }}
-spec:
-  scaleTargetRef:
-    apiVersion: apps/v1
-    kind: Deployment
-    name: {{ $name }}
-  minReplicas: {{ required (printf "workloads.%s.hpa.minReplicas is required" $name) .minReplicas | int64 }}
-  maxReplicas: {{ required (printf "workloads.%s.hpa.maxReplicas is required" $name) .maxReplicas | int64 }}
-  {{- if not (kindIs "invalid" .targetCPUUtilizationPercentage) }}
-  metrics:
-    - type: Resource
-      resource:
-        name: cpu
-        target:
-          type: Utilization
-          averageUtilization: {{ .targetCPUUtilizationPercentage | int64 }}
-  {{- end }}
-  {{- with .behavior }}
-  behavior:
-    {{- toYaml . | nindent 4 }}
-  {{- end }}
-{{- end }}
-{{- end }}
-{{- end }}
@@ -1,72 +0,0 @@
-image:
-  registry: ghcr.io/fluxerapp
-  tag: v1
-  pullPolicy: IfNotPresent
-
-imagePullSecrets: []
-
-env: {}
-
-extraEnv: []
-
-envFrom:
-  - secretRef:
-      name: fluxer-env
-
-podAnnotations: {}
-
-podSecurityContext:
-  runAsNonRoot: true
-  seccompProfile:
-    type: RuntimeDefault
-
-securityContext:
-  allowPrivilegeEscalation: false
-  capabilities:
-    drop:
-      - ALL
-
-probes:
-  liveness:
-    httpGet:
-      path: /_health
-      port: http
-  readiness:
-    httpGet:
-      path: /_health
-      port: http
-
-strategy:
-  type: RollingUpdate
-  rollingUpdate:
-    maxSurge: 25%
-    maxUnavailable: 25%
-
-topologySpreadConstraints: []
-
-nodeSelector: {}
-
-tolerations: []
-
-affinity: {}
-
-workloads:
-  media-proxy:
-    mode: mp
-    replicas: 1
-    resources:
-      requests:
-        cpu: 100m
-        memory: 256Mi
-      limits:
-        memory: 1Gi
-
-  uploads:
-    mode: relay
-    replicas: 1
-    resources:
-      requests:
-        cpu: 50m
-        memory: 64Mi
-      limits:
-        memory: 512Mi
@@ -1,6 +0,0 @@
-apiVersion: v2
-name: fluxer-push
-description: Fluxer push notification delivery service
-type: application
-version: 0.1.0
-appVersion: "v1"
@@ -1,71 +0,0 @@
-{{- define "fluxer-push.selectorLabels" -}}
-app.kubernetes.io/name: {{ .name }}
-app.kubernetes.io/instance: {{ .root.Release.Name }}
-{{- end }}
-
-{{- define "fluxer-push.labels" -}}
-{{ include "fluxer-push.selectorLabels" . }}
-app.kubernetes.io/component: {{ include "fluxer-push.mode" . }}
-app.kubernetes.io/part-of: fluxer
-app.kubernetes.io/managed-by: {{ .root.Release.Service }}
-helm.sh/chart: {{ printf "%s-%s" .root.Chart.Name .root.Chart.Version | replace "+" "_" }}
-{{- end }}
-
-{{- define "fluxer-push.mode" -}}
-{{- $mode := .w.mode | default "delivery" -}}
-{{- if not (has $mode (list "delivery" "relay")) -}}
-{{- fail (printf "workloads.%s.mode must be delivery or relay" .name) -}}
-{{- end -}}
-{{- $mode -}}
-{{- end }}
-
-{{- define "fluxer-push.port" -}}
-{{- .w.port | default (ternary 8127 8126 (eq (include "fluxer-push.mode" .) "relay")) -}}
-{{- end }}
-
-{{- define "fluxer-push.image" -}}
-{{- $global := .root.Values.image | default dict -}}
-{{- $img := .w.image | default dict -}}
-{{- $repo := $img.repository -}}
-{{- if not $repo -}}
-{{- $repo = printf "%s/%s" (required "image.registry is required" $global.registry) ($img.name | default "fluxer-push") -}}
-{{- end -}}
-{{- $ref := printf "%s:%s" $repo (include "fluxer-push.string" (required "image.tag is required" ($img.tag | default $global.tag))) -}}
-{{- with $img.digest }}{{ $ref = printf "%s@%s" $ref . }}{{ end -}}
-{{- $ref -}}
-{{- end }}
-
-{{- define "fluxer-push.string" -}}
-{{- if and (kindIs "float64" .) (eq . (floor .)) -}}
-{{- . | int64 | toString -}}
-{{- else -}}
-{{- . | toString -}}
-{{- end -}}
-{{- end }}
-
-{{- define "fluxer-push.env" -}}
-{{- $env := deepCopy (.root.Values.env | default dict) -}}
-{{- range $k, $v := (.w.env | default dict) -}}
-{{- if kindIs "invalid" $v -}}
-{{- $_ := unset $env $k -}}
-{{- else -}}
-{{- $_ := set $env $k $v -}}
-{{- end -}}
-{{- end -}}
-{{- if not (kindIs "invalid" .w.port) -}}
-{{- $_ := set $env "FLUXER_PUSH_SERVICE_PORT" .w.port -}}
-{{- end -}}
-{{- if not (kindIs "invalid" .w.buildVersion) }}
- name: BUILD_VERSION
-  value: {{ include "fluxer-push.string" .w.buildVersion | quote }}
-{{- end }}
-{{- range $k, $v := $env }}
-{{- if not (kindIs "invalid" $v) }}
- name: {{ $k }}
-  value: {{ include "fluxer-push.string" $v | quote }}
-{{- end }}
-{{- end }}
-{{- with concat (.root.Values.extraEnv | default list) (.w.extraEnv | default list) }}
-{{ toYaml . }}
-{{- end }}
-{{- end }}
@@ -1,205 +0,0 @@
-{{- range $name, $w := .Values.workloads }}
-{{- if not (kindIs "invalid" $w) }}
-{{- $ctx := dict "root" $ "name" $name "w" $w }}
-{{- $mode := include "fluxer-push.mode" $ctx }}
-{{- $port := include "fluxer-push.port" $ctx | int }}
-{{- $globalProbes := $.Values.probes | default dict }}
-{{- $workloadProbes := $w.probes | default dict }}
-{{- $probes := dict }}
-{{- range $probe := list "startup" "liveness" "readiness" }}
-{{- $_ := set $probes $probe (ternary (index $workloadProbes $probe) (index $globalProbes $probe) (hasKey $workloadProbes $probe)) }}
-{{- end }}
-{{- $annotations := mergeOverwrite (deepCopy ($.Values.podAnnotations | default dict)) (deepCopy ($w.podAnnotations | default dict)) }}
-{{- $pullSecrets := ternary $w.imagePullSecrets $.Values.imagePullSecrets (hasKey $w "imagePullSecrets") }}
-{{- $podSecurityContext := ternary $w.podSecurityContext $.Values.podSecurityContext (hasKey $w "podSecurityContext") }}
-{{- $securityContext := ternary $w.securityContext $.Values.securityContext (hasKey $w "securityContext") }}
-{{- $strategy := ternary $w.strategy $.Values.strategy (hasKey $w "strategy") }}
-{{- $tsc := ternary $w.topologySpreadConstraints $.Values.topologySpreadConstraints (hasKey $w "topologySpreadConstraints") }}
-{{- $nodeSelector := ternary $w.nodeSelector $.Values.nodeSelector (hasKey $w "nodeSelector") }}
-{{- $tolerations := ternary $w.tolerations $.Values.tolerations (hasKey $w "tolerations") }}
-{{- $affinity := ternary $w.affinity $.Values.affinity (hasKey $w "affinity") }}
-{{- $envFrom := concat ($.Values.envFrom | default list) ($w.envFrom | default list) }}
-{{- $env := include "fluxer-push.env" $ctx }}
---
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: {{ $name }}
-  namespace: {{ $.Release.Namespace }}
-  labels:
-    {{- include "fluxer-push.labels" $ctx | nindent 4 }}
-spec:
-  {{- if not $w.hpa }}
-  replicas: {{ ternary $w.replicas 1 (hasKey $w "replicas") | int }}
-  {{- end }}
-  {{- if hasKey $w "minReadySeconds" }}
-  minReadySeconds: {{ $w.minReadySeconds | int }}
-  {{- end }}
-  selector:
-    matchLabels:
-      {{- include "fluxer-push.selectorLabels" $ctx | nindent 6 }}
-  {{- with $strategy }}
-  strategy:
-    {{- toYaml . | nindent 4 }}
-  {{- end }}
-  template:
-    metadata:
-      {{- with $annotations }}
-      annotations:
-        {{- toYaml . | nindent 8 }}
-      {{- end }}
-      labels:
-        {{- include "fluxer-push.labels" $ctx | nindent 8 }}
-    spec:
-      {{- with $pullSecrets }}
-      imagePullSecrets:
-        {{- toYaml . | nindent 8 }}
-      {{- end }}
-      {{- with $podSecurityContext }}
-      securityContext:
-        {{- toYaml . | nindent 8 }}
-      {{- end }}
-      {{- if hasKey $w "terminationGracePeriodSeconds" }}
-      terminationGracePeriodSeconds: {{ $w.terminationGracePeriodSeconds | int }}
-      {{- end }}
-      {{- with $nodeSelector }}
-      nodeSelector:
-        {{- toYaml . | nindent 8 }}
-      {{- end }}
-      {{- with $tolerations }}
-      tolerations:
-        {{- toYaml . | nindent 8 }}
-      {{- end }}
-      {{- with $affinity }}
-      affinity:
-        {{- toYaml . | nindent 8 }}
-      {{- end }}
-      {{- with $tsc }}
-      topologySpreadConstraints:
-        {{- range . }}
-        {{- $c := deepCopy . }}
-        {{- if not $c.labelSelector }}
-        {{- $_ := set $c "labelSelector" (dict "matchLabels" (include "fluxer-push.selectorLabels" $ctx | fromYaml)) }}
-        {{- end }}
-        {{- toYaml (list $c) | nindent 8 }}
-        {{- end }}
-      {{- end }}
-      containers:
-        - name: {{ $name }}
-          image: {{ include "fluxer-push.image" $ctx | quote }}
-          imagePullPolicy: {{ ($w.image | default dict).pullPolicy | default ($.Values.image | default dict).pullPolicy | default "IfNotPresent" }}
-          command:
-            - /usr/local/bin/fluxer-push
-          {{- if eq $mode "relay" }}
-          args:
-            - --mode
-            - relay
-          {{- end }}
-          {{- with trim $env }}
-          env:
-            {{- . | nindent 12 }}
-          {{- end }}
-          {{- with $envFrom }}
-          envFrom:
-            {{- toYaml . | nindent 12 }}
-          {{- end }}
-          ports:
-            - name: http
-              containerPort: {{ $port }}
-              protocol: TCP
-          {{- with $probes.startup }}
-          startupProbe:
-            {{- toYaml . | nindent 12 }}
-          {{- end }}
-          {{- with $probes.liveness }}
-          livenessProbe:
-            {{- toYaml . | nindent 12 }}
-          {{- end }}
-          {{- with $probes.readiness }}
-          readinessProbe:
-            {{- toYaml . | nindent 12 }}
-          {{- end }}
-          {{- with $w.resources }}
-          resources:
-            {{- toYaml . | nindent 12 }}
-          {{- end }}
-          {{- with $securityContext }}
-          securityContext:
-            {{- toYaml . | nindent 12 }}
-          {{- end }}
-          {{- with $w.lifecycle }}
-          lifecycle:
-            {{- toYaml . | nindent 12 }}
-          {{- end }}
-          {{- with $w.extraVolumeMounts }}
-          volumeMounts:
-            {{- toYaml . | nindent 12 }}
-          {{- end }}
-      {{- with $w.extraVolumes }}
-      volumes:
-        {{- toYaml . | nindent 8 }}
-      {{- end }}
---
-apiVersion: v1
-kind: Service
-metadata:
-  name: {{ $name }}
-  namespace: {{ $.Release.Namespace }}
-  labels:
-    {{- include "fluxer-push.labels" $ctx | nindent 4 }}
-spec:
-  type: ClusterIP
-  selector:
-    {{- include "fluxer-push.selectorLabels" $ctx | nindent 4 }}
-  ports:
-    - name: http
-      port: {{ $port }}
-      protocol: TCP
-      targetPort: http
-{{- with $w.pdb }}
---
-apiVersion: policy/v1
-kind: PodDisruptionBudget
-metadata:
-  name: {{ $name }}-pdb
-  namespace: {{ $.Release.Namespace }}
-  labels:
-    {{- include "fluxer-push.labels" $ctx | nindent 4 }}
-spec:
-  {{- toYaml . | nindent 2 }}
-  selector:
-    matchLabels:
-      {{- include "fluxer-push.selectorLabels" $ctx | nindent 6 }}
-{{- end }}
-{{- with $w.hpa }}
---
-apiVersion: autoscaling/v2
-kind: HorizontalPodAutoscaler
-metadata:
-  name: {{ $name }}
-  namespace: {{ $.Release.Namespace }}
-  labels:
-    {{- include "fluxer-push.labels" $ctx | nindent 4 }}
-spec:
-  scaleTargetRef:
-    apiVersion: apps/v1
-    kind: Deployment
-    name: {{ $name }}
-  minReplicas: {{ required (printf "workloads.%s.hpa.minReplicas is required" $name) .minReplicas | int }}
-  maxReplicas: {{ required (printf "workloads.%s.hpa.maxReplicas is required" $name) .maxReplicas | int }}
-  {{- if not (kindIs "invalid" .targetCPUUtilizationPercentage) }}
-  metrics:
-    - type: Resource
-      resource:
-        name: cpu
-        target:
-          type: Utilization
-          averageUtilization: {{ .targetCPUUtilizationPercentage | int }}
-  {{- end }}
-  {{- with .behavior }}
-  behavior:
-    {{- toYaml . | nindent 4 }}
-  {{- end }}
-{{- end }}
-{{- end }}
-{{- end }}
@@ -1,65 +0,0 @@
-image:
-  registry: ghcr.io/fluxerapp
-  tag: v1
-  pullPolicy: IfNotPresent
-
-imagePullSecrets: []
-
-env: {}
-
-extraEnv: []
-
-envFrom:
-  - secretRef:
-      name: fluxer-env
-
-podAnnotations: {}
-
-podSecurityContext:
-  runAsNonRoot: true
-  seccompProfile:
-    type: RuntimeDefault
-
-securityContext:
-  allowPrivilegeEscalation: false
-  capabilities:
-    drop:
-      - ALL
-
-probes:
-  liveness:
-    httpGet:
-      path: /_healthz
-      port: http
-  readiness:
-    httpGet:
-      path: /_healthz
-      port: http
-
-strategy:
-  type: RollingUpdate
-  rollingUpdate:
-    maxSurge: 25%
-    maxUnavailable: 25%
-
-topologySpreadConstraints: []
-
-nodeSelector: {}
-
-tolerations: []
-
-affinity: {}
-
-workloads:
-  push:
-    mode: delivery
-    replicas: 1
-    env:
-      FLUXER_INTERNAL_API_ENDPOINT: http://api:8080
-      FLUXER_SVC_NATS_URL: nats://nats:4222
-    resources:
-      requests:
-        cpu: 50m
-        memory: 64Mi
-      limits:
-        memory: 256Mi
@@ -1,6 +0,0 @@
-apiVersion: v2
-name: fluxer-svc
-description: Fluxer internal services, each a router Deployment and a shard StatefulSet
-type: application
-version: 0.1.0
-appVersion: v1
@@ -1,203 +0,0 @@
-{{- define "fluxer-svc.chart" -}}
-{{ printf "%s-%s" .Chart.Name .Chart.Version | replace "+" "_" }}
-{{- end }}
-
-{{- define "fluxer-svc.selectorLabels" -}}
-app.kubernetes.io/name: {{ .name }}
-app.kubernetes.io/instance: {{ .root.Release.Name }}
-{{- end }}
-
-{{- define "fluxer-svc.labels" -}}
-{{ include "fluxer-svc.selectorLabels" . }}
-app.kubernetes.io/component: {{ .mode }}
-app.kubernetes.io/part-of: fluxer
-app.kubernetes.io/managed-by: {{ .root.Release.Service }}
-helm.sh/chart: {{ include "fluxer-svc.chart" .root }}
-{{- end }}
-
-{{- define "fluxer-svc.envValue" -}}
-{{- if and (kindIs "float64" .) (eq . (float64 (int64 .))) -}}
-{{- int64 . | toString -}}
-{{- else -}}
-{{- toString . -}}
-{{- end -}}
-{{- end }}
-
-{{- define "fluxer-svc.mergeEnv" -}}
-{{- $out := dict -}}
-{{- range $layer := . -}}
-{{- range $k, $v := ($layer | default dict) -}}
-{{- if kindIs "invalid" $v -}}
-{{- $_ := unset $out $k -}}
-{{- else -}}
-{{- $_ := set $out $k $v -}}
-{{- end -}}
-{{- end -}}
-{{- end -}}
-{{- toYaml $out -}}
-{{- end }}
-
-{{- define "fluxer-svc.topologySpreadConstraints" -}}
-{{- $out := list -}}
-{{- range .constraints -}}
-{{- if .labelSelector -}}
-{{- $out = append $out . -}}
-{{- else -}}
-{{- $out = append $out (merge (dict "labelSelector" (dict "matchLabels" $.selector)) .) -}}
-{{- end -}}
-{{- end -}}
-{{- toYaml $out -}}
-{{- end }}
-
-{{- define "fluxer-svc.pdb" -}}
-{{- $out := dict -}}
-{{- range $k := list "minAvailable" "maxUnavailable" -}}
-{{- if and (hasKey $ $k) (not (kindIs "invalid" (index $ $k))) -}}
-{{- $_ := set $out $k (index $ $k) -}}
-{{- end -}}
-{{- end -}}
-{{- toYaml $out -}}
-{{- end }}
-
-{{- define "fluxer-svc.config" -}}
-{{- $v := .root.Values -}}
-{{- $levels := list (index $v .mode) (index .svc .mode) -}}
-{{- $c := dict "extraEnv" ($v.extraEnv | default list) "envFrom" ($v.envFrom | default list) "podAnnotations" (deepCopy ($v.podAnnotations | default dict)) "probes" (deepCopy ($v.probes | default dict)) "image" (deepCopy (.svc.image | default dict)) -}}
-{{- range $k := list "imagePullSecrets" "podSecurityContext" "securityContext" "topologySpreadConstraints" "nodeSelector" "tolerations" "affinity" (ternary "updateStrategy" "strategy" (eq .mode "shard")) -}}
-{{- $_ := set $c $k (index $v $k) -}}
-{{- end -}}
-{{- $envLayers := list $v.env -}}
-{{- range $level := $levels -}}
-{{- range $k, $x := ($level | default dict) -}}
-{{- if eq $k "env" -}}
-{{- $envLayers = append $envLayers $x -}}
-{{- else if has $k (list "podAnnotations" "image") -}}
-{{- $_ := set $c $k (mergeOverwrite (index $c $k) (deepCopy ($x | default dict))) -}}
-{{- else if has $k (list "extraEnv" "envFrom") -}}
-{{- $_ := set $c $k (concat (index $c $k) ($x | default list)) -}}
-{{- else if eq $k "probes" -}}
-{{- range $name, $p := ($x | default dict) -}}
-{{- $_ := set $c.probes $name $p -}}
-{{- end -}}
-{{- else -}}
-{{- $_ := set $c $k $x -}}
-{{- end -}}
-{{- end -}}
-{{- end -}}
-{{- $_ := set $c "env" (include "fluxer-svc.mergeEnv" $envLayers | fromYaml) -}}
-{{- toYaml $c }}
-{{- end }}
-
-{{- define "fluxer-svc.image" -}}
-{{- $g := .root.Values.image -}}
-{{- $i := .c.image -}}
-{{- $repo := $i.repository | default (printf "%s/%s" $g.registry ($i.name | default (printf "fluxer-%s" .service))) -}}
-{{- $ref := printf "%s:%s" $repo ($i.tag | default $g.tag) -}}
-{{- with $i.digest }}{{ $ref = printf "%s@%s" $ref . }}{{ end -}}
-{{- $ref -}}
-{{- end }}
-
-{{- define "fluxer-svc.pod" -}}
-{{- $v := .root.Values -}}
-{{- $c := .c -}}
-metadata:
-  {{- with $c.podAnnotations }}
-  annotations:
-    {{- toYaml . | nindent 4 }}
-  {{- end }}
-  labels:
-    {{- include "fluxer-svc.labels" . | nindent 4 }}
-spec:
-  {{- with $c.imagePullSecrets }}
-  imagePullSecrets:
-    {{- toYaml . | nindent 4 }}
-  {{- end }}
-  {{- with $c.podSecurityContext }}
-  securityContext:
-    {{- toYaml . | nindent 4 }}
-  {{- end }}
-  {{- if not (kindIs "invalid" $c.terminationGracePeriodSeconds) }}
-  terminationGracePeriodSeconds: {{ $c.terminationGracePeriodSeconds | int64 }}
-  {{- end }}
-  {{- with $c.nodeSelector }}
-  nodeSelector:
-    {{- toYaml . | nindent 4 }}
-  {{- end }}
-  {{- with $c.tolerations }}
-  tolerations:
-    {{- toYaml . | nindent 4 }}
-  {{- end }}
-  {{- with $c.affinity }}
-  affinity:
-    {{- toYaml . | nindent 4 }}
-  {{- end }}
-  {{- with $c.topologySpreadConstraints }}
-  topologySpreadConstraints:
-    {{- include "fluxer-svc.topologySpreadConstraints" (dict "constraints" . "selector" (include "fluxer-svc.selectorLabels" $ | fromYaml)) | nindent 4 }}
-  {{- end }}
-  containers:
-    - name: {{ .mode }}
-      image: {{ include "fluxer-svc.image" . | quote }}
-      imagePullPolicy: {{ $c.image.pullPolicy | default $v.image.pullPolicy }}
-      env:
-        - name: FLUXER_SVC_MODE
-          value: {{ .mode | quote }}
-        - name: FLUXER_SVC_NAME
-          value: {{ .service | quote }}
-        - name: FLUXER_SVC_SHARD_COUNT
-          value: {{ .shardCount | quote }}
-        - name: FLUXER_SVC_PORT
-          value: {{ include "fluxer-svc.envValue" $v.port | quote }}
-        {{- if not (kindIs "invalid" $c.buildVersion) }}
-        - name: BUILD_VERSION
-          value: {{ include "fluxer-svc.envValue" $c.buildVersion | quote }}
-        {{- end }}
-        {{- if eq .mode "shard" }}
-        - name: POD_NAME
-          valueFrom:
-            fieldRef:
-              apiVersion: v1
-              fieldPath: metadata.name
-        {{- end }}
-        {{- range $name, $value := $c.env }}
-        - name: {{ $name }}
-          value: {{ include "fluxer-svc.envValue" $value | quote }}
-        {{- end }}
-        {{- with $c.extraEnv }}
-        {{- toYaml . | nindent 8 }}
-        {{- end }}
-      {{- with $c.envFrom }}
-      envFrom:
-        {{- toYaml . | nindent 8 }}
-      {{- end }}
-      ports:
-        - name: http
-          containerPort: {{ $v.port }}
-          protocol: TCP
-      {{- with $c.lifecycle }}
-      lifecycle:
-        {{- toYaml . | nindent 8 }}
-      {{- end }}
-      {{- range $name := list "startup" "liveness" "readiness" }}
-      {{- with index $c.probes $name }}
-      {{ $name }}Probe:
-        {{- toYaml . | nindent 8 }}
-      {{- end }}
-      {{- end }}
-      {{- with $c.resources }}
-      resources:
-        {{- toYaml . | nindent 8 }}
-      {{- end }}
-      {{- with $c.securityContext }}
-      securityContext:
-        {{- toYaml . | nindent 8 }}
-      {{- end }}
-      {{- with $c.extraVolumeMounts }}
-      volumeMounts:
-        {{- toYaml . | nindent 8 }}
-      {{- end }}
-  {{- with $c.extraVolumes }}
-  volumes:
-    {{- toYaml . | nindent 4 }}
-  {{- end }}
-{{- end }}
@@ -1,145 +0,0 @@
-{{- range $service, $svc := .Values.services }}
-{{- if not (kindIs "invalid" $svc) }}
-{{- $svc = $svc | default dict }}
-{{- $rc := fromYaml (include "fluxer-svc.config" (dict "root" $ "svc" $svc "mode" "router")) }}
-{{- $sc := fromYaml (include "fluxer-svc.config" (dict "root" $ "svc" $svc "mode" "shard")) }}
-{{- $routerReplicas := ternary $rc.replicas 1 (hasKey $rc "replicas") | int64 }}
-{{- $shardCount := ternary $sc.replicas 1 (hasKey $sc "replicas") | int64 }}
-{{- if lt $shardCount 1 }}
-{{- fail (printf "services.%s shard replicas must be at least 1" $service) }}
-{{- end }}
-{{- $router := dict "root" $ "service" $service "svc" $svc "mode" "router" "name" $service "c" $rc "shardCount" (toString $shardCount) }}
-{{- $shard := dict "root" $ "service" $service "svc" $svc "mode" "shard" "name" (printf "%s-shard" $service) "c" $sc "shardCount" (toString $shardCount) }}
---
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: {{ $service }}
-  namespace: {{ $.Release.Namespace }}
-  labels:
-    {{- include "fluxer-svc.labels" $router | nindent 4 }}
-spec:
-  {{- if not $rc.hpa }}
-  replicas: {{ $routerReplicas }}
-  {{- end }}
-  {{- if not (kindIs "invalid" $rc.minReadySeconds) }}
-  minReadySeconds: {{ $rc.minReadySeconds | int64 }}
-  {{- end }}
-  selector:
-    matchLabels:
-      {{- include "fluxer-svc.selectorLabels" $router | nindent 6 }}
-  {{- with $rc.strategy }}
-  strategy:
-    {{- toYaml . | nindent 4 }}
-  {{- end }}
-  template:
-    {{- include "fluxer-svc.pod" $router | nindent 4 }}
---
-apiVersion: apps/v1
-kind: StatefulSet
-metadata:
-  name: {{ $service }}-shard
-  namespace: {{ $.Release.Namespace }}
-  labels:
-    {{- include "fluxer-svc.labels" $shard | nindent 4 }}
-spec:
-  replicas: {{ $shardCount }}
-  {{- if not (kindIs "invalid" $sc.minReadySeconds) }}
-  minReadySeconds: {{ $sc.minReadySeconds | int64 }}
-  {{- end }}
-  podManagementPolicy: Parallel
-  serviceName: {{ $service }}-shard-headless
-  selector:
-    matchLabels:
-      {{- include "fluxer-svc.selectorLabels" $shard | nindent 6 }}
-  {{- with $sc.updateStrategy }}
-  updateStrategy:
-    {{- toYaml . | nindent 4 }}
-  {{- end }}
-  template:
-    {{- include "fluxer-svc.pod" $shard | nindent 4 }}
---
-apiVersion: v1
-kind: Service
-metadata:
-  name: {{ $service }}
-  namespace: {{ $.Release.Namespace }}
-  labels:
-    {{- include "fluxer-svc.labels" $router | nindent 4 }}
-spec:
-  type: ClusterIP
-  selector:
-    {{- include "fluxer-svc.selectorLabels" $router | nindent 4 }}
-  ports:
-    - name: http
-      port: {{ $.Values.port }}
-      targetPort: {{ $.Values.port }}
-      protocol: TCP
---
-apiVersion: v1
-kind: Service
-metadata:
-  name: {{ $service }}-shard-headless
-  namespace: {{ $.Release.Namespace }}
-  labels:
-    {{- include "fluxer-svc.labels" $shard | nindent 4 }}
-spec:
-  type: ClusterIP
-  clusterIP: None
-  publishNotReadyAddresses: true
-  selector:
-    {{- include "fluxer-svc.selectorLabels" $shard | nindent 4 }}
-  ports:
-    - name: http
-      port: {{ $.Values.port }}
-      targetPort: {{ $.Values.port }}
-      protocol: TCP
-{{- with $rc.hpa }}
---
-apiVersion: autoscaling/v2
-kind: HorizontalPodAutoscaler
-metadata:
-  name: {{ $service }}
-  namespace: {{ $.Release.Namespace }}
-  labels:
-    {{- include "fluxer-svc.labels" $router | nindent 4 }}
-spec:
-  scaleTargetRef:
-    apiVersion: apps/v1
-    kind: Deployment
-    name: {{ $service }}
-  minReplicas: {{ required (printf "services.%s router hpa.minReplicas is required" $service) .minReplicas | int64 }}
-  maxReplicas: {{ required (printf "services.%s router hpa.maxReplicas is required" $service) .maxReplicas | int64 }}
-  {{- if not (kindIs "invalid" .targetCPUUtilizationPercentage) }}
-  metrics:
-    - type: Resource
-      resource:
-        name: cpu
-        target:
-          type: Utilization
-          averageUtilization: {{ .targetCPUUtilizationPercentage | int64 }}
-  {{- end }}
-  {{- with .behavior }}
-  behavior:
-    {{- toYaml . | nindent 4 }}
-  {{- end }}
-{{- end }}
-{{- range $ctx := list $router $shard }}
-{{- with include "fluxer-svc.pdb" ($ctx.c.pdb | default dict) | fromYaml }}
---
-apiVersion: policy/v1
-kind: PodDisruptionBudget
-metadata:
-  name: {{ $ctx.name }}-pdb
-  namespace: {{ $.Release.Namespace }}
-  labels:
-    {{- include "fluxer-svc.labels" $ctx | nindent 4 }}
-spec:
-  {{- toYaml . | nindent 2 }}
-  selector:
-    matchLabels:
-      {{- include "fluxer-svc.selectorLabels" $ctx | nindent 6 }}
-{{- end }}
-{{- end }}
-{{- end }}
-{{- end }}
@@ -1,89 +0,0 @@
-image:
-  registry: ghcr.io/fluxerapp
-  tag: v1
-  pullPolicy: IfNotPresent
-
-imagePullSecrets: []
-
-env:
-  FLUXER_SVC_NATS_URL: nats://nats:4222
-
-extraEnv: []
-
-envFrom:
-  - secretRef:
-      name: fluxer-env
-
-podAnnotations: {}
-
-podSecurityContext:
-  runAsNonRoot: true
-  seccompProfile:
-    type: RuntimeDefault
-
-securityContext:
-  allowPrivilegeEscalation: false
-
-probes:
-  liveness:
-    httpGet:
-      path: /_healthz
-      port: http
-  readiness:
-    httpGet:
-      path: /_health
-      port: http
-
-strategy:
-  type: RollingUpdate
-  rollingUpdate:
-    maxSurge: 25%
-    maxUnavailable: 25%
-
-updateStrategy:
-  type: RollingUpdate
-
-topologySpreadConstraints: []
-nodeSelector: {}
-tolerations: []
-affinity: {}
-
-port: 8090
-
-router:
-  replicas: 1
-  resources:
-    requests:
-      cpu: 50m
-      memory: 64Mi
-    limits:
-      memory: 192Mi
-
-shard:
-  replicas: 2
-  probes:
-    startup:
-      httpGet:
-        path: /_healthz
-        port: http
-      periodSeconds: 10
-      failureThreshold: 30
-  resources:
-    requests:
-      cpu: 50m
-      memory: 96Mi
-    limits:
-      memory: 384Mi
-
-services:
-  gifs:
-    shard:
-      env:
-        FLUXER_MEDIA_PROXY_PUBLIC_ENDPOINT: https://media.example.com
-  messages: {}
-  snowflakes: {}
-  unfurl:
-    shard:
-      env:
-        FLUXER_MEDIA_PROXY_ENDPOINT: http://media-proxy:8080
-  users: {}
@@ -1,6 +0,0 @@
-apiVersion: v2
-name: fluxer-web
-description: Fluxer web app proxy and admin dashboard.
-type: application
-version: 0.1.0
-appVersion: "v1"
@@ -1,80 +0,0 @@
-{{- define "fluxer-web.chart" -}}
-{{- printf "%s-%s" .Chart.Name .Chart.Version | replace "+" "_" | trunc 63 | trimSuffix "-" -}}
-{{- end }}
-
-{{- define "fluxer-web.selectorLabels" -}}
-app.kubernetes.io/name: {{ .name }}
-app.kubernetes.io/instance: {{ .root.Release.Name }}
-{{- end }}
-
-{{- define "fluxer-web.labels" -}}
-{{ include "fluxer-web.selectorLabels" . }}
-app.kubernetes.io/component: web
-app.kubernetes.io/part-of: fluxer
-app.kubernetes.io/managed-by: {{ .root.Release.Service }}
-helm.sh/chart: {{ include "fluxer-web.chart" .root }}
-{{- end }}
-
-{{- define "fluxer-web.image" -}}
-{{- $g := .root.Values.image | default dict -}}
-{{- $i := .w.image | default dict -}}
-{{- $repo := $i.repository -}}
-{{- if not $repo -}}
-{{- $repo = printf "%s/%s" (required "image.registry is required" $g.registry) ($i.name | default (printf "fluxer-%s" .name)) -}}
-{{- end -}}
-{{- $tag := required "image.tag is required" ($i.tag | default $g.tag) -}}
-{{- if $i.digest -}}
-{{- printf "%s:%s@%s" $repo $tag $i.digest | quote -}}
-{{- else -}}
-{{- printf "%s:%s" $repo $tag | quote -}}
-{{- end -}}
-{{- end }}
-
-{{- define "fluxer-web.pick" -}}
-{{- $v := ternary (get .w .key) (get .root.Values .key) (hasKey .w .key) -}}
-{{- if $v }}
-{{- toYaml $v }}
-{{- end }}
-{{- end }}
-
-{{- define "fluxer-web.str" -}}
-{{- if and (kindIs "float64" .) (eq . (floor .)) -}}
-{{- int64 . | toString | quote -}}
-{{- else -}}
-{{- toString . | quote -}}
-{{- end -}}
-{{- end }}
-
-{{- define "fluxer-web.env" -}}
-{{- $env := dict -}}
-{{- range $k, $val := .root.Values.env | default dict }}
-{{- $_ := set $env $k $val }}
-{{- end }}
-{{- range $k, $val := .w.env | default dict }}
-{{- $_ := set $env $k $val }}
-{{- end }}
-{{- range $k, $val := $env }}
-{{- if not (kindIs "invalid" $val) }}
- name: {{ $k }}
-  value: {{ include "fluxer-web.str" $val }}
-{{- end }}
-{{- end }}
-{{- with .w.buildVersion }}
- name: BUILD_VERSION
-  value: {{ include "fluxer-web.str" . }}
-{{- end }}
-{{- with concat (.root.Values.extraEnv | default list) (.w.extraEnv | default list) }}
-{{ toYaml . }}
-{{- end }}
-{{- end }}
-
-{{- define "fluxer-web.topologySpread" -}}
-{{- $tscs := ternary .w.topologySpreadConstraints .root.Values.topologySpreadConstraints (hasKey .w "topologySpreadConstraints") -}}
-{{- range $tscs }}
-{{- $c := deepCopy . }}
-{{- if not $c.labelSelector }}
-{{- $_ := set $c "labelSelector" (dict "matchLabels" (include "fluxer-web.selectorLabels" $ | fromYaml)) }}
-{{- end }}
- {{- toYaml $c | nindent 2 }}
-{{- end }}
-{{- end }}
@@ -1,172 +0,0 @@
-{{- $v := .Values }}
-{{- range $name, $w := .Values.workloads }}
-{{- if not (kindIs "invalid" $w) }}
-{{- $ctx := dict "root" $ "name" $name "w" $w }}
-{{- $envFrom := concat ($v.envFrom | default list) ($w.envFrom | default list) }}
-{{- $podAnnotations := merge (dict) ($w.podAnnotations | default dict) ($v.podAnnotations | default dict) }}
-{{- $wProbes := $w.probes | default dict }}
-{{- $gProbes := $v.probes | default dict }}
---
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: {{ $name }}
-  namespace: {{ $.Release.Namespace }}
-  labels:
-    {{- include "fluxer-web.labels" $ctx | nindent 4 }}
-spec:
-  {{- if not $w.hpa }}
-  replicas: {{ if kindIs "invalid" $w.replicas }}1{{ else }}{{ int $w.replicas }}{{ end }}
-  {{- end }}
-  {{- if not (kindIs "invalid" $w.minReadySeconds) }}
-  minReadySeconds: {{ int $w.minReadySeconds }}
-  {{- end }}
-  selector:
-    matchLabels:
-      {{- include "fluxer-web.selectorLabels" $ctx | nindent 6 }}
-  {{- with include "fluxer-web.pick" (dict "root" $ "w" $w "key" "strategy") }}
-  strategy:
-    {{- . | nindent 4 }}
-  {{- end }}
-  template:
-    metadata:
-      labels:
-        {{- include "fluxer-web.labels" $ctx | nindent 8 }}
-      {{- with $podAnnotations }}
-      annotations:
-        {{- toYaml . | nindent 8 }}
-      {{- end }}
-    spec:
-      {{- with include "fluxer-web.pick" (dict "root" $ "w" $w "key" "imagePullSecrets") }}
-      imagePullSecrets:
-        {{- . | nindent 8 }}
-      {{- end }}
-      {{- with include "fluxer-web.pick" (dict "root" $ "w" $w "key" "podSecurityContext") }}
-      securityContext:
-        {{- . | nindent 8 }}
-      {{- end }}
-      {{- if not (kindIs "invalid" $w.terminationGracePeriodSeconds) }}
-      terminationGracePeriodSeconds: {{ int $w.terminationGracePeriodSeconds }}
-      {{- end }}
-      {{- with include "fluxer-web.pick" (dict "root" $ "w" $w "key" "nodeSelector") }}
-      nodeSelector:
-        {{- . | nindent 8 }}
-      {{- end }}
-      {{- with include "fluxer-web.pick" (dict "root" $ "w" $w "key" "affinity") }}
-      affinity:
-        {{- . | nindent 8 }}
-      {{- end }}
-      {{- with include "fluxer-web.pick" (dict "root" $ "w" $w "key" "tolerations") }}
-      tolerations:
-        {{- . | nindent 8 }}
-      {{- end }}
-      {{- with include "fluxer-web.topologySpread" $ctx | trim }}
-      topologySpreadConstraints:
-        {{- . | nindent 8 }}
-      {{- end }}
-      containers:
-        - name: {{ $name }}
-          image: {{ include "fluxer-web.image" $ctx }}
-          imagePullPolicy: {{ ($w.image | default dict).pullPolicy | default ($v.image | default dict).pullPolicy | default "IfNotPresent" }}
-          {{- with include "fluxer-web.env" $ctx | trim }}
-          env:
-            {{- . | nindent 12 }}
-          {{- end }}
-          {{- with $envFrom }}
-          envFrom:
-            {{- toYaml . | nindent 12 }}
-          {{- end }}
-          ports:
-            - name: http
-              containerPort: 8080
-              protocol: TCP
-          {{- with $w.lifecycle }}
-          lifecycle:
-            {{- toYaml . | nindent 12 }}
-          {{- end }}
-          {{- range $probe := list "startup" "liveness" "readiness" }}
-          {{- with hasKey $wProbes $probe | ternary (get $wProbes $probe) (get $gProbes $probe) }}
-          {{ $probe }}Probe:
-            {{- toYaml . | nindent 12 }}
-          {{- end }}
-          {{- end }}
-          {{- with $w.resources }}
-          resources:
-            {{- toYaml . | nindent 12 }}
-          {{- end }}
-          {{- with include "fluxer-web.pick" (dict "root" $ "w" $w "key" "securityContext") }}
-          securityContext:
-            {{- . | nindent 12 }}
-          {{- end }}
-          {{- with $w.extraVolumeMounts }}
-          volumeMounts:
-            {{- toYaml . | nindent 12 }}
-          {{- end }}
-      {{- with $w.extraVolumes }}
-      volumes:
-        {{- toYaml . | nindent 8 }}
-      {{- end }}
---
-apiVersion: v1
-kind: Service
-metadata:
-  name: {{ $name }}
-  namespace: {{ $.Release.Namespace }}
-  labels:
-    {{- include "fluxer-web.labels" $ctx | nindent 4 }}
-spec:
-  type: ClusterIP
-  selector:
-    {{- include "fluxer-web.selectorLabels" $ctx | nindent 4 }}
-  ports:
-    - name: http
-      port: 8080
-      targetPort: http
-      protocol: TCP
-{{- with $w.hpa }}
---
-apiVersion: autoscaling/v2
-kind: HorizontalPodAutoscaler
-metadata:
-  name: {{ $name }}
-  namespace: {{ $.Release.Namespace }}
-  labels:
-    {{- include "fluxer-web.labels" $ctx | nindent 4 }}
-spec:
-  scaleTargetRef:
-    apiVersion: apps/v1
-    kind: Deployment
-    name: {{ $name }}
-  minReplicas: {{ required (printf "%s.hpa.minReplicas is required" $name) .minReplicas }}
-  maxReplicas: {{ required (printf "%s.hpa.maxReplicas is required" $name) .maxReplicas }}
-  {{- with .targetCPUUtilizationPercentage }}
-  metrics:
-    - type: Resource
-      resource:
-        name: cpu
-        target:
-          type: Utilization
-          averageUtilization: {{ . }}
-  {{- end }}
-  {{- with .behavior }}
-  behavior:
-    {{- toYaml . | nindent 4 }}
-  {{- end }}
-{{- end }}
-{{- with $w.pdb }}
---
-apiVersion: policy/v1
-kind: PodDisruptionBudget
-metadata:
-  name: {{ $name }}-pdb
-  namespace: {{ $.Release.Namespace }}
-  labels:
-    {{- include "fluxer-web.labels" $ctx | nindent 4 }}
-spec:
-  {{- toYaml . | nindent 2 }}
-  selector:
-    matchLabels:
-      {{- include "fluxer-web.selectorLabels" $ctx | nindent 6 }}
-{{- end }}
-{{- end }}
-{{- end }}
@@ -1,83 +0,0 @@
-image:
-  registry: ghcr.io/fluxerapp
-  tag: v1
-  pullPolicy: IfNotPresent
-
-imagePullSecrets: []
-
-env: {}
-
-extraEnv: []
-
-envFrom:
-  - secretRef:
-      name: fluxer-env
-
-podAnnotations: {}
-
-podSecurityContext:
-  runAsNonRoot: true
-  seccompProfile:
-    type: RuntimeDefault
-
-securityContext:
-  allowPrivilegeEscalation: false
-
-probes:
-  startup:
-    httpGet:
-      path: /_health
-      port: http
-    periodSeconds: 10
-    failureThreshold: 30
-  liveness:
-    httpGet:
-      path: /_health
-      port: http
-  readiness:
-    httpGet:
-      path: /_health
-      port: http
-
-strategy:
-  type: RollingUpdate
-
-topologySpreadConstraints: []
-
-nodeSelector: {}
-
-tolerations: []
-
-affinity: {}
-
-workloads:
-  admin:
-    image:
-      name: fluxer-admin
-    replicas: 1
-    env:
-      FLUXER_ENV: production
-      FLUXER_API_ENDPOINT: https://api.example.com
-      FLUXER_ADMIN_ENDPOINT: https://admin.example.com
-      FLUXER_MEDIA_ENDPOINT: https://media.example.com
-      FLUXER_APP_ENDPOINT: https://web.example.com
-    resources:
-      requests:
-        cpu: 50m
-        memory: 96Mi
-      limits:
-        memory: 384Mi
-  app-proxy:
-    image:
-      name: fluxer-app-proxy-self-hosted
-    replicas: 1
-    env:
-      RELEASE_CHANNEL: stable
-      PUBLIC_BOOTSTRAP_API_ENDPOINT: /api
-      PUBLIC_BOOTSTRAP_API_PUBLIC_ENDPOINT: https://web.example.com/api
-    resources:
-      requests:
-        cpu: 50m
-        memory: 96Mi
-      limits:
-        memory: 384Mi
@@ -1,8 +1,6 @@
-# Every variable docker-compose.yml reads. A value an install must set is
-# uncommented. A commented line shows the default, or an example where its comment
-# says so, and nothing after = means the service decides. An empty value keeps the
-# default too. Compose expands top to bottom, so a line using ${...} must sit below
-# every name it reads.
+# Every variable docker-compose.yml reads, uncommented when it has no default and
+# commented with its default when it has one. Compose expands top to bottom, so a
+# line using ${...} must sit below every name it reads.

 FLUXER_DOMAIN=chat.example.com
 FLUXER_PUBLIC_SCHEME=https
@@ -70,9 +68,7 @@ FLUXER_IMAGE_TAG=v1
 POSTGRES_PASSWORD=CHANGE_ME
 MEILI_MASTER_KEY=CHANGE_ME
 # Set these to run Postgres or the object store outside the stack. Backing up a
-# store you moved out is yours to arrange. An upgrade dumps the bundled postgres
-# service and skips the dump only when the stack defines none. The values below
-# are examples.
+# store you moved out is yours to arrange, and an upgrade skips it.
 #FLUXER_POSTGRES_HOST=db.example.com
 #FLUXER_POSTGRES_PORT=5432
 #FLUXER_POSTGRES_DATABASE=fluxer
@@ -82,109 +78,50 @@ MEILI_MASTER_KEY=CHANGE_ME
 #FLUXER_S3_PUBLIC_ENDPOINT=https://cdn.example.com
 #FLUXER_S3_REGION=eu-central-1
 #FLUXER_S3_FORCE_PATH_STYLE=false
-
 # Bucket names. The bundled store creates these. An outside store needs them to
 # exist already.
 #FLUXER_S3_BUCKET_CDN=fluxer
 #FLUXER_S3_BUCKET_UPLOADS=fluxer-uploads
 #FLUXER_S3_BUCKET_REPORTS=fluxer-reports
 #FLUXER_S3_BUCKET_HARVESTS=fluxer-harvests
-# With the object store outside the stack, add this overlay to COMPOSE_FILE and
-# the bundled seaweedfs no longer starts. Put it after any other overlay, such as
-# docker-compose.yml:docker-compose.proxy.yml:external-object-store.compose.yml.
-# Needs Compose 2.24.4 or newer.
-#COMPOSE_FILE=docker-compose.yml:external-object-store.compose.yml
-
-# A full connection URL wins over the host, port and database above. The URL is an
-# example. The CA is the PEM text of the certificate, with \n for line breaks.
-#FLUXER_POSTGRES_URL=postgres://fluxer:[email protected]:5432/fluxer
-#FLUXER_POSTGRES_SSL_CA=
-# The Postgres table that holds the key-value store.
-#FLUXER_POSTGRES_KV_TABLE=fluxer_kv
-# media-proxy reads through these when the store serves reads from another
-# address or bucket.
-#FLUXER_S3_READ_ENDPOINT=
-#FLUXER_S3_READ_BUCKET=
-#FLUXER_S3_READ_BUCKET_STYLE=
-# A temporary S3 session token, read by media-proxy only.
-#FLUXER_S3_SESSION_TOKEN=
-# The bundled store refuses unsigned reads. Set false only for a public-read bucket.
-#FLUXER_S3_READ_SIGNED=true

 # The other bundled services, pointed elsewhere. Removing a service from the
 # stack belongs in an override file, since an upgrade replaces docker-compose.yml.
-# The URLs below are examples.
 #FLUXER_KV_URL=redis://cache.example.com:6379/0
 #FLUXER_NATS_URL=nats://mq.example.com:4222
 #FLUXER_NATS_JETSTREAM_URL=nats://mq.example.com:4222
 #FLUXER_SVC_NATS_URL=nats://mq.example.com:4222
 #FLUXER_SEARCH_URL=https://search.example.com
 #FLUXER_LIVEKIT_INTERNAL_URL=http://livekit.example.com:7880
-# How the stack talks to those services.
-#FLUXER_KV_MODE=standalone
-#FLUXER_SEARCH_ENGINE=meilisearch
-#FLUXER_SEARCH_USERNAME=
-#FLUXER_SEARCH_PASSWORD=
-#FLUXER_SEARCH_TLS_REJECT_UNAUTHORIZED=true

 # Voice off. The livekit service still runs until an override removes it.
 #FLUXER_LIVEKIT_ENABLED=false

 # Optional systems, each off unless configured.
+#FLUXER_SMS_ENABLED=false
 #FLUXER_STRIPE_ENABLED=false
-#FLUXER_STRIPE_SECRET_KEY=
-#FLUXER_STRIPE_WEBHOOK_SECRET=
-# Stripe prices as one JSON object. The admin dashboard can set them instead.
-#FLUXER_STRIPE_PRICES={}
-#FLUXER_STRIPE_LEGACY_PRICES={}
-#FLUXER_API_DONATION_PROXY_KEY=
-#FLUXER_API_TRUSTED_CALLERS=[]
-#FLUXER_VISIONARIES_GUILD_ID=
-#FLUXER_VISIONARIES_GUILD_VISIONARY_ROLE_ID=
+#FLUXER_NCMEC_ENABLED=false
+#FLUXER_CLAMAV_ENABLED=false

-# NCMEC CyberTipline reporting, off by default. All four values are required
-# once it is on. The values below are examples.
-#FLUXER_NCMEC_ENABLED=true
-#FLUXER_NCMEC_BASE_URL=https://report.cybertip.org/ispws
-#FLUXER_NCMEC_USERNAME=
-#FLUXER_NCMEC_PASSWORD=
-#[email protected]
-
-# Upload virus scanning, off by default. No ClamAV container ships, so point
-# this at your own. The values below are examples.
-#FLUXER_CLAMAV_ENABLED=true
-#FLUXER_CLAMAV_HOST=clamav
-#FLUXER_CLAMAV_PORT=3310
-#FLUXER_CLAMAV_FAIL_OPEN=false
-
-# Outside lookups, off unless turned on. The breached password check asks
+# Outside lookups, off unless turned on. The Tor exit list comes from
+# onionoo.torproject.org and the breached password check asks
 # api.pwnedpasswords.com.
-#FLUXER_BREACHED_PASSWORD_CHECK_ENABLED=false
-#FLUXER_BLOCKLIST_FEEDS_ENABLED=false
-# A local path, or an s3:// URL read with the S3 credentials of this file.
-#FLUXER_GEOIP_DB_PATH=
+#FLUXER_TOR_EXIT_LIST_ENABLED=true
+#FLUXER_BREACHED_PASSWORD_CHECK_ENABLED=true

-# The client address. The edge sets X-Forwarded-For on every hop, so keep the
-# trust on and the default header. Turning the trust off makes the api refuse
-# every request outside its exempt routes with a 403.
-#FLUXER_CLIENT_IP_HEADER_NAME=x-forwarded-for
+# The client address. Name the header your proxy actually writes, and turn the
+# trust off when nothing sits in front.
+#FLUXER_CLIENT_IP_HEADER_NAME=cf-connecting-ip
 #FLUXER_TRUST_CLIENT_IP_HEADER=true

-# How much the services write. LOG_LEVEL covers the api and worker and takes trace,
-# debug, info, warn, error or fatal. RUST_LOG covers the Rust services and takes
-# an EnvFilter such as debug. The gateway takes an Erlang level such as notice,
-# and LOGGER_LEVEL beats FLUXER_GATEWAY_LOGGER_LEVEL.
-#LOG_LEVEL=info
-#RUST_LOG=info
-#FLUXER_GATEWAY_LOGGER_LEVEL=info
-#LOGGER_LEVEL=
+# How much the services write. trace, debug, info, warn, error or fatal.
+#LOG_LEVEL=debug

 FLUXER_S3_ACCESS_KEY=fluxer
 FLUXER_S3_SECRET_KEY=CHANGE_ME

 FLUXER_SUDO_MODE_SECRET=CHANGE_ME
 FLUXER_CONNECTION_INITIATION_SECRET=CHANGE_ME
-FLUXER_PROFILE_PSEUDONYM_SECRET=CHANGE_ME
 FLUXER_GATEWAY_RPC_AUTH_TOKEN=CHANGE_ME
 FLUXER_ERLANG_COOKIE=CHANGE_ME
 FLUXER_MEDIA_PROXY_SECRET_KEY=CHANGE_ME
@@ -203,7 +140,7 @@ FLUXER_VAPID_PRIVATE_KEY=CHANGE_ME
 # exist.
 #[email protected]

-# The passkey RP ID defaults to FLUXER_DOMAIN, whatever FLUXER_PUBLIC_ORIGIN says.
+# Passkeys follow FLUXER_DOMAIN. Set these only if browsers use another host.
 # Changing the RP ID invalidates every passkey registered against the old value.
 #FLUXER_PASSKEY_RP_ID=chat.example.com
 #FLUXER_PASSKEY_RP_NAME=Fluxer
@@ -214,32 +151,6 @@ FLUXER_VAPID_PRIVATE_KEY=CHANGE_ME
 #FLUXER_PUSH_SERVICE_QUEUE_CAPACITY=10000
 # Provider requests the push container sends at once, 1 to 65536.
 #FLUXER_PUSH_SERVICE_SEND_CONCURRENCY=256
-# The push container's provider addresses and relay hosts.
-#FLUXER_PUSH_SERVICE_APNS_BASE_URL=
-#FLUXER_PUSH_SERVICE_FCM_BASE_URL=https://fcm.googleapis.com
-#FLUXER_PUSH_SERVICE_MANAGED_RELAY_HOSTS=push.fluxer.com
-#FLUXER_PUSH_SERVICE_OWN_RELAY_HOSTS=
-# Push hosts on your own network, such as a ntfy server, that may resolve to
-# private addresses. Comma separated.
-#FLUXER_PUSH_SERVICE_PRIVATE_HOSTS=ntfy.example.com
-#FLUXER_PUSH_SERVICE_RELAY_CONSENT_ACCEPTED=false
-
-# Direct mobile push through your own APNs and FCM credentials, off by default.
-#FLUXER_PUSH_APNS_ENABLED=false
-#FLUXER_PUSH_APNS_TEAM_ID=
-#FLUXER_PUSH_APNS_KEY_ID=
-#FLUXER_PUSH_APNS_PRIVATE_KEY=
-#FLUXER_PUSH_APNS_PRIVATE_KEY_PATH=
-#FLUXER_PUSH_APNS_APPS=
-#FLUXER_PUSH_APNS_DEFAULT_ENVIRONMENT=production
-#FLUXER_PUSH_FCM_ENABLED=false
-#FLUXER_PUSH_FCM_PROJECT_ID=
-#FLUXER_PUSH_FCM_CLIENT_EMAIL=
-#FLUXER_PUSH_FCM_PRIVATE_KEY=
-#FLUXER_PUSH_FCM_PRIVATE_KEY_PATH=
-#FLUXER_PUSH_FCM_SERVICE_ACCOUNT_JSON_PATH=
-#FLUXER_PUSH_FCM_TOKEN_URI=https://oauth2.googleapis.com/token
-#FLUXER_PUSH_FCM_APPS=


 # Optional media policies, both off by default. See the operator docs.
@@ -251,9 +162,8 @@ FLUXER_VAPID_PRIVATE_KEY=CHANGE_ME
 # working. Needs a secret from openssl rand -base64 32, first entry signs and
 # every entry verifies.
 #
-# Each mode is off, report or enforce, and off is the default. Start at report.
-# media-proxy reads these at start, so apply with docker compose up -d
-# media-proxy. The values below are examples.
+# Each mode is off, report or enforce. Start at report. media-proxy reads these
+# at start, so apply with docker compose up -d media-proxy.
 #FLUXER_MEDIA_PROXY_CORS_MODE=enforce
 #FLUXER_MEDIA_PROXY_CORS_ALLOWED_ORIGINS=https://chat.example.com,https://web.fluxer.app
 #FLUXER_MEDIA_PROXY_ATTACHMENT_URL_SECRETS_BASE64=
@@ -263,7 +173,7 @@ FLUXER_VAPID_PRIVATE_KEY=CHANGE_ME
 # only when a browser must reach an origin the defaults do not cover. Separate
 # several with spaces or commas. The three values below are illustrations.
 #FLUXER_CSP_EXTRA_DEFAULT_SRC=
-#FLUXER_CSP_EXTRA_CONNECT_SRC=wss://livekit.example.com
+#FLUXER_CSP_EXTRA_CONNECT_SRC=wss://livekit.example.com:7881
 #FLUXER_CSP_EXTRA_IMG_SRC=https://cdn.example.com
 #FLUXER_CSP_EXTRA_MEDIA_SRC=
 #FLUXER_CSP_EXTRA_FONT_SRC=
@@ -278,7 +188,7 @@ FLUXER_VAPID_PRIVATE_KEY=CHANGE_ME

 # Let the SSO provider resolve to a private address. Off by default, so a
 # misconfigured provider URL cannot reach internal services. Turn it on only for
-# a provider on your own network. The value below is an example.
+# a provider on your own network.
 #FLUXER_SSO_ALLOW_PRIVATE_ADDRESSES=true

 # These reach both LiveKit and the api. Change them together.
@@ -295,123 +205,32 @@ LIVEKIT_API_SECRET=CHANGE_ME

 # LiveKit finds its public address over STUN. A host that cannot reach one stops
 # with "could not resolve external IP", so set the address by hand instead, or
-# point STUN elsewhere. The values below are examples.
+# point STUN elsewhere.
 #FLUXER_LIVEKIT_USE_EXTERNAL_IP=false
 #FLUXER_LIVEKIT_NODE_IP=203.0.113.10
 #FLUXER_LIVEKIT_STUN_PRIMARY=stun.l.google.com:19302
 #FLUXER_LIVEKIT_STUN_SECONDARY=stun1.l.google.com:19302

-# The voice region users see, and how much LiveKit logs.
-#FLUXER_LIVEKIT_DEFAULT_REGION={"id":"default","name":"Default","emoji":"🌍","latitude":0,"longitude":0}
-#FLUXER_LIVEKIT_LOG_LEVEL=info
-
 FLUXER_KLIPY_API_KEY=
-#FLUXER_YOUTUBE_API_KEY=
-# Hosts the api never unfurls, comma separated.
-#FLUXER_API_UNFURL_IGNORED_HOSTS=

-# Email delivery. Only an instance where members sign in with email needs it.
 FLUXER_EMAIL_ENABLED=false
 FLUXER_EMAIL_PROVIDER=none
 FLUXER_EMAIL_FROM_EMAIL=[email protected]
 FLUXER_EMAIL_FROM_NAME=Fluxer
-#[email protected]
 FLUXER_EMAIL_APP_BASE_URL=
 FLUXER_EMAIL_SMTP_HOST=
 FLUXER_EMAIL_SMTP_PORT=587
 FLUXER_EMAIL_SMTP_USERNAME=
 FLUXER_EMAIL_SMTP_PASSWORD=
 FLUXER_EMAIL_SMTP_SECURE=true
-#FLUXER_EMAIL_WEBHOOK_SECRET=

+FLUXER_CAPTCHA_ENABLED=false
+FLUXER_CAPTCHA_PROVIDER=none
+FLUXER_CAPTCHA_HCAPTCHA_SITE_KEY=
+FLUXER_CAPTCHA_HCAPTCHA_SECRET_KEY=
+FLUXER_CAPTCHA_TURNSTILE_SITE_KEY=
+FLUXER_CAPTCHA_TURNSTILE_SECRET_KEY=
 FLUXER_DISCOVERY_ENABLED=true
-#FLUXER_DISCOVERY_MIN_MEMBER_COUNT=1
-
-# Instance identity and account policy.
-#FLUXER_APP_PRODUCT_NAME=Fluxer
-#FLUXER_APP_ICON_URL=
-#FLUXER_APP_SYMBOL_URL=
-#FLUXER_APP_LOGO_URL=
-#FLUXER_APP_WORDMARK_URL=
-#FLUXER_APP_FAVICON_URL=
-#FLUXER_APP_THEME_COLOR=
-#FLUXER_APP_STATUS_PAGE_URL=
-#FLUXER_APP_STATUS_PAGE_INCIDENT_HISTORY_URL=
-#FLUXER_INSTANCE_SETUP_CONFIGURED=false
-# How members sign in on a new instance, username or email. Unset means username. Read only on the first start.
-#FLUXER_ACCOUNT_IDENTITY=
-# Username tags on a new email instance. none gives unique names with no tag, random gives name#4821. Unset means none. A username instance always uses none. Read only on the first start.
-#FLUXER_TAG_STYLE=
-#FLUXER_AUTO_JOIN_INVITE_CODE=
-#FLUXER_DELETION_GRACE_PERIOD_HOURS=336
-
-# Sign in with Bluesky, off unless turned on.
-#FLUXER_AUTH_BLUESKY_ENABLED=false
-#FLUXER_AUTH_BLUESKY_CLIENT_NAME=Fluxer
-#FLUXER_AUTH_BLUESKY_CLIENT_URI=
-#FLUXER_AUTH_BLUESKY_LOGO_URI=
-#FLUXER_AUTH_BLUESKY_TOS_URI=
-#FLUXER_AUTH_BLUESKY_POLICY_URI=
-#FLUXER_AUTH_BLUESKY_KEYS=
-
-# Public addresses. Each follows the public origin unless set here.
-#FLUXER_API_ENDPOINT=
-#FLUXER_API_CLIENT_ENDPOINT=
-#FLUXER_APP_ENDPOINT=
-#FLUXER_GATEWAY_ENDPOINT=
-#FLUXER_MEDIA_ENDPOINT=
-#FLUXER_STATIC_CDN_ENDPOINT=
-#FLUXER_ADMIN_ENDPOINT=
-#FLUXER_MARKETING_ENDPOINT=
-#FLUXER_INVITE_ENDPOINT=
-#FLUXER_GIFT_ENDPOINT=
-#FLUXER_MEDIA_PROXY_UPLOAD_RELAY_ENDPOINT=
-#PUBLIC_BOOTSTRAP_API_PUBLIC_ENDPOINT=
-# This follows FLUXER_STATIC_CDN_ENDPOINT first, then the public origin.
-#FLUXER_GATEWAY_STATIC_CDN_ENDPOINT=
-# These follow FLUXER_MEDIA_ENDPOINT first, then the public origin.
-#FLUXER_MEDIA_PROXY_PUBLIC_ENDPOINT=
-#FLUXER_GATEWAY_MEDIA_PROXY_ENDPOINT=
-
-# Extra hosts for static assets, invites, gifts and the web app. Empty by default.
-#FLUXER_STATIC_CDN_DOMAIN=
-#FLUXER_INVITE_DOMAIN=
-#FLUXER_GIFT_DOMAIN=
-#FLUXER_APP_ORIGIN_ALIASES=
-
-# The path the admin panel is served under. The edge and the admin service read
-# it. The api follows it through the default FLUXER_ADMIN_ENDPOINT, and not when
-# FLUXER_ADMIN_ENDPOINT is set. Write it with a leading slash and no trailing
-# slash.
-#FLUXER_ADMIN_BASE_PATH=/admin
-
-# The compression the edge offers, as Caddy encode arguments.
-#FLUXER_EDGE_ENCODE=zstd gzip
-
-# Images of the bundled services, for a mirror or another tag. A new Postgres
-# major needs a dump and restore, as the upgrade guide describes.
-#FLUXER_CADDY_IMAGE=caddy:2.11-alpine
-#FLUXER_POSTGRES_IMAGE=postgres:16-alpine
-#FLUXER_VALKEY_IMAGE=valkey/valkey:9.1-alpine
-#FLUXER_NATS_IMAGE=nats:2.14-alpine
-#FLUXER_MEILISEARCH_IMAGE=getmeili/meilisearch:v1.53
-#FLUXER_SEAWEEDFS_IMAGE=chrislusf/seaweedfs:4.47
-#FLUXER_LIVEKIT_IMAGE=livekit/livekit-server:v1.12.0
-
-# Restart policy for every long-running service.
-#FLUXER_RESTART_POLICY=unless-stopped
-
-# Health checks. Raise the retries or start periods on a slow host.
-#FLUXER_HEALTHCHECK_INTERVAL=10s
-#FLUXER_HEALTHCHECK_TIMEOUT=5s
-#FLUXER_HEALTHCHECK_RETRIES=10
-#FLUXER_APP_HEALTHCHECK_RETRIES=30
-#FLUXER_APP_HEALTHCHECK_START_PERIOD=90s
-#FLUXER_SVC_HEALTHCHECK_START_PERIOD=60s
-#FLUXER_WORKER_HEALTHCHECK_RETRIES=3
-#FLUXER_SEAWEEDFS_HEALTHCHECK_RETRIES=20
-#FLUXER_SEAWEEDFS_HEALTHCHECK_START_PERIOD=60s
-#FLUXER_SEAWEEDFS_INIT_ATTEMPTS=60

 # Container memory. These are ceilings, not allocations, and the defaults suit a
 # 16 GB host. The reservations bias the kernel away from reclaiming from services
@@ -421,7 +240,7 @@ FLUXER_DISCOVERY_ENABLED=true
 #FLUXER_POSTGRES_MEMORY_RESERVATION=3gb
 #FLUXER_VALKEY_MEMORY_LIMIT=256mb
 #FLUXER_NATS_MEMORY_LIMIT=256mb
-#FLUXER_MEILISEARCH_MEMORY_LIMIT=1536mb
+#FLUXER_MEILISEARCH_MEMORY_LIMIT=768mb
 #FLUXER_SEAWEEDFS_MEMORY_LIMIT=2gb
 #FLUXER_SEAWEEDFS_INIT_MEMORY_LIMIT=128mb
 #FLUXER_LIVEKIT_MEMORY_LIMIT=512mb
@@ -447,41 +266,20 @@ FLUXER_DISCOVERY_ENABLED=true
 #FLUXER_UNFURL_SHARD_MEMORY_LIMIT=256mb
 #FLUXER_ADMIN_MEMORY_LIMIT=256mb

-# Meilisearch indexing memory and threads. Each indexing thread needs its own
-# buffers on top of the indexing memory, so raise the threads only together with
-# the container limit above.
-#FLUXER_MEILISEARCH_MAX_INDEXING_MEMORY=256mb
-#FLUXER_MEILISEARCH_MAX_INDEXING_THREADS=2
-#FLUXER_MEILISEARCH_ENV=production
-#FLUXER_MEILISEARCH_NO_ANALYTICS=true
+# Meilisearch indexing memory. Keep it well under the container limit above.
+#FLUXER_MEILISEARCH_MAX_INDEXING_MEMORY=384mb

 # SeaweedFS heap ceiling. Go cannot see the container limit, so without this an
 # upload burst gets the container OOM-killed. Keep it near three quarters of
 # FLUXER_SEAWEEDFS_MEMORY_LIMIT and raise both together.
 #FLUXER_SEAWEEDFS_GOMEMLIMIT=1536MiB
-#FLUXER_SEAWEEDFS_TELEMETRY=false
-
-# Volumes SeaweedFS creates at once when a bucket needs space. Each reserves 1 GB
-# of free disk from the start, and SeaweedFS's own default of 7 fills a small
-# disk before every bucket has one, so uploads fail with no free volumes left.
-#FLUXER_SEAWEEDFS_VOLUME_GROWTH=1

 # Node sizes its heap from the container limit by default. Leave these unset
 # unless you need to pin it. A heap ceiling above the container limit gets the
-# container OOM-killed instead of reporting a heap error. The values below are
-# examples.
+# container OOM-killed instead of reporting a heap error.
 #FLUXER_API_NODE_HEAP_MB=1792
 #FLUXER_WORKER_NODE_HEAP_MB=1792

-# Extra Node flags for api and worker, appended to NODE_OPTIONS. Empty by
-# default. The value below is an example.
-#FLUXER_API_NODE_OPTIONS=--heapsnapshot-near-heap-limit=1
-#FLUXER_WORKER_NODE_OPTIONS=--heapsnapshot-near-heap-limit=1
-
-# Extra CA certificates api and worker trust, as a PEM bundle path inside the
-# container. The default is the image's system bundle.
-#FLUXER_NODE_EXTRA_CA_CERTS=/etc/ssl/certs/ca-certificates.crt
-
 # Bundled Postgres tuning. Keep it consistent with the memory limit above. This
 # is the server setting, not the per-service pool sizes.
 #FLUXER_POSTGRES_SERVER_MAX_CONNECTIONS=150
@@ -491,81 +289,23 @@ FLUXER_DISCOVERY_ENABLED=true
 #FLUXER_POSTGRES_MAINTENANCE_WORK_MEM=256MB
 #FLUXER_POSTGRES_AUTOVACUUM_WORK_MEM=128MB
 #FLUXER_POSTGRES_SHM_SIZE=1gb
-#FLUXER_POSTGRES_RANDOM_PAGE_COST=1.1
-#FLUXER_POSTGRES_EFFECTIVE_IO_CONCURRENCY=200
-#FLUXER_POSTGRES_DEFAULT_STATISTICS_TARGET=200
-#FLUXER_POSTGRES_JIT=off
-#FLUXER_POSTGRES_MIN_WAL_SIZE=512MB
-#FLUXER_POSTGRES_MAX_WAL_SIZE=2GB
-#FLUXER_POSTGRES_CHECKPOINT_COMPLETION_TARGET=0.9
-#FLUXER_POSTGRES_WAL_BUFFERS=16MB
-#FLUXER_POSTGRES_WAL_COMPRESSION=zstd
-#FLUXER_POSTGRES_BGWRITER_DELAY=50ms
-#FLUXER_POSTGRES_BGWRITER_LRU_MAXPAGES=1000
-#FLUXER_POSTGRES_AUTOVACUUM_VACUUM_SCALE_FACTOR=0.05
-#FLUXER_POSTGRES_AUTOVACUUM_ANALYZE_SCALE_FACTOR=0.02
-#FLUXER_POSTGRES_AUTOVACUUM_VACUUM_COST_LIMIT=2000
-#FLUXER_POSTGRES_TRACK_IO_TIMING=on
-#FLUXER_POSTGRES_SHARED_PRELOAD_LIBRARIES=pg_stat_statements
-
-# Postgres pool size of each service that opens a pool.
-#FLUXER_API_POSTGRES_MAX_CONNECTIONS=25
-#FLUXER_WORKER_POSTGRES_MAX_CONNECTIONS=25
-#FLUXER_USERS_SHARD_POSTGRES_MAX_CONNECTIONS=20
-#FLUXER_MESSAGES_SHARD_POSTGRES_MAX_CONNECTIONS=20

 # The bundled Valkey holds durable state as well as cache, so it runs with an
 # append-only file and with noeviction, which fails an over-limit write instead
 # of dropping queued work. Change the policy only if that state lives elsewhere.
 #FLUXER_VALKEY_MAXMEMORY=192mb
 #FLUXER_VALKEY_MAXMEMORY_POLICY=noeviction
-#FLUXER_VALKEY_APPENDFSYNC=everysec

 # The gateway derives its scheduler count from the CPU quota, clamped here. One
 # scheduler lets a single blocking operation stall every websocket on the node.
 #FLUXER_ERLANG_SCHEDULERS_MIN=2
 #FLUXER_ERLANG_SCHEDULERS_MAX=16
-# A fixed scheduler count skips the clamp. Dirty CPU schedulers default to two
-# thirds of it.
-#FLUXER_ERLANG_SCHEDULERS=
-#FLUXER_ERLANG_DIRTY_CPU_SCHEDULERS=

-# Gateway push and RPC tuning.
-#FLUXER_GATEWAY_PUSH_ENABLED=true
-#FLUXER_GATEWAY_PUSH_ENROLLED_CLEAR_NOTIFICATIONS_ENABLED=true
-#FLUXER_GATEWAY_PUSH_OUTBOX_REQUEST_TIMEOUT_MS=100000
-#FLUXER_GATEWAY_PRESENCE_PUSH_BUFFER_MAX_ENTRIES=128
-#FLUXER_GATEWAY_PRESENCE_PUSH_BUFFER_MAX_BYTES=1048576
-#FLUXER_GATEWAY_HTTP_RPC_MAX_CONCURRENCY=512
-#FLUXER_GATEWAY_NATS_RPC_MAX_HANDLERS=512
-#FLUXER_GATEWAY_HTTP_FAILURE_THRESHOLD=6
-#FLUXER_GATEWAY_HTTP_RECOVERY_TIMEOUT_MS=15000
-
-# In-flight request ceiling for every svc router and shard. Unset, each keeps its
-# own default: 192 for messages, 320 for snowflakes and 64 for the rest. One value
-# replaces all of them, so size it for the busiest. Too low a value rejects
-# requests rather than slowing them, and the api turns that into a 503. The value
-# below is an example.
-#FLUXER_SVC_MAX_CONCURRENT_REQUESTS=320
-
-# svc caches, and how the api calls the svc services over NATS.
-#FLUXER_SVC_CACHE_MAX_ENTRIES=100000
-#FLUXER_SVC_CACHE_TTL_MS=30000
-#FLUXER_GIFS_SHARD_CACHE_MAX_BYTES=536870912
-#FLUXER_GIF_SERVICE_NATS_CLIENT_NAME=fluxer-api-gifs
-#FLUXER_GIF_SERVICE_TIMEOUT_MS=12000
-#FLUXER_GIF_SERVICE_REGISTER_SHARE_TIMEOUT_MS=3000
-#FLUXER_USERS_SERVICE_NATS_CLIENT_NAME=fluxer-api-users
-#FLUXER_USERS_SERVICE_TIMEOUT_MS=6000
-#FLUXER_USERS_SERVICE_INFLIGHT_MAX_ENTRIES=10000
-#FLUXER_SNOWFLAKE_SERVICE_NATS_CLIENT_NAME=fluxer-api-snowflakes
-#FLUXER_SNOWFLAKE_SERVICE_BATCH_SIZE=128
-#FLUXER_SNOWFLAKE_SERVICE_LOW_WATERMARK=
-#FLUXER_SNOWFLAKE_SERVICE_MAX_BUFFER_AGE_MS=5000
-#FLUXER_SNOWFLAKE_SERVICE_REQUEST_TIMEOUT_MS=6000
-
-# Worker concurrency per lane, as a JSON object keyed by lane.
-#FLUXER_API_WORKER_LANE_CONCURRENCY_OVERRIDES=
+# In-flight request ceiling for the users and messages routers and their shards.
+# One value replaces the built-in default on all of them, so size it for the
+# busiest. Too low a value rejects requests rather than slowing them, and the api
+# turns that into a 503.
+#FLUXER_SVC_MAX_CONCURRENT_REQUESTS=192

 # Named prepared statements need a session that outlives the transaction, so set
 # this to false behind a transaction-pooling connection pooler. The bundled
@@ -577,51 +317,3 @@ FLUXER_DISCOVERY_ENABLED=true
 # is clamped down to the second. Milliseconds, 1000 to 3600000.
 #FLUXER_API_HEADERS_TIMEOUT_MS=30000
 #FLUXER_API_REQUEST_TIMEOUT_MS=120000
-
-# api request limits and IP bans. A refresh interval of 0 stops the periodic
-# ban reload.
-#FLUXER_API_MAX_INFLIGHT_REQUESTS=512
-#FLUXER_API_IP_BAN_EXEMPT_IPS=
-#FLUXER_IP_BAN_REFRESH_INTERVAL_MS=300000
-
-# Uploads and data exports. Presigned exports link to FLUXER_S3_PUBLIC_ENDPOINT,
-# so turn them on only once browsers can reach it.
-#FLUXER_API_PRESIGNED_ATTACHMENT_UPLOADS_ENABLED=true
-#FLUXER_API_PRESIGNED_HARVEST_DOWNLOADS_ENABLED=false
-#FLUXER_MEDIA_PROXY_UPLOAD_RELAY_MAX_BODY_BYTES=524288000
-#FLUXER_MEDIA_PROXY_UPLOAD_RELAY_TOKEN_TTL_SECS=900
-#FLUXER_MEDIA_PROXY_UPLOAD_RELAY_KEEP_DIRECT_COUNTRIES=
-#FLUXER_API_STORAGE_CHANGE_FEED_ENABLED=false
-#FLUXER_API_STORAGE_CHANGE_FEED_STREAM=STORAGE_CHANGES
-#FLUXER_API_STORAGE_CHANGE_FEED_SKIP_BUCKETS=
-#FLUXER_CACHE_PURGE_ADAPTER=none
-#FLUXER_CACHE_PURGE_HTTP_ENDPOINT=
-#FLUXER_CACHE_PURGE_HTTP_TOKEN=
-#FLUXER_CACHE_PURGE_HTTP_TIMEOUT_MS=10000
-
-# media-proxy limits and timeouts.
-#FLUXER_MEDIA_PROXY_READ_ONLY=false
-#FLUXER_MEDIA_PROXY_NSFW_THRESHOLD=0.85
-#FLUXER_NSFW_SERVICE_ENDPOINT=
-#FLUXER_MEDIA_PROXY_MAX_NATIVE_TRANSFORMS=
-#FLUXER_MEDIA_PROXY_WORKER_QUEUE_CAPACITY=
-#FLUXER_MEDIA_PROXY_MAX_ENCODE_DURATION_MS=30000
-#FLUXER_MEDIA_PROXY_MAX_ENCODE_FRAMES=20000
-#FLUXER_MEDIA_PROXY_TRANSFORM_TIMEOUT_MS=15000
-#FLUXER_MEDIA_PROXY_TRANSFORM_CACHE_BYTES=268435456
-#FLUXER_MEDIA_PROXY_TRANSFORM_CACHE_MAX_ENTRY_BYTES=67108864
-#FLUXER_MEDIA_PROXY_TRANSFORM_CACHE_TTL_MS=120000
-#FLUXER_MEDIA_PROXY_SOCKET_IO_TIMEOUT_MS=30000
-#FLUXER_MEDIA_PROXY_SHUTDOWN_GRACE_MS=30000
-#FLUXER_MEDIA_PROXY_UPLOAD_RELAY_S3_TIMEOUT_MS=900000
-#FLUXER_MEDIA_PROXY_UPLOAD_RELAY_BUFFERED_RETRY_BYTES=33554432
-#FLUXER_MEDIA_PROXY_UPLOAD_RELAY_BUFFERED_RETRY_TOTAL_BYTES=536870912
-#FLUXER_MEDIA_PROXY_UPLOAD_RELAY_SPOOL_DIR=
-#FLUXER_MEDIA_PROXY_UPLOAD_RELAY_SPOOL_CHUNK_BYTES=1048576
-#FLUXER_MEDIA_PROXY_UPLOAD_RELAY_SPOOL_MAX_TOTAL_BYTES=8589934592
-
-# app-proxy discovery refresh, index upstream and manifest scope.
-#DISCOVERY_REFRESH_INTERVAL_MS=60000
-#FLUXER_APP_PROXY_INDEX_UPSTREAM_URL=
-#FLUXER_APP_PROXY_SAME_ORIGIN_HOSTS=
-#FLUXER_APP_PROXY_MANIFEST_SCOPE_EXTENSIONS=
@@ -6,7 +6,7 @@
 }

 {$FLUXER_EDGE_SITE_ADDRESS} {
-	encode {$FLUXER_EDGE_ENCODE:zstd gzip}
+	encode zstd gzip

 	handle /_health {
 		respond "OK" 200
@@ -33,16 +33,16 @@
 		reverse_proxy livekit:7880
 	}

-	handle {$FLUXER_ADMIN_BASE_PATH:/admin} {
+	handle /admin {
 		rewrite * /
 		reverse_proxy admin:8080
 	}

-	handle_path {$FLUXER_ADMIN_BASE_PATH:/admin}/* {
+	handle_path /admin/* {
 		reverse_proxy admin:8080
 	}

-	@staticAssets path /web/* /emoji/* /libs/* /avatars/* /badges/* /desktop/*
+	@staticAssets path /web/* /emoji/* /libs/* /avatars/* /badges/* /desktop/* /embeds/*
 	handle @staticAssets {
 		reverse_proxy static-proxy:8080
 	}
@@ -3,81 +3,40 @@ name: fluxer
 x-fluxer-postgres-env: &fluxer-postgres-env
  FLUXER_DATABASE_BACKEND: postgres
  FLUXER_POSTGRES_HOST: ${FLUXER_POSTGRES_HOST:-postgres}
-  FLUXER_POSTGRES_PORT: ${FLUXER_POSTGRES_PORT:-}
-  FLUXER_POSTGRES_DATABASE: ${FLUXER_POSTGRES_DATABASE:-}
-  FLUXER_POSTGRES_USERNAME: ${FLUXER_POSTGRES_USERNAME:-}
+  FLUXER_POSTGRES_PORT: "${FLUXER_POSTGRES_PORT:-5432}"
+  FLUXER_POSTGRES_DATABASE: ${FLUXER_POSTGRES_DATABASE:-fluxer}
+  FLUXER_POSTGRES_USERNAME: ${FLUXER_POSTGRES_USERNAME:-fluxer}
  FLUXER_POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?set POSTGRES_PASSWORD in .env}
-  FLUXER_POSTGRES_URL: ${FLUXER_POSTGRES_URL:-}
-  FLUXER_POSTGRES_SSL: ${FLUXER_POSTGRES_SSL:-}
-  FLUXER_POSTGRES_SSL_CA: ${FLUXER_POSTGRES_SSL_CA:-}
-  FLUXER_POSTGRES_PREPARED_STATEMENTS: ${FLUXER_POSTGRES_PREPARED_STATEMENTS:-}
-  FLUXER_POSTGRES_KV_TABLE: ${FLUXER_POSTGRES_KV_TABLE:-}
+  FLUXER_POSTGRES_SSL: "${FLUXER_POSTGRES_SSL:-false}"
+  FLUXER_POSTGRES_PREPARED_STATEMENTS: ${FLUXER_POSTGRES_PREPARED_STATEMENTS:-true}

 x-fluxer-env: &fluxer-env
  <<: *fluxer-postgres-env
  FLUXER_ENV: production
-  LOG_LEVEL: ${LOG_LEVEL:-}
-  RUST_LOG: ${RUST_LOG:-}
+  NODE_ENV: production
+  LOG_LEVEL: ${LOG_LEVEL:-info}
  FLUXER_SELF_HOSTED: "true"
  FLUXER_BASE_DOMAIN: ${FLUXER_DOMAIN:?set FLUXER_DOMAIN in .env}
  FLUXER_PUBLIC_SCHEME: ${FLUXER_PUBLIC_SCHEME:-https}
  FLUXER_PUBLIC_PORT: ${FLUXER_PUBLIC_PORT:-443}
  FLUXER_PUBLIC_ORIGIN: ${FLUXER_PUBLIC_ORIGIN:-}
  FLUXER_TRUST_CLIENT_IP_HEADER: "${FLUXER_TRUST_CLIENT_IP_HEADER:-true}"
-  FLUXER_CLIENT_IP_HEADER_NAME: ${FLUXER_CLIENT_IP_HEADER_NAME:-}
-  FLUXER_API_HEADERS_TIMEOUT_MS: ${FLUXER_API_HEADERS_TIMEOUT_MS:-}
-  FLUXER_API_REQUEST_TIMEOUT_MS: ${FLUXER_API_REQUEST_TIMEOUT_MS:-}
-  FLUXER_API_MAX_INFLIGHT_REQUESTS: ${FLUXER_API_MAX_INFLIGHT_REQUESTS:-}
-  FLUXER_API_IP_BAN_EXEMPT_IPS: ${FLUXER_API_IP_BAN_EXEMPT_IPS:-}
-  FLUXER_IP_BAN_REFRESH_INTERVAL_MS: ${FLUXER_IP_BAN_REFRESH_INTERVAL_MS:-}
-  FLUXER_APP_ORIGIN_ALIASES: ${FLUXER_APP_ORIGIN_ALIASES:-}
-  FLUXER_BREACHED_PASSWORD_CHECK_ENABLED: ${FLUXER_BREACHED_PASSWORD_CHECK_ENABLED:-}
-  FLUXER_BLOCKLIST_FEEDS_ENABLED: ${FLUXER_BLOCKLIST_FEEDS_ENABLED:-}
-  FLUXER_GEOIP_DB_PATH: ${FLUXER_GEOIP_DB_PATH:-}
-
-  FLUXER_API_ENDPOINT: ${FLUXER_API_ENDPOINT:-}
-  FLUXER_API_CLIENT_ENDPOINT: ${FLUXER_API_CLIENT_ENDPOINT:-}
-  FLUXER_APP_ENDPOINT: ${FLUXER_APP_ENDPOINT:-${FLUXER_PUBLIC_ORIGIN:-${FLUXER_PUBLIC_SCHEME:-https}://${FLUXER_DOMAIN}}}
-  FLUXER_GATEWAY_ENDPOINT: ${FLUXER_GATEWAY_ENDPOINT:-}
-  FLUXER_MEDIA_ENDPOINT: ${FLUXER_MEDIA_ENDPOINT:-${FLUXER_PUBLIC_ORIGIN:-${FLUXER_PUBLIC_SCHEME:-https}://${FLUXER_DOMAIN}}/media}
-  FLUXER_MEDIA_PROXY_PUBLIC_ENDPOINT: ${FLUXER_MEDIA_PROXY_PUBLIC_ENDPOINT:-${FLUXER_MEDIA_ENDPOINT:-${FLUXER_PUBLIC_ORIGIN:-${FLUXER_PUBLIC_SCHEME:-https}://${FLUXER_DOMAIN}}/media}}
-  FLUXER_STATIC_CDN_ENDPOINT: ${FLUXER_STATIC_CDN_ENDPOINT:-}
-  FLUXER_ADMIN_ENDPOINT: ${FLUXER_ADMIN_ENDPOINT:-${FLUXER_PUBLIC_ORIGIN:-${FLUXER_PUBLIC_SCHEME:-https}://${FLUXER_DOMAIN}}${FLUXER_ADMIN_BASE_PATH:-/admin}}
-  FLUXER_MARKETING_ENDPOINT: ${FLUXER_MARKETING_ENDPOINT:-${FLUXER_PUBLIC_ORIGIN:-${FLUXER_PUBLIC_SCHEME:-https}://${FLUXER_DOMAIN}}}
-  FLUXER_INVITE_ENDPOINT: ${FLUXER_INVITE_ENDPOINT:-}
-  FLUXER_GIFT_ENDPOINT: ${FLUXER_GIFT_ENDPOINT:-}
-  FLUXER_STATIC_CDN_DOMAIN: ${FLUXER_STATIC_CDN_DOMAIN:-}
-  FLUXER_INVITE_DOMAIN: ${FLUXER_INVITE_DOMAIN:-}
-  FLUXER_GIFT_DOMAIN: ${FLUXER_GIFT_DOMAIN:-}
+  FLUXER_CLIENT_IP_HEADER_NAME: ${FLUXER_CLIENT_IP_HEADER_NAME:-x-forwarded-for}
+  FLUXER_API_HEADERS_TIMEOUT_MS: ${FLUXER_API_HEADERS_TIMEOUT_MS:-30000}
+  FLUXER_API_REQUEST_TIMEOUT_MS: ${FLUXER_API_REQUEST_TIMEOUT_MS:-120000}
+  FLUXER_TOR_EXIT_LIST_ENABLED: "${FLUXER_TOR_EXIT_LIST_ENABLED:-false}"
+  FLUXER_BREACHED_PASSWORD_CHECK_ENABLED: "${FLUXER_BREACHED_PASSWORD_CHECK_ENABLED:-false}"

  FLUXER_KV_URL: ${FLUXER_KV_URL:-redis://valkey:6379/0}
-  FLUXER_KV_MODE: ${FLUXER_KV_MODE:-}
  FLUXER_NATS_URL: ${FLUXER_NATS_URL:-nats://nats:4222}
  FLUXER_NATS_JETSTREAM_URL: ${FLUXER_NATS_JETSTREAM_URL:-${FLUXER_NATS_URL:-nats://nats:4222}}
  FLUXER_NATS_AUTH_TOKEN: ${FLUXER_NATS_AUTH_TOKEN:-}
  FLUXER_SVC_NATS_URL: ${FLUXER_SVC_NATS_URL:-${FLUXER_NATS_URL:-nats://nats:4222}}
  FLUXER_SVC_SHARD_COUNT: "1"
-  FLUXER_SVC_MAX_CONCURRENT_REQUESTS: ${FLUXER_SVC_MAX_CONCURRENT_REQUESTS:-}
-  FLUXER_SVC_CACHE_MAX_ENTRIES: ${FLUXER_SVC_CACHE_MAX_ENTRIES:-}
-  FLUXER_SVC_CACHE_TTL_MS: ${FLUXER_SVC_CACHE_TTL_MS:-}
-  FLUXER_GIF_SERVICE_NATS_CLIENT_NAME: ${FLUXER_GIF_SERVICE_NATS_CLIENT_NAME:-}
-  FLUXER_GIF_SERVICE_TIMEOUT_MS: ${FLUXER_GIF_SERVICE_TIMEOUT_MS:-}
-  FLUXER_GIF_SERVICE_REGISTER_SHARE_TIMEOUT_MS: ${FLUXER_GIF_SERVICE_REGISTER_SHARE_TIMEOUT_MS:-}
-  FLUXER_USERS_SERVICE_NATS_CLIENT_NAME: ${FLUXER_USERS_SERVICE_NATS_CLIENT_NAME:-}
-  FLUXER_USERS_SERVICE_TIMEOUT_MS: ${FLUXER_USERS_SERVICE_TIMEOUT_MS:-}
-  FLUXER_USERS_SERVICE_INFLIGHT_MAX_ENTRIES: ${FLUXER_USERS_SERVICE_INFLIGHT_MAX_ENTRIES:-}
-  FLUXER_SNOWFLAKE_SERVICE_NATS_CLIENT_NAME: ${FLUXER_SNOWFLAKE_SERVICE_NATS_CLIENT_NAME:-}
-  FLUXER_SNOWFLAKE_SERVICE_BATCH_SIZE: ${FLUXER_SNOWFLAKE_SERVICE_BATCH_SIZE:-}
-  FLUXER_SNOWFLAKE_SERVICE_LOW_WATERMARK: ${FLUXER_SNOWFLAKE_SERVICE_LOW_WATERMARK:-}
-  FLUXER_SNOWFLAKE_SERVICE_MAX_BUFFER_AGE_MS: ${FLUXER_SNOWFLAKE_SERVICE_MAX_BUFFER_AGE_MS:-}
-  FLUXER_SNOWFLAKE_SERVICE_REQUEST_TIMEOUT_MS: ${FLUXER_SNOWFLAKE_SERVICE_REQUEST_TIMEOUT_MS:-}

-  FLUXER_SEARCH_ENGINE: ${FLUXER_SEARCH_ENGINE:-meilisearch}
+  FLUXER_SEARCH_ENGINE: meilisearch
  FLUXER_SEARCH_URL: ${FLUXER_SEARCH_URL:-http://meilisearch:7700}
  FLUXER_SEARCH_API_KEY: ${MEILI_MASTER_KEY:?set MEILI_MASTER_KEY in .env}
-  FLUXER_SEARCH_USERNAME: ${FLUXER_SEARCH_USERNAME:-}
-  FLUXER_SEARCH_PASSWORD: ${FLUXER_SEARCH_PASSWORD:-}
-  FLUXER_SEARCH_TLS_REJECT_UNAUTHORIZED: ${FLUXER_SEARCH_TLS_REJECT_UNAUTHORIZED:-}

  FLUXER_S3_ENDPOINT: ${FLUXER_S3_ENDPOINT:-http://seaweedfs:8333}
  FLUXER_S3_PUBLIC_ENDPOINT: ${FLUXER_S3_PUBLIC_ENDPOINT:-${FLUXER_S3_ENDPOINT:-http://seaweedfs:8333}}
@@ -89,101 +48,52 @@ x-fluxer-env: &fluxer-env
  FLUXER_S3_BUCKET_UPLOADS: ${FLUXER_S3_BUCKET_UPLOADS:-fluxer-uploads}
  FLUXER_S3_BUCKET_REPORTS: ${FLUXER_S3_BUCKET_REPORTS:-fluxer-reports}
  FLUXER_S3_BUCKET_HARVESTS: ${FLUXER_S3_BUCKET_HARVESTS:-fluxer-harvests}
-  FLUXER_API_PRESIGNED_HARVEST_DOWNLOADS_ENABLED: "${FLUXER_API_PRESIGNED_HARVEST_DOWNLOADS_ENABLED:-false}"
-  FLUXER_API_STORAGE_CHANGE_FEED_ENABLED: ${FLUXER_API_STORAGE_CHANGE_FEED_ENABLED:-}
-  FLUXER_API_STORAGE_CHANGE_FEED_STREAM: ${FLUXER_API_STORAGE_CHANGE_FEED_STREAM:-}
-  FLUXER_API_STORAGE_CHANGE_FEED_SKIP_BUCKETS: ${FLUXER_API_STORAGE_CHANGE_FEED_SKIP_BUCKETS:-}
-  FLUXER_CACHE_PURGE_ADAPTER: ${FLUXER_CACHE_PURGE_ADAPTER:-}
-  FLUXER_CACHE_PURGE_HTTP_ENDPOINT: ${FLUXER_CACHE_PURGE_HTTP_ENDPOINT:-}
-  FLUXER_CACHE_PURGE_HTTP_TOKEN: ${FLUXER_CACHE_PURGE_HTTP_TOKEN:-}
-  FLUXER_CACHE_PURGE_HTTP_TIMEOUT_MS: ${FLUXER_CACHE_PURGE_HTTP_TIMEOUT_MS:-}
+  AWS_ACCESS_KEY_ID: ${FLUXER_S3_ACCESS_KEY:?set FLUXER_S3_ACCESS_KEY in .env}
+  AWS_SECRET_ACCESS_KEY: ${FLUXER_S3_SECRET_KEY:?set FLUXER_S3_SECRET_KEY in .env}
+  AWS_DEFAULT_REGION: ${FLUXER_S3_REGION:-us-east-1}
+  AWS_EC2_METADATA_DISABLED: "true"

  FLUXER_LIVEKIT_ENABLED: "${FLUXER_LIVEKIT_ENABLED:-true}"
  FLUXER_LIVEKIT_API_KEY: ${LIVEKIT_API_KEY:?set LIVEKIT_API_KEY in .env}
  FLUXER_LIVEKIT_API_SECRET: ${LIVEKIT_API_SECRET:?set LIVEKIT_API_SECRET in .env}
  FLUXER_LIVEKIT_INTERNAL_URL: ${FLUXER_LIVEKIT_INTERNAL_URL:-http://livekit:7880}
-  FLUXER_LIVEKIT_DEFAULT_REGION: '${FLUXER_LIVEKIT_DEFAULT_REGION:-{"id":"default","name":"Default","emoji":"🌍","latitude":0,"longitude":0}}'
+  FLUXER_LIVEKIT_WEBHOOK_URL: http://api:8080/webhooks/livekit
+  FLUXER_LIVEKIT_DEFAULT_REGION: '{"id":"default","name":"Default","emoji":"🌍","latitude":0,"longitude":0}'
  FLUXER_LIVEKIT_URL: ${FLUXER_LIVEKIT_URL:-${FLUXER_PUBLIC_ORIGIN:-${FLUXER_PUBLIC_SCHEME:-https}://${FLUXER_DOMAIN}:${FLUXER_PUBLIC_PORT:-443}}/livekit}

  FLUXER_KLIPY_API_KEY: ${FLUXER_KLIPY_API_KEY:-}
-  FLUXER_YOUTUBE_API_KEY: ${FLUXER_YOUTUBE_API_KEY:-}
-  FLUXER_API_UNFURL_IGNORED_HOSTS: ${FLUXER_API_UNFURL_IGNORED_HOSTS:-}

-  FLUXER_EMAIL_ENABLED: ${FLUXER_EMAIL_ENABLED:-}
-  FLUXER_EMAIL_PROVIDER: ${FLUXER_EMAIL_PROVIDER:-}
+  FLUXER_EMAIL_ENABLED: ${FLUXER_EMAIL_ENABLED:-false}
+  FLUXER_EMAIL_PROVIDER: ${FLUXER_EMAIL_PROVIDER:-none}
  FLUXER_EMAIL_FROM_EMAIL: ${FLUXER_EMAIL_FROM_EMAIL:-noreply@localhost}
-  FLUXER_EMAIL_FROM_NAME: ${FLUXER_EMAIL_FROM_NAME:-}
-  FLUXER_EMAIL_REPLY_TO_EMAIL: ${FLUXER_EMAIL_REPLY_TO_EMAIL:-}
+  FLUXER_EMAIL_FROM_NAME: ${FLUXER_EMAIL_FROM_NAME:-Fluxer}
  FLUXER_EMAIL_APP_BASE_URL: ${FLUXER_EMAIL_APP_BASE_URL:-}
-  FLUXER_EMAIL_WEBHOOK_SECRET: ${FLUXER_EMAIL_WEBHOOK_SECRET:-}
  FLUXER_EMAIL_SMTP_HOST: ${FLUXER_EMAIL_SMTP_HOST:-}
-  FLUXER_EMAIL_SMTP_PORT: ${FLUXER_EMAIL_SMTP_PORT:-}
+  FLUXER_EMAIL_SMTP_PORT: ${FLUXER_EMAIL_SMTP_PORT:-587}
  FLUXER_EMAIL_SMTP_USERNAME: ${FLUXER_EMAIL_SMTP_USERNAME:-}
  FLUXER_EMAIL_SMTP_PASSWORD: ${FLUXER_EMAIL_SMTP_PASSWORD:-}
-  FLUXER_EMAIL_SMTP_SECURE: ${FLUXER_EMAIL_SMTP_SECURE:-}
+  FLUXER_EMAIL_SMTP_SECURE: ${FLUXER_EMAIL_SMTP_SECURE:-true}

-  FLUXER_STRIPE_ENABLED: ${FLUXER_STRIPE_ENABLED:-}
-  FLUXER_STRIPE_SECRET_KEY: ${FLUXER_STRIPE_SECRET_KEY:-}
-  FLUXER_STRIPE_WEBHOOK_SECRET: ${FLUXER_STRIPE_WEBHOOK_SECRET:-}
-  FLUXER_STRIPE_PRICES: ${FLUXER_STRIPE_PRICES:-}
-  FLUXER_STRIPE_LEGACY_PRICES: ${FLUXER_STRIPE_LEGACY_PRICES:-}
-  FLUXER_API_DONATION_PROXY_KEY: ${FLUXER_API_DONATION_PROXY_KEY:-}
-  FLUXER_API_TRUSTED_CALLERS: ${FLUXER_API_TRUSTED_CALLERS:-}
-  FLUXER_VISIONARIES_GUILD_ID: ${FLUXER_VISIONARIES_GUILD_ID:-}
-  FLUXER_VISIONARIES_GUILD_VISIONARY_ROLE_ID: ${FLUXER_VISIONARIES_GUILD_VISIONARY_ROLE_ID:-}
-
-  FLUXER_NCMEC_ENABLED: ${FLUXER_NCMEC_ENABLED:-}
-  FLUXER_NCMEC_BASE_URL: ${FLUXER_NCMEC_BASE_URL:-}
-  FLUXER_NCMEC_USERNAME: ${FLUXER_NCMEC_USERNAME:-}
-  FLUXER_NCMEC_PASSWORD: ${FLUXER_NCMEC_PASSWORD:-}
-  FLUXER_NCMEC_REPORTER_EMAIL: ${FLUXER_NCMEC_REPORTER_EMAIL:-}
-  FLUXER_CLAMAV_ENABLED: ${FLUXER_CLAMAV_ENABLED:-}
-  FLUXER_CLAMAV_HOST: ${FLUXER_CLAMAV_HOST:-}
-  FLUXER_CLAMAV_PORT: ${FLUXER_CLAMAV_PORT:-}
-  FLUXER_CLAMAV_FAIL_OPEN: ${FLUXER_CLAMAV_FAIL_OPEN:-}
-
-  FLUXER_APP_PRODUCT_NAME: ${FLUXER_APP_PRODUCT_NAME:-}
-  FLUXER_APP_ICON_URL: ${FLUXER_APP_ICON_URL:-}
-  FLUXER_APP_SYMBOL_URL: ${FLUXER_APP_SYMBOL_URL:-}
-  FLUXER_APP_LOGO_URL: ${FLUXER_APP_LOGO_URL:-}
-  FLUXER_APP_WORDMARK_URL: ${FLUXER_APP_WORDMARK_URL:-}
-  FLUXER_APP_FAVICON_URL: ${FLUXER_APP_FAVICON_URL:-}
-  FLUXER_APP_THEME_COLOR: ${FLUXER_APP_THEME_COLOR:-}
-  FLUXER_APP_STATUS_PAGE_URL: ${FLUXER_APP_STATUS_PAGE_URL:-}
-  FLUXER_APP_STATUS_PAGE_INCIDENT_HISTORY_URL: ${FLUXER_APP_STATUS_PAGE_INCIDENT_HISTORY_URL:-}
-  FLUXER_INSTANCE_SETUP_CONFIGURED: ${FLUXER_INSTANCE_SETUP_CONFIGURED:-}
-  FLUXER_ACCOUNT_IDENTITY: ${FLUXER_ACCOUNT_IDENTITY:-}
-  FLUXER_TAG_STYLE: ${FLUXER_TAG_STYLE:-}
-  FLUXER_AUTO_JOIN_INVITE_CODE: ${FLUXER_AUTO_JOIN_INVITE_CODE:-}
-  FLUXER_DISCOVERY_ENABLED: ${FLUXER_DISCOVERY_ENABLED:-}
-  FLUXER_DISCOVERY_MIN_MEMBER_COUNT: ${FLUXER_DISCOVERY_MIN_MEMBER_COUNT:-}
-  FLUXER_DELETION_GRACE_PERIOD_HOURS: ${FLUXER_DELETION_GRACE_PERIOD_HOURS:-}
-  FLUXER_API_WORKER_LANE_CONCURRENCY_OVERRIDES: ${FLUXER_API_WORKER_LANE_CONCURRENCY_OVERRIDES:-}
-
-  FLUXER_AUTH_BLUESKY_ENABLED: ${FLUXER_AUTH_BLUESKY_ENABLED:-}
-  FLUXER_AUTH_BLUESKY_CLIENT_NAME: ${FLUXER_AUTH_BLUESKY_CLIENT_NAME:-}
-  FLUXER_AUTH_BLUESKY_CLIENT_URI: ${FLUXER_AUTH_BLUESKY_CLIENT_URI:-}
-  FLUXER_AUTH_BLUESKY_LOGO_URI: ${FLUXER_AUTH_BLUESKY_LOGO_URI:-}
-  FLUXER_AUTH_BLUESKY_TOS_URI: ${FLUXER_AUTH_BLUESKY_TOS_URI:-}
-  FLUXER_AUTH_BLUESKY_POLICY_URI: ${FLUXER_AUTH_BLUESKY_POLICY_URI:-}
-  FLUXER_AUTH_BLUESKY_KEYS: ${FLUXER_AUTH_BLUESKY_KEYS:-}
-
-  FLUXER_PUSH_APNS_ENABLED: ${FLUXER_PUSH_APNS_ENABLED:-}
-  FLUXER_PUSH_APNS_TEAM_ID: ${FLUXER_PUSH_APNS_TEAM_ID:-}
-  FLUXER_PUSH_APNS_KEY_ID: ${FLUXER_PUSH_APNS_KEY_ID:-}
-  FLUXER_PUSH_APNS_PRIVATE_KEY: ${FLUXER_PUSH_APNS_PRIVATE_KEY:-}
-  FLUXER_PUSH_APNS_PRIVATE_KEY_PATH: ${FLUXER_PUSH_APNS_PRIVATE_KEY_PATH:-}
-  FLUXER_PUSH_APNS_APPS: ${FLUXER_PUSH_APNS_APPS:-}
+  FLUXER_SMS_ENABLED: "${FLUXER_SMS_ENABLED:-false}"
+  FLUXER_CAPTCHA_ENABLED: ${FLUXER_CAPTCHA_ENABLED:-false}
+  FLUXER_CAPTCHA_PROVIDER: ${FLUXER_CAPTCHA_PROVIDER:-none}
+  FLUXER_CAPTCHA_HCAPTCHA_SITE_KEY: ${FLUXER_CAPTCHA_HCAPTCHA_SITE_KEY:-}
+  FLUXER_CAPTCHA_HCAPTCHA_SECRET_KEY: ${FLUXER_CAPTCHA_HCAPTCHA_SECRET_KEY:-}
+  FLUXER_CAPTCHA_TURNSTILE_SITE_KEY: ${FLUXER_CAPTCHA_TURNSTILE_SITE_KEY:-}
+  FLUXER_CAPTCHA_TURNSTILE_SECRET_KEY: ${FLUXER_CAPTCHA_TURNSTILE_SECRET_KEY:-}
+  FLUXER_STRIPE_ENABLED: "${FLUXER_STRIPE_ENABLED:-false}"
+  FLUXER_NCMEC_ENABLED: "${FLUXER_NCMEC_ENABLED:-false}"
+  FLUXER_CLAMAV_ENABLED: "${FLUXER_CLAMAV_ENABLED:-false}"
+  FLUXER_DISCOVERY_ENABLED: ${FLUXER_DISCOVERY_ENABLED:-true}

  FLUXER_SUDO_MODE_SECRET: ${FLUXER_SUDO_MODE_SECRET:?set FLUXER_SUDO_MODE_SECRET in .env}
  FLUXER_CONNECTION_INITIATION_SECRET: ${FLUXER_CONNECTION_INITIATION_SECRET:?set FLUXER_CONNECTION_INITIATION_SECRET in .env}
-  FLUXER_PROFILE_PSEUDONYM_SECRET: ${FLUXER_PROFILE_PSEUDONYM_SECRET:?set FLUXER_PROFILE_PSEUDONYM_SECRET in .env}
-  FLUXER_SSO_ALLOW_PRIVATE_ADDRESSES: ${FLUXER_SSO_ALLOW_PRIVATE_ADDRESSES:-}
+  FLUXER_SSO_ALLOW_PRIVATE_ADDRESSES: ${FLUXER_SSO_ALLOW_PRIVATE_ADDRESSES:-false}
  FLUXER_VAPID_PUBLIC_KEY: ${FLUXER_VAPID_PUBLIC_KEY:?set FLUXER_VAPID_PUBLIC_KEY in .env}
  FLUXER_VAPID_PRIVATE_KEY: ${FLUXER_VAPID_PRIVATE_KEY:?set FLUXER_VAPID_PRIVATE_KEY in .env}
  FLUXER_VAPID_EMAIL: ${FLUXER_VAPID_EMAIL:-admin@${FLUXER_DOMAIN}}
  FLUXER_PASSKEY_RP_ID: ${FLUXER_PASSKEY_RP_ID:-${FLUXER_DOMAIN}}
-  FLUXER_PASSKEY_RP_NAME: ${FLUXER_PASSKEY_RP_NAME:-}
+  FLUXER_PASSKEY_RP_NAME: ${FLUXER_PASSKEY_RP_NAME:-Fluxer}
  FLUXER_PASSKEY_ADDITIONAL_ALLOWED_ORIGINS: ${FLUXER_PASSKEY_ADDITIONAL_ALLOWED_ORIGINS:-${FLUXER_PUBLIC_ORIGIN:-${FLUXER_PUBLIC_SCHEME:-https}://${FLUXER_DOMAIN}}}
  FLUXER_GATEWAY_RPC_AUTH_TOKEN: ${FLUXER_GATEWAY_RPC_AUTH_TOKEN:?set FLUXER_GATEWAY_RPC_AUTH_TOKEN in .env}
  FLUXER_MEDIA_PROXY_SECRET_KEY: ${FLUXER_MEDIA_PROXY_SECRET_KEY:?set FLUXER_MEDIA_PROXY_SECRET_KEY in .env}
@@ -193,36 +103,34 @@ x-fluxer-env: &fluxer-env
  FLUXER_ADMIN_OAUTH_CLIENT_SECRET: ${FLUXER_ADMIN_OAUTH_CLIENT_SECRET:?set FLUXER_ADMIN_OAUTH_CLIENT_SECRET in .env}

  FLUXER_INTERNAL_API_ENDPOINT: http://api:8080
+  FLUXER_INTERNAL_GATEWAY_ENDPOINT: http://gateway:8080
  FLUXER_INTERNAL_MEDIA_PROXY_ENDPOINT: http://media-proxy:8080
-  FLUXER_MEDIA_PROXY_UPLOAD_RELAY_ENDPOINT: ${FLUXER_MEDIA_PROXY_UPLOAD_RELAY_ENDPOINT:-${FLUXER_PUBLIC_ORIGIN:-${FLUXER_PUBLIC_SCHEME:-https}://${FLUXER_DOMAIN}}/media}
-  FLUXER_MEDIA_PROXY_UPLOAD_RELAY_MAX_BODY_BYTES: ${FLUXER_MEDIA_PROXY_UPLOAD_RELAY_MAX_BODY_BYTES:-}
-  FLUXER_MEDIA_PROXY_UPLOAD_RELAY_TOKEN_TTL_SECS: ${FLUXER_MEDIA_PROXY_UPLOAD_RELAY_TOKEN_TTL_SECS:-}
-  FLUXER_MEDIA_PROXY_UPLOAD_RELAY_KEEP_DIRECT_COUNTRIES: ${FLUXER_MEDIA_PROXY_UPLOAD_RELAY_KEEP_DIRECT_COUNTRIES:-}
+  FLUXER_MARKETING_ENDPOINT: ${FLUXER_PUBLIC_ORIGIN:-${FLUXER_PUBLIC_SCHEME:-https}://${FLUXER_DOMAIN}}
+  FLUXER_MEDIA_PROXY_ENDPOINT: http://media-proxy:8080
+  FLUXER_MEDIA_ENDPOINT: ${FLUXER_PUBLIC_ORIGIN:-${FLUXER_PUBLIC_SCHEME:-https}://${FLUXER_DOMAIN}}/media
+  FLUXER_MEDIA_PROXY_UPLOAD_RELAY_ENDPOINT: ${FLUXER_PUBLIC_ORIGIN:-${FLUXER_PUBLIC_SCHEME:-https}://${FLUXER_DOMAIN}}/media

 x-fluxer-service: &fluxer-service
-  restart: ${FLUXER_RESTART_POLICY:-unless-stopped}
+  restart: unless-stopped
  networks: [fluxer]

-x-fluxer-app-healthcheck: &fluxer-app-healthcheck
-  interval: ${FLUXER_HEALTHCHECK_INTERVAL:-10s}
-  timeout: ${FLUXER_HEALTHCHECK_TIMEOUT:-5s}
-  retries: ${FLUXER_APP_HEALTHCHECK_RETRIES:-30}
-  start_period: ${FLUXER_APP_HEALTHCHECK_START_PERIOD:-90s}
-  start_interval: 1s
-
 x-fluxer-svc-healthcheck: &fluxer-svc-healthcheck
-  <<: *fluxer-app-healthcheck
-  start_period: ${FLUXER_SVC_HEALTHCHECK_START_PERIOD:-60s}
  test: ["CMD", "bash", "-c", "exec 3<>/dev/tcp/127.0.0.1/8090 && printf 'GET /_health HTTP/1.0\\r\\n\\r\\n' >&3 && head -n 1 <&3 | grep -q ' 200 '"]
+  interval: 10s
+  timeout: 5s
+  retries: 30
+  start_period: 60s
+  start_interval: 1s

 services:
  edge:
-    <<: *fluxer-service
-    image: ${FLUXER_CADDY_IMAGE:-caddy:2.11-alpine}
+    image: caddy:2.11-alpine
    deploy:
      resources:
        limits:
          memory: ${FLUXER_CADDY_MEMORY_LIMIT:-256mb}
+    restart: unless-stopped
+    networks: [fluxer]
    ports:
      - "${FLUXER_HTTP_PORT:-80}:80"
      - "${FLUXER_HTTPS_PORT:-443}:443"
@@ -230,17 +138,15 @@ services:
    environment:
      FLUXER_EDGE_SITE_ADDRESS: ${FLUXER_EDGE_SITE_ADDRESS:-${FLUXER_CADDY_SITE_ADDRESS:-${FLUXER_PUBLIC_SCHEME:-https}://${FLUXER_DOMAIN:?set FLUXER_DOMAIN in .env}}}
      FLUXER_EDGE_TRUSTED_PROXIES: ${FLUXER_EDGE_TRUSTED_PROXIES:-private_ranges}
-      FLUXER_EDGE_ENCODE: ${FLUXER_EDGE_ENCODE:-zstd gzip}
-      FLUXER_ADMIN_BASE_PATH: ${FLUXER_ADMIN_BASE_PATH:-/admin}
    volumes:
      - ./Caddyfile:/etc/caddy/Caddyfile:ro
      - edge-data:/data
      - edge-config:/config
    healthcheck:
      test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:2019/config/"]
-      interval: ${FLUXER_HEALTHCHECK_INTERVAL:-10s}
-      timeout: ${FLUXER_HEALTHCHECK_TIMEOUT:-5s}
-      retries: ${FLUXER_HEALTHCHECK_RETRIES:-10}
+      interval: 10s
+      timeout: 5s
+      retries: 10
    depends_on:
      api: {condition: service_started}
      gateway: {condition: service_healthy}
@@ -249,14 +155,15 @@ services:
      admin: {condition: service_started}

  postgres:
-    <<: *fluxer-service
-    image: ${FLUXER_POSTGRES_IMAGE:-postgres:16-alpine}
+    image: postgres:16-alpine
    deploy:
      resources:
        limits:
          memory: ${FLUXER_POSTGRES_MEMORY_LIMIT:-5gb}
        reservations:
          memory: ${FLUXER_POSTGRES_MEMORY_RESERVATION:-3gb}
+    restart: unless-stopped
+    networks: [fluxer]
    command: >
      postgres
      -c max_connections=${FLUXER_POSTGRES_SERVER_MAX_CONNECTIONS:-150}
@@ -265,113 +172,115 @@ services:
      -c work_mem=${FLUXER_POSTGRES_WORK_MEM:-8MB}
      -c maintenance_work_mem=${FLUXER_POSTGRES_MAINTENANCE_WORK_MEM:-256MB}
      -c autovacuum_work_mem=${FLUXER_POSTGRES_AUTOVACUUM_WORK_MEM:-128MB}
-      -c random_page_cost=${FLUXER_POSTGRES_RANDOM_PAGE_COST:-1.1}
-      -c effective_io_concurrency=${FLUXER_POSTGRES_EFFECTIVE_IO_CONCURRENCY:-200}
-      -c default_statistics_target=${FLUXER_POSTGRES_DEFAULT_STATISTICS_TARGET:-200}
-      -c jit=${FLUXER_POSTGRES_JIT:-off}
-      -c min_wal_size=${FLUXER_POSTGRES_MIN_WAL_SIZE:-512MB}
-      -c max_wal_size=${FLUXER_POSTGRES_MAX_WAL_SIZE:-2GB}
-      -c checkpoint_completion_target=${FLUXER_POSTGRES_CHECKPOINT_COMPLETION_TARGET:-0.9}
-      -c wal_buffers=${FLUXER_POSTGRES_WAL_BUFFERS:-16MB}
-      -c wal_compression=${FLUXER_POSTGRES_WAL_COMPRESSION:-zstd}
-      -c bgwriter_delay=${FLUXER_POSTGRES_BGWRITER_DELAY:-50ms}
-      -c bgwriter_lru_maxpages=${FLUXER_POSTGRES_BGWRITER_LRU_MAXPAGES:-1000}
-      -c autovacuum_vacuum_scale_factor=${FLUXER_POSTGRES_AUTOVACUUM_VACUUM_SCALE_FACTOR:-0.05}
-      -c autovacuum_analyze_scale_factor=${FLUXER_POSTGRES_AUTOVACUUM_ANALYZE_SCALE_FACTOR:-0.02}
-      -c autovacuum_vacuum_cost_limit=${FLUXER_POSTGRES_AUTOVACUUM_VACUUM_COST_LIMIT:-2000}
-      -c track_io_timing=${FLUXER_POSTGRES_TRACK_IO_TIMING:-on}
-      -c shared_preload_libraries=${FLUXER_POSTGRES_SHARED_PRELOAD_LIBRARIES:-pg_stat_statements}
+      -c random_page_cost=1.1
+      -c effective_io_concurrency=200
+      -c default_statistics_target=200
+      -c jit=off
+      -c min_wal_size=512MB
+      -c max_wal_size=2GB
+      -c checkpoint_completion_target=0.9
+      -c wal_buffers=16MB
+      -c wal_compression=zstd
+      -c bgwriter_delay=50ms
+      -c bgwriter_lru_maxpages=1000
+      -c autovacuum_vacuum_scale_factor=0.05
+      -c autovacuum_analyze_scale_factor=0.02
+      -c autovacuum_vacuum_cost_limit=2000
+      -c track_io_timing=on
+      -c shared_preload_libraries=pg_stat_statements
    shm_size: ${FLUXER_POSTGRES_SHM_SIZE:-1gb}
    environment:
-      POSTGRES_DB: ${FLUXER_POSTGRES_DATABASE:-fluxer}
-      POSTGRES_USER: ${FLUXER_POSTGRES_USERNAME:-fluxer}
+      POSTGRES_DB: fluxer
+      POSTGRES_USER: fluxer
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?set POSTGRES_PASSWORD in .env}
    volumes:
      - postgres-data:/var/lib/postgresql/data
    healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U \"$$POSTGRES_USER\" -d \"$$POSTGRES_DB\""]
-      interval: ${FLUXER_HEALTHCHECK_INTERVAL:-10s}
-      timeout: ${FLUXER_HEALTHCHECK_TIMEOUT:-5s}
-      retries: ${FLUXER_HEALTHCHECK_RETRIES:-10}
+      test: ["CMD-SHELL", "pg_isready -U fluxer -d fluxer"]
+      interval: 10s
+      timeout: 5s
+      retries: 10

  valkey:
-    <<: *fluxer-service
-    image: ${FLUXER_VALKEY_IMAGE:-valkey/valkey:9.1-alpine}
+    image: valkey/valkey:9.1-alpine
    deploy:
      resources:
        limits:
          memory: ${FLUXER_VALKEY_MEMORY_LIMIT:-256mb}
-    command: ["valkey-server", "--appendonly", "yes", "--appendfsync", "${FLUXER_VALKEY_APPENDFSYNC:-everysec}", "--dir", "/data",
+    restart: unless-stopped
+    networks: [fluxer]
+    command: ["valkey-server", "--appendonly", "yes", "--appendfsync", "everysec", "--dir", "/data",
              "--maxmemory", "${FLUXER_VALKEY_MAXMEMORY:-192mb}",
              "--maxmemory-policy", "${FLUXER_VALKEY_MAXMEMORY_POLICY:-noeviction}"]
    volumes:
      - valkey-data:/data
    healthcheck:
      test: ["CMD", "valkey-cli", "ping"]
-      interval: ${FLUXER_HEALTHCHECK_INTERVAL:-10s}
-      timeout: ${FLUXER_HEALTHCHECK_TIMEOUT:-5s}
-      retries: ${FLUXER_HEALTHCHECK_RETRIES:-10}
+      interval: 10s
+      timeout: 5s
+      retries: 10

  nats:
-    <<: *fluxer-service
-    image: ${FLUXER_NATS_IMAGE:-nats:2.14-alpine}
+    image: nats:2.14-alpine
    deploy:
      resources:
        limits:
          memory: ${FLUXER_NATS_MEMORY_LIMIT:-256mb}
+    restart: unless-stopped
+    networks: [fluxer]
    command: ["-js", "-sd", "/data", "-m", "8222"]
    volumes:
      - nats-data:/data
    healthcheck:
      test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:8222/healthz"]
-      interval: ${FLUXER_HEALTHCHECK_INTERVAL:-10s}
-      timeout: ${FLUXER_HEALTHCHECK_TIMEOUT:-5s}
-      retries: ${FLUXER_HEALTHCHECK_RETRIES:-10}
+      interval: 10s
+      timeout: 5s
+      retries: 10

  meilisearch:
-    <<: *fluxer-service
-    image: ${FLUXER_MEILISEARCH_IMAGE:-getmeili/meilisearch:v1.53}
+    image: getmeili/meilisearch:v1.53
    deploy:
      resources:
        limits:
-          memory: ${FLUXER_MEILISEARCH_MEMORY_LIMIT:-1536mb}
+          memory: ${FLUXER_MEILISEARCH_MEMORY_LIMIT:-768mb}
+    restart: unless-stopped
+    networks: [fluxer]
    environment:
-      MEILI_ENV: ${FLUXER_MEILISEARCH_ENV:-production}
-      MEILI_NO_ANALYTICS: "${FLUXER_MEILISEARCH_NO_ANALYTICS:-true}"
+      MEILI_ENV: production
+      MEILI_NO_ANALYTICS: "true"
      MEILI_UPGRADE_DB: "true"
-      MEILI_MAX_INDEXING_MEMORY: ${FLUXER_MEILISEARCH_MAX_INDEXING_MEMORY:-256mb}
-      MEILI_MAX_INDEXING_THREADS: ${FLUXER_MEILISEARCH_MAX_INDEXING_THREADS:-2}
+      MEILI_MAX_INDEXING_MEMORY: ${FLUXER_MEILISEARCH_MAX_INDEXING_MEMORY:-384mb}
      MEILI_MASTER_KEY: ${MEILI_MASTER_KEY:?set MEILI_MASTER_KEY in .env}
    volumes:
      - meilisearch-data:/meili_data
    healthcheck:
      test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:7700/health"]
-      interval: ${FLUXER_HEALTHCHECK_INTERVAL:-10s}
-      timeout: ${FLUXER_HEALTHCHECK_TIMEOUT:-5s}
-      retries: ${FLUXER_HEALTHCHECK_RETRIES:-10}
+      interval: 10s
+      timeout: 5s
+      retries: 10

  seaweedfs:
-    <<: *fluxer-service
-    image: ${FLUXER_SEAWEEDFS_IMAGE:-chrislusf/seaweedfs:4.47}
+    image: chrislusf/seaweedfs:4.47
    deploy:
      resources:
        limits:
          memory: ${FLUXER_SEAWEEDFS_MEMORY_LIMIT:-2gb}
+    restart: unless-stopped
+    networks: [fluxer]
    environment:
      GOMEMLIMIT: ${FLUXER_SEAWEEDFS_GOMEMLIMIT:-1536MiB}
-      WEED_MASTER_VOLUME_GROWTH_COPY_1: ${FLUXER_SEAWEEDFS_VOLUME_GROWTH:-1}
-    command: ["server", "-s3", "-dir=/data", "-master.telemetry=${FLUXER_SEAWEEDFS_TELEMETRY:-false}"]
+    command: ["server", "-s3", "-dir=/data", "-master.telemetry=false"]
    volumes:
      - seaweedfs-data:/data
    healthcheck:
      test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:8333/healthz"]
-      interval: ${FLUXER_HEALTHCHECK_INTERVAL:-10s}
-      timeout: ${FLUXER_HEALTHCHECK_TIMEOUT:-5s}
-      retries: ${FLUXER_SEAWEEDFS_HEALTHCHECK_RETRIES:-20}
-      start_period: ${FLUXER_SEAWEEDFS_HEALTHCHECK_START_PERIOD:-60s}
+      interval: 10s
+      timeout: 5s
+      retries: 20
+      start_period: 60s

  seaweedfs-init:
-    image: ${FLUXER_SEAWEEDFS_IMAGE:-chrislusf/seaweedfs:4.47}
+    image: chrislusf/seaweedfs:4.47
    deploy:
      resources:
        limits:
@@ -387,14 +296,13 @@ services:
      FLUXER_S3_BUCKET_UPLOADS: ${FLUXER_S3_BUCKET_UPLOADS:-fluxer-uploads}
      FLUXER_S3_BUCKET_REPORTS: ${FLUXER_S3_BUCKET_REPORTS:-fluxer-reports}
      FLUXER_S3_BUCKET_HARVESTS: ${FLUXER_S3_BUCKET_HARVESTS:-fluxer-harvests}
-      FLUXER_SEAWEEDFS_INIT_ATTEMPTS: ${FLUXER_SEAWEEDFS_INIT_ATTEMPTS:-60}
    entrypoint:
      - /bin/sh
      - -c
      - >
        buckets="$$FLUXER_S3_BUCKET_CDN $$FLUXER_S3_BUCKET_UPLOADS $$FLUXER_S3_BUCKET_REPORTS $$FLUXER_S3_BUCKET_HARVESTS";
        missing="$$buckets";
-        for attempt in $$(seq 1 $$FLUXER_SEAWEEDFS_INIT_ATTEMPTS); do
+        for attempt in $$(seq 1 60); do
          if ! nc -z seaweedfs 9333 2>/dev/null; then
            sleep 2;
            continue;
@@ -421,17 +329,18 @@ services:
        exit 1;

  livekit:
-    <<: *fluxer-service
-    image: ${FLUXER_LIVEKIT_IMAGE:-livekit/livekit-server:v1.12.0}
+    image: livekit/livekit-server:v1.12.0
    deploy:
      resources:
        limits:
          memory: ${FLUXER_LIVEKIT_MEMORY_LIMIT:-512mb}
+    restart: unless-stopped
+    networks: [fluxer]
    environment:
      LIVEKIT_KEYS: "${LIVEKIT_API_KEY:?set LIVEKIT_API_KEY in .env}: ${LIVEKIT_API_SECRET:?set LIVEKIT_API_SECRET in .env}"
      LIVEKIT_CONFIG: |
        port: 7880
-        log_level: ${FLUXER_LIVEKIT_LOG_LEVEL:-info}
+        log_level: info
        rtc:
          tcp_port: ${FLUXER_LIVEKIT_TCP_PORT:-7881}
          udp_port: ${FLUXER_LIVEKIT_UDP_PORT:-7882}
@@ -449,9 +358,9 @@ services:
      - "${FLUXER_LIVEKIT_UDP_PORT:-7882}:${FLUXER_LIVEKIT_UDP_PORT:-7882}/udp"
    healthcheck:
      test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:7880/"]
-      interval: ${FLUXER_HEALTHCHECK_INTERVAL:-10s}
-      timeout: ${FLUXER_HEALTHCHECK_TIMEOUT:-5s}
-      retries: ${FLUXER_HEALTHCHECK_RETRIES:-10}
+      interval: 10s
+      timeout: 5s
+      retries: 10

  api:
    <<: *fluxer-service
@@ -465,13 +374,16 @@ services:
    environment:
      <<: *fluxer-env
      FLUXER_API_PORT: "8080"
-      NODE_OPTIONS: --enable-source-maps${FLUXER_API_NODE_HEAP_MB:+ --max-old-space-size=$FLUXER_API_NODE_HEAP_MB}${FLUXER_API_NODE_OPTIONS:+ $FLUXER_API_NODE_OPTIONS}
-      NODE_EXTRA_CA_CERTS: ${FLUXER_NODE_EXTRA_CA_CERTS:-/etc/ssl/certs/ca-certificates.crt}
-      FLUXER_POSTGRES_MAX_CONNECTIONS: "${FLUXER_API_POSTGRES_MAX_CONNECTIONS:-25}"
-      FLUXER_API_PRESIGNED_ATTACHMENT_UPLOADS_ENABLED: "${FLUXER_API_PRESIGNED_ATTACHMENT_UPLOADS_ENABLED:-true}"
+      NODE_OPTIONS: --enable-source-maps${FLUXER_API_NODE_HEAP_MB:+ --max-old-space-size=$FLUXER_API_NODE_HEAP_MB}
+      FLUXER_API_PRESIGNED_ATTACHMENT_UPLOADS_ENABLED: "true"
+      FLUXER_POSTGRES_MAX_CONNECTIONS: "25"
    healthcheck:
      test: ["CMD-SHELL", "node -e \"fetch('http://127.0.0.1:8080/_health').then(r=>process.exit(r.ok?0:1)).catch(()=>process.exit(1))\""]
-      <<: *fluxer-app-healthcheck
+      interval: 10s
+      timeout: 5s
+      retries: 30
+      start_period: 90s
+      start_interval: 1s
    depends_on:
      postgres: {condition: service_healthy}
      valkey: {condition: service_healthy}
@@ -496,18 +408,21 @@ services:
          memory: ${FLUXER_WORKER_MEMORY_LIMIT:-2560mb}
        reservations:
          memory: ${FLUXER_WORKER_MEMORY_RESERVATION:-1gb}
-    command: ["node", "dist/WorkerEntrypoint.js"]
+    working_dir: /usr/src/app/fluxer_api
+    command: ["sh", "-c", "if [ -f dist/WorkerEntrypoint.js ]; then exec node dist/WorkerEntrypoint.js; else exec ./node_modules/.bin/tsx src/WorkerEntrypoint.ts; fi"]
    environment:
      <<: *fluxer-env
-      NODE_OPTIONS: --enable-source-maps${FLUXER_WORKER_NODE_HEAP_MB:+ --max-old-space-size=$FLUXER_WORKER_NODE_HEAP_MB}${FLUXER_WORKER_NODE_OPTIONS:+ $FLUXER_WORKER_NODE_OPTIONS}
-      NODE_EXTRA_CA_CERTS: ${FLUXER_NODE_EXTRA_CA_CERTS:-/etc/ssl/certs/ca-certificates.crt}
+      NODE_OPTIONS: --enable-source-maps${FLUXER_WORKER_NODE_HEAP_MB:+ --max-old-space-size=$FLUXER_WORKER_NODE_HEAP_MB}
      FLUXER_API_WORKER_MODE: all_lanes
      FLUXER_API_WORKER_ENABLE_CRON_SCHEDULER: "true"
-      FLUXER_POSTGRES_MAX_CONNECTIONS: "${FLUXER_WORKER_POSTGRES_MAX_CONNECTIONS:-25}"
+      FLUXER_POSTGRES_MAX_CONNECTIONS: "25"
    healthcheck:
      test: ["CMD", "node", "-e", "const age=Date.now()-require('node:fs').statSync('/tmp/fluxer-worker-heartbeat').mtimeMs;if(age>30000){console.error('worker heartbeat is '+Math.round(age)+'ms old');process.exit(1)}"]
-      <<: *fluxer-app-healthcheck
-      retries: ${FLUXER_WORKER_HEALTHCHECK_RETRIES:-3}
+      interval: 10s
+      timeout: 5s
+      retries: 3
+      start_period: 90s
+      start_interval: 1s
    depends_on:
      postgres: {condition: service_healthy}
      valkey: {condition: service_healthy}
@@ -529,30 +444,18 @@ services:
    environment:
      <<: *fluxer-env
      FLUXER_GATEWAY_PORT: "8080"
-      FLUXER_GATEWAY_MEDIA_PROXY_ENDPOINT: ${FLUXER_GATEWAY_MEDIA_PROXY_ENDPOINT:-${FLUXER_MEDIA_ENDPOINT:-${FLUXER_PUBLIC_ORIGIN:-${FLUXER_PUBLIC_SCHEME:-https}://${FLUXER_DOMAIN}}/media}}
-      FLUXER_GATEWAY_STATIC_CDN_ENDPOINT: ${FLUXER_GATEWAY_STATIC_CDN_ENDPOINT:-${FLUXER_STATIC_CDN_ENDPOINT:-${FLUXER_PUBLIC_ORIGIN:-${FLUXER_PUBLIC_SCHEME:-https}://${FLUXER_DOMAIN}}}}
-      FLUXER_GATEWAY_LOGGER_LEVEL: ${FLUXER_GATEWAY_LOGGER_LEVEL:-}
-      LOGGER_LEVEL: ${LOGGER_LEVEL:-}
-      FLUXER_GATEWAY_PUSH_ENABLED: ${FLUXER_GATEWAY_PUSH_ENABLED:-}
-      FLUXER_GATEWAY_PUSH_ENROLLED_CLEAR_NOTIFICATIONS_ENABLED: ${FLUXER_GATEWAY_PUSH_ENROLLED_CLEAR_NOTIFICATIONS_ENABLED:-}
-      FLUXER_GATEWAY_PUSH_OUTBOX_REQUEST_TIMEOUT_MS: ${FLUXER_GATEWAY_PUSH_OUTBOX_REQUEST_TIMEOUT_MS:-}
-      FLUXER_GATEWAY_PRESENCE_PUSH_BUFFER_MAX_ENTRIES: ${FLUXER_GATEWAY_PRESENCE_PUSH_BUFFER_MAX_ENTRIES:-}
-      FLUXER_GATEWAY_PRESENCE_PUSH_BUFFER_MAX_BYTES: ${FLUXER_GATEWAY_PRESENCE_PUSH_BUFFER_MAX_BYTES:-}
-      FLUXER_GATEWAY_HTTP_RPC_MAX_CONCURRENCY: ${FLUXER_GATEWAY_HTTP_RPC_MAX_CONCURRENCY:-}
-      FLUXER_GATEWAY_NATS_RPC_MAX_HANDLERS: ${FLUXER_GATEWAY_NATS_RPC_MAX_HANDLERS:-}
-      FLUXER_GATEWAY_HTTP_FAILURE_THRESHOLD: ${FLUXER_GATEWAY_HTTP_FAILURE_THRESHOLD:-}
-      FLUXER_GATEWAY_HTTP_RECOVERY_TIMEOUT_MS: ${FLUXER_GATEWAY_HTTP_RECOVERY_TIMEOUT_MS:-}
+      FLUXER_GATEWAY_MEDIA_PROXY_ENDPOINT: ${FLUXER_PUBLIC_ORIGIN:-${FLUXER_PUBLIC_SCHEME:-https}://${FLUXER_DOMAIN}}/media
+      FLUXER_GATEWAY_STATIC_CDN_ENDPOINT: ${FLUXER_PUBLIC_ORIGIN:-${FLUXER_PUBLIC_SCHEME:-https}://${FLUXER_DOMAIN}}
+      FLUXER_GATEWAY_LOGGER_LEVEL: info
      FLUXER_ERLANG_COOKIE: ${FLUXER_ERLANG_COOKIE:?set FLUXER_ERLANG_COOKIE in .env}
-      FLUXER_ERLANG_SCHEDULERS: ${FLUXER_ERLANG_SCHEDULERS:-}
-      FLUXER_ERLANG_SCHEDULERS_MIN: ${FLUXER_ERLANG_SCHEDULERS_MIN:-}
-      FLUXER_ERLANG_SCHEDULERS_MAX: ${FLUXER_ERLANG_SCHEDULERS_MAX:-}
-      FLUXER_ERLANG_DIRTY_CPU_SCHEDULERS: ${FLUXER_ERLANG_DIRTY_CPU_SCHEDULERS:-}
+      FLUXER_ERLANG_SCHEDULERS_MIN: "${FLUXER_ERLANG_SCHEDULERS_MIN:-2}"
+      FLUXER_ERLANG_SCHEDULERS_MAX: "${FLUXER_ERLANG_SCHEDULERS_MAX:-16}"
    healthcheck:
      test: ["CMD", "curl", "-fsS", "-o", "/dev/null", "http://127.0.0.1:8080/_health/ready"]
-      interval: ${FLUXER_HEALTHCHECK_INTERVAL:-10s}
-      timeout: ${FLUXER_HEALTHCHECK_TIMEOUT:-5s}
-      retries: ${FLUXER_APP_HEALTHCHECK_RETRIES:-30}
-      start_period: ${FLUXER_APP_HEALTHCHECK_START_PERIOD:-90s}
+      interval: 10s
+      timeout: 5s
+      retries: 30
+      start_period: 90s
    depends_on:
      nats: {condition: service_healthy}
      valkey: {condition: service_healthy}
@@ -566,36 +469,15 @@ services:
          memory: ${FLUXER_MEDIA_PROXY_MEMORY_LIMIT:-512mb}
    environment:
      <<: *fluxer-env
+      FLUXER_MEDIA_PROXY_HOST: 0.0.0.0
      FLUXER_MEDIA_PROXY_PORT: "8080"
      FLUXER_MEDIA_PROXY_MODE: upload
      FLUXER_MEDIA_PROXY_STORAGE_BACKEND: s3
-      FLUXER_MEDIA_PROXY_CORS_MODE: ${FLUXER_MEDIA_PROXY_CORS_MODE:-}
+      FLUXER_MEDIA_PROXY_PUBLIC_ENDPOINT: ${FLUXER_PUBLIC_ORIGIN:-${FLUXER_PUBLIC_SCHEME:-https}://${FLUXER_DOMAIN}}/media
+      FLUXER_MEDIA_PROXY_CORS_MODE: ${FLUXER_MEDIA_PROXY_CORS_MODE:-off}
      FLUXER_MEDIA_PROXY_CORS_ALLOWED_ORIGINS: ${FLUXER_MEDIA_PROXY_CORS_ALLOWED_ORIGINS:-${FLUXER_PUBLIC_ORIGIN:-${FLUXER_PUBLIC_SCHEME:-https}://${FLUXER_DOMAIN}:${FLUXER_PUBLIC_PORT:-443}}}
-      FLUXER_MEDIA_PROXY_ATTACHMENT_SIGNATURE_MODE: ${FLUXER_MEDIA_PROXY_ATTACHMENT_SIGNATURE_MODE:-}
-      FLUXER_MEDIA_PROXY_READ_ONLY: ${FLUXER_MEDIA_PROXY_READ_ONLY:-}
-      FLUXER_MEDIA_PROXY_NSFW_THRESHOLD: ${FLUXER_MEDIA_PROXY_NSFW_THRESHOLD:-}
-      FLUXER_NSFW_SERVICE_ENDPOINT: ${FLUXER_NSFW_SERVICE_ENDPOINT:-}
-      FLUXER_MEDIA_PROXY_MAX_NATIVE_TRANSFORMS: ${FLUXER_MEDIA_PROXY_MAX_NATIVE_TRANSFORMS:-}
-      FLUXER_MEDIA_PROXY_WORKER_QUEUE_CAPACITY: ${FLUXER_MEDIA_PROXY_WORKER_QUEUE_CAPACITY:-}
-      FLUXER_MEDIA_PROXY_MAX_ENCODE_DURATION_MS: ${FLUXER_MEDIA_PROXY_MAX_ENCODE_DURATION_MS:-}
-      FLUXER_MEDIA_PROXY_MAX_ENCODE_FRAMES: ${FLUXER_MEDIA_PROXY_MAX_ENCODE_FRAMES:-}
-      FLUXER_MEDIA_PROXY_TRANSFORM_TIMEOUT_MS: ${FLUXER_MEDIA_PROXY_TRANSFORM_TIMEOUT_MS:-}
-      FLUXER_MEDIA_PROXY_TRANSFORM_CACHE_BYTES: ${FLUXER_MEDIA_PROXY_TRANSFORM_CACHE_BYTES:-}
-      FLUXER_MEDIA_PROXY_TRANSFORM_CACHE_MAX_ENTRY_BYTES: ${FLUXER_MEDIA_PROXY_TRANSFORM_CACHE_MAX_ENTRY_BYTES:-}
-      FLUXER_MEDIA_PROXY_TRANSFORM_CACHE_TTL_MS: ${FLUXER_MEDIA_PROXY_TRANSFORM_CACHE_TTL_MS:-}
-      FLUXER_MEDIA_PROXY_SOCKET_IO_TIMEOUT_MS: ${FLUXER_MEDIA_PROXY_SOCKET_IO_TIMEOUT_MS:-}
-      FLUXER_MEDIA_PROXY_SHUTDOWN_GRACE_MS: ${FLUXER_MEDIA_PROXY_SHUTDOWN_GRACE_MS:-}
-      FLUXER_MEDIA_PROXY_UPLOAD_RELAY_S3_TIMEOUT_MS: ${FLUXER_MEDIA_PROXY_UPLOAD_RELAY_S3_TIMEOUT_MS:-}
-      FLUXER_MEDIA_PROXY_UPLOAD_RELAY_BUFFERED_RETRY_BYTES: ${FLUXER_MEDIA_PROXY_UPLOAD_RELAY_BUFFERED_RETRY_BYTES:-}
-      FLUXER_MEDIA_PROXY_UPLOAD_RELAY_BUFFERED_RETRY_TOTAL_BYTES: ${FLUXER_MEDIA_PROXY_UPLOAD_RELAY_BUFFERED_RETRY_TOTAL_BYTES:-}
-      FLUXER_MEDIA_PROXY_UPLOAD_RELAY_SPOOL_DIR: ${FLUXER_MEDIA_PROXY_UPLOAD_RELAY_SPOOL_DIR:-}
-      FLUXER_MEDIA_PROXY_UPLOAD_RELAY_SPOOL_CHUNK_BYTES: ${FLUXER_MEDIA_PROXY_UPLOAD_RELAY_SPOOL_CHUNK_BYTES:-}
-      FLUXER_MEDIA_PROXY_UPLOAD_RELAY_SPOOL_MAX_TOTAL_BYTES: ${FLUXER_MEDIA_PROXY_UPLOAD_RELAY_SPOOL_MAX_TOTAL_BYTES:-}
-      FLUXER_S3_SESSION_TOKEN: ${FLUXER_S3_SESSION_TOKEN:-}
-      FLUXER_S3_READ_ENDPOINT: ${FLUXER_S3_READ_ENDPOINT:-}
-      FLUXER_S3_READ_BUCKET: ${FLUXER_S3_READ_BUCKET:-}
-      FLUXER_S3_READ_BUCKET_STYLE: ${FLUXER_S3_READ_BUCKET_STYLE:-}
-      FLUXER_S3_READ_SIGNED: "${FLUXER_S3_READ_SIGNED:-true}"
+      FLUXER_MEDIA_PROXY_ATTACHMENT_SIGNATURE_MODE: ${FLUXER_MEDIA_PROXY_ATTACHMENT_SIGNATURE_MODE:-off}
+      FLUXER_S3_READ_SIGNED: "true"
    depends_on:
      seaweedfs-init: {condition: service_completed_successfully}
      nats: {condition: service_healthy}
@@ -609,27 +491,17 @@ services:
          memory: ${FLUXER_PUSH_MEMORY_LIMIT:-256mb}
    environment:
      <<: *fluxer-env
-      FLUXER_PUSH_SERVICE_QUEUE_CAPACITY: ${FLUXER_PUSH_SERVICE_QUEUE_CAPACITY:-}
-      FLUXER_PUSH_SERVICE_SEND_CONCURRENCY: ${FLUXER_PUSH_SERVICE_SEND_CONCURRENCY:-}
-      FLUXER_PUSH_SERVICE_APNS_BASE_URL: ${FLUXER_PUSH_SERVICE_APNS_BASE_URL:-}
-      FLUXER_PUSH_SERVICE_FCM_BASE_URL: ${FLUXER_PUSH_SERVICE_FCM_BASE_URL:-}
-      FLUXER_PUSH_SERVICE_MANAGED_RELAY_HOSTS: ${FLUXER_PUSH_SERVICE_MANAGED_RELAY_HOSTS:-}
-      FLUXER_PUSH_SERVICE_OWN_RELAY_HOSTS: ${FLUXER_PUSH_SERVICE_OWN_RELAY_HOSTS:-}
-      FLUXER_PUSH_SERVICE_PRIVATE_HOSTS: ${FLUXER_PUSH_SERVICE_PRIVATE_HOSTS:-}
-      FLUXER_PUSH_SERVICE_RELAY_CONSENT_ACCEPTED: ${FLUXER_PUSH_SERVICE_RELAY_CONSENT_ACCEPTED:-}
-      FLUXER_PUSH_APNS_DEFAULT_ENVIRONMENT: ${FLUXER_PUSH_APNS_DEFAULT_ENVIRONMENT:-}
-      FLUXER_PUSH_FCM_ENABLED: ${FLUXER_PUSH_FCM_ENABLED:-}
-      FLUXER_PUSH_FCM_PROJECT_ID: ${FLUXER_PUSH_FCM_PROJECT_ID:-}
-      FLUXER_PUSH_FCM_CLIENT_EMAIL: ${FLUXER_PUSH_FCM_CLIENT_EMAIL:-}
-      FLUXER_PUSH_FCM_PRIVATE_KEY: ${FLUXER_PUSH_FCM_PRIVATE_KEY:-}
-      FLUXER_PUSH_FCM_PRIVATE_KEY_PATH: ${FLUXER_PUSH_FCM_PRIVATE_KEY_PATH:-}
-      FLUXER_PUSH_FCM_SERVICE_ACCOUNT_JSON_PATH: ${FLUXER_PUSH_FCM_SERVICE_ACCOUNT_JSON_PATH:-}
-      FLUXER_PUSH_FCM_TOKEN_URI: ${FLUXER_PUSH_FCM_TOKEN_URI:-}
-      FLUXER_PUSH_FCM_APPS: ${FLUXER_PUSH_FCM_APPS:-}
+      FLUXER_PUSH_SERVICE_HOST: 0.0.0.0
+      FLUXER_PUSH_SERVICE_PORT: "8126"
+      FLUXER_PUSH_SERVICE_QUEUE_CAPACITY: "${FLUXER_PUSH_SERVICE_QUEUE_CAPACITY:-}"
+      FLUXER_PUSH_SERVICE_SEND_CONCURRENCY: "${FLUXER_PUSH_SERVICE_SEND_CONCURRENCY:-}"
    healthcheck:
      test: ["CMD", "/usr/local/bin/fluxer-push", "healthcheck"]
-      <<: *fluxer-app-healthcheck
-      start_period: ${FLUXER_SVC_HEALTHCHECK_START_PERIOD:-60s}
+      interval: 10s
+      timeout: 5s
+      retries: 30
+      start_period: 60s
+      start_interval: 1s
    depends_on:
      nats: {condition: service_healthy}
      api: {condition: service_healthy}
@@ -643,9 +515,9 @@ services:
          memory: ${FLUXER_STATIC_PROXY_MEMORY_LIMIT:-256mb}
    healthcheck:
      test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:8080/avatars/0.png"]
-      interval: ${FLUXER_HEALTHCHECK_INTERVAL:-10s}
-      timeout: ${FLUXER_HEALTHCHECK_TIMEOUT:-5s}
-      retries: ${FLUXER_HEALTHCHECK_RETRIES:-10}
+      interval: 10s
+      timeout: 5s
+      retries: 10

  app-proxy:
    <<: *fluxer-service
@@ -655,29 +527,15 @@ services:
        limits:
          memory: ${FLUXER_APP_PROXY_MEMORY_LIMIT:-256mb}
    environment:
-      RUST_LOG: ${RUST_LOG:-}
+      FLUXER_APP_PROXY_HOST: 0.0.0.0
      FLUXER_APP_PROXY_PORT: "8080"
      FLUXER_BASE_DOMAIN: ${FLUXER_DOMAIN:?set FLUXER_DOMAIN in .env}
      FLUXER_PUBLIC_SCHEME: ${FLUXER_PUBLIC_SCHEME:-https}
      FLUXER_PUBLIC_PORT: ${FLUXER_PUBLIC_PORT:-443}
      FLUXER_PUBLIC_ORIGIN: ${FLUXER_PUBLIC_ORIGIN:-}
-      FLUXER_TRUST_CLIENT_IP_HEADER: "${FLUXER_TRUST_CLIENT_IP_HEADER:-true}"
-      FLUXER_CLIENT_IP_HEADER_NAME: ${FLUXER_CLIENT_IP_HEADER_NAME:-}
-      FLUXER_GEOIP_DB_PATH: ${FLUXER_GEOIP_DB_PATH:-}
-      FLUXER_S3_ENDPOINT: ${FLUXER_S3_ENDPOINT:-http://seaweedfs:8333}
-      FLUXER_S3_PUBLIC_ENDPOINT: ${FLUXER_S3_PUBLIC_ENDPOINT:-}
-      FLUXER_S3_REGION: ${FLUXER_S3_REGION:-us-east-1}
-      FLUXER_S3_ACCESS_KEY_ID: ${FLUXER_S3_ACCESS_KEY:?set FLUXER_S3_ACCESS_KEY in .env}
-      FLUXER_S3_SECRET_ACCESS_KEY: ${FLUXER_S3_SECRET_KEY:?set FLUXER_S3_SECRET_KEY in .env}
-      FLUXER_S3_BUCKET_UPLOADS: ${FLUXER_S3_BUCKET_UPLOADS:-}
-      FLUXER_STATIC_CDN_ENDPOINT: ${FLUXER_STATIC_CDN_ENDPOINT:-}
      DISCOVERY_UPSTREAM_URL: http://edge:8088/.well-known/fluxer
-      DISCOVERY_REFRESH_INTERVAL_MS: ${DISCOVERY_REFRESH_INTERVAL_MS:-}
      PUBLIC_BOOTSTRAP_API_ENDPOINT: /api
-      PUBLIC_BOOTSTRAP_API_PUBLIC_ENDPOINT: ${PUBLIC_BOOTSTRAP_API_PUBLIC_ENDPOINT:-${FLUXER_PUBLIC_ORIGIN:-${FLUXER_PUBLIC_SCHEME:-https}://${FLUXER_DOMAIN}}/api}
-      FLUXER_APP_PROXY_INDEX_UPSTREAM_URL: ${FLUXER_APP_PROXY_INDEX_UPSTREAM_URL:-}
-      FLUXER_APP_PROXY_SAME_ORIGIN_HOSTS: ${FLUXER_APP_PROXY_SAME_ORIGIN_HOSTS:-}
-      FLUXER_APP_PROXY_MANIFEST_SCOPE_EXTENSIONS: ${FLUXER_APP_PROXY_MANIFEST_SCOPE_EXTENSIONS:-}
+      PUBLIC_BOOTSTRAP_API_PUBLIC_ENDPOINT: ${FLUXER_PUBLIC_ORIGIN:-${FLUXER_PUBLIC_SCHEME:-https}://${FLUXER_DOMAIN}}/api
      FLUXER_CSP_EXTRA_DEFAULT_SRC: ${FLUXER_CSP_EXTRA_DEFAULT_SRC:-}
      FLUXER_CSP_EXTRA_CONNECT_SRC: ${FLUXER_CSP_EXTRA_CONNECT_SRC:-}
      FLUXER_CSP_EXTRA_IMG_SRC: ${FLUXER_CSP_EXTRA_IMG_SRC:-}
@@ -735,6 +593,7 @@ services:
      <<: *fluxer-env
      FLUXER_SVC_NAME: users
      FLUXER_SVC_MODE: router
+      FLUXER_SVC_MAX_CONCURRENT_REQUESTS: "${FLUXER_SVC_MAX_CONCURRENT_REQUESTS:-}"
    healthcheck: *fluxer-svc-healthcheck
    depends_on:
      nats: {condition: service_healthy}
@@ -751,7 +610,8 @@ services:
      FLUXER_SVC_NAME: users
      FLUXER_SVC_MODE: shard
      FLUXER_SVC_SHARD_ID: "0"
-      FLUXER_POSTGRES_MAX_CONNECTIONS: "${FLUXER_USERS_SHARD_POSTGRES_MAX_CONNECTIONS:-20}"
+      FLUXER_POSTGRES_MAX_CONNECTIONS: "20"
+      FLUXER_SVC_MAX_CONCURRENT_REQUESTS: "${FLUXER_SVC_MAX_CONCURRENT_REQUESTS:-}"
    healthcheck: *fluxer-svc-healthcheck
    depends_on:
      nats: {condition: service_healthy}
@@ -768,6 +628,7 @@ services:
      <<: *fluxer-env
      FLUXER_SVC_NAME: gifs
      FLUXER_SVC_MODE: router
+      FLUXER_MEDIA_PROXY_PUBLIC_ENDPOINT: ${FLUXER_PUBLIC_ORIGIN:-${FLUXER_PUBLIC_SCHEME:-https}://${FLUXER_DOMAIN}}/media
    healthcheck: *fluxer-svc-healthcheck
    depends_on:
      nats: {condition: service_healthy}
@@ -784,7 +645,7 @@ services:
      FLUXER_SVC_NAME: gifs
      FLUXER_SVC_MODE: shard
      FLUXER_SVC_SHARD_ID: "0"
-      FLUXER_GIFS_SHARD_CACHE_MAX_BYTES: ${FLUXER_GIFS_SHARD_CACHE_MAX_BYTES:-}
+      FLUXER_MEDIA_PROXY_PUBLIC_ENDPOINT: ${FLUXER_PUBLIC_ORIGIN:-${FLUXER_PUBLIC_SCHEME:-https}://${FLUXER_DOMAIN}}/media
    healthcheck: *fluxer-svc-healthcheck
    depends_on:
      nats: {condition: service_healthy}
@@ -800,6 +661,7 @@ services:
      <<: *fluxer-env
      FLUXER_SVC_NAME: messages
      FLUXER_SVC_MODE: router
+      FLUXER_SVC_MAX_CONCURRENT_REQUESTS: "${FLUXER_SVC_MAX_CONCURRENT_REQUESTS:-}"
    healthcheck: *fluxer-svc-healthcheck
    depends_on:
      nats: {condition: service_healthy}
@@ -816,7 +678,8 @@ services:
      FLUXER_SVC_NAME: messages
      FLUXER_SVC_MODE: shard
      FLUXER_SVC_SHARD_ID: "0"
-      FLUXER_POSTGRES_MAX_CONNECTIONS: "${FLUXER_MESSAGES_SHARD_POSTGRES_MAX_CONNECTIONS:-20}"
+      FLUXER_POSTGRES_MAX_CONNECTIONS: "20"
+      FLUXER_SVC_MAX_CONCURRENT_REQUESTS: "${FLUXER_SVC_MAX_CONCURRENT_REQUESTS:-}"
    healthcheck: *fluxer-svc-healthcheck
    depends_on:
      nats: {condition: service_healthy}
@@ -833,6 +696,8 @@ services:
      <<: *fluxer-env
      FLUXER_SVC_NAME: unfurl
      FLUXER_SVC_MODE: router
+      FLUXER_MEDIA_PROXY_PUBLIC_ENDPOINT: ${FLUXER_PUBLIC_ORIGIN:-${FLUXER_PUBLIC_SCHEME:-https}://${FLUXER_DOMAIN}}/media
+      FLUXER_STATIC_CDN_ENDPOINT: ${FLUXER_PUBLIC_ORIGIN:-${FLUXER_PUBLIC_SCHEME:-https}://${FLUXER_DOMAIN}}
    healthcheck: *fluxer-svc-healthcheck
    depends_on:
      nats: {condition: service_healthy}
@@ -849,7 +714,8 @@ services:
      FLUXER_SVC_NAME: unfurl
      FLUXER_SVC_MODE: shard
      FLUXER_SVC_SHARD_ID: "0"
-      FLUXER_MEDIA_PROXY_ENDPOINT: http://media-proxy:8080
+      FLUXER_MEDIA_PROXY_PUBLIC_ENDPOINT: ${FLUXER_PUBLIC_ORIGIN:-${FLUXER_PUBLIC_SCHEME:-https}://${FLUXER_DOMAIN}}/media
+      FLUXER_STATIC_CDN_ENDPOINT: ${FLUXER_PUBLIC_ORIGIN:-${FLUXER_PUBLIC_SCHEME:-https}://${FLUXER_DOMAIN}}
    healthcheck: *fluxer-svc-healthcheck
    depends_on:
      nats: {condition: service_healthy}
@@ -863,14 +729,22 @@ services:
          memory: ${FLUXER_ADMIN_MEMORY_LIMIT:-256mb}
    environment:
      <<: *fluxer-env
+      FLUXER_ADMIN_HOST: 0.0.0.0
      FLUXER_ADMIN_PORT: "8080"
-      FLUXER_ADMIN_BASE_PATH: ${FLUXER_ADMIN_BASE_PATH:-/admin}
+      FLUXER_ADMIN_BASE_PATH: /admin
      FLUXER_API_ENDPOINT: http://api:8080
-      FLUXER_STATIC_CDN_ENDPOINT: ${FLUXER_STATIC_CDN_ENDPOINT:-${FLUXER_PUBLIC_ORIGIN:-${FLUXER_PUBLIC_SCHEME:-https}://${FLUXER_DOMAIN}}}
+      FLUXER_ADMIN_ENDPOINT: ${FLUXER_PUBLIC_ORIGIN:-${FLUXER_PUBLIC_SCHEME:-https}://${FLUXER_DOMAIN}}/admin
+      FLUXER_APP_ENDPOINT: ${FLUXER_PUBLIC_ORIGIN:-${FLUXER_PUBLIC_SCHEME:-https}://${FLUXER_DOMAIN}}
+      FLUXER_MEDIA_ENDPOINT: ${FLUXER_PUBLIC_ORIGIN:-${FLUXER_PUBLIC_SCHEME:-https}://${FLUXER_DOMAIN}}/media
+      FLUXER_STATIC_CDN_ENDPOINT: ${FLUXER_PUBLIC_ORIGIN:-${FLUXER_PUBLIC_SCHEME:-https}://${FLUXER_DOMAIN}}
+      FLUXER_ADMIN_OAUTH_REDIRECT_URI: ${FLUXER_PUBLIC_ORIGIN:-${FLUXER_PUBLIC_SCHEME:-https}://${FLUXER_DOMAIN}}/admin/oauth2_callback
    healthcheck:
      test: ["CMD", "bash", "-c", "exec 3<>/dev/tcp/127.0.0.1/8080 && printf 'GET /_health HTTP/1.0\\r\\n\\r\\n' >&3 && head -n 1 <&3 | grep -q ' 200 '"]
-      <<: *fluxer-app-healthcheck
-      start_period: ${FLUXER_SVC_HEALTHCHECK_START_PERIOD:-60s}
+      interval: 10s
+      timeout: 5s
+      retries: 30
+      start_period: 60s
+      start_interval: 1s
    depends_on:
      api: {condition: service_healthy}

@@ -1,14 +0,0 @@
-services:
-  seaweedfs:
-    profiles: [bundled-object-store]
-  seaweedfs-init:
-    profiles: [bundled-object-store]
-  api:
-    depends_on:
-      seaweedfs-init: !reset null
-  worker:
-    depends_on:
-      seaweedfs-init: !reset null
-  media-proxy:
-    depends_on:
-      seaweedfs-init: !reset null
@@ -26,7 +26,7 @@ tokio = { version = "1.53.1", features = ["macros", "net", "rt-multi-thread", "s
 tower = { version = "0.5.3", features = ["util"] }
 tower-http = { version = "0.7.1", features = ["compression-gzip", "trace"] }
 tracing = "0.1.44"
-tracing-subscriber = "0.3.23"
+tracing-subscriber = { version = "0.3.23", features = ["env-filter"] }
 url = "2.5"
 urlencoding = "2.1.3"
 progenitor-client = { version = "0.15.0", default-features = false }
@@ -2,6 +2,7 @@

 FROM rust:1-trixie AS builder

+ARG BUILD_VERSION=""
 ARG TARGETARCH

 WORKDIR /usr/src/app
@@ -44,6 +45,8 @@ RUN printf '%s\n' \
 	'strip = "symbols"' \
 	> Cargo.toml

+ENV FLUXER_BUILD_VERSION="${BUILD_VERSION}"
+
 RUN cargo build --release -p fluxer_admin \
 	&& cp target/release/fluxer_admin /usr/local/bin/fluxer-admin

@@ -40,7 +40,6 @@ fn generate_admin_api(manifest_dir: &Path, out_dir: &Path) {
    adapt_progenitor_throttled_errors(&mut spec);
    relax_guild_audit_log_schemas(&mut spec);
    relax_progenitor_schema_strictness(&mut spec);
-    relax_integer_enums(&mut spec);

    let mut settings = progenitor::GenerationSettings::new();
    settings.with_interface(progenitor::InterfaceStyle::Positional);
@@ -175,23 +174,6 @@ fn relax_guild_audit_log_schemas(spec: &mut openapiv3::OpenAPI) {
    }
 }

-const OPEN_INTEGER_ENUMS: &[&str] = &["ChannelType", "MessageType", "WebhookType"];
-
-fn relax_integer_enums(spec: &mut openapiv3::OpenAPI) {
-    let components = spec.components.as_mut().expect("missing API components");
-    for name in OPEN_INTEGER_ENUMS {
-        let Some(openapiv3::ReferenceOr::Item(schema)) = components.schemas.get_mut(*name) else {
-            panic!("missing inline {name} schema");
-        };
-        let openapiv3::SchemaKind::Type(openapiv3::Type::Integer(integer)) =
-            &mut schema.schema_kind
-        else {
-            panic!("{name} must be an integer schema");
-        };
-        integer.enumeration.clear();
-    }
-}
-
 fn object_schema_mut<'a>(
    components: &'a mut openapiv3::Components,
    name: &str,
@@ -600,7 +582,7 @@ fn select_faces(package_dir: &Path) -> Vec<Face> {
            }
            assert!(
                face["unicodeRange"].is_null(),
-                "{wanted} face {} has a unicode-range; Latin-core faces must not",
+                "{wanted} face {} carries a unicode-range; Latin-core faces must not",
                face["file"]
            );
            faces.push(Face {
@@ -17,6 +17,9 @@ pub const JOBS_CANCEL: &str = "jobs:cancel";
 pub const BAN_EMAIL_ADD: &str = "ban:email:add";
 pub const BAN_EMAIL_CHECK: &str = "ban:email:check";
 pub const BAN_EMAIL_REMOVE: &str = "ban:email:remove";
+pub const SUSPICIOUS_EMAIL_DOMAIN_ADD: &str = "suspicious_email_domain:add";
+pub const SUSPICIOUS_EMAIL_DOMAIN_CHECK: &str = "suspicious_email_domain:check";
+pub const SUSPICIOUS_EMAIL_DOMAIN_REMOVE: &str = "suspicious_email_domain:remove";
 pub const BAN_PHRASE_ADD: &str = "ban:phrase:add";
 pub const BAN_PHRASE_CHECK: &str = "ban:phrase:check";
 pub const BAN_PHRASE_REMOVE: &str = "ban:phrase:remove";
@@ -42,6 +45,7 @@ pub const BULK_ADD_GUILD_MEMBERS: &str = "bulk:add:guild_members";
 pub const BULK_DELETE_USERS: &str = "bulk:delete:users";
 pub const BULK_DELETE_USER_MESSAGES: &str = "bulk:delete:user_messages";
 pub const BULK_UPDATE_GUILD_FEATURES: &str = "bulk:update:guild_features";
+pub const BULK_UPDATE_SUSPICIOUS_ACTIVITY: &str = "bulk:update:suspicious_activity";
 pub const BULK_UPDATE_USER_FLAGS: &str = "bulk:update:user_flags";
 pub const CSAM_SUBMIT_NCMEC: &str = "csam:submit_ncmec";
 pub const DISCOVERY_REMOVE: &str = "discovery:remove";
@@ -76,9 +80,8 @@ pub const REPORT_VIEW: &str = "report:view";
 pub const REPORT_VIEW_REPORTER_PII: &str = "report:view:reporter_pii";
 pub const SYSTEM_DM_SEND: &str = "system_dm:send";
 pub const USER_CANCEL_BULK_MESSAGE_DELETION: &str = "user:cancel:bulk_message_deletion";
-pub const USER_CREATE_PASSWORD_RESET_LINK: &str = "user:create:password_reset_link";
-pub const USER_DELETE_RECOVERY_KIT: &str = "user:delete:recovery_kit";
 pub const USER_DELETE: &str = "user:delete";
+pub const USER_DISABLE_SUSPICIOUS: &str = "user:disable:suspicious";
 pub const USER_LIST_DM_CHANNELS: &str = "user:list:dm_channels";
 pub const USER_LIST_GUILDS: &str = "user:list:guilds";
 pub const USER_LIST_RELATIONSHIPS: &str = "user:list:relationships";
@@ -90,11 +93,14 @@ pub const USER_VIEW_DOB: &str = "user:view:dob";
 pub const USER_VIEW_EMAIL: &str = "user:view:email";
 pub const USER_VIEW_IP: &str = "user:view:ip";
 pub const USER_TEMP_BAN: &str = "user:temp_ban";
+pub const USER_UPDATE_BOT_STATUS: &str = "user:update:bot_status";
 pub const USER_UPDATE_DOB: &str = "user:update:dob";
 pub const USER_UPDATE_EMAIL: &str = "user:update:email";
 pub const USER_UPDATE_FLAGS: &str = "user:update:flags";
 pub const USER_UPDATE_MFA: &str = "user:update:mfa";
+pub const USER_UPDATE_PHONE: &str = "user:update:phone";
 pub const USER_UPDATE_PROFILE: &str = "user:update:profile";
+pub const USER_UPDATE_SUSPICIOUS_ACTIVITY: &str = "user:update:suspicious_activity";
 pub const USER_UPDATE_TRAITS: &str = "user:update:traits";
 pub const USER_UPDATE_USERNAME: &str = "user:update:username";
 pub const VOICE_REGION_CREATE: &str = "voice:region:create";
@@ -123,6 +129,9 @@ pub const ALL_ACLS: &[&str] = &[
    BAN_EMAIL_ADD,
    BAN_EMAIL_CHECK,
    BAN_EMAIL_REMOVE,
+    SUSPICIOUS_EMAIL_DOMAIN_ADD,
+    SUSPICIOUS_EMAIL_DOMAIN_CHECK,
+    SUSPICIOUS_EMAIL_DOMAIN_REMOVE,
    BAN_PHRASE_ADD,
    BAN_PHRASE_CHECK,
    BAN_PHRASE_REMOVE,
@@ -148,6 +157,7 @@ pub const ALL_ACLS: &[&str] = &[
    BULK_DELETE_USERS,
    BULK_DELETE_USER_MESSAGES,
    BULK_UPDATE_GUILD_FEATURES,
+    BULK_UPDATE_SUSPICIOUS_ACTIVITY,
    BULK_UPDATE_USER_FLAGS,
    CSAM_SUBMIT_NCMEC,
    DISCOVERY_REMOVE,
@@ -182,9 +192,8 @@ pub const ALL_ACLS: &[&str] = &[
    REPORT_VIEW_REPORTER_PII,
    SYSTEM_DM_SEND,
    USER_CANCEL_BULK_MESSAGE_DELETION,
-    USER_CREATE_PASSWORD_RESET_LINK,
-    USER_DELETE_RECOVERY_KIT,
    USER_DELETE,
+    USER_DISABLE_SUSPICIOUS,
    USER_LIST_DM_CHANNELS,
    USER_LIST_GUILDS,
    USER_LIST_RELATIONSHIPS,
@@ -196,11 +205,14 @@ pub const ALL_ACLS: &[&str] = &[
    USER_VIEW_EMAIL,
    USER_VIEW_IP,
    USER_TEMP_BAN,
+    USER_UPDATE_BOT_STATUS,
    USER_UPDATE_DOB,
    USER_UPDATE_EMAIL,
    USER_UPDATE_FLAGS,
    USER_UPDATE_MFA,
+    USER_UPDATE_PHONE,
    USER_UPDATE_PROFILE,
+    USER_UPDATE_SUSPICIOUS_ACTIVITY,
    USER_UPDATE_TRAITS,
    USER_UPDATE_USERNAME,
    VOICE_REGION_CREATE,
@@ -19,18 +19,19 @@ pub mod user_flag_bits {
    pub const SPAMMER: u64 = 1 << 6;
    pub const HIGH_GLOBAL_RATE_LIMIT: u64 = 1 << 33;
    pub const DELETED: u64 = 1 << 34;
+    pub const DISABLED_SUSPICIOUS_ACTIVITY: u64 = 1 << 35;
    pub const SELF_DELETED: u64 = 1 << 36;
    pub const DISABLED: u64 = 1 << 38;
    pub const HAS_SESSION_STARTED: u64 = 1 << 39;
    pub const RATE_LIMIT_BYPASS: u64 = 1 << 47;
    pub const REPORT_BANNED: u64 = 1 << 48;
    pub const VERIFIED_NOT_UNDERAGE: u64 = 1 << 49;
-    pub const ACCOUNT_LIMITED: u64 = 1 << 50;
    pub const HAS_DISMISSED_PREMIUM_ONBOARDING: u64 = 1 << 51;
    pub const APP_STORE_REVIEWER: u64 = 1 << 53;
    pub const STAFF_HIDDEN: u64 = 1 << 57;
    pub const AGE_VERIFIED_ADULT: u64 = 1 << 60;
-    pub const LIMIT_EXEMPT: u64 = 1 << 62;
+    pub const FORCE_INBOUND_PHONE_VERIFICATION: u64 = 1 << 61;
+    pub const NOT_SUSPICIOUS: u64 = 1 << 62;
 }

 pub const USER_FLAGS: &[U64Flag] = &[
@@ -66,6 +67,10 @@ pub const USER_FLAGS: &[U64Flag] = &[
        name: "DELETED",
        value: user_flag_bits::DELETED,
    },
+    U64Flag {
+        name: "DISABLED_SUSPICIOUS_ACTIVITY",
+        value: user_flag_bits::DISABLED_SUSPICIOUS_ACTIVITY,
+    },
    U64Flag {
        name: "SELF_DELETED",
        value: user_flag_bits::SELF_DELETED,
@@ -90,10 +95,6 @@ pub const USER_FLAGS: &[U64Flag] = &[
        name: "VERIFIED_NOT_UNDERAGE",
        value: user_flag_bits::VERIFIED_NOT_UNDERAGE,
    },
-    U64Flag {
-        name: "ACCOUNT_LIMITED",
-        value: user_flag_bits::ACCOUNT_LIMITED,
-    },
    U64Flag {
        name: "HAS_DISMISSED_PREMIUM_ONBOARDING",
        value: user_flag_bits::HAS_DISMISSED_PREMIUM_ONBOARDING,
@@ -111,8 +112,12 @@ pub const USER_FLAGS: &[U64Flag] = &[
        value: user_flag_bits::AGE_VERIFIED_ADULT,
    },
    U64Flag {
-        name: "LIMIT_EXEMPT",
-        value: user_flag_bits::LIMIT_EXEMPT,
+        name: "FORCE_INBOUND_PHONE_VERIFICATION",
+        value: user_flag_bits::FORCE_INBOUND_PHONE_VERIFICATION,
+    },
+    U64Flag {
+        name: "NOT_SUSPICIOUS",
+        value: user_flag_bits::NOT_SUSPICIOUS,
    },
 ];

@@ -154,3 +159,42 @@ pub const PREMIUM_FLAGS: &[I32Flag] = &[
        value: 1 << 8,
    },
 ];
+
+pub const SUSPICIOUS_ACTIVITY_FLAGS: &[I32Flag] = &[
+    I32Flag {
+        name: "REQUIRE_VERIFIED_EMAIL",
+        value: 1 << 0,
+    },
+    I32Flag {
+        name: "REQUIRE_REVERIFIED_EMAIL",
+        value: 1 << 1,
+    },
+    I32Flag {
+        name: "REQUIRE_VERIFIED_PHONE",
+        value: 1 << 2,
+    },
+    I32Flag {
+        name: "REQUIRE_REVERIFIED_PHONE",
+        value: 1 << 3,
+    },
+    I32Flag {
+        name: "REQUIRE_VERIFIED_EMAIL_OR_VERIFIED_PHONE",
+        value: 1 << 4,
+    },
+    I32Flag {
+        name: "REQUIRE_REVERIFIED_EMAIL_OR_VERIFIED_PHONE",
+        value: 1 << 5,
+    },
+    I32Flag {
+        name: "REQUIRE_VERIFIED_EMAIL_OR_REVERIFIED_PHONE",
+        value: 1 << 6,
+    },
+    I32Flag {
+        name: "REQUIRE_REVERIFIED_EMAIL_OR_REVERIFIED_PHONE",
+        value: 1 << 7,
+    },
+    I32Flag {
+        name: "REQUIRE_INBOUND_PHONE_VERIFICATION",
+        value: 1 << 8,
+    },
+];
@@ -1,17 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-
-use crate::templates::components::tooltip::{Hint, HintLink};
-
-pub fn limit_key_hint(key: &str) -> Option<Hint<'static>> {
-    match key {
-        "feature_guild_create" => Some(Hint {
-            name: Some("Community Creation Access"),
-            body: "Admins with the wildcard ACL can always create communities.",
-            link: Some(HintLink::new(
-                "/instance-config#community-creation",
-                "Community creation policy",
-            )),
-        }),
-        _ => None,
-    }
-}
@@ -12,7 +12,7 @@ impl AdminApiClient {
        acls: &[String],
    ) -> ApiResult<CreateAdminApiKeyResponse> {
        let body = generated_types::CreateAdminApiKeyRequest {
-            acls: parse_acls(acls),
+            acls: parse_acls(acls)?,
            expires_in_days: None,
            name: generated_types::CreateAdminApiKeyRequestName::try_from(name)
                .map_err(|e| ApiError::Parse(e.to_string()))?,
@@ -44,8 +44,11 @@ impl AdminApiClient {
    }
 }

-pub(super) fn parse_acls(acls: &[String]) -> Vec<generated_types::AdminAclType> {
+pub(super) fn parse_acls(acls: &[String]) -> ApiResult<Vec<generated_types::AdminAclType>> {
    acls.iter()
-        .filter_map(|acl| generated_types::AdminAclType::try_from(acl.as_str()).ok())
+        .map(|acl| {
+            generated_types::AdminAclType::try_from(acl.as_str())
+                .map_err(|e| ApiError::Parse(e.to_string()))
+        })
        .collect()
 }
@@ -3,17 +3,18 @@
 use crate::api::generated::{snowflake, types as generated_types};

 use super::client::{AdminApiClient, ApiError, ApiResult};
-use super::types::{BanAvatarResult, BanCheckResult, BlocklistEntryPage, BulkBanResult};
+use super::types::{BanAvatarResult, BanCheckResult, BulkBanResult};

 impl AdminApiClient {
    pub async fn ban_email(&self, email: &str, audit_log_reason: Option<&str>) -> ApiResult<()> {
        self.create_blocklist_entry(
            "email",
-            generated_types::AdminBlocklistEntryCreateRequest::from(
-                generated_types::BanEmailRequest {
-                    email: generated_types::EmailBlocklistEntryType::from(email.to_owned()),
-                },
-            ),
+            generated_types::AdminBlocklistEntryCreateRequest {
+                subtype_1: Some(generated_types::BanEmailRequest {
+                    email: generated_types::EmailType::from(email.to_owned()),
+                }),
+                ..Default::default()
+            },
            audit_log_reason,
        )
        .await
@@ -28,24 +29,13 @@ impl AdminApiClient {
        self.check_blocklist_entry("email", email, None).await
    }

-    pub async fn ban_ip(
-        &self,
-        ip: &str,
-        duration_hours: u32,
-        audit_log_reason: Option<&str>,
-    ) -> ApiResult<()> {
+    pub async fn ban_ip(&self, ip: &str, audit_log_reason: Option<&str>) -> ApiResult<()> {
        self.create_blocklist_entry(
            "ip",
-            generated_types::AdminBlocklistEntryCreateRequest::from(
-                generated_types::BanIpRequest {
-                    duration_hours: Some(
-                        i32::try_from(duration_hours)
-                            .map_err(|e| ApiError::Parse(e.to_string()))?
-                            .into(),
-                    ),
-                    ip: ip.to_owned(),
-                },
-            ),
+            generated_types::AdminBlocklistEntryCreateRequest {
+                subtype_0: Some(generated_types::BanIpRequest { ip: ip.to_owned() }),
+                ..Default::default()
+            },
            audit_log_reason,
        )
        .await
@@ -60,14 +50,45 @@ impl AdminApiClient {
        self.check_blocklist_entry("ip", ip, None).await
    }

+    pub async fn add_suspicious_email_domain(
+        &self,
+        domain: &str,
+        audit_log_reason: Option<&str>,
+    ) -> ApiResult<()> {
+        self.create_blocklist_entry(
+            SUSPICIOUS_EMAIL_DOMAIN_LIST,
+            generated_types::AdminBlocklistEntryCreateRequest {
+                subtype_2: Some(suspicious_email_domain_request(domain)?),
+                ..Default::default()
+            },
+            audit_log_reason,
+        )
+        .await
+    }
+
+    pub async fn remove_suspicious_email_domain(
+        &self,
+        domain: &str,
+        audit_log_reason: Option<&str>,
+    ) -> ApiResult<()> {
+        self.delete_blocklist_entry(SUSPICIOUS_EMAIL_DOMAIN_LIST, domain, None, audit_log_reason)
+            .await
+    }
+
+    pub async fn check_suspicious_email_domain(&self, domain: &str) -> ApiResult<BanCheckResult> {
+        self.check_blocklist_entry(SUSPICIOUS_EMAIL_DOMAIN_LIST, domain, None)
+            .await
+    }
+
    pub async fn ban_phrase(&self, phrase: &str, audit_log_reason: Option<&str>) -> ApiResult<()> {
        self.create_blocklist_entry(
            "phrase",
-            generated_types::AdminBlocklistEntryCreateRequest::from(
-                generated_types::BanPhraseRequest {
+            generated_types::AdminBlocklistEntryCreateRequest {
+                subtype_3: Some(generated_types::BanPhraseRequest {
                    phrase: phrase.to_owned(),
-                },
-            ),
+                }),
+                ..Default::default()
+            },
            audit_log_reason,
        )
        .await
@@ -89,15 +110,16 @@ impl AdminApiClient {
    pub async fn ban_url(&self, url: &str, audit_log_reason: Option<&str>) -> ApiResult<()> {
        self.create_blocklist_entry(
            "url",
-            generated_types::AdminBlocklistEntryCreateRequest::from(
-                generated_types::BanUrlRequest {
+            generated_types::AdminBlocklistEntryCreateRequest {
+                subtype_4: Some(generated_types::BanUrlRequest {
                    category: None,
                    notes: None,
                    severity: None,
                    source_url: None,
                    url: url.to_owned(),
-                },
-            ),
+                }),
+                ..Default::default()
+            },
            audit_log_reason,
        )
        .await
@@ -120,16 +142,17 @@ impl AdminApiClient {
    ) -> ApiResult<()> {
        self.create_blocklist_entry(
            "url-domain",
-            generated_types::AdminBlocklistEntryCreateRequest::from(
-                generated_types::BanUrlDomainRequest {
+            generated_types::AdminBlocklistEntryCreateRequest {
+                subtype_5: Some(generated_types::BanUrlDomainRequest {
                    category: None,
                    domain: domain.to_owned(),
                    match_subdomains,
                    notes: None,
                    severity: None,
                    source_url: None,
-                },
-            ),
+                }),
+                ..Default::default()
+            },
            audit_log_reason,
        )
        .await
@@ -148,19 +171,6 @@ impl AdminApiClient {
        self.check_blocklist_entry("url-domain", domain, None).await
    }

-    pub async fn list_url_domain_entries(
-        &self,
-        after: Option<&str>,
-    ) -> ApiResult<BlocklistEntryPage> {
-        let list_type = blocklist_list_type("url-domain")?;
-        let response = self
-            .generated()
-            .list_admin_blocklist_entries(list_type, after, Some(BLOCKLIST_PAGE_SIZE), None)
-            .await
-            .map_err(|e| self.generated_error(e))?;
-        self.generated_value(response.into_inner())
-    }
-
    pub async fn ban_file_sha(
        &self,
        sha256_hex: &str,
@@ -168,16 +178,17 @@ impl AdminApiClient {
    ) -> ApiResult<()> {
        self.create_blocklist_entry(
            "file-sha",
-            generated_types::AdminBlocklistEntryCreateRequest::from(
-                generated_types::BanFileShaRequest {
+            generated_types::AdminBlocklistEntryCreateRequest {
+                subtype_6: Some(generated_types::BanFileShaRequest {
                    category: None,
                    content_type: None,
                    notes: None,
                    severity: None,
                    sha256_hex: sha256_hex.to_owned(),
                    source_url: None,
-                },
-            ),
+                }),
+                ..Default::default()
+            },
            audit_log_reason,
        )
        .await
@@ -220,16 +231,17 @@ impl AdminApiClient {
    ) -> ApiResult<()> {
        self.create_blocklist_entry(
            "avatar-hash",
-            generated_types::AdminBlocklistEntryCreateRequest::from(
-                generated_types::BanAvatarHashRequest {
+            generated_types::AdminBlocklistEntryCreateRequest {
+                subtype_7: Some(generated_types::BanAvatarHashRequest {
                    category: None,
                    hashes: vec![hash_short.to_owned()],
                    notes: None,
                    reason: None,
                    severity: None,
                    source_url: None,
-                },
-            ),
+                }),
+                ..Default::default()
+            },
            audit_log_reason,
        )
        .await
@@ -267,9 +279,10 @@ impl AdminApiClient {
    ) -> ApiResult<()> {
        self.create_blocklist_entry(
            PROFILE_SUBSTRING_LIST,
-            generated_types::AdminBlocklistEntryCreateRequest::from(profile_substring_request(
-                scope, substring,
-            )?),
+            generated_types::AdminBlocklistEntryCreateRequest {
+                subtype_8: Some(profile_substring_request(scope, substring)?),
+                ..Default::default()
+            },
            audit_log_reason,
        )
        .await
@@ -346,9 +359,9 @@ impl AdminApiClient {
    }
 }

-const PROFILE_SUBSTRING_LIST: &str = "profile-substring";
+const SUSPICIOUS_EMAIL_DOMAIN_LIST: &str = "email-domain-suspicious";

-const BLOCKLIST_PAGE_SIZE: &str = "200";
+const PROFILE_SUBSTRING_LIST: &str = "profile-substring";

 fn blocklist_list_type(list_type: &str) -> ApiResult<generated_types::AdminBlocklistListType> {
    generated_types::AdminBlocklistListType::try_from(list_type)
@@ -367,6 +380,15 @@ fn blocklist_delete_scope(
        .map_err(|e| ApiError::Parse(e.to_string()))
 }

+fn suspicious_email_domain_request(
+    domain: &str,
+) -> ApiResult<generated_types::SuspiciousEmailDomainRequest> {
+    Ok(generated_types::SuspiciousEmailDomainRequest {
+        domain: generated_types::SuspiciousEmailDomainRequestDomain::try_from(domain)
+            .map_err(|e| ApiError::Parse(e.to_string()))?,
+    })
+}
+
 fn profile_substring_request(
    scope: &str,
    substring: &str,
@@ -22,6 +22,22 @@ impl AdminApiClient {
            .await
    }

+    pub async fn bulk_update_suspicious_activity_flags(
+        &self,
+        user_ids: &[String],
+        add_flags: &[String],
+        remove_flags: &[String],
+        audit_log_reason: Option<&str>,
+    ) -> ApiResult<BulkJobResponse> {
+        let body = generated_types::AdminBulkJobCreateRequest::UpdateSuspiciousActivityFlags {
+            add_flags: add_flags.to_vec(),
+            remove_flags: remove_flags.to_vec(),
+            user_ids: snowflakes(user_ids),
+        };
+        self.post_typed_with_reason("/admin/bulk-jobs", &body, audit_log_reason)
+            .await
+    }
+
    pub async fn bulk_update_guild_features(
        &self,
        guild_ids: &[String],
@@ -70,7 +86,6 @@ impl AdminApiClient {
        reason_code: u32,
        days_until_deletion: u32,
        public_reason: Option<&str>,
-        notify_user: bool,
        audit_log_reason: Option<&str>,
    ) -> ApiResult<BulkJobResponse> {
        let body = generated_types::AdminBulkJobCreateRequest::ScheduleUserDeletion {
@@ -80,7 +95,6 @@ impl AdminApiClient {
            )
            .map_err(ApiError::Parse)?
            .into(),
-            notify_user,
            public_reason: public_reason.map(std::borrow::ToOwned::to_owned),
            reason_code: crate::api::generated::deletion_reason_code(
                i32::try_from(reason_code).map_err(|e| ApiError::Parse(e.to_string()))?,
@@ -90,7 +90,10 @@ impl AdminApiClient {
    fn headers_with_reason(&self, audit_log_reason: Option<&str>) -> ApiResult<HeaderMap> {
        let mut headers = self.generated.inner().clone();
        if let Some(reason) = audit_log_reason {
-            headers.insert("x-audit-log-reason", audit_log_reason_header(reason)?);
+            let mut value = HeaderValue::from_str(reason)
+                .map_err(|_| ApiError::Parse("invalid audit log reason header".to_owned()))?;
+            value.set_sensitive(true);
+            headers.insert("x-audit-log-reason", value);
        }
        Ok(headers)
    }
@@ -419,27 +422,11 @@ impl std::fmt::Display for ApiError {
    }
 }

-fn audit_log_reason_header(reason: &str) -> ApiResult<HeaderValue> {
-    let mut value = HeaderValue::from_bytes(reason.as_bytes())
-        .map_err(|_| ApiError::Parse("invalid audit log reason header".to_owned()))?;
-    value.set_sensitive(true);
-    Ok(value)
-}
-
 #[cfg(test)]
 mod tests {
    use super::*;
    use serde_json::{Value, json};

-    #[test]
-    fn audit_log_reason_header_keeps_utf8_bytes() {
-        let reason = "§ 3 Regel – wiederholt 日本";
-        let value = audit_log_reason_header(reason).expect("valid reason header");
-        assert_eq!(value.as_bytes(), reason.as_bytes());
-        assert!(value.is_sensitive());
-        assert!(audit_log_reason_header("line one\nline two").is_err());
-    }
-
    fn response(status: u16, body: &'static str) -> reqwest::Response {
        axum::http::Response::builder()
            .status(status)
@@ -85,6 +85,7 @@ mod tests {
                "email": "[email protected]",
                "email_verified": true,
                "email_bounced": false,
+                "has_verified_phone": false,
                "date_of_birth": "2000-01-15",
                "locale": "en-US",
                "premium_type": 2,
@@ -92,6 +93,8 @@ mod tests {
                "premium_until": null,
                "premium_grace_ends_at": null,
                "premium_lifetime_sequence": null,
+                "suspicious_activity_flags": 0,
+                "phone_verification_deferred": false,
                "temp_banned_until": null,
                "pending_deletion_at": null,
                "pending_bulk_message_deletion_at": null,
@@ -1,25 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-
-use crate::api::generated::snowflake;
-
-use super::client::{AdminApiClient, ApiResult};
-use super::types::ListGuildThreadsResponse;
-
-impl AdminApiClient {
-    pub async fn list_guild_threads(&self, guild_id: &str) -> ApiResult<ListGuildThreadsResponse> {
-        let response = self
-            .generated()
-            .list_admin_guild_threads(&snowflake(guild_id))
-            .await
-            .map_err(|e| self.generated_error(e))?;
-        self.generated_value(response.into_inner())
-    }
-
-    pub async fn delete_thread_channel(&self, channel_id: &str) -> ApiResult<()> {
-        self.generated()
-            .delete_admin_thread_channel(&snowflake(channel_id))
-            .await
-            .map_err(|e| self.generated_error(e))?;
-        Ok(())
-    }
-}
@@ -2,9 +2,8 @@

 use super::client::{AdminApiClient, ApiResult};
 use super::types::{
-    AccountIdentitySettings, CreateRegistrationUrlRequest, CreateRegistrationUrlResponse,
-    InstanceAccountIdentityDiscovery, InstanceConfigResponse, InstanceConfigUpdateRequest,
-    InstanceEmailSmtpTestRequest, InstanceEmailSmtpTestResponse, InstancePremiumDiscovery,
+    CreateRegistrationUrlRequest, CreateRegistrationUrlResponse, InstanceConfigResponse,
+    InstanceConfigUpdateRequest, InstanceEmailSmtpTestRequest, InstanceEmailSmtpTestResponse,
 };

 impl AdminApiClient {
@@ -12,20 +11,6 @@ impl AdminApiClient {
        self.get("/admin/instance/config", None).await
    }

-    pub async fn get_instance_premium_discovery(&self) -> ApiResult<InstancePremiumDiscovery> {
-        self.get("/.well-known/fluxer", None).await
-    }
-
-    pub async fn get_instance_account_identity(&self) -> ApiResult<AccountIdentitySettings> {
-        let discovery: InstanceAccountIdentityDiscovery =
-            self.get("/.well-known/fluxer", None).await?;
-        let mode = discovery.features.account_identity;
-        Ok(AccountIdentitySettings {
-            mode,
-            tag_style: discovery.features.tag_style,
-        })
-    }
-
    pub async fn update_instance_config(
        &self,
        update: &InstanceConfigUpdateRequest,
@@ -13,7 +13,6 @@ pub mod client;
 pub mod codes;
 pub mod discovery;
 pub mod guild_assets;
-pub mod guild_threads;
 pub mod guilds;
 pub mod instance_config;
 pub mod jobs;
@@ -56,14 +56,12 @@ impl AdminApiClient {
        &self,
        report_id: &str,
        public_comment: Option<&str>,
-        notify_reporter: bool,
        audit_log_reason: Option<&str>,
    ) -> ApiResult<ResolveReportResponse> {
        let mut body = serde_json::json!({"status": "resolved"});
        if let Some(public_comment) = public_comment {
            body["public_comment"] = serde_json::Value::from(public_comment);
        }
-        body["notify_reporter"] = serde_json::Value::from(notify_reporter);
        self.patch_with_reason(
            &format!("/admin/reports/{}", urlencoding::encode(report_id)),
            Some(&body),
@@ -8,18 +8,13 @@ use super::types::SendSystemDmResponse;
 impl AdminApiClient {
    pub async fn send_system_dm(
        &self,
-        user_ids: Option<&[String]>,
+        user_ids: &[String],
        content: &str,
    ) -> ApiResult<SendSystemDmResponse> {
        let body = generated_types::SendSystemDmRequest {
            content: generated_types::SendSystemDmRequestContent::try_from(content)
                .map_err(|e| ApiError::Parse(e.to_string()))?,
-            user_ids: user_ids
-                .unwrap_or_default()
-                .iter()
-                .map(|id| snowflake(id))
-                .collect(),
-            all_users: user_ids.is_none().then_some(true),
+            user_ids: user_ids.iter().map(|id| snowflake(id)).collect(),
        };
        let response = self
            .generated()
@@ -108,20 +108,20 @@ pub struct AdminUser {
    pub premium_grace_ends_at: Option<String>,
    pub premium_lifetime_sequence: Option<i32>,
    #[serde(default)]
+    pub suspicious_activity_flags: i32,
+    #[serde(default)]
+    pub phone_verification_deferred: bool,
+    #[serde(default)]
    pub has_totp: bool,
    #[serde(default)]
    pub authenticator_types: Vec<i32>,
+    #[serde(default)]
+    pub has_verified_phone: bool,
    pub temp_banned_until: Option<String>,
    pub pending_deletion_at: Option<String>,
    pub pending_bulk_message_deletion_at: Option<String>,
    pub deletion_reason_code: Option<i32>,
    pub deletion_public_reason: Option<String>,
-    #[serde(default)]
-    pub deletion_audit_log_reason: Option<String>,
-    #[serde(default)]
-    pub deletion_scheduled_by: Option<String>,
-    #[serde(default)]
-    pub deletion_scheduled_at: Option<String>,
    pub last_active_at: Option<String>,
    pub last_active_ip: Option<String>,
    pub last_active_ip_reverse: Option<String>,
@@ -255,30 +255,9 @@ pub enum FlashLevel {
 pub struct BanCheckResult {
    pub banned: bool,
    #[serde(default)]
-    pub expires_at: Option<String>,
-    #[serde(default)]
    pub entries: Vec<serde_json::Value>,
 }

-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct BlocklistEntry {
-    pub value: String,
-    #[serde(default)]
-    pub match_subdomains: Option<bool>,
-    #[serde(default)]
-    pub category: Option<String>,
-    #[serde(default)]
-    pub created_at: Option<String>,
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct BlocklistEntryPage {
-    pub items: Vec<BlocklistEntry>,
-    pub has_more: bool,
-    #[serde(default)]
-    pub next_after: Option<String>,
-}
-
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct BulkBanResult {
    pub job_id: String,
@@ -1,35 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-
-use serde::{Deserialize, Serialize};
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct GuildThreadMetadata {
-    pub archived: bool,
-    pub locked: bool,
-    pub auto_archive_duration: i32,
-    pub archive_timestamp: String,
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct GuildThreadItem {
-    pub id: String,
-    #[serde(rename = "type")]
-    pub channel_type: i32,
-    #[serde(default)]
-    pub name: Option<String>,
-    #[serde(default)]
-    pub parent_id: Option<String>,
-    #[serde(default)]
-    pub owner_id: Option<String>,
-    #[serde(default)]
-    pub member_count: Option<i32>,
-    #[serde(default)]
-    pub message_count: Option<i32>,
-    #[serde(default)]
-    pub thread_metadata: Option<GuildThreadMetadata>,
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct ListGuildThreadsResponse {
-    pub threads: Vec<GuildThreadItem>,
-}
@@ -1,332 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-
-use super::{InstanceConfigResponse, PremiumMode};
-use serde::{Deserialize, Serialize};
-use std::collections::BTreeMap;
-
-pub const BILLING_MAX_CURRENCIES: usize = 64;
-pub const BILLING_MAX_COUNTRY_CURRENCIES: usize = 300;
-pub const BILLING_MAX_LEGACY_SLOTS: usize = 256;
-pub const BILLING_MAX_LEGACY_PRICES_PER_SLOT: usize = 32;
-pub const BILLING_PRICE_SLOTS: [&str; 4] = ["monthly", "yearly", "gift_1_month", "gift_1_year"];
-pub const PREMIUM_PRODUCT_NAME_MAX_CHARS: usize = 40;
-pub const TRI_STATE_DEFAULT: &str = "default";
-pub const TRI_STATE_ON: &str = "on";
-pub const TRI_STATE_OFF: &str = "off";
-
-#[derive(Clone, Copy, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
-#[serde(rename_all = "snake_case")]
-pub enum BillingCatalogMode {
-    #[default]
-    Env,
-    Operator,
-}
-
-#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
-pub struct BillingPriceSet {
-    pub monthly: Option<String>,
-    pub yearly: Option<String>,
-    pub gift_1_month: Option<String>,
-    pub gift_1_year: Option<String>,
-}
-
-impl BillingPriceSet {
-    pub fn has_recurring_pair(&self) -> bool {
-        self.monthly.is_some() && self.yearly.is_some()
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.monthly.is_none()
-            && self.yearly.is_none()
-            && self.gift_1_month.is_none()
-            && self.gift_1_year.is_none()
-    }
-}
-
-#[derive(Clone, Debug, Default, Deserialize, Serialize)]
-pub struct InstanceBillingResponse {
-    pub enabled: Option<bool>,
-    #[serde(default)]
-    pub effective_enabled: bool,
-    #[serde(default)]
-    pub stripe_secret_key_set: bool,
-    #[serde(default)]
-    pub stripe_webhook_secret_set: bool,
-    #[serde(default)]
-    pub stripe_secret_key_stored: bool,
-    #[serde(default)]
-    pub stripe_webhook_secret_stored: bool,
-    pub default_currency: Option<String>,
-    pub prices: Option<BTreeMap<String, BillingPriceSet>>,
-    pub country_currencies: Option<BTreeMap<String, String>>,
-    pub legacy_prices: Option<BTreeMap<String, Vec<String>>>,
-    #[serde(default)]
-    pub billing_active: bool,
-    #[serde(default)]
-    pub stripe_serviceable: bool,
-    #[serde(default)]
-    pub catalog_mode: BillingCatalogMode,
-    #[serde(default)]
-    pub webhook_url: String,
-    pub automatic_tax: Option<bool>,
-    pub tax_id_collection: Option<bool>,
-    pub terms_consent_required: Option<bool>,
-    #[serde(default)]
-    pub effective_automatic_tax: bool,
-    #[serde(default)]
-    pub effective_tax_id_collection: bool,
-    #[serde(default)]
-    pub effective_terms_consent_required: bool,
-}
-
-#[derive(Clone, Debug, Default, Serialize)]
-pub struct InstanceBillingUpdateRequest {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub enabled: Option<Option<bool>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub stripe_secret_key: Option<Option<String>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub stripe_webhook_secret: Option<Option<String>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub default_currency: Option<Option<String>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub prices: Option<Option<BTreeMap<String, BillingPriceSet>>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub country_currencies: Option<Option<BTreeMap<String, String>>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub legacy_prices: Option<Option<BTreeMap<String, Vec<String>>>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub automatic_tax: Option<Option<bool>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub tax_id_collection: Option<Option<bool>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub terms_consent_required: Option<Option<bool>>,
-}
-
-#[derive(Clone, Debug, Default, Deserialize)]
-pub struct InstancePremiumDiscovery {
-    #[serde(default)]
-    pub app_public: InstancePremiumDiscoveryAppPublic,
-    #[serde(default)]
-    pub features: InstancePremiumDiscoveryFeatures,
-}
-
-#[derive(Clone, Debug, Default, Deserialize)]
-pub struct InstancePremiumDiscoveryAppPublic {
-    #[serde(default)]
-    pub branding: InstancePremiumDiscoveryBranding,
-}
-
-#[derive(Clone, Debug, Default, Deserialize)]
-pub struct InstancePremiumDiscoveryBranding {
-    pub premium_product_name: Option<String>,
-}
-
-#[derive(Clone, Debug, Default, Deserialize)]
-pub struct InstancePremiumDiscoveryFeatures {
-    #[serde(default)]
-    pub premium_enabled: bool,
-}
-
-impl InstancePremiumDiscovery {
-    pub fn premium_product_name(&self) -> Option<&str> {
-        self.app_public
-            .branding
-            .premium_product_name
-            .as_deref()
-            .map(str::trim)
-            .filter(|name| !name.is_empty())
-    }
-}
-
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct PremiumBranding {
-    pub name: Option<String>,
-    pub premium_enabled: bool,
-}
-
-impl PremiumBranding {
-    pub fn from_discovery(discovery: &InstancePremiumDiscovery) -> Self {
-        Self {
-            name: discovery.premium_product_name().map(str::to_owned),
-            premium_enabled: discovery.features.premium_enabled,
-        }
-    }
-
-    pub fn from_instance_config(config: &InstanceConfigResponse) -> Self {
-        Self::from_config_parts(
-            config.self_hosted,
-            &config.app_public.branding.premium_product_name,
-            config.policy.premium_mode,
-        )
-    }
-
-    fn from_config_parts(self_hosted: bool, name: &str, premium_mode: PremiumMode) -> Self {
-        let name = name.trim();
-        Self {
-            name: (!name.is_empty()).then(|| name.to_owned()),
-            premium_enabled: !self_hosted || matches!(premium_mode, PremiumMode::Mirror),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::api::generated::types as generated_types;
-    use serde_json::json;
-
-    #[test]
-    fn billing_response_round_trips_through_the_generated_contract() {
-        let value = json!({
-            "enabled": true,
-            "effective_enabled": true,
-            "stripe_secret_key_set": true,
-            "stripe_webhook_secret_set": false,
-            "stripe_secret_key_stored": true,
-            "stripe_webhook_secret_stored": false,
-            "default_currency": "GBP",
-            "prices": {
-                "GBP": {
-                    "monthly": "price_1Monthly",
-                    "yearly": "price_1Yearly",
-                    "gift_1_month": null,
-                    "gift_1_year": null
-                }
-            },
-            "country_currencies": {"GB": "GBP"},
-            "legacy_prices": {"monthly_GBP": ["price_1Old"]},
-            "billing_active": false,
-            "stripe_serviceable": false,
-            "catalog_mode": "operator",
-            "webhook_url": "https://api.example.com/stripe/webhook",
-            "automatic_tax": null,
-            "tax_id_collection": false,
-            "terms_consent_required": true,
-            "effective_automatic_tax": false,
-            "effective_tax_id_collection": false,
-            "effective_terms_consent_required": true
-        });
-        let generated: generated_types::InstanceBillingResponse =
-            serde_json::from_value(value.clone()).expect("generated billing response");
-        let ours: InstanceBillingResponse =
-            serde_json::from_value(value.clone()).expect("hand-written billing response");
-        assert_eq!(ours.catalog_mode, BillingCatalogMode::Operator);
-        assert!(ours.stripe_secret_key_stored);
-        assert_eq!(ours.automatic_tax, None);
-        assert_eq!(ours.tax_id_collection, Some(false));
-        assert!(ours.effective_terms_consent_required);
-        assert!(ours.prices.as_ref().expect("prices")["GBP"].has_recurring_pair());
-        assert_eq!(serde_json::to_value(&ours).expect("serializable"), value);
-        assert_eq!(
-            serde_json::to_value(generated).expect("serializable generated"),
-            value
-        );
-    }
-
-    #[test]
-    fn default_billing_response_matches_the_generated_contract() {
-        let value = serde_json::to_value(InstanceBillingResponse::default()).expect("serializable");
-        serde_json::from_value::<generated_types::InstanceBillingResponse>(value.clone())
-            .expect("generated billing response");
-        assert_eq!(value["catalog_mode"], json!("env"));
-        assert_eq!(value["prices"], json!(null));
-    }
-
-    #[test]
-    fn billing_update_preserves_explicit_nulls_and_omits_untouched_fields() {
-        let mut prices = BTreeMap::new();
-        prices.insert(
-            "SEK".to_owned(),
-            BillingPriceSet {
-                monthly: Some("price_1Monthly".to_owned()),
-                yearly: Some("price_1Yearly".to_owned()),
-                ..Default::default()
-            },
-        );
-        let update = InstanceBillingUpdateRequest {
-            enabled: Some(None),
-            stripe_secret_key: Some(None),
-            default_currency: Some(None),
-            prices: Some(Some(prices)),
-            country_currencies: Some(None),
-            legacy_prices: Some(Some(BTreeMap::new())),
-            automatic_tax: Some(None),
-            tax_id_collection: Some(Some(true)),
-            terms_consent_required: Some(Some(false)),
-            ..Default::default()
-        };
-        let value = serde_json::to_value(update).expect("serializable update");
-        serde_json::from_value::<generated_types::InstanceBillingUpdateRequest>(value.clone())
-            .expect("generated update contract");
-        assert_eq!(
-            value,
-            json!({
-                "enabled": null,
-                "stripe_secret_key": null,
-                "default_currency": null,
-                "prices": {
-                    "SEK": {
-                        "monthly": "price_1Monthly",
-                        "yearly": "price_1Yearly",
-                        "gift_1_month": null,
-                        "gift_1_year": null
-                    }
-                },
-                "country_currencies": null,
-                "legacy_prices": {},
-                "automatic_tax": null,
-                "tax_id_collection": true,
-                "terms_consent_required": false
-            })
-        );
-        assert_eq!(
-            serde_json::to_value(InstanceBillingUpdateRequest::default())
-                .expect("serializable update"),
-            json!({})
-        );
-    }
-
-    #[test]
-    fn premium_discovery_reads_the_name_and_feature_flag() {
-        let discovery: InstancePremiumDiscovery = serde_json::from_value(json!({
-            "app_public": {"branding": {"product_name": "Example", "premium_product_name": " Gold "}},
-            "features": {"premium_enabled": true, "stripe_enabled": false}
-        }))
-        .expect("discovery");
-        assert_eq!(discovery.premium_product_name(), Some("Gold"));
-        assert!(discovery.features.premium_enabled);
-        let empty: InstancePremiumDiscovery =
-            serde_json::from_value(json!({})).expect("empty discovery");
-        assert_eq!(empty.premium_product_name(), None);
-        assert!(!empty.features.premium_enabled);
-        assert_eq!(
-            PremiumBranding::from_discovery(&discovery),
-            PremiumBranding {
-                name: Some("Gold".to_owned()),
-                premium_enabled: true
-            }
-        );
-    }
-
-    #[test]
-    fn premium_branding_from_instance_config_matches_discovery_rules() {
-        assert_eq!(
-            PremiumBranding::from_config_parts(true, " Gold ", PremiumMode::Everyone),
-            PremiumBranding {
-                name: Some("Gold".to_owned()),
-                premium_enabled: false
-            }
-        );
-        assert!(
-            PremiumBranding::from_config_parts(true, "Gold", PremiumMode::Mirror).premium_enabled
-        );
-        assert_eq!(
-            PremiumBranding::from_config_parts(false, "  ", PremiumMode::Everyone),
-            PremiumBranding {
-                name: None,
-                premium_enabled: true
-            }
-        );
-    }
-}
@@ -2,7 +2,7 @@

 use serde::{Deserialize, Serialize};

-use super::{InstanceBillingResponse, InstanceBillingUpdateRequest};
+pub use crate::api::generated::types::VoiceNoiseSuppressionBackendSchema as NoiseSuppressionBackend;

 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct InstanceConfigResponse {
@@ -13,8 +13,6 @@ pub struct InstanceConfigResponse {
    #[serde(default)]
    pub self_hosted: bool,
    #[serde(default)]
-    pub account_identity: AccountIdentityConfigResponse,
-    #[serde(default)]
    pub app_public: AppPublicConfigResponse,
    #[serde(default)]
    pub policy: InstancePolicyResponse,
@@ -23,92 +21,15 @@ pub struct InstanceConfigResponse {
    #[serde(default)]
    pub media: InstanceMediaResponse,
    #[serde(default)]
-    pub push_relay: PushRelayConfigResponse,
+    pub voice_noise_suppression: VoiceNoiseSuppressionConfigResponse,
+    #[serde(default)]
+    pub push_service_delivery: PushServiceDeliveryConfigResponse,
    #[serde(default)]
    pub domain_migration: DomainMigrationConfigResponse,
    #[serde(default)]
-    pub plutonium_page: PlutoniumPageConfigResponse,
-    #[serde(default)]
-    pub captcha: CaptchaConfigResponse,
-    #[serde(default)]
-    pub channel_threads: ChannelThreadsConfigResponse,
+    pub altcha_captcha: AltchaCaptchaConfigResponse,
    #[serde(default)]
    pub experiment_delivery: ExperimentDeliveryConfigResponse,
-    #[serde(default)]
-    pub billing: InstanceBillingResponse,
-}
-
-#[derive(Clone, Copy, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
-#[serde(rename_all = "snake_case")]
-pub enum AccountIdentityMode {
-    #[default]
-    Email,
-    Username,
-}
-
-impl AccountIdentityMode {
-    pub fn is_username(self) -> bool {
-        matches!(self, Self::Username)
-    }
-
-    pub fn label(self) -> &'static str {
-        match self {
-            Self::Email => "Email",
-            Self::Username => "Username",
-        }
-    }
-}
-
-#[derive(Clone, Copy, Debug, Default, Deserialize, Serialize, Eq, PartialEq)]
-#[serde(rename_all = "snake_case")]
-pub enum TagStyle {
-    None,
-    #[default]
-    #[serde(other)]
-    Random,
-}
-
-impl TagStyle {
-    pub fn is_none(self) -> bool {
-        matches!(self, Self::None)
-    }
-
-    pub fn label(self) -> &'static str {
-        match self {
-            Self::None => "No tags",
-            Self::Random => "Random tags",
-        }
-    }
-}
-
-#[derive(Clone, Copy, Debug, Default, Deserialize, Serialize)]
-pub struct AccountIdentityConfigResponse {
-    #[serde(default)]
-    pub mode: AccountIdentityMode,
-    #[serde(default)]
-    pub locked: Option<bool>,
-    #[serde(default)]
-    pub tag_style: TagStyle,
-}
-
-#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
-pub struct AccountIdentitySettings {
-    pub mode: AccountIdentityMode,
-    pub tag_style: TagStyle,
-}
-
-#[derive(Clone, Debug, Default, Deserialize)]
-pub struct InstanceAccountIdentityDiscovery {
-    #[serde(default)]
-    pub features: InstanceAccountIdentityDiscoveryFeatures,
-}
-
-#[derive(Clone, Debug, Default, Deserialize)]
-pub struct InstanceAccountIdentityDiscoveryFeatures {
-    #[serde(default)]
-    pub account_identity: AccountIdentityMode,
-    #[serde(default)]
-    pub tag_style: TagStyle,
 }

 #[derive(Clone, Debug, Deserialize, Serialize)]
@@ -122,18 +43,34 @@ pub struct InstancePolicyResponse {
    pub direct_messages_locked: bool,
    #[serde(default)]
    pub premium_mode: PremiumMode,
-    #[serde(default = "default_guild_create_access")]
-    pub guild_create_access: bool,
    #[serde(default)]
    pub services: InstanceServicesOverrides,
    #[serde(default)]
    pub services_resolved: InstanceServicesResolved,
    #[serde(default)]
    pub services_available: InstanceServicesAvailable,
+    #[serde(default)]
+    pub deferred_phone_gate: DeferredPhoneGateResponse,
 }

-fn default_guild_create_access() -> bool {
-    true
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct DeferredPhoneGateResponse {
+    #[serde(default)]
+    pub enabled: bool,
+    #[serde(default)]
+    pub window_hours: f64,
+    #[serde(default)]
+    pub member_threshold: i64,
+}
+
+impl Default for DeferredPhoneGateResponse {
+    fn default() -> Self {
+        Self {
+            enabled: true,
+            window_hours: 6.0,
+            member_threshold: 50,
+        }
+    }
 }

 impl Default for InstancePolicyResponse {
@@ -144,10 +81,10 @@ impl Default for InstancePolicyResponse {
            direct_messages_disabled: false,
            direct_messages_locked: false,
            premium_mode: PremiumMode::Everyone,
-            guild_create_access: default_guild_create_access(),
            services: InstanceServicesOverrides::default(),
            services_resolved: InstanceServicesResolved::default(),
            services_available: InstanceServicesAvailable::default(),
+            deferred_phone_gate: DeferredPhoneGateResponse::default(),
        }
    }
 }
@@ -186,6 +123,8 @@ pub struct InstanceIntegrationsResponse {
    #[serde(default)]
    pub youtube: InstanceYoutubeIntegrationResponse,
    #[serde(default)]
+    pub captcha: InstanceCaptchaIntegrationResponse,
+    #[serde(default)]
    pub email: InstanceEmailIntegrationResponse,
    #[serde(default)]
    pub bluesky: InstanceBlueskyIntegrationResponse,
@@ -206,6 +145,21 @@ pub struct InstanceYoutubeIntegrationResponse {
    pub effective_available: bool,
 }

+#[derive(Clone, Debug, Default, Deserialize, Serialize)]
+pub struct InstanceCaptchaIntegrationResponse {
+    pub provider: Option<String>,
+    #[serde(default)]
+    pub effective_provider: String,
+    pub hcaptcha_site_key: Option<String>,
+    #[serde(default)]
+    pub hcaptcha_secret_key_set: bool,
+    pub turnstile_site_key: Option<String>,
+    #[serde(default)]
+    pub turnstile_secret_key_set: bool,
+    #[serde(default)]
+    pub effective_enabled: bool,
+}
+
 #[derive(Clone, Debug, Default, Deserialize, Serialize)]
 pub struct InstanceEmailIntegrationResponse {
    pub enabled: Option<bool>,
@@ -380,9 +334,6 @@ pub struct AppBrandingConfigResponse {
    pub theme_color: Option<String>,
    pub status_page_url: Option<String>,
    pub status_page_incident_history_url: Option<String>,
-    #[serde(default = "default_premium_product_name")]
-    pub premium_product_name: String,
-    pub premium_info_url: Option<String>,
 }

 impl Default for AppBrandingConfigResponse {
@@ -397,8 +348,6 @@ impl Default for AppBrandingConfigResponse {
            theme_color: None,
            status_page_url: None,
            status_page_incident_history_url: None,
-            premium_product_name: default_premium_product_name(),
-            premium_info_url: None,
        }
    }
 }
@@ -407,10 +356,6 @@ fn default_product_name() -> String {
    "Fluxer".to_owned()
 }

-fn default_premium_product_name() -> String {
-    "Premium".to_owned()
-}
-
 #[derive(Clone, Debug, Default, Deserialize, Serialize)]
 pub struct AppSetupConfigResponse {
    #[serde(default)]
@@ -508,23 +453,143 @@ impl VoiceE2eeScope {
 }

 pub const EXPERIMENT_MAX_TARGETED_USERS: usize = 1_000;
+pub const PUSH_SERVICE_DELIVERY_DEFAULT_SALT: &str = "push-service-delivery-v1";
 pub const DOMAIN_MIGRATION_DEFAULT_SALT: &str = "domain-migration-v1";
-pub const PLUTONIUM_PAGE_DEFAULT_SALT: &str = "plutonium-page-v1";
-pub const CAPTCHA_COST_RANGE: std::ops::RangeInclusive<u32> = 1_000..=20_000;
-pub const CAPTCHA_MAX_COUNTER_RANGE: std::ops::RangeInclusive<u32> = 100..=20_000;
-pub const CHANNEL_THREADS_DEFAULT_GUILD_SALT: &str = "channel-threads-guild-v1";
-pub const CHANNEL_THREADS_DEFAULT_USER_SALT: &str = "channel-threads-user-v1";
+pub const ALTCHA_CAPTCHA_DEFAULT_SALT: &str = "altcha-captcha-v1";
+pub const ALTCHA_CAPTCHA_COST_RANGE: std::ops::RangeInclusive<u32> = 1_000..=100_000;
+pub const ALTCHA_CAPTCHA_MAX_COUNTER_RANGE: std::ops::RangeInclusive<u32> = 100..=1_000_000;
+pub const VOICE_NS_MAX_GUILD_OVERRIDES: usize = 200;

-#[derive(Clone, Debug, Default, Deserialize, Serialize)]
+impl NoiseSuppressionBackend {
+    pub const ALL: [Self; 7] = [
+        Self::None,
+        Self::Standard,
+        Self::Gate,
+        Self::Speex,
+        Self::Rnnoise,
+        Self::Gtcrn,
+        Self::DeepFilter,
+    ];
+
+    pub fn label(&self) -> &'static str {
+        match self {
+            Self::None => "None (pass-through)",
+            Self::Standard => "Standard (WebRTC)",
+            Self::Gate => "Noise gate",
+            Self::Speex => "Speex",
+            Self::Rnnoise => "RNNoise",
+            Self::Gtcrn => "GTCRN",
+            Self::DeepFilter => "DeepFilterNet",
+        }
+    }
+}
+
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+pub struct VoiceNoiseSuppressionGuildOverride {
+    pub guild_id: String,
+    pub backend: NoiseSuppressionBackend,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
 #[serde(default)]
-pub struct PushRelayConfigResponse {
+pub struct VoiceNoiseSuppressionConfigResponse {
+    pub enabled: bool,
+    pub config_version: u64,
+    pub default_backend: NoiseSuppressionBackend,
+    pub enabled_backends: Vec<NoiseSuppressionBackend>,
+    pub allow_user_override: bool,
+    pub rollout_basis_points: u32,
+    pub rollout_salt: String,
+    pub included_user_ids: Vec<String>,
+    pub excluded_user_ids: Vec<String>,
+    pub guild_overrides: Vec<VoiceNoiseSuppressionGuildOverride>,
+    pub suppression_strength: u32,
+}
+
+impl Default for VoiceNoiseSuppressionConfigResponse {
+    fn default() -> Self {
+        Self {
+            enabled: false,
+            config_version: 0,
+            default_backend: NoiseSuppressionBackend::Standard,
+            enabled_backends: NoiseSuppressionBackend::ALL.to_vec(),
+            allow_user_override: true,
+            rollout_basis_points: 0,
+            rollout_salt: "voice-ns-v1".to_owned(),
+            included_user_ids: Vec::new(),
+            excluded_user_ids: Vec::new(),
+            guild_overrides: Vec::new(),
+            suppression_strength: 80,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Default, Serialize)]
+pub struct VoiceNoiseSuppressionConfigUpdateRequest {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub enabled: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub default_backend: Option<NoiseSuppressionBackend>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub enabled_backends: Option<Vec<NoiseSuppressionBackend>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub allow_user_override: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub rollout_basis_points: Option<u32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub rollout_salt: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub included_user_ids: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub excluded_user_ids: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub guild_overrides: Option<Vec<VoiceNoiseSuppressionGuildOverride>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub suppression_strength: Option<u32>,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(default)]
+pub struct PushServiceDeliveryConfigResponse {
+    pub enabled: bool,
+    pub config_version: u64,
+    pub rollout_basis_points: u32,
+    pub rollout_salt: String,
+    pub included_user_ids: Vec<String>,
+    pub excluded_user_ids: Vec<String>,
    pub relay_consent_accepted: bool,
    pub relay_consent_accepted_at: Option<String>,
    pub relay_consent_accepted_by: Option<String>,
 }

+impl Default for PushServiceDeliveryConfigResponse {
+    fn default() -> Self {
+        Self {
+            enabled: false,
+            config_version: 0,
+            rollout_basis_points: 0,
+            rollout_salt: PUSH_SERVICE_DELIVERY_DEFAULT_SALT.to_owned(),
+            included_user_ids: Vec::new(),
+            excluded_user_ids: Vec::new(),
+            relay_consent_accepted: false,
+            relay_consent_accepted_at: None,
+            relay_consent_accepted_by: None,
+        }
+    }
+}
+
 #[derive(Clone, Debug, Default, Serialize)]
-pub struct PushRelayConfigUpdateRequest {
+pub struct PushServiceDeliveryConfigUpdateRequest {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub enabled: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub rollout_basis_points: Option<u32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub rollout_salt: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub included_user_ids: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub excluded_user_ids: Option<Vec<String>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub relay_consent_accepted: Option<bool>,
 }
@@ -537,8 +602,6 @@ pub struct DomainMigrationConfigResponse {
    pub rollout_basis_points: u32,
    pub rollout_salt: String,
    pub included_user_ids: Vec<String>,
-    pub included_guild_ids: Vec<String>,
-    pub include_premium_users: bool,
    pub excluded_user_ids: Vec<String>,
    pub anonymous_rollout_basis_points: u32,
    pub standalone_forwarding: bool,
@@ -552,8 +615,6 @@ impl Default for DomainMigrationConfigResponse {
            rollout_basis_points: 0,
            rollout_salt: DOMAIN_MIGRATION_DEFAULT_SALT.to_owned(),
            included_user_ids: Vec::new(),
-            included_guild_ids: Vec::new(),
-            include_premium_users: false,
            excluded_user_ids: Vec::new(),
            anonymous_rollout_basis_points: 0,
            standalone_forwarding: false,
@@ -572,10 +633,6 @@ pub struct DomainMigrationConfigUpdateRequest {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub included_user_ids: Option<Vec<String>>,
    #[serde(skip_serializing_if = "Option::is_none")]
-    pub included_guild_ids: Option<Vec<String>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub include_premium_users: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
    pub excluded_user_ids: Option<Vec<String>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub anonymous_rollout_basis_points: Option<u32>,
@@ -585,34 +642,36 @@ pub struct DomainMigrationConfigUpdateRequest {

 #[derive(Clone, Debug, Deserialize, Serialize)]
 #[serde(default)]
-pub struct PlutoniumPageConfigResponse {
+pub struct AltchaCaptchaConfigResponse {
    pub enabled: bool,
    pub config_version: u64,
    pub rollout_basis_points: u32,
    pub rollout_salt: String,
    pub included_user_ids: Vec<String>,
-    pub included_guild_ids: Vec<String>,
-    pub include_premium_users: bool,
    pub excluded_user_ids: Vec<String>,
+    pub anonymous_enabled: bool,
+    pub cost: u32,
+    pub max_counter: u32,
 }

-impl Default for PlutoniumPageConfigResponse {
+impl Default for AltchaCaptchaConfigResponse {
    fn default() -> Self {
        Self {
            enabled: false,
            config_version: 0,
            rollout_basis_points: 0,
-            rollout_salt: PLUTONIUM_PAGE_DEFAULT_SALT.to_owned(),
+            rollout_salt: ALTCHA_CAPTCHA_DEFAULT_SALT.to_owned(),
            included_user_ids: Vec::new(),
-            included_guild_ids: Vec::new(),
-            include_premium_users: false,
            excluded_user_ids: Vec::new(),
+            anonymous_enabled: false,
+            cost: 5_000,
+            max_counter: 10_000,
        }
    }
 }

 #[derive(Clone, Debug, Default, Serialize)]
-pub struct PlutoniumPageConfigUpdateRequest {
+pub struct AltchaCaptchaConfigUpdateRequest {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
@@ -622,97 +681,15 @@ pub struct PlutoniumPageConfigUpdateRequest {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub included_user_ids: Option<Vec<String>>,
    #[serde(skip_serializing_if = "Option::is_none")]
-    pub included_guild_ids: Option<Vec<String>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub include_premium_users: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
    pub excluded_user_ids: Option<Vec<String>>,
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-#[serde(default)]
-pub struct CaptchaConfigResponse {
-    pub enabled: bool,
-    pub cost: u32,
-    pub max_counter: u32,
-}
-
-impl Default for CaptchaConfigResponse {
-    fn default() -> Self {
-        Self {
-            enabled: true,
-            cost: 5_000,
-            max_counter: 1_000,
-        }
-    }
-}
-
-#[derive(Clone, Debug, Default, Serialize)]
-pub struct CaptchaConfigUpdateRequest {
    #[serde(skip_serializing_if = "Option::is_none")]
-    pub enabled: Option<bool>,
+    pub anonymous_enabled: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cost: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_counter: Option<u32>,
 }

-#[derive(Clone, Debug, Deserialize, Serialize)]
-#[serde(default)]
-pub struct ChannelThreadsConfigResponse {
-    pub enabled: bool,
-    pub config_version: u64,
-    pub ever_enabled: bool,
-    pub guild_basis_points: u32,
-    pub guild_salt: String,
-    pub enabled_guild_ids: Vec<String>,
-    pub disabled_guild_ids: Vec<String>,
-    pub user_basis_points: u32,
-    pub user_salt: String,
-    pub included_user_ids: Vec<String>,
-    pub excluded_user_ids: Vec<String>,
-}
-
-impl Default for ChannelThreadsConfigResponse {
-    fn default() -> Self {
-        Self {
-            enabled: false,
-            config_version: 0,
-            ever_enabled: false,
-            guild_basis_points: 0,
-            guild_salt: CHANNEL_THREADS_DEFAULT_GUILD_SALT.to_owned(),
-            enabled_guild_ids: Vec::new(),
-            disabled_guild_ids: Vec::new(),
-            user_basis_points: 0,
-            user_salt: CHANNEL_THREADS_DEFAULT_USER_SALT.to_owned(),
-            included_user_ids: Vec::new(),
-            excluded_user_ids: Vec::new(),
-        }
-    }
-}
-
-#[derive(Clone, Debug, Default, Serialize)]
-pub struct ChannelThreadsConfigUpdateRequest {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub enabled: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub guild_basis_points: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub guild_salt: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub enabled_guild_ids: Option<Vec<String>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub disabled_guild_ids: Option<Vec<String>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub user_basis_points: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub user_salt: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub included_user_ids: Option<Vec<String>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub excluded_user_ids: Option<Vec<String>>,
-}
-
 #[derive(Clone, Debug, Deserialize, Serialize)]
 #[serde(default)]
 pub struct ExperimentDeliveryConfigResponse {
@@ -827,19 +804,15 @@ pub struct InstanceConfigUpdateRequest {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub media: Option<InstanceMediaUpdateRequest>,
    #[serde(skip_serializing_if = "Option::is_none")]
-    pub push_relay: Option<PushRelayConfigUpdateRequest>,
+    pub voice_noise_suppression: Option<VoiceNoiseSuppressionConfigUpdateRequest>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub push_service_delivery: Option<PushServiceDeliveryConfigUpdateRequest>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub domain_migration: Option<DomainMigrationConfigUpdateRequest>,
    #[serde(skip_serializing_if = "Option::is_none")]
-    pub plutonium_page: Option<PlutoniumPageConfigUpdateRequest>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub captcha: Option<CaptchaConfigUpdateRequest>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub channel_threads: Option<ChannelThreadsConfigUpdateRequest>,
+    pub altcha_captcha: Option<AltchaCaptchaConfigUpdateRequest>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub experiment_delivery: Option<ExperimentDeliveryConfigUpdateRequest>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub billing: Option<InstanceBillingUpdateRequest>,
 }

 #[derive(Clone, Debug, Default, Serialize)]
@@ -851,11 +824,21 @@ pub struct InstancePolicyUpdateRequest {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub direct_messages_disabled: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
-    pub guild_create_access: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
    pub premium_mode: Option<PremiumMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub services: Option<InstanceServicesUpdateRequest>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub deferred_phone_gate: Option<DeferredPhoneGateUpdateRequest>,
+}
+
+#[derive(Clone, Debug, Default, Serialize)]
+pub struct DeferredPhoneGateUpdateRequest {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub enabled: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub window_hours: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub member_threshold: Option<i64>,
 }

 #[derive(Clone, Debug, Default, Serialize)]
@@ -875,6 +858,8 @@ pub struct InstanceIntegrationsUpdateRequest {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub youtube: Option<InstanceYoutubeIntegrationUpdateRequest>,
    #[serde(skip_serializing_if = "Option::is_none")]
+    pub captcha: Option<InstanceCaptchaIntegrationUpdateRequest>,
+    #[serde(skip_serializing_if = "Option::is_none")]
    pub email: Option<InstanceEmailIntegrationUpdateRequest>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub bluesky: Option<InstanceBlueskyIntegrationUpdateRequest>,
@@ -892,6 +877,20 @@ pub struct InstanceYoutubeIntegrationUpdateRequest {
    pub api_key: Option<String>,
 }

+#[derive(Clone, Debug, Default, Serialize)]
+pub struct InstanceCaptchaIntegrationUpdateRequest {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub provider: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub hcaptcha_site_key: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub hcaptcha_secret_key: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub turnstile_site_key: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub turnstile_secret_key: Option<String>,
+}
+
 #[derive(Clone, Debug, Default, Serialize)]
 pub struct InstanceEmailIntegrationUpdateRequest {
    #[serde(skip_serializing_if = "Option::is_none")]
@@ -1022,10 +1021,6 @@ pub struct AppBrandingConfigUpdateRequest {
    pub status_page_url: Option<Option<String>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status_page_incident_history_url: Option<Option<String>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub premium_product_name: Option<Option<String>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub premium_info_url: Option<Option<String>>,
 }

 #[derive(Clone, Debug, Default, Serialize)]
@@ -1131,47 +1126,64 @@ mod tests {
    use serde_json::json;

    #[test]
-    fn default_instance_config_sections_match_the_published_contract() {
+    fn noise_suppression_backend_choices_use_the_generated_wire_contract() {
+        assert_eq!(
+            serde_json::to_value(NoiseSuppressionBackend::ALL).expect("serializable backends"),
+            json!([
+                "none",
+                "standard",
+                "gate",
+                "speex",
+                "rnnoise",
+                "gtcrn",
+                "deep_filter"
+            ])
+        );
+        assert!(serde_json::from_value::<NoiseSuppressionBackend>(json!("deepfilter")).is_err());
+    }
+
+    #[test]
+    fn default_instance_experiment_config_matches_the_published_contract() {
        let schema: serde_json::Value =
            serde_json::from_str(include_str!("../../../openapi-admin.json"))
                .expect("admin schema");
+        let noise = serde_json::from_value::<VoiceNoiseSuppressionConfigResponse>(json!({}))
+            .expect("default noise config");
        let domain_migration = serde_json::from_value::<DomainMigrationConfigResponse>(json!({}))
            .expect("default domain migration config");
-        let plutonium_page = serde_json::from_value::<PlutoniumPageConfigResponse>(json!({}))
-            .expect("default plutonium page config");
-        let captcha = serde_json::from_value::<CaptchaConfigResponse>(json!({}))
-            .expect("default captcha config");
+        let altcha_captcha = serde_json::from_value::<AltchaCaptchaConfigResponse>(json!({}))
+            .expect("default altcha captcha config");
        let delivery = serde_json::from_value::<ExperimentDeliveryConfigResponse>(json!({}))
            .expect("default delivery config");
+        let noise = serde_json::to_value(noise).expect("serializable noise config");
        let domain_migration =
            serde_json::to_value(domain_migration).expect("serializable domain migration config");
-        let plutonium_page =
-            serde_json::to_value(plutonium_page).expect("serializable plutonium page config");
-        let captcha = serde_json::to_value(captcha).expect("serializable captcha config");
+        let altcha_captcha =
+            serde_json::to_value(altcha_captcha).expect("serializable altcha captcha config");
        let delivery = serde_json::to_value(delivery).expect("serializable delivery config");
+        let generated_noise: generated_types::VoiceNoiseSuppressionConfigResponse =
+            serde_json::from_value(noise.clone()).expect("generated noise config contract");
        let generated_domain_migration: generated_types::DomainMigrationConfigResponse =
            serde_json::from_value(domain_migration.clone())
                .expect("generated domain migration config contract");
-        let generated_plutonium_page: generated_types::PlutoniumPageConfigResponse =
-            serde_json::from_value(plutonium_page.clone())
-                .expect("generated plutonium page config contract");
-        let generated_captcha: generated_types::CaptchaConfigResponse =
-            serde_json::from_value(captcha.clone()).expect("generated captcha config contract");
+        let generated_altcha_captcha: generated_types::AltchaCaptchaConfigResponse =
+            serde_json::from_value(altcha_captcha.clone())
+                .expect("generated altcha captcha config contract");
        let generated_delivery: generated_types::ExperimentDeliveryConfigResponse =
            serde_json::from_value(delivery.clone()).expect("generated delivery config contract");
+        assert_eq!(
+            serde_json::to_value(generated_noise).expect("serializable generated noise config"),
+            noise
+        );
        assert_eq!(
            serde_json::to_value(generated_domain_migration)
                .expect("serializable generated domain migration config"),
            domain_migration
        );
        assert_eq!(
-            serde_json::to_value(generated_plutonium_page)
-                .expect("serializable generated plutonium page config"),
-            plutonium_page
-        );
-        assert_eq!(
-            serde_json::to_value(generated_captcha).expect("serializable generated captcha config"),
-            captcha
+            serde_json::to_value(generated_altcha_captcha)
+                .expect("serializable generated altcha captcha config"),
+            altcha_captcha
        );
        assert_eq!(
            serde_json::to_value(generated_delivery)
@@ -1179,9 +1191,9 @@ mod tests {
            delivery
        );
        for (name, value) in [
+            ("VoiceNoiseSuppressionConfigResponse", noise),
            ("DomainMigrationConfigResponse", domain_migration),
-            ("PlutoniumPageConfigResponse", plutonium_page),
-            ("CaptchaConfigResponse", captcha),
+            ("AltchaCaptchaConfigResponse", altcha_captcha),
            ("ExperimentDeliveryConfigResponse", delivery),
        ] {
            for (field, value) in value.as_object().expect("config object") {
@@ -1193,6 +1205,31 @@ mod tests {
        }
    }

+    #[test]
+    fn noise_suppression_update_preserves_empty_lists_and_omitted_fields() {
+        let update = VoiceNoiseSuppressionConfigUpdateRequest {
+            enabled_backends: Some(Vec::new()),
+            included_user_ids: Some(Vec::new()),
+            excluded_user_ids: Some(Vec::new()),
+            guild_overrides: Some(Vec::new()),
+            ..Default::default()
+        };
+        let value = serde_json::to_value(update).expect("serializable update");
+        serde_json::from_value::<generated_types::VoiceNoiseSuppressionConfigUpdateRequest>(
+            value.clone(),
+        )
+        .expect("generated update contract");
+        assert_eq!(
+            value,
+            json!({"enabled_backends": [], "included_user_ids": [], "excluded_user_ids": [], "guild_overrides": []})
+        );
+        assert_eq!(
+            serde_json::to_value(VoiceNoiseSuppressionConfigUpdateRequest::default())
+                .expect("serializable update"),
+            json!({})
+        );
+    }
+
    #[test]
    fn domain_migration_update_preserves_empty_lists_and_omitted_fields() {
        let update = DomainMigrationConfigUpdateRequest {
@@ -1215,25 +1252,4 @@ mod tests {
            json!({})
        );
    }
-
-    #[test]
-    fn plutonium_page_update_preserves_empty_lists_and_omitted_fields() {
-        let update = PlutoniumPageConfigUpdateRequest {
-            included_user_ids: Some(Vec::new()),
-            excluded_user_ids: Some(Vec::new()),
-            ..Default::default()
-        };
-        let value = serde_json::to_value(update).expect("serializable update");
-        serde_json::from_value::<generated_types::PlutoniumPageConfigUpdateRequest>(value.clone())
-            .expect("generated update contract");
-        assert_eq!(
-            value,
-            json!({"included_user_ids": [], "excluded_user_ids": []})
-        );
-        assert_eq!(
-            serde_json::to_value(PlutoniumPageConfigUpdateRequest::default())
-                .expect("serializable update"),
-            json!({})
-        );
-    }
 }
@@ -9,8 +9,6 @@ mod codes;
 mod common;
 mod discovery;
 mod guild_assets;
-mod guild_threads;
-mod instance_billing;
 mod instance_config;
 mod jobs;
 mod limit_config;
@@ -30,8 +28,6 @@ pub use codes::*;
 pub use common::*;
 pub use discovery::*;
 pub use guild_assets::*;
-pub use guild_threads::*;
-pub use instance_billing::*;
 pub use instance_config::*;
 pub use jobs::*;
 pub use limit_config::*;
@@ -4,5 +4,5 @@ use serde::{Deserialize, Serialize};

 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct SendSystemDmResponse {
-    pub recipient_count: Option<i64>,
+    pub recipient_count: i64,
 }
@@ -232,9 +232,3 @@ pub struct WebAuthnCredential {
 }

 pub type WebAuthnCredentialListResponse = Vec<WebAuthnCredential>;
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct PasswordResetLinkResponse {
-    pub url: String,
-    pub expires_at: String,
-}
@@ -5,8 +5,7 @@ use crate::api::generated::{snowflake, types as generated_types};
 use super::client::{AdminApiClient, ApiError, ApiResult};
 use super::types::{
    AdminUser, AdminUserMeResponse, GuildInfo, ListUserGuildsResponse, LookupUserResponse,
-    PasswordResetLinkResponse, SearchUsersResponse, TerminateSessionsResponse,
-    UserMutationResponse,
+    SearchUsersResponse, TerminateSessionsResponse, UserMutationResponse,
 };

 impl AdminApiClient {
@@ -232,9 +231,22 @@ impl AdminApiClient {
        Ok(resp.user)
    }

+    pub async fn update_suspicious_flags(&self, user_id: &str, flags: i32) -> ApiResult<AdminUser> {
+        let body = generated_types::AdminUserSuspiciousActivityFlagsRequest {
+            flags: generated_types::SuspiciousActivityFlags::from(flags),
+        };
+        let response = self
+            .generated()
+            .update_admin_user_suspicious_activity_flags(&snowflake(user_id), &body)
+            .await
+            .map_err(|e| self.generated_error(e))?;
+        let resp: UserMutationResponse = self.generated_value(response.into_inner())?;
+        Ok(resp.user)
+    }
+
    pub async fn set_user_acls(&self, user_id: &str, acls: &[String]) -> ApiResult<AdminUser> {
        let body = generated_types::AdminUserAclsRequest {
-            acls: super::admin_api_keys::parse_acls(acls),
+            acls: super::admin_api_keys::parse_acls(acls)?,
        };
        let response = self
            .generated()
@@ -284,6 +296,21 @@ impl AdminApiClient {
        Ok(resp.user)
    }

+    pub async fn update_has_verified_phone(
+        &self,
+        user_id: &str,
+        has_verified_phone: bool,
+    ) -> ApiResult<AdminUser> {
+        let body = generated_types::AdminUserPhoneVerificationRequest { has_verified_phone };
+        let response = self
+            .generated()
+            .update_admin_user_phone_verification(&snowflake(user_id), &body)
+            .await
+            .map_err(|e| self.generated_error(e))?;
+        let resp: UserMutationResponse = self.generated_value(response.into_inner())?;
+        Ok(resp.user)
+    }
+
    pub async fn clear_user_fields(
        &self,
        user_id: &str,
@@ -306,6 +333,28 @@ impl AdminApiClient {
        Ok(resp.user)
    }

+    pub async fn set_bot_status(&self, user_id: &str, is_bot: bool) -> ApiResult<AdminUser> {
+        let body = generated_types::AdminUserBotStatusRequest { bot: is_bot };
+        let response = self
+            .generated()
+            .set_admin_user_bot_status(&snowflake(user_id), &body)
+            .await
+            .map_err(|e| self.generated_error(e))?;
+        let resp: UserMutationResponse = self.generated_value(response.into_inner())?;
+        Ok(resp.user)
+    }
+
+    pub async fn set_system_status(&self, user_id: &str, is_system: bool) -> ApiResult<AdminUser> {
+        let body = generated_types::AdminUserSystemStatusRequest { system: is_system };
+        let response = self
+            .generated()
+            .set_admin_user_system_status(&snowflake(user_id), &body)
+            .await
+            .map_err(|e| self.generated_error(e))?;
+        let resp: UserMutationResponse = self.generated_value(response.into_inner())?;
+        Ok(resp.user)
+    }
+
    pub async fn change_username(
        &self,
        user_id: &str,
@@ -344,14 +393,12 @@ impl AdminApiClient {
        user_id: &str,
        duration_hours: u32,
        reason: Option<&str>,
-        notify_user: bool,
        private_reason: Option<&str>,
    ) -> ApiResult<AdminUser> {
        let body = generated_types::AdminUserBanRequest {
            duration_hours: i32::try_from(duration_hours)
                .map_err(|e| ApiError::Parse(e.to_string()))?
                .into(),
-            notify_user,
            reason: reason.map(std::borrow::ToOwned::to_owned),
        };
        let resp: UserMutationResponse = self
@@ -364,20 +411,10 @@ impl AdminApiClient {
        Ok(resp.user)
    }

-    pub async fn unban_user(
-        &self,
-        user_id: &str,
-        public_reason: Option<&str>,
-        notify_user: bool,
-        private_reason: Option<&str>,
-    ) -> ApiResult<AdminUser> {
-        let body = generated_types::AdminUserUnbanRequest {
-            notify_user,
-            public_reason: public_reason.map(std::borrow::ToOwned::to_owned),
-        };
+    pub async fn unban_user(&self, user_id: &str) -> ApiResult<AdminUser> {
        let response = self
-            .generated_with_reason(private_reason)?
-            .unban_admin_user(&snowflake(user_id), &body)
+            .generated()
+            .unban_admin_user(&snowflake(user_id))
            .await
            .map_err(|e| self.generated_error(e))?;
        let resp: UserMutationResponse = self.generated_value(response.into_inner())?;
@@ -390,7 +427,6 @@ impl AdminApiClient {
        reason_code: i32,
        public_reason: Option<&str>,
        days_until_deletion: u32,
-        notify_user: bool,
        audit_log_reason: Option<&str>,
    ) -> ApiResult<AdminUser> {
        let body = generated_types::AdminUserDeletionScheduleRequest {
@@ -400,11 +436,9 @@ impl AdminApiClient {
            )
            .map_err(ApiError::Parse)?
            .into(),
-            notify_user,
            public_reason: public_reason.map(std::borrow::ToOwned::to_owned),
            reason_code: crate::api::generated::deletion_reason_code(reason_code, "reason_code")
                .map_err(ApiError::Parse)?,
-            replace_pending_deletion_at: None,
        };
        let response = self
            .generated_with_reason(audit_log_reason)?
@@ -415,44 +449,16 @@ impl AdminApiClient {
        Ok(resp.user)
    }

-    pub async fn cancel_deletion(
-        &self,
-        user_id: &str,
-        expected_pending_deletion_at: &str,
-        notify_user: bool,
-        audit_log_reason: Option<&str>,
-    ) -> ApiResult<AdminUser> {
-        let body = serde_json::json!({
-            "expected_pending_deletion_at": expected_pending_deletion_at,
-            "notify_user": notify_user,
-        });
-        let resp: UserMutationResponse = self
-            .delete_with_reason(
-                &format!("/admin/users/{}/deletion", urlencoding::encode(user_id)),
-                Some(&body),
-                audit_log_reason,
-            )
-            .await?;
+    pub async fn cancel_deletion(&self, user_id: &str) -> ApiResult<AdminUser> {
+        let response = self
+            .generated()
+            .cancel_admin_user_deletion(&snowflake(user_id))
+            .await
+            .map_err(|e| self.generated_error(e))?;
+        let resp: UserMutationResponse = self.generated_value(response.into_inner())?;
        Ok(resp.user)
    }

-    pub async fn annotate_ban(
-        &self,
-        user_id: &str,
-        ban_audit_log_id: &str,
-        note: &str,
-    ) -> ApiResult<()> {
-        let body = serde_json::json!({
-            "ban_audit_log_id": ban_audit_log_id,
-            "note": note,
-        });
-        self.post_void(
-            &format!("/admin/users/{}/ban/notes", urlencoding::encode(user_id)),
-            Some(&body),
-        )
-        .await
-    }
-
    pub async fn change_dob(&self, user_id: &str, dob: &str) -> ApiResult<AdminUser> {
        let body = generated_types::AdminUserDobUpdateRequest {
            date_of_birth: dob.to_owned(),
@@ -474,26 +480,6 @@ impl AdminApiClient {
        Ok(())
    }

-    pub async fn create_password_reset_link(
-        &self,
-        user_id: &str,
-    ) -> ApiResult<PasswordResetLinkResponse> {
-        let response = self
-            .generated()
-            .create_admin_user_password_reset_link(&snowflake(user_id))
-            .await
-            .map_err(|e| self.generated_error(e))?;
-        self.generated_value(response.into_inner())
-    }
-
-    pub async fn revoke_recovery_kit(&self, user_id: &str) -> ApiResult<()> {
-        self.generated()
-            .revoke_admin_user_recovery_kit(&snowflake(user_id))
-            .await
-            .map_err(|e| self.generated_error(e))?;
-        Ok(())
-    }
-
    pub async fn remove_relationship(
        &self,
        user_id: &str,
@@ -1,9 +1,7 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later

-use fluxer_common::config::{
-    normalize_base_path, normalize_public_endpoint_from_env, read_bool_env, read_env,
-    read_first_env, trim_trailing_slash,
-};
+use fluxer_common::config::normalize_public_endpoint_from_env;
+use std::env;

 const DEFAULT_ADMIN_OAUTH_CLIENT_ID: &str = "1234567890123456789";

@@ -19,10 +17,12 @@ pub struct AdminConfig {
    pub static_cdn_endpoint: String,
    pub admin_endpoint: String,
    pub web_app_endpoint: String,
+    pub kv_url: String,
    pub oauth_client_id: String,
    pub oauth_client_secret: String,
    pub oauth_redirect_uri: String,
    pub build_version: String,
+    pub release_channel: String,
    pub self_hosted: bool,
    pub proxy: ProxyConfig,
 }
@@ -47,8 +47,8 @@ impl AdminConfig {
            "FLUXER_ADMIN_ENDPOINT",
            "https://admin.fluxer.app",
        )));
-        let oauth_redirect_uri = normalize_public_endpoint_from_env(&read_env(
-            "FLUXER_ADMIN_OAUTH_REDIRECT_URI",
+        let oauth_redirect_uri = normalize_public_endpoint_from_env(&read_env_preferred(
+            &["FLUXER_ADMIN_OAUTH_REDIRECT_URI"],
            &format!("{admin_endpoint}/oauth2_callback"),
        ));
        let secret_key_base = read_env("FLUXER_ADMIN_SECRET_KEY_BASE", "");
@@ -82,22 +82,38 @@ impl AdminConfig {
                "FLUXER_APP_ENDPOINT",
                "https://app.fluxer.app",
            ))),
+            kv_url: read_env("FLUXER_KV_URL", ""),
            oauth_client_id: read_env(
                "FLUXER_ADMIN_OAUTH_CLIENT_ID",
                DEFAULT_ADMIN_OAUTH_CLIENT_ID,
            ),
            oauth_client_secret: read_env("FLUXER_ADMIN_OAUTH_CLIENT_SECRET", ""),
            oauth_redirect_uri,
-            build_version: read_first_env(
+            build_version: read_env_preferred(
                &["BUILD_VERSION", "FLUXER_BUILD_VERSION"],
                env!("CARGO_PKG_VERSION"),
            ),
-            self_hosted: read_bool_env("FLUXER_SELF_HOSTED", false),
+            release_channel: read_env_preferred(
+                &["RELEASE_CHANNEL", "FLUXER_RELEASE_CHANNEL"],
+                "stable",
+            ),
+            self_hosted: read_bool_env(&["FLUXER_SELF_HOSTED"], false),
            proxy: ProxyConfig {
-                trust_client_ip_header: read_bool_env("FLUXER_TRUST_CLIENT_IP_HEADER", false),
-                client_ip_header_name: read_env("FLUXER_CLIENT_IP_HEADER_NAME", "x-forwarded-for")
-                    .trim()
-                    .to_ascii_lowercase(),
+                trust_client_ip_header: read_bool_env(
+                    &["FLUXER_TRUST_CLIENT_IP_HEADER", "TRUST_CLIENT_IP_HEADER"],
+                    false,
+                ),
+                client_ip_header_name: read_env_preferred(
+                    &[
+                        "FLUXER_CLIENT_IP_HEADER_NAME",
+                        "FLUXER_CLIENT_IP_HEADER",
+                        "CLIENT_IP_HEADER_NAME",
+                        "CLIENT_IP_HEADER",
+                    ],
+                    "x-forwarded-for",
+                )
+                .trim()
+                .to_ascii_lowercase(),
            },
        })
    }
@@ -130,21 +146,55 @@ impl RuntimeEnv {
    }
 }

+pub fn normalize_base_path(value: &str) -> String {
+    let trimmed = value.trim().trim_matches('/');
+    if trimmed.is_empty() {
+        String::new()
+    } else {
+        format!("/{trimmed}")
+    }
+}
+
+pub fn trim_trailing_slash(value: &str) -> String {
+    value.trim_end_matches('/').to_owned()
+}
+
+pub(crate) fn read_env(name: &str, fallback: &str) -> String {
+    env::var(name).unwrap_or_else(|_| fallback.to_owned())
+}
+
+pub(crate) fn read_env_preferred(names: &[&str], fallback: &str) -> String {
+    names
+        .iter()
+        .find_map(|name| env::var(name).ok().filter(|value| !value.trim().is_empty()))
+        .unwrap_or_else(|| fallback.to_owned())
+}
+
+pub(crate) fn read_bool_env(names: &[&str], fallback: bool) -> bool {
+    let Some(value) = names.iter().find_map(|name| env::var(name).ok()) else {
+        return fallback;
+    };
+    matches!(
+        value.trim().to_ascii_lowercase().as_str(),
+        "1" | "true" | "yes" | "on"
+    )
+}
+
 #[cfg(test)]
 mod tests {
    use super::*;
-    use std::env;
    use std::sync::Mutex;

    static ENV_LOCK: Mutex<()> = Mutex::new(());

-    const MANAGED_ENV: [&str; 10] = [
+    const MANAGED_ENV: [&str; 11] = [
        "FLUXER_ENV",
        "FLUXER_ADMIN_HOST",
        "FLUXER_ADMIN_PORT",
        "FLUXER_ADMIN_ENDPOINT",
        "FLUXER_ADMIN_OAUTH_CLIENT_ID",
        "FLUXER_ADMIN_OAUTH_REDIRECT_URI",
+        "FLUXER_MASTER_CONFIG",
        "FLUXER_APP_ENDPOINT",
        "FLUXER_MEDIA_ENDPOINT",
        "FLUXER_STATIC_CDN_ENDPOINT",
@@ -241,10 +291,12 @@ mod tests {

            admin_endpoint: String::new(),
            web_app_endpoint: String::new(),
+            kv_url: String::new(),
            oauth_client_id: String::new(),
            oauth_client_secret: String::new(),
            oauth_redirect_uri: String::new(),
            build_version: String::new(),
+            release_channel: String::new(),
            self_hosted: false,
            proxy: ProxyConfig {
                trust_client_ip_header: false,
@@ -269,10 +321,12 @@ mod tests {

            admin_endpoint: String::new(),
            web_app_endpoint: String::new(),
+            kv_url: String::new(),
            oauth_client_id: String::new(),
            oauth_client_secret: String::new(),
            oauth_redirect_uri: String::new(),
            build_version: String::new(),
+            release_channel: String::new(),
            self_hosted: false,
            proxy: ProxyConfig {
                trust_client_ip_header: false,
@@ -2,7 +2,6 @@

 pub mod acl;
 pub mod admin_flags;
-pub mod admin_hints;
 pub mod api;
 pub mod config;
 pub mod fonts;
@@ -8,7 +8,9 @@ use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
    tracing_subscriber::registry()
-        .with(fluxer_common::config::env_filter("info"))
+        .with(
+            tracing_subscriber::EnvFilter::try_from_default_env().unwrap_or_else(|_| "info".into()),
+        )
        .with(tracing_subscriber::fmt::layer())
        .init();

@@ -1,25 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-
-use crate::{
-    api::client::AdminApiClient, middleware::auth::AuthContext, state::AppState,
-    utils::user_tag::with_unique_usernames,
-};
-use axum::{
-    extract::{Request, State},
-    middleware::Next,
-    response::Response,
-};
-
-pub async fn scope_account_identity(
-    State(state): State<AppState>,
-    request: Request,
-    next: Next,
-) -> Response {
-    let Some(auth) = request.extensions().get::<AuthContext>() else {
-        return next.run(request).await;
-    };
-    let client = AdminApiClient::new(state.http_client(), state.config(), &auth.session);
-    let settings = state.account_identity_settings(&client).await;
-    let unique_usernames = settings.mode.is_username() || settings.tag_style.is_none();
-    with_unique_usernames(unique_usernames, next.run(request)).await
-}
@@ -215,10 +215,12 @@ mod tests {
            static_cdn_endpoint: String::new(),
            admin_endpoint: admin_endpoint.to_owned(),
            web_app_endpoint: String::new(),
+            kv_url: String::new(),
            oauth_client_id: String::new(),
            oauth_client_secret: String::new(),
            oauth_redirect_uri: String::new(),
            build_version: "test".to_owned(),
+            release_channel: String::new(),
            self_hosted: false,
            proxy: ProxyConfig {
                trust_client_ip_header: false,
@@ -1,6 +1,5 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later

-pub mod account_identity;
 pub mod auth;
 pub mod csrf;
 pub mod error_handler;
@@ -1,10 +1,7 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later

 use crate::{
-    api::{
-        client::{AdminApiClient, ApiError},
-        types::FlashMessage,
-    },
+    api::client::AdminApiClient,
    middleware::{auth::AuthContext, csrf, htmx},
    state::AppState,
    templates,
@@ -16,18 +13,20 @@ use axum::{
    response::{Html, IntoResponse, Response},
    routing::get,
 };
-use serde::Deserialize;

 use super::ActionQuery;
 use super::bans_actions::{
    BanFormData, custom_flash, execute_ban, extract_value, flash_response, render_inline_flash,
-    to_flash,
 };

 pub fn router() -> Router<AppState> {
    Router::new()
        .route("/ip-bans", get(ip_bans).post(ip_bans_post))
        .route("/email-bans", get(email_bans).post(email_bans_post))
+        .route(
+            "/suspicious-email-domains",
+            get(suspicious_email_domains).post(suspicious_email_domains_post),
+        )
        .route("/phrase-bans", get(phrase_bans).post(phrase_bans_post))
        .route("/url-bans", get(url_bans).post(url_bans_post))
        .route(
@@ -48,41 +47,17 @@ pub fn router() -> Router<AppState> {
        )
 }

-async fn render_ban_page(
-    state: &AppState,
-    auth: &AuthContext,
-    key: &str,
-    csrf_token: String,
-) -> Response {
+fn render_ban_page(state: &AppState, auth: &AuthContext, key: &str, req: &Request) -> Response {
    let config = state.config();
    let ban_cfg = match templates::pages::bans::get_ban_config(key) {
        Some(c) => c,
        None => return axum::http::StatusCode::NOT_FOUND.into_response(),
    };
-    let username_sign_in = email_bans_on_username_instance(state, auth, key).await;
-    let markup = templates::pages::bans::bans_page(
-        config,
-        auth,
-        ban_cfg,
-        None,
-        &csrf_token,
-        username_sign_in,
-    );
+    let csrf_token = csrf::get_csrf_token(req);
+    let markup = templates::pages::bans::bans_page(config, auth, ban_cfg, None, &csrf_token);
    Html(markup.into_string()).into_response()
 }

-async fn email_bans_on_username_instance(state: &AppState, auth: &AuthContext, key: &str) -> bool {
-    key == "email-bans"
-        && state
-            .account_identity(&AdminApiClient::new(
-                state.http_client(),
-                state.config(),
-                &auth.session,
-            ))
-            .await
-            .is_username()
-}
-
 macro_rules! ban_get {
    ($name:ident, $key:expr) => {
        async fn $name(
@@ -90,14 +65,14 @@ macro_rules! ban_get {
            auth: axum::Extension<AuthContext>,
            request: Request,
        ) -> Response {
-            let csrf_token = csrf::get_csrf_token(&request);
-            render_ban_page(&state, &auth.0, $key, csrf_token).await
+            render_ban_page(&state, &auth.0, $key, &request)
        }
    };
 }

 ban_get!(ip_bans, "ip-bans");
 ban_get!(email_bans, "email-bans");
+ban_get!(suspicious_email_domains, "suspicious-email-domains");
 ban_get!(phrase_bans, "phrase-bans");
 ban_get!(url_bans, "url-bans");
 ban_get!(file_sha_bans, "file-sha-bans");
@@ -120,18 +95,17 @@ async fn generic_ban_post(
    };
    let value = extract_value(form, ban_cfg.input_name);
    let is_htmx = htmx::is_htmx_request(headers);
-    let (level, msg) = execute_ban(&client, ban_key, action, &value, form).await;
-    let username_sign_in = !is_htmx && email_bans_on_username_instance(state, auth, ban_key).await;
-    flash_response(
-        config,
-        auth,
-        is_htmx,
-        level,
-        &msg,
-        ban_cfg,
-        csrf_token,
-        username_sign_in,
+    let (level, msg) = execute_ban(
+        &client,
+        ban_key,
+        action,
+        &value,
+        form.hashes.as_deref(),
+        form.sha256_list.as_deref(),
+        form.audit_log_reason.as_deref(),
    )
+    .await;
+    flash_response(config, auth, is_htmx, level, &msg, ban_cfg, csrf_token)
 }

 macro_rules! ban_post {
@@ -149,18 +123,14 @@ macro_rules! ban_post {
            let form: BanFormData = match Form::from_request(request, &state).await {
                Ok(Form(f)) => f,
                Err(_) => {
-                    let is_htmx = htmx::is_htmx_request(&headers);
-                    let username_sign_in =
-                        !is_htmx && email_bans_on_username_instance(&state, &auth.0, $key).await;
                    return flash_response(
                        state.config(),
                        &auth.0,
-                        is_htmx,
+                        htmx::is_htmx_request(&headers),
                        "error",
                        "Invalid form data",
                        templates::pages::bans::get_ban_config($key).unwrap(),
                        &csrf_token,
-                        username_sign_in,
                    );
                }
            };
@@ -171,61 +141,22 @@ macro_rules! ban_post {

 ban_post!(ip_bans_post, "ip-bans");
 ban_post!(email_bans_post, "email-bans");
+ban_post!(suspicious_email_domains_post, "suspicious-email-domains");
 ban_post!(phrase_bans_post, "phrase-bans");
 ban_post!(url_bans_post, "url-bans");
 ban_post!(file_sha_bans_post, "file-sha-bans");
 ban_post!(avatar_hash_bans_post, "avatar-hash-bans");

-#[derive(Deserialize)]
-struct UrlDomainListQuery {
-    after: Option<String>,
-}
-
-async fn render_url_domain_page(
-    state: &AppState,
-    auth: &AuthContext,
-    flash: Option<&FlashMessage>,
-    csrf_token: &str,
-    after: Option<&str>,
-) -> Response {
-    let config = state.config();
-    let client = AdminApiClient::new(state.http_client(), config, &auth.session);
-    let entries = match client.list_url_domain_entries(after).await {
-        Ok(page) => Some(page),
-        Err(error) => {
-            tracing::warn!(%error, "admin API request failed: list URL domain blocklist");
-            None
-        }
-    };
-    let markup = templates::pages::url_domain_bans::url_domain_bans_page(
-        config,
-        auth,
-        flash,
-        csrf_token,
-        entries.as_ref(),
-    );
-    Html(markup.into_string()).into_response()
-}
-
-fn ban_url_domain_error(domain: &str, error: &ApiError) -> String {
-    match error {
-        ApiError::Http { status: 400, .. } => {
-            format!("Failed to ban {domain}: not a valid domain, or the pattern is too broad")
-        }
-        _ => format!("Failed to ban {domain}"),
-    }
-}
-
 async fn url_domain_bans(
    State(state): State<AppState>,
    auth: axum::Extension<AuthContext>,
    request: Request,
 ) -> Response {
+    let config = state.config();
    let csrf_token = csrf::get_csrf_token(&request);
-    let Query(query): Query<UrlDomainListQuery> =
-        Query::try_from_uri(request.uri()).unwrap_or(Query(UrlDomainListQuery { after: None }));
-    let after = query.after.as_deref().filter(|value| !value.is_empty());
-    render_url_domain_page(&state, &auth.0, None, &csrf_token, after).await
+    let markup =
+        templates::pages::url_domain_bans::url_domain_bans_page(config, &auth.0, None, &csrf_token);
+    Html(markup.into_string()).into_response()
 }

 async fn url_domain_bans_post(
@@ -256,10 +187,10 @@ async fn url_domain_bans_post(
                .ban_url_domain(&domain, m_sub, form.audit_log_reason.as_deref())
                .await
            {
-                Ok(()) => ("success", format!("{domain} banned successfully")),
+                Ok(()) => ("success", format!("Domain {domain} banned successfully")),
                Err(error) => {
                    tracing::warn!(%error, domain, "admin API request failed: ban URL domain");
-                    ("error", ban_url_domain_error(&domain, &error))
+                    ("error", format!("Failed to ban domain {domain}"))
                }
            }
        }
@@ -267,15 +198,15 @@ async fn url_domain_bans_post(
            .unban_url_domain(&domain, form.audit_log_reason.as_deref())
            .await
        {
-            Ok(()) => ("success", format!("{domain} unbanned")),
+            Ok(()) => ("success", format!("Domain {domain} unbanned")),
            Err(error) => {
                tracing::warn!(%error, domain, "admin API request failed: unban URL domain");
-                ("error", format!("Failed to unban {domain}"))
+                ("error", format!("Failed to unban domain {domain}"))
            }
        },
        "check" => match client.check_url_domain_ban(&domain).await {
-            Ok(r) if r.banned => ("info", format!("{domain} is blocked")),
-            Ok(_) => ("info", format!("{domain} is NOT blocked")),
+            Ok(r) if r.banned => ("info", format!("Domain {domain} is banned")),
+            Ok(_) => ("info", format!("Domain {domain} is NOT banned")),
            Err(error) => {
                tracing::warn!(%error, domain, "admin API request failed: check URL domain ban");
                ("error", "Error checking ban status".into())
@@ -283,11 +214,15 @@ async fn url_domain_bans_post(
        },
        _ => ("error", "Unknown action".into()),
    };
-    if is_htmx {
-        return render_inline_flash(level, &msg);
-    }
-    let flash = to_flash(level, &msg);
-    render_url_domain_page(&state, &auth.0, Some(&flash), &csrf_token, None).await
+    custom_flash(
+        config,
+        &auth.0,
+        is_htmx,
+        level,
+        &msg,
+        &csrf_token,
+        "url-domain",
+    )
 }

 async fn profile_substring_bans(
@@ -359,5 +294,13 @@ async fn profile_substring_bans_post(
        },
        _ => ("error", "Unknown action".into()),
    };
-    custom_flash(config, &auth.0, is_htmx, level, &msg, &csrf_token)
+    custom_flash(
+        config,
+        &auth.0,
+        is_htmx,
+        level,
+        &msg,
+        &csrf_token,
+        "profile-substring",
+    )
 }
@@ -34,8 +34,6 @@ pub struct BanFormData {
    #[serde(default)]
    pub substring: Option<String>,
    #[serde(default)]
-    pub duration_hours: Option<String>,
-    #[serde(default)]
    pub audit_log_reason: Option<String>,
    #[serde(default)]
    pub _csrf: Option<String>,
@@ -60,12 +58,10 @@ pub async fn execute_ban(
    ban_type: &str,
    action: &str,
    value: &str,
-    form: &BanFormData,
+    bulk_hashes: Option<&str>,
+    bulk_sha256_list: Option<&str>,
+    audit_log_reason: Option<&str>,
 ) -> (&'static str, String) {
-    let bulk_hashes = form.hashes.as_deref();
-    let bulk_sha256_list = form.sha256_list.as_deref();
-    let duration_hours = form.duration_hours.as_deref();
-    let audit_log_reason = form.audit_log_reason.as_deref();
    if (action == "bulk-ban" || action == "bulk-ban-files") && ban_type == "file-sha-bans" {
        let raw_hashes = if action == "bulk-ban-files" {
            bulk_sha256_list
@@ -78,9 +74,6 @@ pub async fn execute_ban(
        return ("error", "Value is required".into());
    }
    match action {
-        "ban" if ban_type == "ip-bans" => {
-            execute_ip_ban(client, value, duration_hours, audit_log_reason).await
-        }
        "ban" => execute_single_ban(client, ban_type, value, audit_log_reason).await,
        "unban" => execute_single_unban(client, ban_type, value, audit_log_reason).await,
        "check" => execute_check(client, ban_type, value).await,
@@ -114,34 +107,6 @@ async fn execute_bulk_ban(
    }
 }

-async fn execute_ip_ban(
-    client: &AdminApiClient,
-    value: &str,
-    duration_hours: Option<&str>,
-    audit_log_reason: Option<&str>,
-) -> (&'static str, String) {
-    let duration_hours = match duration_hours.map(str::trim).filter(|v| !v.is_empty()) {
-        None => 0,
-        Some(raw) => match raw.parse::<u32>() {
-            Ok(hours) => hours,
-            Err(_) => return ("error", "Invalid ban duration".into()),
-        },
-    };
-    let success_message = if duration_hours == 0 {
-        format!("{value} banned permanently")
-    } else {
-        format!(
-            "{value} banned for {}",
-            crate::templates::pages::bans::ip_ban_duration_label(duration_hours)
-        )
-    };
-    ban_action_result(
-        client.ban_ip(value, duration_hours, audit_log_reason).await,
-        success_message,
-        format!("Failed to ban {value}"),
-    )
-}
-
 async fn execute_single_ban(
    client: &AdminApiClient,
    ban_type: &str,
@@ -149,7 +114,13 @@ async fn execute_single_ban(
    audit_log_reason: Option<&str>,
 ) -> (&'static str, String) {
    let result = match ban_type {
+        "ip-bans" => client.ban_ip(value, audit_log_reason).await,
        "email-bans" => client.ban_email(value, audit_log_reason).await,
+        "suspicious-email-domains" => {
+            client
+                .add_suspicious_email_domain(value, audit_log_reason)
+                .await
+        }
        "phrase-bans" => client.ban_phrase(value, audit_log_reason).await,
        "url-bans" => client.ban_url(value, audit_log_reason).await,
        "file-sha-bans" => client.ban_file_sha(value, audit_log_reason).await,
@@ -172,6 +143,11 @@ async fn execute_single_unban(
    let result = match ban_type {
        "ip-bans" => client.unban_ip(value, audit_log_reason).await,
        "email-bans" => client.unban_email(value, audit_log_reason).await,
+        "suspicious-email-domains" => {
+            client
+                .remove_suspicious_email_domain(value, audit_log_reason)
+                .await
+        }
        "phrase-bans" => client.unban_phrase(value, audit_log_reason).await,
        "url-bans" => client.unban_url(value, audit_log_reason).await,
        "file-sha-bans" => client.unban_file_sha(value, audit_log_reason).await,
@@ -193,6 +169,7 @@ async fn execute_check(
    let result = match ban_type {
        "ip-bans" => client.check_ip_ban(value).await,
        "email-bans" => client.check_email_ban(value).await,
+        "suspicious-email-domains" => client.check_suspicious_email_domain(value).await,
        "phrase-bans" => client.check_phrase_ban(value).await,
        "url-bans" => client.check_url_ban(value).await,
        "file-sha-bans" => client.check_file_sha_ban(value).await,
@@ -200,10 +177,7 @@ async fn execute_check(
        _ => return ("error", "Unknown ban type".into()),
    };
    match result {
-        Ok(r) if r.banned => match r.expires_at {
-            Some(expires_at) => ("info", format!("{value} is banned until {expires_at}")),
-            None => ("info", format!("{value} is banned")),
-        },
+        Ok(r) if r.banned => ("info", format!("{value} is banned")),
        Ok(_) => ("info", format!("{value} is NOT banned")),
        Err(error) => {
            tracing::warn!(%error, ban_type, value, "admin API request failed: check ban status");
@@ -226,7 +200,6 @@ fn ban_action_result(
    }
 }

-#[allow(clippy::too_many_arguments)]
 pub fn flash_response(
    config: &crate::config::AdminConfig,
    auth: &AuthContext,
@@ -235,20 +208,13 @@ pub fn flash_response(
    message: &str,
    ban_cfg: &templates::pages::bans::BanConfig,
    csrf_token: &str,
-    username_sign_in: bool,
 ) -> Response {
    if is_htmx {
        render_inline_flash(level, message)
    } else {
        let flash = to_flash(level, message);
-        let markup = templates::pages::bans::bans_page(
-            config,
-            auth,
-            ban_cfg,
-            Some(&flash),
-            csrf_token,
-            username_sign_in,
-        );
+        let markup =
+            templates::pages::bans::bans_page(config, auth, ban_cfg, Some(&flash), csrf_token);
        Html(markup.into_string()).into_response()
    }
 }
@@ -288,16 +254,25 @@ pub fn custom_flash(
    level: &str,
    message: &str,
    csrf_token: &str,
+    page_type: &str,
 ) -> Response {
    if is_htmx {
        return render_inline_flash(level, message);
    }
    let flash = to_flash(level, message);
-    let markup = templates::pages::profile_substring_bans::profile_substring_bans_page(
-        config,
-        auth,
-        Some(&flash),
-        csrf_token,
-    );
+    let markup = match page_type {
+        "url-domain" => templates::pages::url_domain_bans::url_domain_bans_page(
+            config,
+            auth,
+            Some(&flash),
+            csrf_token,
+        ),
+        _ => templates::pages::profile_substring_bans::profile_substring_bans_page(
+            config,
+            auth,
+            Some(&flash),
+            csrf_token,
+        ),
+    };
    Html(markup.into_string()).into_response()
 }
@@ -1,597 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-
-use crate::{
-    api::{
-        client::ApiError,
-        types::{
-            AppBrandingConfigUpdateRequest, AppPublicConfigUpdateRequest,
-            BILLING_MAX_COUNTRY_CURRENCIES, BILLING_MAX_CURRENCIES,
-            BILLING_MAX_LEGACY_PRICES_PER_SLOT, BILLING_MAX_LEGACY_SLOTS, BILLING_PRICE_SLOTS,
-            BillingPriceSet, InstanceBillingUpdateRequest, InstanceConfigUpdateRequest,
-            PREMIUM_PRODUCT_NAME_MAX_CHARS, TRI_STATE_DEFAULT, TRI_STATE_OFF, TRI_STATE_ON,
-        },
-    },
-    middleware::flash::FlashData,
-    utils::forms::MultiValueForm,
-};
-use std::collections::BTreeMap;
-
-const PRICE_ID_MAX_CHARS: usize = 255;
-const INFO_URL_MAX_CHARS: usize = 2048;
-
-pub(super) fn build_billing_update(
-    form: &MultiValueForm,
-) -> Result<InstanceConfigUpdateRequest, String> {
-    let premium_product_name = if form.contains_key("billing_premium_product_name") {
-        Some(parse_premium_product_name(
-            form.clean("billing_premium_product_name"),
-        )?)
-    } else {
-        None
-    };
-    let premium_info_url = if form.contains_key("billing_premium_info_url") {
-        Some(parse_info_url(form.clean("billing_premium_info_url"))?)
-    } else {
-        None
-    };
-    let branding = (premium_product_name.is_some() || premium_info_url.is_some()).then(|| {
-        AppBrandingConfigUpdateRequest {
-            premium_product_name,
-            premium_info_url,
-            ..Default::default()
-        }
-    });
-    let prices = if form.contains_key("billing_price_currency") {
-        Some(parse_price_rows(form)?)
-    } else {
-        None
-    };
-    let default_currency = if form.contains_key("billing_default_currency") {
-        Some(
-            form.clean("billing_default_currency")
-                .map(|value| parse_currency(&value))
-                .transpose()?,
-        )
-    } else {
-        None
-    };
-    let country_currencies = if form.contains_key("billing_country_currencies") {
-        Some(parse_country_currencies(
-            form.first("billing_country_currencies").unwrap_or(""),
-        )?)
-    } else {
-        None
-    };
-    let legacy_prices = if form.contains_key("billing_legacy_prices") {
-        Some(parse_legacy_prices(
-            form.first("billing_legacy_prices").unwrap_or(""),
-        )?)
-    } else {
-        None
-    };
-    if let Some(Some(prices)) = &prices {
-        if let Some(Some(currency)) = &default_currency
-            && !prices.contains_key(currency)
-        {
-            return Err(format!(
-                "Default currency {currency} has no row in the price table"
-            ));
-        }
-        if let Some(Some(countries)) = &country_currencies
-            && let Some((country, currency)) = countries
-                .iter()
-                .find(|(_, currency)| !prices.contains_key(*currency))
-        {
-            return Err(format!(
-                "{country} maps to {currency}, which has no row in the price table"
-            ));
-        }
-    }
-    Ok(InstanceConfigUpdateRequest {
-        app_public: branding.map(|branding| AppPublicConfigUpdateRequest {
-            branding: Some(branding),
-            ..Default::default()
-        }),
-        billing: Some(InstanceBillingUpdateRequest {
-            enabled: parse_tri_state(form, "billing_enabled")?,
-            stripe_secret_key: secret_update(
-                form,
-                "billing_stripe_secret_key",
-                "billing_clear_stripe_secret_key",
-            ),
-            stripe_webhook_secret: secret_update(
-                form,
-                "billing_stripe_webhook_secret",
-                "billing_clear_stripe_webhook_secret",
-            ),
-            default_currency,
-            prices,
-            country_currencies,
-            legacy_prices,
-            automatic_tax: parse_tri_state(form, "billing_automatic_tax")?,
-            tax_id_collection: parse_tri_state(form, "billing_tax_id_collection")?,
-            terms_consent_required: parse_tri_state(form, "billing_terms_consent_required")?,
-        }),
-        ..Default::default()
-    })
-}
-
-fn parse_tri_state(form: &MultiValueForm, key: &str) -> Result<Option<Option<bool>>, String> {
-    if !form.contains_key(key) {
-        return Ok(None);
-    }
-    match form.first(key).map(str::trim).unwrap_or("") {
-        TRI_STATE_DEFAULT => Ok(Some(None)),
-        TRI_STATE_ON => Ok(Some(Some(true))),
-        TRI_STATE_OFF => Ok(Some(Some(false))),
-        other => Err(format!("Invalid choice \"{other}\" for {key}")),
-    }
-}
-
-pub(super) fn billing_result<T>(result: Result<T, ApiError>) -> FlashData {
-    match result {
-        Ok(_) => FlashData::success("Premium and billing settings updated"),
-        Err(error) => {
-            tracing::warn!(%error, "admin API request failed: update billing config");
-            match validation_message(&error) {
-                Some(message) => FlashData::error(format!(
-                    "Failed to update premium and billing settings: {message}"
-                )),
-                None => FlashData::error("Failed to update premium and billing settings"),
-            }
-        }
-    }
-}
-
-fn validation_message(error: &ApiError) -> Option<String> {
-    let ApiError::Http {
-        status: 400,
-        message,
-    } = error
-    else {
-        return None;
-    };
-    let body: serde_json::Value = serde_json::from_str(message).ok()?;
-    let first = body["errors"].as_array().and_then(|errors| errors.first());
-    let detail = first.and_then(|error| {
-        let message = error["message"].as_str()?;
-        Some(
-            match error["path"].as_str().filter(|path| !path.is_empty()) {
-                Some(path) => format!("{path}: {message}"),
-                None => message.to_owned(),
-            },
-        )
-    });
-    detail.or_else(|| body["message"].as_str().map(str::to_owned))
-}
-
-fn secret_update(form: &MultiValueForm, key: &str, clear_key: &str) -> Option<Option<String>> {
-    match form.clean(key) {
-        Some(secret) => Some(Some(secret)),
-        None if form.bool_value(clear_key) => Some(None),
-        None => None,
-    }
-}
-
-fn parse_premium_product_name(value: Option<String>) -> Result<Option<String>, String> {
-    match value {
-        Some(name) if name.encode_utf16().count() > PREMIUM_PRODUCT_NAME_MAX_CHARS => Err(format!(
-            "Premium name must be at most {PREMIUM_PRODUCT_NAME_MAX_CHARS} characters"
-        )),
-        other => Ok(other),
-    }
-}
-
-fn parse_info_url(value: Option<String>) -> Result<Option<String>, String> {
-    let Some(value) = value else {
-        return Ok(None);
-    };
-    let valid = value.chars().count() <= INFO_URL_MAX_CHARS
-        && url::Url::parse(&value).is_ok_and(|url| {
-            matches!(url.scheme(), "http" | "https")
-                && url.host_str().is_some_and(|h| !h.is_empty())
-        });
-    if valid {
-        Ok(Some(value))
-    } else {
-        Err("Premium info URL must be an absolute http or https URL".to_owned())
-    }
-}
-
-fn parse_currency(value: &str) -> Result<String, String> {
-    let currency = value.trim().to_ascii_uppercase();
-    if currency.len() == 3 && currency.bytes().all(|byte| byte.is_ascii_uppercase()) {
-        Ok(currency)
-    } else {
-        Err(format!(
-            "Invalid currency \"{}\": use a 3-letter ISO 4217 code such as GBP",
-            value.trim()
-        ))
-    }
-}
-
-fn parse_country(value: &str) -> Result<String, String> {
-    let country = value.trim().to_ascii_uppercase();
-    if country.len() == 2 && country.bytes().all(|byte| byte.is_ascii_uppercase()) {
-        Ok(country)
-    } else {
-        Err(format!(
-            "Invalid country \"{}\": use a 2-letter ISO 3166 code such as SE",
-            value.trim()
-        ))
-    }
-}
-
-fn parse_price_id(value: &str) -> Result<String, String> {
-    let id = value.trim();
-    let valid = id.len() <= PRICE_ID_MAX_CHARS
-        && id.strip_prefix("price_").is_some_and(|rest| {
-            !rest.is_empty() && rest.bytes().all(|b| b.is_ascii_alphanumeric())
-        });
-    if valid {
-        Ok(id.to_owned())
-    } else {
-        Err(format!(
-            "Invalid Stripe price ID \"{id}\": it must look like price_1AbC"
-        ))
-    }
-}
-
-fn parse_optional_price_id(value: Option<&String>) -> Result<Option<String>, String> {
-    match value
-        .map(|value| value.trim())
-        .filter(|value| !value.is_empty())
-    {
-        Some(id) => parse_price_id(id).map(Some),
-        None => Ok(None),
-    }
-}
-
-fn parse_price_rows(
-    form: &MultiValueForm,
-) -> Result<Option<BTreeMap<String, BillingPriceSet>>, String> {
-    let currencies = form.values("billing_price_currency");
-    let column = |key: &str, index: usize| form.values(key).get(index);
-    let mut prices = BTreeMap::new();
-    for (index, currency) in currencies.iter().enumerate() {
-        if currency.trim().is_empty() {
-            continue;
-        }
-        let currency = parse_currency(currency)?;
-        let set = BillingPriceSet {
-            monthly: parse_optional_price_id(column("billing_price_monthly", index))?,
-            yearly: parse_optional_price_id(column("billing_price_yearly", index))?,
-            gift_1_month: parse_optional_price_id(column("billing_price_gift_1_month", index))?,
-            gift_1_year: parse_optional_price_id(column("billing_price_gift_1_year", index))?,
-        };
-        if set.is_empty() {
-            return Err(format!("{currency} needs at least one price ID"));
-        }
-        if prices.insert(currency.clone(), set).is_some() {
-            return Err(format!(
-                "{currency} appears more than once in the price table"
-            ));
-        }
-    }
-    if prices.len() > BILLING_MAX_CURRENCIES {
-        return Err(format!(
-            "The price table holds at most {BILLING_MAX_CURRENCIES} currencies"
-        ));
-    }
-    Ok((!prices.is_empty()).then_some(prices))
-}
-
-fn key_value_lines(value: &str) -> impl Iterator<Item = Result<(&str, &str), String>> {
-    value
-        .lines()
-        .map(str::trim)
-        .filter(|line| !line.is_empty())
-        .map(|line| {
-            line.split_once('=')
-                .map(|(key, value)| (key.trim(), value.trim()))
-                .ok_or_else(|| format!("Line \"{line}\" must use the form KEY=VALUE"))
-        })
-}
-
-fn parse_country_currencies(value: &str) -> Result<Option<BTreeMap<String, String>>, String> {
-    let mut countries = BTreeMap::new();
-    for line in key_value_lines(value) {
-        let (country, currency) = line?;
-        let country = parse_country(country)?;
-        let currency = parse_currency(currency)?;
-        if countries.insert(country.clone(), currency).is_some() {
-            return Err(format!("{country} is mapped more than once"));
-        }
-    }
-    if countries.len() > BILLING_MAX_COUNTRY_CURRENCIES {
-        return Err(format!(
-            "At most {BILLING_MAX_COUNTRY_CURRENCIES} country mappings are allowed"
-        ));
-    }
-    Ok((!countries.is_empty()).then_some(countries))
-}
-
-fn parse_legacy_slot(value: &str) -> Result<String, String> {
-    let invalid = || {
-        format!(
-            "Invalid legacy price slot \"{value}\": use monthly, yearly, gift_1_month or gift_1_year followed by _ and a currency, such as monthly_GBP"
-        )
-    };
-    let (slot, currency) = value.rsplit_once('_').ok_or_else(invalid)?;
-    let slot = slot.to_ascii_lowercase();
-    if !BILLING_PRICE_SLOTS.contains(&slot.as_str()) {
-        return Err(invalid());
-    }
-    let currency = parse_currency(currency).map_err(|_| invalid())?;
-    Ok(format!("{slot}_{currency}"))
-}
-
-fn parse_legacy_prices(value: &str) -> Result<Option<BTreeMap<String, Vec<String>>>, String> {
-    let mut legacy: BTreeMap<String, Vec<String>> = BTreeMap::new();
-    for line in key_value_lines(value) {
-        let (slot, ids) = line?;
-        let slot = parse_legacy_slot(slot)?;
-        let entry = legacy.entry(slot.clone()).or_default();
-        for id in ids.split(',').map(str::trim).filter(|id| !id.is_empty()) {
-            let id = parse_price_id(id)?;
-            if !entry.contains(&id) {
-                entry.push(id);
-            }
-        }
-        if entry.is_empty() {
-            return Err(format!("{slot} needs at least one price ID"));
-        }
-        if entry.len() > BILLING_MAX_LEGACY_PRICES_PER_SLOT {
-            return Err(format!(
-                "{slot} holds at most {BILLING_MAX_LEGACY_PRICES_PER_SLOT} legacy price IDs"
-            ));
-        }
-    }
-    if legacy.len() > BILLING_MAX_LEGACY_SLOTS {
-        return Err(format!(
-            "At most {BILLING_MAX_LEGACY_SLOTS} legacy price slots are allowed"
-        ));
-    }
-    Ok((!legacy.is_empty()).then_some(legacy))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::api::generated::types as generated_types;
-    use serde_json::json;
-
-    fn full_form(extra: &str) -> MultiValueForm {
-        let base = "billing_premium_product_name=%20Gold%20\
-            &billing_premium_info_url=https%3A%2F%2Fexample.com%2Fgold\
-            &billing_enabled=on\
-            &billing_automatic_tax=default&billing_tax_id_collection=on&billing_terms_consent_required=off\
-            &billing_stripe_secret_key=\
-            &billing_stripe_webhook_secret=whsec_new\
-            &billing_default_currency=gbp\
-            &billing_price_currency=gbp&billing_price_monthly=price_1GbpM&billing_price_yearly=price_1GbpY\
-            &billing_price_gift_1_month=&billing_price_gift_1_year=price_1GbpG\
-            &billing_price_currency=SEK&billing_price_monthly=price_1SekM&billing_price_yearly=price_1SekY\
-            &billing_price_gift_1_month=&billing_price_gift_1_year=\
-            &billing_price_currency=&billing_price_monthly=&billing_price_yearly=\
-            &billing_price_gift_1_month=&billing_price_gift_1_year=\
-            &billing_country_currencies=se%3Dsek%0D%0AGB%20%3D%20GBP%0D%0A\
-            &billing_legacy_prices=monthly_GBP%3Dprice_1OldA%0Amonthly_gbp%3Dprice_1OldB%2Cprice_1OldA%0Ayearly_SEK%3Dprice_1OldC";
-        MultiValueForm::parse(format!("{base}{extra}").as_bytes())
-    }
-
-    #[test]
-    fn full_billing_form_builds_the_expected_patch() {
-        let update = build_billing_update(&full_form("")).expect("valid form");
-        let value = serde_json::to_value(&update).expect("serializable");
-        serde_json::from_value::<generated_types::InstanceConfigUpdateRequest>(value.clone())
-            .expect("generated update contract");
-        assert_eq!(
-            value,
-            json!({
-                "app_public": {
-                    "branding": {
-                        "premium_product_name": "Gold",
-                        "premium_info_url": "https://example.com/gold"
-                    }
-                },
-                "billing": {
-                    "enabled": true,
-                    "stripe_webhook_secret": "whsec_new",
-                    "default_currency": "GBP",
-                    "prices": {
-                        "GBP": {
-                            "monthly": "price_1GbpM",
-                            "yearly": "price_1GbpY",
-                            "gift_1_month": null,
-                            "gift_1_year": "price_1GbpG"
-                        },
-                        "SEK": {
-                            "monthly": "price_1SekM",
-                            "yearly": "price_1SekY",
-                            "gift_1_month": null,
-                            "gift_1_year": null
-                        }
-                    },
-                    "country_currencies": {"GB": "GBP", "SE": "SEK"},
-                    "legacy_prices": {
-                        "monthly_GBP": ["price_1OldA", "price_1OldB"],
-                        "yearly_SEK": ["price_1OldC"]
-                    },
-                    "automatic_tax": null,
-                    "tax_id_collection": true,
-                    "terms_consent_required": false
-                }
-            })
-        );
-    }
-
-    #[test]
-    fn blank_fields_clear_and_the_default_choice_sends_null() {
-        let form = MultiValueForm::parse(
-            b"billing_premium_product_name=&billing_premium_info_url=&billing_enabled=default\
-              &billing_stripe_secret_key=&billing_clear_stripe_secret_key=true\
-              &billing_stripe_webhook_secret=\
-              &billing_default_currency=\
-              &billing_price_currency=&billing_price_monthly=price_1Ignored\
-              &billing_country_currencies=&billing_legacy_prices=",
-        );
-        let value = serde_json::to_value(build_billing_update(&form).expect("valid form")).unwrap();
-        assert_eq!(
-            value,
-            json!({
-                "app_public": {
-                    "branding": {"premium_product_name": null, "premium_info_url": null}
-                },
-                "billing": {
-                    "enabled": null,
-                    "stripe_secret_key": null,
-                    "default_currency": null,
-                    "prices": null,
-                    "country_currencies": null,
-                    "legacy_prices": null
-                }
-            })
-        );
-    }
-
-    #[test]
-    fn a_new_secret_wins_over_the_clear_checkbox() {
-        let form = MultiValueForm::parse(
-            b"billing_stripe_secret_key=%20sk_live_x%20&billing_clear_stripe_secret_key=true",
-        );
-        let billing = build_billing_update(&form)
-            .expect("valid form")
-            .billing
-            .expect("billing");
-        assert_eq!(
-            billing.stripe_secret_key,
-            Some(Some("sk_live_x".to_owned()))
-        );
-        assert_eq!(billing.stripe_webhook_secret, None);
-    }
-
-    #[test]
-    fn absent_form_keys_leave_their_fields_untouched() {
-        let update = build_billing_update(&MultiValueForm::parse(b"billing_enabled=off"))
-            .expect("valid form");
-        assert!(update.app_public.is_none());
-        assert_eq!(
-            serde_json::to_value(update.billing).unwrap(),
-            json!({"enabled": false})
-        );
-        let untouched = build_billing_update(&MultiValueForm::parse(b"")).expect("valid form");
-        assert_eq!(serde_json::to_value(untouched.billing).unwrap(), json!({}));
-    }
-
-    #[test]
-    fn invalid_input_is_rejected_with_a_message() {
-        let cases: &[(&str, &str)] = &[
-            (
-                "billing_premium_info_url=ftp%3A%2F%2Fexample.com",
-                "http or https",
-            ),
-            ("billing_premium_info_url=example.com", "http or https"),
-            ("billing_default_currency=GB", "Invalid currency"),
-            ("billing_enabled=true", "Invalid choice"),
-            ("billing_automatic_tax=maybe", "Invalid choice"),
-            (
-                "billing_price_currency=GBPX&billing_price_monthly=price_1A",
-                "Invalid currency",
-            ),
-            (
-                "billing_price_currency=GBP&billing_price_monthly=prod_1A",
-                "Invalid Stripe price ID",
-            ),
-            (
-                "billing_price_currency=GBP&billing_price_monthly=price_1-A",
-                "Invalid Stripe price ID",
-            ),
-            ("billing_price_currency=GBP", "needs at least one price ID"),
-            (
-                "billing_price_currency=GBP&billing_price_monthly=price_1A&billing_price_currency=gbp&billing_price_monthly=price_1B",
-                "more than once",
-            ),
-            ("billing_country_currencies=SWE%3DSEK", "Invalid country"),
-            ("billing_country_currencies=SE", "KEY=VALUE"),
-            (
-                "billing_country_currencies=SE%3DSEK%0ASE%3DEUR",
-                "mapped more than once",
-            ),
-            (
-                "billing_legacy_prices=weekly_GBP%3Dprice_1A",
-                "Invalid legacy price slot",
-            ),
-            (
-                "billing_legacy_prices=monthly_GBP%3D",
-                "needs at least one price ID",
-            ),
-            (
-                "billing_default_currency=EUR&billing_price_currency=GBP&billing_price_monthly=price_1A",
-                "Default currency EUR has no row",
-            ),
-            (
-                "billing_country_currencies=SE%3DSEK&billing_price_currency=GBP&billing_price_monthly=price_1A",
-                "SE maps to SEK",
-            ),
-        ];
-        let long_name = format!("billing_premium_product_name={}", "A".repeat(41));
-        let emoji_name = format!(
-            "billing_premium_product_name=Gold{}",
-            "%F0%9F%92%8E".repeat(20)
-        );
-        let long_case = [
-            (long_name.as_str(), "at most 40"),
-            (emoji_name.as_str(), "at most 40"),
-        ];
-        for (body, expected) in long_case.iter().chain(cases.iter()) {
-            let error =
-                build_billing_update(&MultiValueForm::parse(body.as_bytes())).expect_err(body);
-            assert!(error.contains(expected), "{body}: {error}");
-        }
-    }
-
-    #[test]
-    fn premium_name_limit_counts_utf16_units() {
-        let name = format!("{}{}", "A".repeat(39), "\u{1F48E}");
-        assert_eq!(name.chars().count(), 40);
-        assert!(parse_premium_product_name(Some(name)).is_err());
-        let fits = format!("{}{}", "A".repeat(38), "\u{E9}\u{E9}");
-        assert_eq!(
-            parse_premium_product_name(Some(fits.clone())),
-            Ok(Some(fits))
-        );
-    }
-
-    #[test]
-    fn country_currencies_are_not_cross_checked_without_a_price_table() {
-        let form = MultiValueForm::parse(b"billing_country_currencies=SE%3DSEK");
-        let billing = build_billing_update(&form).unwrap().billing.unwrap();
-        assert_eq!(
-            billing.country_currencies,
-            Some(Some(BTreeMap::from([("SE".to_owned(), "SEK".to_owned())])))
-        );
-    }
-
-    #[test]
-    fn validation_errors_surface_the_first_api_message() {
-        let error = ApiError::Http {
-            status: 400,
-            message: json!({
-                "code": "VALIDATION_ERROR",
-                "message": "Validation failed",
-                "errors": [{"path": "billing.enabled", "code": "X", "message": "Switch the premium model to mirror first"}]
-            })
-            .to_string(),
-        };
-        assert_eq!(
-            validation_message(&error).as_deref(),
-            Some("billing.enabled: Switch the premium model to mirror first")
-        );
-        let server_error = ApiError::Http {
-            status: 500,
-            message: "{}".to_owned(),
-        };
-        assert_eq!(validation_message(&server_error), None);
-    }
-}
@@ -8,15 +8,12 @@ use crate::{
        flash::{self, FlashData},
    },
    state::AppState,
-    templates::{
-        self,
-        pages::gift_codes::{GiftCodesPremium, MAX_GIFT_CODES},
-    },
+    templates::{self, pages::gift_codes::MAX_GIFT_CODES},
 };
 use axum::{
    Form, Router,
    extract::{FromRequest, Query, Request, State},
-    response::{Html, IntoResponse, Response},
+    response::{Html, IntoResponse, Redirect, Response},
    routing::get,
 };
 use serde::Deserialize;
@@ -49,11 +46,10 @@ async fn gift_codes_page(
    Query(query): Query<GiftCodesQuery>,
 ) -> Response {
    let config = state.config();
-    let client = AdminApiClient::new(state.http_client(), config, &auth.0.session);
-    let premium = GiftCodesPremium::from_branding(
-        config.self_hosted,
-        state.premium_branding(&client).await.as_ref(),
-    );
+
+    if config.self_hosted {
+        return Redirect::to(&format!("{}/dashboard", config.base_path)).into_response();
+    }

    let generated_codes: Option<Vec<String>> = query
        .codes
@@ -64,7 +60,6 @@ async fn gift_codes_page(
        config,
        &auth.0,
        &csrf.0.0,
-        &premium,
        generated_codes.as_deref(),
    );
    Html(markup.into_string()).into_response()
@@ -77,6 +72,9 @@ async fn gift_codes_post(
 ) -> Response {
    let config = state.config();
    let base = &config.base_path;
+    if config.self_hosted {
+        return Redirect::to(&format!("{base}/dashboard")).into_response();
+    }
    let form: GiftCodesForm = match Form::from_request(request, &state).await {
        Ok(Form(f)) => f,
        Err(error) => {
@@ -96,33 +96,6 @@ pub async fn render(
                config, &guild, &stickers, csrf_token,
            ))
        }
-        "threads" => {
-            if !acl::has_permission(admin_acls, acl::GUILD_LOOKUP) {
-                return None;
-            }
-            let threads = client
-                .list_guild_threads(guild_id)
-                .await
-                .map(|response| response.threads)
-                .map_err(|error| tracing::warn!(%error, guild_id, "admin API request failed: list guild threads"))
-                .unwrap_or_default();
-            let threads_enabled = client
-                .get_instance_config()
-                .await
-                .map(|instance| instance.channel_threads.enabled)
-                .map_err(
-                    |error| tracing::warn!(%error, "admin API request failed: get instance config"),
-                )
-                .unwrap_or(false);
-            Some(tabs::threads::threads_tab(
-                config,
-                &guild,
-                &threads,
-                acl::has_permission(admin_acls, acl::MESSAGE_DELETE_ALL),
-                threads_enabled,
-                csrf_token,
-            ))
-        }
        "audit_log" | "audit-log" => {
            if !acl::has_permission(admin_acls, acl::GUILD_AUDIT_LOG_VIEW) {
                return None;
@@ -134,7 +134,6 @@ async fn guild_detail(
        .as_ref()
        .map(|user| user.acls.as_slice())
        .unwrap_or(&[]);
-    let username_sign_in = state.account_identity(&client).await.is_username();
    let tab_body = if let Some(guild) = guild.as_ref() {
        guild_tabs::render(
            &client,
@@ -153,7 +152,6 @@ async fn guild_detail(
                active_tab,
                &csrf_token,
                admin_acls,
-                username_sign_in,
            ))
        })
    } else {
@@ -168,7 +166,6 @@ async fn guild_detail(
        active_tab,
        tab_body,
        is_detail_fragment,
-        username_sign_in,
    );
    Html(markup.into_string()).into_response()
 }
@@ -433,16 +430,6 @@ async fn dispatch_guild_action(
                "Failed to delete sticker",
            )
        }
-        "delete_thread" => {
-            let Some(thread_id) = get("thread_id") else {
-                return FlashData::error("Thread ID is required");
-            };
-            action_result(
-                client.delete_thread_channel(&thread_id).await,
-                "Thread deleted",
-                "Failed to delete thread",
-            )
-        }
        "trigger_archive" => {
            let inc = form.bool_value("include_attachments");
            action_result(
@@ -521,7 +508,6 @@ async fn guild_tab(
            normalize_guild_tab(&tab),
            &csrf_token,
            admin_acls,
-            state.account_identity(&client).await.is_username(),
        ),
        None => maud::html! {
            div class="p-4 text-red-600 text-sm" {
@@ -171,8 +171,7 @@ pub(crate) async fn system_dms_post(
    let flash = if let Some(content) = content.as_deref()
        && !user_ids.is_empty()
    {
-        let recipients = (user_ids != ["*"]).then_some(user_ids.as_slice());
-        match client.send_system_dm(recipients, content).await {
+        match client.send_system_dm(&user_ids, content).await {
            Ok(_) => FlashData::success("System DM sent"),
            Err(error) => {
                tracing::warn!(%error, "admin API request failed: send system DM");
@@ -219,6 +218,19 @@ pub(crate) async fn bulk_actions_post(
                .bulk_update_user_flags(&user_ids, &add, &remove, audit_log_reason.as_deref())
                .await
        }
+        "bulk-update-suspicious-activity-flags" => {
+            let user_ids = form.list_values_any(&["user_ids[]", "user_ids"]);
+            let add = form.list_values_any(&["add_flags[]", "add_flags"]);
+            let remove = form.list_values_any(&["remove_flags[]", "remove_flags"]);
+            client
+                .bulk_update_suspicious_activity_flags(
+                    &user_ids,
+                    &add,
+                    &remove,
+                    audit_log_reason.as_deref(),
+                )
+                .await
+        }
        "bulk-update-guild-features" => {
            let guild_ids = form.list_values_any(&["guild_ids[]", "guild_ids"]);
            let mut add = form.list_values_any(&["add_features[]", "add_features"]);
@@ -249,14 +261,12 @@ pub(crate) async fn bulk_actions_post(
                );
            };
            let public_reason = form.clean("public_reason");
-            let notify_user = form.opt_out_value("notify_user");
            client
                .bulk_schedule_user_deletion(
                    &user_ids,
                    reason_code.unwrap_or(2),
                    days.unwrap_or(14),
                    public_reason.as_deref(),
-                    notify_user,
                    audit_log_reason.as_deref(),
                )
                .await
@@ -201,13 +201,6 @@ async fn bulk_actions_page(
    csrf: axum::Extension<CsrfToken>,
 ) -> Response {
    let config = state.config();
-    let client = AdminApiClient::new(state.http_client(), config, &auth.0.session);
-    let account_identity = state.account_identity(&client).await;
-    let markup = templates::pages::bulk_actions::bulk_actions_page(
-        config,
-        &auth.0,
-        &csrf.0.0,
-        account_identity.is_username(),
-    );
+    let markup = templates::pages::bulk_actions::bulk_actions_page(config, &auth.0, &csrf.0.0);
    Html(markup.into_string()).into_response()
 }
@@ -5,7 +5,6 @@ pub mod applications;
 pub mod auth;
 pub mod bans;
 mod bans_actions;
-mod billing_actions;
 pub mod codes;
 pub mod discovery;
 mod guild_tabs;
@@ -73,10 +72,6 @@ pub fn build_router(config: AdminConfig) -> Router {
        .merge(admin::router())
        .route("/", get(dashboard))
        .route("/dashboard", get(dashboard))
-        .layer(from_fn_with_state(
-            state.clone(),
-            middleware::account_identity::scope_account_identity,
-        ))
        .layer(from_fn(middleware::htmx::flash_redirect_to_toast))
        .layer(from_fn_with_state(
            state.clone(),
@@ -52,10 +52,6 @@ struct ResolveForm {
    _csrf: Option<String>,
    #[serde(default)]
    resolution: Option<String>,
-    #[serde(default)]
-    notify_reporter: Option<String>,
-    #[serde(default)]
-    notify_reporter_present: Option<String>,
 }

 pub fn router() -> Router<AppState> {
@@ -231,10 +227,8 @@ async fn report_resolve(
    };
    let client = AdminApiClient::new(state.http_client(), config, &auth.0.session);
    let public_comment = clean_string(form.resolution.as_deref().unwrap_or(""));
-    let notify_reporter =
-        form.notify_reporter_present.is_none() || form.notify_reporter.as_deref() == Some("true");
    let result = client
-        .resolve_report(&report_id, public_comment.as_deref(), notify_reporter, None)
+        .resolve_report(&report_id, public_comment.as_deref(), None)
        .await;
    match result {
        Ok(_) => {
@@ -221,11 +221,6 @@ async fn instance_config_page(
        .get_instance_config()
        .await
        .log_error("load instance config");
-    if let Some(instance_config) = &instance_config {
-        state.remember_premium_branding(crate::api::types::PremiumBranding::from_instance_config(
-            instance_config,
-        ));
-    }
    let limit_config = client
        .get_limit_config()
        .await
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Weblate	444dc2b7d4	Merge remote-tracking branch 'origin/main'	2026-09-27 21:29:29 +00:00
Weblate	669bd3c581	Merge remote-tracking branch 'origin/main'	2026-09-27 19:22:45 +00:00
Weblate	d4e93d3e84	Merge remote-tracking branch 'origin/main'	2026-09-27 19:19:37 +00:00
Weblate	7c82ca1102	Merge remote-tracking branch 'origin/main'	2026-09-27 19:15:35 +00:00
Weblate	83c1710b47	Merge remote-tracking branch 'origin/main'	2026-09-27 19:03:44 +00:00
Weblate	48cf56e732	Merge remote-tracking branch 'origin/main'	2026-09-27 18:50:09 +00:00
Weblate	6b52de6354	Merge remote-tracking branch 'origin/main'	2026-09-27 18:33:11 +00:00
Weblate	59840af1bf	Merge remote-tracking branch 'origin/main'	2026-09-27 18:13:15 +00:00
Weblate	2df37450ae	Merge remote-tracking branch 'origin/main'	2026-09-27 17:37:41 +00:00
Weblate	2fc97f4544	Merge remote-tracking branch 'origin/main'	2026-09-27 14:18:06 +00:00
Weblate	2bf3a610f4	Merge remote-tracking branch 'origin/main'	2026-09-27 11:33:25 +00:00
Weblate	86d92564c0	Merge remote-tracking branch 'origin/main'	2026-09-27 11:33:20 +00:00
Weblate	2edd0f188f	Merge remote-tracking branch 'origin/main'	2026-09-26 11:48:31 +00:00
Weblate	cb55e62bd9	Merge remote-tracking branch 'origin/main'	2026-09-25 20:35:45 +00:00
Weblate	ed579aaeec	Merge remote-tracking branch 'origin/main'	2026-09-25 18:13:02 +00:00
Weblate	0808bf680f	Merge remote-tracking branch 'origin/main'	2026-09-25 18:10:57 +00:00
Weblate	e75ed31a4c	Merge remote-tracking branch 'origin/main'	2026-09-25 16:16:27 +00:00
Weblate	b6e3fa47a8	Merge remote-tracking branch 'origin/main'	2026-09-25 15:46:14 +00:00
Weblate	690cca6edb	Merge remote-tracking branch 'origin/main'	2026-09-25 15:43:23 +00:00
Weblate	f28937d86f	Merge remote-tracking branch 'origin/main'	2026-09-25 14:45:02 +00:00
Weblate	6b04ad25b1	Merge remote-tracking branch 'origin/main'	2026-09-25 11:59:35 +00:00
Weblate	63980fca11	Merge remote-tracking branch 'origin/main'	2026-09-25 11:43:39 +00:00
Weblate	0d92584431	Merge remote-tracking branch 'origin/main'	2026-09-25 11:42:06 +00:00
Weblate	0e2b7a1a2b	Merge remote-tracking branch 'origin/main'	2026-09-25 11:12:21 +00:00
Weblate	bbe55397c3	Merge remote-tracking branch 'origin/main'	2026-09-24 21:38:07 +00:00
Weblate	0b5514f663	Merge remote-tracking branch 'origin/main'	2026-09-24 20:50:38 +00:00
Weblate	380995cc19	Merge remote-tracking branch 'origin/main'	2026-09-24 20:45:58 +00:00
Weblate	e3522ec7be	Merge remote-tracking branch 'origin/main'	2026-09-24 15:52:37 +00:00
Weblate	56bc0e5612	Merge remote-tracking branch 'origin/main'	2026-09-24 15:09:53 +00:00
Weblate	d501a1ea68	Merge remote-tracking branch 'origin/main'	2026-09-24 15:09:40 +00:00
Weblate	6e3739bb9b	Merge remote-tracking branch 'origin/main'	2026-09-24 14:25:29 +00:00
Weblate	b4f789a5ba	Merge remote-tracking branch 'origin/main'	2026-09-24 14:25:10 +00:00
Weblate	49761959b1	Merge remote-tracking branch 'origin/main'	2026-09-24 14:21:46 +00:00
Weblate	34e03c9732	Merge remote-tracking branch 'origin/main'	2026-09-24 14:07:06 +00:00
Weblate	58d6e2d4bf	Merge remote-tracking branch 'origin/main'	2026-09-24 13:15:50 +00:00
Weblate	4766ce7974	Merge remote-tracking branch 'origin/main'	2026-09-24 13:04:28 +00:00
Weblate	9e6aa67834	Merge remote-tracking branch 'origin/main'	2026-09-24 13:04:06 +00:00
Weblate	57832208d5	Merge remote-tracking branch 'origin/main'	2026-09-24 13:03:37 +00:00
Weblate	b35c85fc54	Merge remote-tracking branch 'origin/main'	2026-09-24 12:57:45 +00:00
Weblate	7f58fba66d	Merge remote-tracking branch 'origin/main'	2026-09-24 12:51:09 +00:00
Weblate	5b35d6da7b	Merge remote-tracking branch 'origin/main'	2026-09-24 12:04:12 +00:00
Weblate	53b9f14f35	Merge remote-tracking branch 'origin/main'	2026-09-24 01:41:30 +00:00
Weblate	bb83a6c042	Merge remote-tracking branch 'origin/main'	2026-09-24 00:14:11 +00:00
WeblateandHampus	e7125e4e62	Translated using Weblate (Ukrainian) Currently translated at 98.5% (470 of 477 strings) Co-authored-by: Hampus <[email protected]> Translate-URL: https://weblate.fluxer.tools/projects/fluxer/errors/uk/ Translation: Fluxer/Error messages	2026-09-24 00:06:54 +00:00