No OneTemporary
Actions

Authored By

Unknown

Size

418 KB

Referenced Files

None

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
	index ff3308e31..10a843af2 100644
	--- a/.gitlab-ci.yml
	+++ b/.gitlab-ci.yml
	@@ -1,561 +1,561 @@
	image: git.pleroma.social:5050/pleroma/pleroma/ci-base

	variables: &global_variables
	ELIXIR_VER: 1.12.3
	POSTGRES_DB: pleroma_test
	POSTGRES_USER: postgres
	POSTGRES_PASSWORD: postgres
	DB_HOST: postgres
	- DB_PORT: 5432
	+ DB_PORT: "5432"
	MIX_ENV: test

	workflow:
	rules:
	- if: $CI_PIPELINE_SOURCE == "merge_request_event"
	- if: $CI_COMMIT_BRANCH && $CI_OPEN_MERGE_REQUESTS
	when: never
	- if: $CI_COMMIT_BRANCH

	cache: &global_cache_policy
	key:
	files:
	- mix.lock
	paths:
	- deps
	- _build

	stages:
	- check-changelog
	- build
	- test
	- benchmark
	- deploy
	- release
	- docker
	- docker-combine

	before_script:
	- echo $MIX_ENV
	- rm -rf _build/*/lib/pleroma
	- mix deps.get

	after_script:
	- rm -rf _build/*/lib/pleroma

	check-changelog:
	stage: check-changelog
	image: alpine
	rules:
	- if: $CI_MERGE_REQUEST_SOURCE_PROJECT_PATH == 'pleroma/pleroma' && $CI_MERGE_REQUEST_SOURCE_BRANCH_NAME == 'weblate-extract'
	when: never
	- if: $CI_MERGE_REQUEST_SOURCE_PROJECT_PATH == 'pleroma/pleroma' && $CI_MERGE_REQUEST_SOURCE_BRANCH_NAME == 'weblate'
	when: never
	- if: $CI_MERGE_REQUEST_TARGET_BRANCH_NAME == "develop"
	before_script: ''
	after_script: ''
	cache: {}
	script:
	- apk add git
	- sh ./tools/check-changelog

	.build_changes_policy:
	rules:
	- changes:
	- ".gitlab-ci.yml"
	- "*/.ex"
	- "*/.exs"
	- "mix.lock"

	.using-ci-base:
	tags:
	- amd64

	build:
	extends:
	- .build_changes_policy
	- .using-ci-base
	stage: build
	script:
	- mix compile --force

	spec-build:
	extends:
	- .using-ci-base
	stage: test
	rules:
	- changes:
	- ".gitlab-ci.yml"
	- "lib/pleroma/web/api_spec/*/.ex"
	- "lib/pleroma/web/api_spec.ex"
	artifacts:
	paths:
	- spec.json
	script:
	- mix pleroma.openapi_spec spec.json

	benchmark:
	extends:
	- .using-ci-base
	stage: benchmark
	when: manual
	variables:
	MIX_ENV: benchmark
	services:
	- name: postgres:9.6-alpine
	alias: postgres
	command: ["postgres", "-c", "fsync=off", "-c", "synchronous_commit=off", "-c", "full_page_writes=off"]
	script:
	- mix ecto.create
	- mix ecto.migrate
	- mix pleroma.load_testing

	unit-testing:
	extends:
	- .build_changes_policy
	- .using-ci-base
	stage: test
	cache: &testing_cache_policy
	<<: *global_cache_policy
	policy: pull

	services:
	- name: postgres:13-alpine
	alias: postgres
	command: ["postgres", "-c", "fsync=off", "-c", "synchronous_commit=off", "-c", "full_page_writes=off"]
	script:
	- mix ecto.create
	- mix ecto.migrate
	- mix test --cover --preload-modules
	coverage: '/^Line total: ([^ ]*%)$/'
	artifacts:
	reports:
	coverage_report:
	coverage_format: cobertura
	path: coverage.xml

	unit-testing-erratic:
	extends:
	- .build_changes_policy
	- .using-ci-base
	stage: test
	retry: 2
	allow_failure: true
	cache: &testing_cache_policy
	<<: *global_cache_policy
	policy: pull

	services:
	- name: postgres:13-alpine
	alias: postgres
	command: ["postgres", "-c", "fsync=off", "-c", "synchronous_commit=off", "-c", "full_page_writes=off"]
	script:
	- mix ecto.create
	- mix ecto.migrate
	- mix test --only=erratic

	# Removed to fix CI issue. In this early state it wasn't adding much value anyway.
	# TODO Fix and reinstate federated testing
	# federated-testing:
	# stage: test
	# cache: *testing_cache_policy
	# services:
	# - name: minibikini/postgres-with-rum:12
	# alias: postgres
	# command: ["postgres", "-c", "fsync=off", "-c", "synchronous_commit=off", "-c", "full_page_writes=off"]
	# script:
	# - mix deps.get
	# - mix ecto.create
	# - mix ecto.migrate
	# - epmd -daemon
	# - mix test --trace --only federated

	unit-testing-rum:
	extends:
	- .build_changes_policy
	- .using-ci-base
	stage: test
	cache: *testing_cache_policy
	services:
	- name: minibikini/postgres-with-rum:12
	alias: postgres
	command: ["postgres", "-c", "fsync=off", "-c", "synchronous_commit=off", "-c", "full_page_writes=off"]
	variables:
	<<: *global_variables
	RUM_ENABLED: "true"
	script:
	- mix ecto.create
	- mix ecto.migrate
	- "mix ecto.migrate --migrations-path priv/repo/optional_migrations/rum_indexing/"
	- mix test --preload-modules

	lint:
	extends: .build_changes_policy
	image: &current_elixir elixir:1.12-alpine
	stage: test
	cache: *testing_cache_policy
	before_script: &current_bfr_script
	- apk update
	- apk add build-base cmake file-dev git openssl
	- mix local.hex --force
	- mix local.rebar --force
	- mix deps.get
	script:
	- mix format --check-formatted

	analysis:
	extends:
	- .build_changes_policy
	- .using-ci-base
	stage: test
	cache: *testing_cache_policy
	script:
	- mix credo --strict --only=warnings,todo,fixme,consistency,readability

	cycles:
	extends: .build_changes_policy
	image: *current_elixir
	stage: test
	cache: {}
	before_script: *current_bfr_script
	script:
	- mix compile
	- mix xref graph --format cycles --label compile \| awk '{print $0} END{exit ($0 != "No cycles found")}'

	docs-deploy:
	stage: deploy
	cache: *testing_cache_policy
	image: alpine:latest
	only:
	- stable@pleroma/pleroma
	- develop@pleroma/pleroma
	before_script:
	- apk add curl
	script:
	- curl --fail-with-body -X POST -F"token=$CI_JOB_TOKEN" -F'ref=master' -F"variables[BRANCH]=$CI_COMMIT_REF_NAME" https://git.pleroma.social/api/v4/projects/673/trigger/pipeline
	review_app:
	image: alpine:3.9
	stage: deploy
	before_script:
	- apk update && apk add openssh-client git
	when: manual
	environment:
	name: review/$CI_COMMIT_REF_NAME
	url: https://$CI_ENVIRONMENT_SLUG.pleroma.online/
	on_stop: stop_review_app
	only:
	- branches
	except:
	- master
	- develop
	script:
	- echo "$CI_ENVIRONMENT_SLUG"
	- mkdir -p ~/.ssh
	- eval $(ssh-agent -s)
	- echo "$SSH_PRIVATE_KEY" \| tr -d '\r' \| ssh-add -
	- ssh-keyscan -H "pleroma.online" >> ~/.ssh/known_hosts
	- (ssh -t dokku@pleroma.online -- apps:create "$CI_ENVIRONMENT_SLUG") \|\| true
	- (ssh -t dokku@pleroma.online -- git:set "$CI_ENVIRONMENT_SLUG" keep-git-dir true) \|\| true
	- ssh -t dokku@pleroma.online -- config:set "$CI_ENVIRONMENT_SLUG" APP_NAME="$CI_ENVIRONMENT_SLUG" APP_HOST="$CI_ENVIRONMENT_SLUG.pleroma.online" MIX_ENV=dokku
	- (ssh -t dokku@pleroma.online -- postgres:create $(echo $CI_ENVIRONMENT_SLUG \| sed -e 's/-/_/g')_db) \|\| true
	- (ssh -t dokku@pleroma.online -- postgres:link $(echo $CI_ENVIRONMENT_SLUG \| sed -e 's/-/_/g')_db "$CI_ENVIRONMENT_SLUG") \|\| true
	- (ssh -t dokku@pleroma.online -- certs:add "$CI_ENVIRONMENT_SLUG" /home/dokku/server.crt /home/dokku/server.key) \|\| true
	- git push -f dokku@pleroma.online:$CI_ENVIRONMENT_SLUG $CI_COMMIT_SHA:refs/heads/master

	spec-deploy:
	stage: deploy
	artifacts:
	paths:
	- spec.json
	only:
	- develop@pleroma/pleroma
	image: alpine:latest
	before_script:
	- apk add curl
	script:
	- curl --fail-with-body -X POST -F"token=$CI_JOB_TOKEN" -F'ref=master' -F"variables[BRANCH]=$CI_COMMIT_REF_NAME" -F"variables[JOB_REF]=$CI_JOB_ID" https://git.pleroma.social/api/v4/projects/1130/trigger/pipeline


	stop_review_app:
	image: alpine:3.9
	stage: deploy
	before_script:
	- apk update && apk add openssh-client git
	when: manual
	environment:
	name: review/$CI_COMMIT_REF_NAME
	action: stop
	script:
	- echo "$CI_ENVIRONMENT_SLUG"
	- mkdir -p ~/.ssh
	- eval $(ssh-agent -s)
	- echo "$SSH_PRIVATE_KEY" \| tr -d '\r' \| ssh-add -
	- ssh-keyscan -H "pleroma.online" >> ~/.ssh/known_hosts
	- ssh -t dokku@pleroma.online -- --force apps:destroy "$CI_ENVIRONMENT_SLUG"
	- ssh -t dokku@pleroma.online -- --force postgres:destroy $(echo $CI_ENVIRONMENT_SLUG \| sed -e 's/-/_/g')_db

	amd64:
	stage: release
	image: elixir:$ELIXIR_VER
	only: &release-only
	- stable@pleroma/pleroma
	- develop@pleroma/pleroma
	- /^maint/.*$/@pleroma/pleroma
	- /^release/.*$/@pleroma/pleroma
	tags:
	- amd64
	artifacts: &release-artifacts
	name: "pleroma-$CI_COMMIT_REF_NAME-$CI_COMMIT_SHORT_SHA-$CI_JOB_NAME"
	paths:
	- release/*
	# Ideally it would be never for master branch and with the next commit for develop,
	# but Gitlab does not support neither `only` for artifacts
	# nor setting it to never from .gitlab-ci.yml
	# nor expiring with the next commit
	expire_in: 42 yrs

	cache: &release-cache
	key: $CI_COMMIT_REF_NAME-$CI_JOB_NAME
	paths:
	- deps
	variables: &release-variables
	MIX_ENV: prod
	before_script: &before-release
	- apt-get update && apt-get install -y cmake libmagic-dev
	- echo "import Config" > config/prod.secret.exs
	- mix local.hex --force
	- mix local.rebar --force
	script: &release
	- mix deps.get --only prod
	- mkdir release
	- export PLEROMA_BUILD_BRANCH=$CI_COMMIT_REF_NAME
	- mix release --path release


	amd64-musl:
	stage: release
	artifacts: *release-artifacts
	only: *release-only
	image: elixir:$ELIXIR_VER-alpine
	tags:
	- amd64
	cache: *release-cache
	variables: *release-variables
	before_script: &before-release-musl
	- apk add git build-base cmake file-dev openssl
	- echo "import Config" > config/prod.secret.exs
	- mix local.hex --force
	- mix local.rebar --force
	script: *release

	arm:
	stage: release
	artifacts: *release-artifacts
	only: *release-only
	tags:
	- arm32-specified
	image: arm32v7/elixir:$ELIXIR_VER
	cache: *release-cache
	variables: *release-variables
	before_script: *before-release
	script: *release

	arm-musl:
	stage: release
	artifacts: *release-artifacts
	only: *release-only
	tags:
	- arm32-specified
	image: arm32v7/elixir:$ELIXIR_VER-alpine
	cache: *release-cache
	variables: *release-variables
	before_script: *before-release-musl
	script: *release

	arm64:
	stage: release
	artifacts: *release-artifacts
	only: *release-only
	tags:
	- arm
	image: arm64v8/elixir:$ELIXIR_VER
	cache: *release-cache
	variables: *release-variables
	before_script: *before-release
	script: *release

	arm64-musl:
	stage: release
	artifacts: *release-artifacts
	only: *release-only
	tags:
	- arm
	image: arm64v8/elixir:$ELIXIR_VER-alpine
	cache: *release-cache
	variables: *release-variables
	before_script: *before-release-musl
	script: *release

	.kaniko:
	stage: docker
	image:
	name: gcr.io/kaniko-project/executor:debug
	entrypoint: [""]
	cache: {}
	dependencies: []
	before_script: &before-kaniko
	- export CI_JOB_TIMESTAMP=$(date --utc -Iseconds)
	- export CI_VCS_REF=$CI_COMMIT_SHORT_SHA
	- export IMAGE_TAG=$CI_REGISTRY_IMAGE/$BUILD_ARCH_IMG_SUFFIX:$CI_COMMIT_SHORT_SHA
	- export IMAGE_TAG_SLUG=$CI_REGISTRY_IMAGE/$BUILD_ARCH_IMG_SUFFIX:$CI_COMMIT_REF_SLUG
	- export IMAGE_TAG_LATEST=$CI_REGISTRY_IMAGE/$BUILD_ARCH_IMG_SUFFIX:latest
	- export IMAGE_TAG_LATEST_STABLE=$CI_REGISTRY_IMAGE/$BUILD_ARCH_IMG_SUFFIX:latest-stable
	- mkdir -p /kaniko/.docker
	- echo "{\"auths\":{\"$CI_REGISTRY\":{\"username\":\"$CI_REGISTRY_USER\",\"password\":\"$CI_REGISTRY_PASSWORD\"}}}" > /kaniko/.docker/config.json

	.kaniko-latest:
	extends: .kaniko
	only:
	- develop@pleroma/pleroma
	script:
	- /kaniko/executor --context $CI_PROJECT_DIR --dockerfile $CI_PROJECT_DIR/Dockerfile --custom-platform=$BUILD_ARCH --build-arg VCS_REF=$CI_VCS_REF --build-arg BUILD_DATE=$CI_JOB_TIMESTAMP --build-arg ELIXIR_IMG=$ELIXIR_IMG --destination $IMAGE_TAG --destination $IMAGE_TAG_SLUG --destination $IMAGE_TAG_LATEST

	.kaniko-stable:
	extends: .kaniko
	only:
	- stable@pleroma/pleroma
	script:
	- /kaniko/executor --context $CI_PROJECT_DIR --dockerfile $CI_PROJECT_DIR/Dockerfile --custom-platform=$BUILD_ARCH --build-arg VCS_REF=$CI_VCS_REF --build-arg BUILD_DATE=$CI_JOB_TIMESTAMP --build-arg ELIXIR_IMG=$ELIXIR_IMG --destination $IMAGE_TAG --destination $IMAGE_TAG_SLUG --destination $IMAGE_TAG_LATEST_STABLE

	.kaniko-release:
	extends: .kaniko
	only:
	- /^release/.*$/@pleroma/pleroma
	script:
	- /kaniko/executor --context $CI_PROJECT_DIR --dockerfile $CI_PROJECT_DIR/Dockerfile --custom-platform=$BUILD_ARCH --build-arg VCS_REF=$CI_VCS_REF --build-arg BUILD_DATE=$CI_JOB_TIMESTAMP --build-arg ELIXIR_IMG=$ELIXIR_IMG --destination $IMAGE_TAG --destination $IMAGE_TAG_SLUG

	.kaniko-adhoc:
	extends: .kaniko
	only:
	- /^build-docker/.*$/@pleroma/pleroma
	script:
	- /kaniko/executor --context $CI_PROJECT_DIR --dockerfile $CI_PROJECT_DIR/Dockerfile --custom-platform=$BUILD_ARCH --build-arg VCS_REF=$CI_VCS_REF --build-arg BUILD_DATE=$CI_JOB_TIMESTAMP --build-arg ELIXIR_IMG=$ELIXIR_IMG --destination $IMAGE_TAG --destination $IMAGE_TAG_SLUG

	.kaniko:linux/amd64:
	variables:
	BUILD_ARCH: linux/amd64
	BUILD_ARCH_IMG_SUFFIX: linux-amd64
	ELIXIR_IMG: hexpm/elixir
	tags:
	- amd64

	.kaniko:linux/arm64:
	variables:
	BUILD_ARCH: linux/arm64/v8
	BUILD_ARCH_IMG_SUFFIX: linux-arm64-v8
	ELIXIR_IMG: hexpm/elixir
	tags:
	- arm

	.kaniko:linux/arm:
	variables:
	BUILD_ARCH: linux/arm/v7
	BUILD_ARCH_IMG_SUFFIX: linux-arm-v7
	ELIXIR_IMG: git.pleroma.social:5050/pleroma/ci-image/elixir-linux-arm-v7
	tags:
	- arm32-specified

	kaniko-latest:linux/amd64:
	extends:
	- .kaniko-latest
	- .kaniko:linux/amd64

	kaniko-latest:linux/arm64:
	extends:
	- .kaniko-latest
	- .kaniko:linux/arm64

	kaniko-latest:linux/arm:
	extends:
	- .kaniko-latest
	- .kaniko:linux/arm

	kaniko-stable:linux/amd64:
	extends:
	- .kaniko-stable
	- .kaniko:linux/amd64

	kaniko-stable:linux/arm64:
	extends:
	- .kaniko-stable
	- .kaniko:linux/arm64

	kaniko-stable:linux/arm:
	extends:
	- .kaniko-stable
	- .kaniko:linux/arm

	kaniko-release:linux/amd64:
	extends:
	- .kaniko-release
	- .kaniko:linux/amd64

	kaniko-release:linux/arm64:
	extends:
	- .kaniko-release
	- .kaniko:linux/arm64

	kaniko-release:linux/arm:
	extends:
	- .kaniko-release
	- .kaniko:linux/arm

	.docker-combine:
	stage: docker-combine
	image: docker:cli
	cache: {}
	before_script:
	- 'BUILD_ARCHES="linux-amd64 linux-arm64-v8 linux-arm-v7"'
	- export IMAGE_TAG=$CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA
	- export IMAGE_TAG_SLUG=$CI_REGISTRY_IMAGE:$CI_COMMIT_REF_SLUG
	- export IMAGE_TAG_LATEST=$CI_REGISTRY_IMAGE:latest
	- export IMAGE_TAG_LATEST_STABLE=$CI_REGISTRY_IMAGE:latest-stable
	- 'IMAGES=; for arch in $BUILD_ARCHES; do IMAGES="$IMAGES $CI_REGISTRY_IMAGE/$arch:$CI_COMMIT_SHORT_SHA"; done'
	- 'IMAGES_SLUG=; for arch in $BUILD_ARCHES; do IMAGES_SLUG="$IMAGES_SLUG $CI_REGISTRY_IMAGE/$arch:$CI_COMMIT_REF_SLUG"; done'
	- 'IMAGES_LATEST=; for arch in $BUILD_ARCHES; do IMAGES_LATEST="$IMAGES_LATEST $CI_REGISTRY_IMAGE/$arch:latest"; done'
	- 'IMAGES_LATEST_STABLE=; for arch in $BUILD_ARCHES; do IMAGES_LATEST_STABLE="$IMAGES_LATEST_STABLE $CI_REGISTRY_IMAGE/$arch:latest"; done'
	- mkdir -p ~/.docker
	- echo "{\"auths\":{\"$CI_REGISTRY\":{\"username\":\"$CI_REGISTRY_USER\",\"password\":\"$CI_REGISTRY_PASSWORD\"}}}" > ~/.docker/config.json

	docker-combine:latest:
	extends: .docker-combine
	only:
	- develop@pleroma/pleroma
	script:
	- 'docker manifest create $IMAGE_TAG $IMAGES'
	- 'docker manifest push $IMAGE_TAG'
	- 'docker manifest create $IMAGE_TAG_SLUG $IMAGES_SLUG'
	- 'docker manifest push $IMAGE_TAG_SLUG'
	- 'docker manifest create $IMAGE_TAG_LATEST $IMAGES_LATEST'
	- 'docker manifest push $IMAGE_TAG_LATEST'

	docker-combine:stable:
	extends: .docker-combine
	only:
	- stable@pleroma/pleroma
	script:
	- 'docker manifest create $IMAGE_TAG $IMAGES'
	- 'docker manifest push $IMAGE_TAG'
	- 'docker manifest create $IMAGE_TAG_SLUG $IMAGES_SLUG'
	- 'docker manifest push $IMAGE_TAG_SLUG'
	- 'docker manifest create $IMAGE_TAG_LATEST_STABLE $IMAGES_LATEST_STABLE'
	- 'docker manifest push $IMAGE_TAG_LATEST_STABLE'

	docker-combine:release:
	extends: .docker-combine
	only:
	- /^release/.*$/@pleroma/pleroma
	script:
	- 'docker manifest create $IMAGE_TAG $IMAGES'
	- 'docker manifest push $IMAGE_TAG'
	- 'docker manifest create $IMAGE_TAG_SLUG $IMAGES_SLUG'
	- 'docker manifest push $IMAGE_TAG_SLUG'
	diff --git a/Dockerfile b/Dockerfile
	index d2a3e3573..13d8a85ac 100644
	--- a/Dockerfile
	+++ b/Dockerfile
	@@ -1,57 +1,57 @@
	ARG ELIXIR_IMG=hexpm/elixir
	ARG ELIXIR_VER=1.12.3
	ARG ERLANG_VER=24.2.1
	ARG ALPINE_VER=3.17.0

	FROM ${ELIXIR_IMG}:${ELIXIR_VER}-erlang-${ERLANG_VER}-alpine-${ALPINE_VER} as build

	COPY . .

	ENV MIX_ENV=prod

	-RUN apk add git gcc g++ musl-dev make cmake file-dev &&\
	+RUN apk add git gcc g++ musl-dev make cmake file-dev rust &&\
	echo "import Config" > config/prod.secret.exs &&\
	mix local.hex --force &&\
	mix local.rebar --force &&\
	mix deps.get --only prod &&\
	mkdir release &&\
	mix release --path release

	FROM alpine:${ALPINE_VER}

	ARG BUILD_DATE
	ARG VCS_REF

	LABEL maintainer="ops@pleroma.social" \
	org.opencontainers.image.title="pleroma" \
	org.opencontainers.image.description="Pleroma for Docker" \
	org.opencontainers.image.authors="ops@pleroma.social" \
	org.opencontainers.image.vendor="pleroma.social" \
	org.opencontainers.image.documentation="https://git.pleroma.social/pleroma/pleroma" \
	org.opencontainers.image.licenses="AGPL-3.0" \
	org.opencontainers.image.url="https://pleroma.social" \
	org.opencontainers.image.revision=$VCS_REF \
	org.opencontainers.image.created=$BUILD_DATE

	ARG HOME=/opt/pleroma
	ARG DATA=/var/lib/pleroma

	RUN apk update &&\
	- apk add exiftool ffmpeg imagemagick libmagic ncurses postgresql-client &&\
	+ apk add exiftool ffmpeg vips libmagic ncurses postgresql-client &&\
	adduser --system --shell /bin/false --home ${HOME} pleroma &&\
	mkdir -p ${DATA}/uploads &&\
	mkdir -p ${DATA}/static &&\
	chown -R pleroma ${DATA} &&\
	mkdir -p /etc/pleroma &&\
	chown -R pleroma /etc/pleroma

	USER pleroma

	COPY --from=build --chown=pleroma:0 /release ${HOME}

	COPY --chown=pleroma --chmod=640 ./config/docker.exs /etc/pleroma/config.exs
	COPY ./docker-entrypoint.sh ${HOME}

	EXPOSE 4000

	ENTRYPOINT ["/opt/pleroma/docker-entrypoint.sh"]
	diff --git a/changelog.d/anonymous-exception-else.fix b/changelog.d/anonymous-exception-else.fix
	new file mode 100644
	index 000000000..38d5d1be5
	--- /dev/null
	+++ b/changelog.d/anonymous-exception-else.fix
	@@ -0,0 +1 @@
	+Fix #strip_report_status_data
	diff --git a/changelog.d/blurhash.change b/changelog.d/blurhash.change
	new file mode 100644
	index 000000000..4276eb164
	--- /dev/null
	+++ b/changelog.d/blurhash.change
	@@ -0,0 +1 @@
	+Replace eblurhash with rinpatch_blurhash. This also removes a dependency on ImageMagick.
	diff --git a/changelog.d/doc-fix.skip b/changelog.d/doc-fix.skip
	new file mode 100644
	index 000000000..e69de29bb
	diff --git a/changelog.d/docs-max-elixir-erlang.change b/changelog.d/docs-max-elixir-erlang.change
	new file mode 100644
	index 000000000..a58b7fc17
	--- /dev/null
	+++ b/changelog.d/docs-max-elixir-erlang.change
	@@ -0,0 +1 @@
	+- Document maximum supported version of Erlang & Elixir
	diff --git a/changelog.d/favicon.add b/changelog.d/favicon.add
	new file mode 100644
	index 000000000..cf12395e7
	--- /dev/null
	+++ b/changelog.d/favicon.add
	@@ -0,0 +1 @@
	+Add support for configuring favicon, embed favicon and PWA manifest in server-generated meta
	diff --git a/changelog.d/federation_status-access.change b/changelog.d/federation_status-access.change
	new file mode 100644
	index 000000000..952254476
	--- /dev/null
	+++ b/changelog.d/federation_status-access.change
	@@ -0,0 +1 @@
	+- Make `/api/v1/pleroma/federation_status` publicly available
	diff --git a/changelog.d/frontend-management.add b/changelog.d/frontend-management.add
	new file mode 100644
	index 000000000..b85cddd96
	--- /dev/null
	+++ b/changelog.d/frontend-management.add
	@@ -0,0 +1 @@
	+[docs] add frontends management documentation
	diff --git a/changelog.d/generate-unset-user-keys-migration.skip b/changelog.d/generate-unset-user-keys-migration.skip
	new file mode 100644
	index 000000000..e69de29bb
	diff --git a/changelog.d/loading-order-test-fix.skip b/changelog.d/loading-order-test-fix.skip
	new file mode 100644
	index 000000000..e69de29bb
	diff --git a/changelog.d/promex.change b/changelog.d/promex.change
	new file mode 100644
	index 000000000..6c1571c54
	--- /dev/null
	+++ b/changelog.d/promex.change
	@@ -0,0 +1 @@
	+Change the prometheus library to PromEx.
	diff --git a/changelog.d/reachability.change b/changelog.d/reachability.change
	new file mode 100644
	index 000000000..06f63272b
	--- /dev/null
	+++ b/changelog.d/reachability.change
	@@ -0,0 +1 @@
	+Reduce the reachability timestamp update to a single upsert query
	diff --git a/changelog.d/scrobble-url.add b/changelog.d/scrobble-url.add
	new file mode 100644
	index 000000000..24bdeed89
	--- /dev/null
	+++ b/changelog.d/scrobble-url.add
	@@ -0,0 +1 @@
	+Adds the capability to add a URL to a scrobble (optional field)
	diff --git a/changelog.d/system-cflags.fix b/changelog.d/system-cflags.fix
	new file mode 100644
	index 000000000..84de5ad57
	--- /dev/null
	+++ b/changelog.d/system-cflags.fix
	@@ -0,0 +1 @@
	+- Fix eblurhash and elixir-captcha not using system cflags
	diff --git a/changelog.d/vips.change b/changelog.d/vips.change
	new file mode 100644
	index 000000000..ee18cd34b
	--- /dev/null
	+++ b/changelog.d/vips.change
	@@ -0,0 +1 @@
	+Change mediaproxy previews to use vips to generate thumbnails instead of ImageMagick
	diff --git a/config/config.exs b/config/config.exs
	index f2c137872..b884b3514 100644
	--- a/config/config.exs
	+++ b/config/config.exs
	@@ -1,895 +1,912 @@
	# .i;;;;i.
	# iYcviii;vXY:
	# .YXi .i1c.
	# .YC. . in7.
	# .vc. ...... ;1c.
	# i7, .. .;1;
	# i7, .. ... .Y1i
	# ,7v .6MMM@; .YX,
	# .7;. ..IMMMMMM1 :t7.
	# .;Y. ;$MMMMMM9. :tc.
	# vY. .. .nMMM@MMU. ;1v.
	# i7i ... .#MM@M@C. .....:71i
	# it: .... $MMM@9;.,i;;;i,;tti
	# :t7. ..... 0MMMWv.,iii:::,,;St.
	# .nC. ..... IMMMQ..,::::::,.,czX.
	# .ct: ....... .ZMMMI..,:::::::,,:76Y.
	# c2: ......,i..Y$M@t..:::::::,,..inZY
	# vov ......:ii..c$MBc..,,,,,,,,,,..iI9i
	# i9Y ......iii:..7@MA,..,,,,,,,,,....;AA:
	# iIS. ......:ii::..;@MI....,............;Ez.
	# .I9. ......:i::::...8M1..................C0z.
	# .z9; ......:i::::,.. .i:...................zWX.
	# vbv ......,i::::,,. ................. :AQY
	# c6Y. .,...,::::,,..:t0@@QY. ................ :8bi
	# :6S. ..,,...,:::,,,..EMMMMMMI. ............... .;bZ,
	# :6o, .,,,,..:::,,,..i#MMMMMM#v................. YW2.
	# .n8i ..,,,,,,,::,,,,.. tMMMMM@C:.................. .1Wn
	# 7Uc. .:::,,,,,::,,,,.. i1t;,..................... .UEi
	# 7C...::::::::::::,,,,.. .................... vSi.
	# ;1;...,,::::::,......... .................. Yz:
	# v97,......... .voC.
	# izAotX7777777777777777777777777777777777777777Y7n92:
	# .;CoIIIIIUAA666666699999ZZZZZZZZZZZZZZZZZZZZ6ov.
	#
	# !!! ATTENTION !!!
	# DO NOT EDIT THIS FILE! THIS FILE CONTAINS THE DEFAULT VALUES FOR THE CON-
	# FIGURATION! EDIT YOUR SECRET FILE (either prod.secret.exs, dev.secret.exs).
	#
	# This file is responsible for configuring your application
	# and its dependencies with the aid of the Config module.
	#
	# This configuration file is loaded before any dependency and
	# is restricted to this project.
	import Config

	# General application configuration
	config :pleroma, ecto_repos: [Pleroma.Repo]

	config :pleroma, Pleroma.Repo,
	telemetry_event: [Pleroma.Repo.Instrumenter],
	migration_lock: nil

	config :pleroma, Pleroma.Captcha,
	enabled: true,
	seconds_valid: 300,
	method: Pleroma.Captcha.Native

	config :pleroma, Pleroma.Captcha.Kocaptcha, endpoint: "https://captcha.kotobank.ch"

	# Upload configuration
	config :pleroma, Pleroma.Upload,
	uploader: Pleroma.Uploaders.Local,
	filters: [Pleroma.Upload.Filter.Dedupe],
	link_name: false,
	proxy_remote: false,
	filename_display_max_length: 30,
	default_description: nil,
	base_url: nil

	config :pleroma, Pleroma.Uploaders.Local, uploads: "uploads"

	config :pleroma, Pleroma.Uploaders.S3,
	bucket: nil,
	bucket_namespace: nil,
	truncated_namespace: nil,
	streaming_enabled: true

	config :ex_aws, :s3,
	# host: "s3.wasabisys.com", # required if not Amazon AWS
	access_key_id: nil,
	secret_access_key: nil,
	# region: "us-east-1", # may be required for Amazon AWS
	scheme: "https://"

	config :pleroma, :emoji,
	shortcode_globs: ["/emoji/custom/*/.png"],
	pack_extensions: [".png", ".gif"],
	groups: [
	Custom: ["/emoji/.png", "/emoji//.png"]
	],
	default_manifest: "https://git.pleroma.social/pleroma/emoji-index/raw/master/index.json",
	shared_pack_cache_seconds_per_file: 60

	config :pleroma, :uri_schemes,
	valid_schemes: [
	"https",
	"http",
	"dat",
	"dweb",
	"gopher",
	"hyper",
	"ipfs",
	"ipns",
	"irc",
	"ircs",
	"magnet",
	"mailto",
	"mumble",
	"ssb",
	"xmpp"
	]

	# Configures the endpoint
	config :pleroma, Pleroma.Web.Endpoint,
	url: [host: "localhost"],
	http: [
	ip: {127, 0, 0, 1},
	dispatch: [
	{:_,
	[
	{"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
	{:_, Plug.Cowboy.Handler, {Pleroma.Web.Endpoint, []}}
	]}
	]
	],
	protocol: "https",
	secret_key_base: "aK4Abxf29xU9TTDKre9coZPUgevcVCFQJe/5xP/7Lt4BEif6idBIbjupVbOrbKxl",
	live_view: [signing_salt: "U5ELgdEwTD3n1+D5s0rY0AMg8/y1STxZ3Zvsl3bWh+oBcGrYdil0rXqPMRd3Glcq"],
	signing_salt: "CqaoopA2",
	render_errors: [view: Pleroma.Web.ErrorView, accepts: ~w(json)],
	pubsub_server: Pleroma.PubSub,
	secure_cookie_flag: true,
	extra_cookie_attrs: [
	"SameSite=Lax"
	]

	# Configures Elixir's Logger
	config :logger, :console,
	level: :debug,
	format: "\n$time $metadata[$level] $message\n",
	metadata: [:request_id]

	config :logger, :ex_syslogger,
	level: :debug,
	ident: "pleroma",
	format: "$metadata[$level] $message",
	metadata: [:request_id]

	config :mime, :types, %{
	"application/xml" => ["xml"],
	"application/xrd+xml" => ["xrd+xml"],
	"application/jrd+json" => ["jrd+json"],
	"application/activity+json" => ["activity+json"],
	"application/ld+json" => ["activity+json"]
	}

	config :tesla, adapter: Tesla.Adapter.Hackney

	# Configures http settings, upstream proxy etc.
	config :pleroma, :http,
	proxy_url: nil,
	send_user_agent: true,
	user_agent: :default,
	adapter: []

	config :pleroma, :instance,
	name: "Pleroma",
	email: "example@example.com",
	notify_email: "noreply@example.com",
	description: "Pleroma: An efficient and flexible fediverse server",
	short_description: "",
	background_image: "/images/city.jpg",
	instance_thumbnail: "/instance/thumbnail.jpeg",
	+ favicon: "/favicon.png",
	limit: 5_000,
	description_limit: 5_000,
	remote_limit: 100_000,
	upload_limit: 16_000_000,
	avatar_upload_limit: 2_000_000,
	background_upload_limit: 4_000_000,
	banner_upload_limit: 4_000_000,
	poll_limits: %{
	max_options: 20,
	max_option_chars: 200,
	min_expiration: 0,
	max_expiration: 365 * 24 * 60 * 60
	},
	registrations_open: true,
	invites_enabled: false,
	account_activation_required: false,
	account_approval_required: false,
	federating: true,
	federation_incoming_replies_max_depth: 100,
	federation_reachability_timeout_days: 7,
	federation_publisher_modules: [
	Pleroma.Web.ActivityPub.Publisher
	],
	allow_relay: true,
	public: true,
	quarantined_instances: [],
	static_dir: "instance/static/",
	allowed_post_formats: [
	"text/plain",
	"text/html",
	"text/markdown",
	"text/bbcode"
	],
	autofollowed_nicknames: [],
	autofollowing_nicknames: [],
	max_pinned_statuses: 1,
	attachment_links: false,
	max_report_comment_size: 1000,
	report_strip_status: true,
	safe_dm_mentions: false,
	healthcheck: false,
	remote_post_retention_days: 90,
	skip_thread_containment: true,
	limit_to_local_content: :unauthenticated,
	user_bio_length: 5000,
	user_name_length: 100,
	max_account_fields: 10,
	max_remote_account_fields: 20,
	account_field_name_length: 512,
	account_field_value_length: 2048,
	registration_reason_length: 500,
	external_user_synchronization: true,
	extended_nickname_format: true,
	cleanup_attachments: false,
	multi_factor_authentication: [
	totp: [
	# digits 6 or 8
	digits: 6,
	period: 30
	],
	backup_codes: [
	number: 5,
	length: 16
	]
	],
	show_reactions: true,
	password_reset_token_validity: 60 * 60 * 24,
	profile_directory: true,
	admin_privileges: [
	:users_read,
	:users_manage_invites,
	:users_manage_activation_state,
	:users_manage_tags,
	:users_manage_credentials,
	:users_delete,
	:messages_read,
	:messages_delete,
	:instances_delete,
	:reports_manage_reports,
	:moderation_log_read,
	:announcements_manage_announcements,
	:emoji_manage_emoji,
	:statistics_read
	],
	moderator_privileges: [:messages_delete, :reports_manage_reports],
	max_endorsed_users: 20,
	birthday_required: false,
	birthday_min_age: 0,
	max_media_attachments: 1_000

	config :pleroma, :welcome,
	direct_message: [
	enabled: false,
	sender_nickname: nil,
	message: nil
	],
	chat_message: [
	enabled: false,
	sender_nickname: nil,
	message: nil
	],
	email: [
	enabled: false,
	sender: nil,
	subject: "Welcome to <%= instance_name %>",
	html: "Welcome to <%= instance_name %>",
	text: "Welcome to <%= instance_name %>"
	]

	config :pleroma, :feed,
	post_title: %{
	max_length: 100,
	omission: "..."
	}

	config :pleroma, :markup,
	# XXX - unfortunately, inline images must be enabled by default right now, because
	# of custom emoji. Issue #275 discusses defanging that somehow.
	allow_inline_images: true,
	allow_headings: false,
	allow_tables: false,
	allow_fonts: false,
	scrub_policy: [
	Pleroma.HTML.Scrubber.Default,
	Pleroma.HTML.Transform.MediaProxy
	]

	config :pleroma, :frontend_configurations,
	pleroma_fe: %{
	alwaysShowSubjectInput: true,
	background: "/images/city.jpg",
	collapseMessageWithSubject: false,
	disableChat: false,
	greentext: false,
	hideFilteredStatuses: false,
	hideMutedPosts: false,
	hidePostStats: false,
	hideSitename: false,
	hideUserStats: false,
	loginMethod: "password",
	logo: "/static/logo.svg",
	logoMargin: ".1em",
	logoMask: true,
	minimalScopesMode: false,
	noAttachmentLinks: false,
	nsfwCensorImage: "",
	postContentType: "text/plain",
	redirectRootLogin: "/main/friends",
	redirectRootNoLogin: "/main/all",
	scopeCopy: true,
	sidebarRight: false,
	showFeaturesPanel: true,
	showInstanceSpecificPanel: false,
	subjectLineBehavior: "email",
	theme: "pleroma-dark",
	webPushNotifications: false
	}

	config :pleroma, :assets,
	mascots: [
	pleroma_fox_tan: %{
	url: "/images/pleroma-fox-tan-smol.png",
	mime_type: "image/png"
	},
	pleroma_fox_tan_shy: %{
	url: "/images/pleroma-fox-tan-shy.png",
	mime_type: "image/png"
	}
	],
	default_mascot: :pleroma_fox_tan

	config :pleroma, :manifest,
	icons: [
	%{
	src: "/static/logo.svg",
	+ sizes: "144x144",
	+ purpose: "any",
	type: "image/svg+xml"
	}
	],
	theme_color: "#282c37",
	background_color: "#191b22"

	config :pleroma, :activitypub,
	unfollow_blocked: true,
	outgoing_blocks: true,
	blockers_visible: true,
	follow_handshake_timeout: 500,
	note_replies_output_limit: 5,
	sign_object_fetches: true,
	authorized_fetch_mode: false

	config :pleroma, :streamer,
	workers: 3,
	overflow_workers: 2

	config :pleroma, :user, deny_follow_blocked: true

	config :pleroma, :mrf_normalize_markup, scrub_policy: Pleroma.HTML.Scrubber.Default

	config :pleroma, :mrf_rejectnonpublic,
	allow_followersonly: false,
	allow_direct: false

	config :pleroma, :mrf_hellthread,
	delist_threshold: 10,
	reject_threshold: 20

	config :pleroma, :mrf_simple,
	media_removal: [],
	media_nsfw: [],
	federated_timeline_removal: [],
	report_removal: [],
	reject: [],
	followers_only: [],
	accept: [],
	avatar_removal: [],
	banner_removal: [],
	reject_deletes: []

	config :pleroma, :mrf_keyword,
	reject: [],
	federated_timeline_removal: [],
	replace: []

	config :pleroma, :mrf_emoji,
	remove_url: [],
	remove_shortcode: [],
	federated_timeline_removal_url: [],
	federated_timeline_removal_shortcode: []

	config :pleroma, :mrf_hashtag,
	sensitive: ["nsfw"],
	reject: [],
	federated_timeline_removal: []

	config :pleroma, :mrf_subchain, match_actor: %{}

	config :pleroma, :mrf_activity_expiration, days: 365

	config :pleroma, :mrf_vocabulary,
	accept: [],
	reject: []

	# threshold of 7 days
	config :pleroma, :mrf_object_age,
	threshold: 604_800,
	actions: [:delist, :strip_followers]

	config :pleroma, :mrf_follow_bot, follower_nickname: nil

	config :pleroma, :mrf_inline_quote, template: "<bdi>RT:</bdi> {url}"

	config :pleroma, :rich_media,
	enabled: true,
	ignore_hosts: [],
	ignore_tld: ["local", "localdomain", "lan"],
	parsers: [
	Pleroma.Web.RichMedia.Parsers.TwitterCard,
	Pleroma.Web.RichMedia.Parsers.OEmbed
	],
	failure_backoff: 60_000,
	ttl_setters: [Pleroma.Web.RichMedia.Parser.TTL.AwsSignedUrl]

	config :pleroma, :media_proxy,
	enabled: false,
	invalidation: [
	enabled: false,
	provider: Pleroma.Web.MediaProxy.Invalidation.Script
	],
	proxy_opts: [
	redirect_on_failure: false,
	max_body_length: 25 * 1_048_576,
	# Note: max_read_duration defaults to Pleroma.ReverseProxy.max_read_duration_default/1
	max_read_duration: 30_000,
	http: [
	follow_redirect: true,
	pool: :media
	]
	],
	whitelist: []

	config :pleroma, Pleroma.Web.MediaProxy.Invalidation.Http,
	method: :purge,
	headers: [],
	options: []

	config :pleroma, Pleroma.Web.MediaProxy.Invalidation.Script,
	script_path: nil,
	url_format: nil

	# Note: media preview proxy depends on media proxy to be enabled
	config :pleroma, :media_preview_proxy,
	enabled: false,
	thumbnail_max_width: 600,
	thumbnail_max_height: 600,
	image_quality: 85,
	min_content_length: 100 * 1024

	config :pleroma, :shout,
	enabled: true,
	limit: 5_000

	config :phoenix, :format_encoders, json: Jason, "activity+json": Jason

	config :phoenix, :json_library, Jason

	config :phoenix, :filter_parameters, ["password", "confirm"]

	config :pleroma, :gopher,
	enabled: false,
	ip: {0, 0, 0, 0},
	port: 9999

	config :pleroma, Pleroma.Web.Metadata,
	providers: [
	Pleroma.Web.Metadata.Providers.OpenGraph,
	Pleroma.Web.Metadata.Providers.TwitterCard
	],
	unfurl_nsfw: false

	config :pleroma, Pleroma.Web.Preload,
	providers: [
	Pleroma.Web.Preload.Providers.Instance
	]

	config :pleroma, :http_security,
	enabled: true,
	sts: false,
	sts_max_age: 31_536_000,
	ct_max_age: 2_592_000,
	referrer_policy: "same-origin"

	config :cors_plug,
	max_age: 86_400,
	methods: ["POST", "PUT", "DELETE", "GET", "PATCH", "OPTIONS"],
	expose: [
	"Link",
	"X-RateLimit-Reset",
	"X-RateLimit-Limit",
	"X-RateLimit-Remaining",
	"X-Request-Id",
	"Idempotency-Key"
	],
	credentials: true,
	headers: ["Authorization", "Content-Type", "Idempotency-Key"]

	config :pleroma, Pleroma.User,
	restricted_nicknames: [
	".well-known",
	"~",
	"about",
	"activities",
	"api",
	"auth",
	"check_password",
	"dev",
	"friend-requests",
	"inbox",
	"internal",
	"main",
	"media",
	"nodeinfo",
	"notice",
	"oauth",
	"objects",
	"ostatus_subscribe",
	"pleroma",
	"proxy",
	"push",
	"registration",
	"relay",
	"settings",
	"status",
	"tag",
	"user-search",
	"user_exists",
	"users",
	"web",
	"verify_credentials",
	"update_credentials",
	"relationships",
	"search",
	"confirmation_resend",
	"mfa"
	],
	email_blacklist: []

	config :pleroma, Oban,
	repo: Pleroma.Repo,
	log: false,
	queues: [
	activity_expiration: 10,
	token_expiration: 5,
	filter_expiration: 1,
	backup: 1,
	federator_incoming: 5,
	federator_outgoing: 5,
	ingestion_queue: 50,
	web_push: 50,
	mailer: 10,
	transmogrifier: 20,
	scheduled_activities: 10,
	poll_notifications: 10,
	background: 5,
	remote_fetcher: 2,
	attachments_cleanup: 1,
	new_users_digest: 1,
	mute_expire: 5,
	search_indexing: 10
	],
	plugins: [Oban.Plugins.Pruner],
	crontab: [
	{"0 0 * * 0", Pleroma.Workers.Cron.DigestEmailsWorker},
	{"0 0 * * *", Pleroma.Workers.Cron.NewUsersDigestWorker}
	]

	config :pleroma, :workers,
	retries: [
	federator_incoming: 5,
	federator_outgoing: 5,
	search_indexing: 2
	]

	config :pleroma, Pleroma.Formatter,
	class: false,
	rel: "ugc",
	new_window: false,
	truncate: false,
	strip_prefix: false,
	extra: true,
	validate_tld: :no_scheme

	config :pleroma, :ldap,
	enabled: System.get_env("LDAP_ENABLED") == "true",
	host: System.get_env("LDAP_HOST") \|\| "localhost",
	port: String.to_integer(System.get_env("LDAP_PORT") \|\| "389"),
	ssl: System.get_env("LDAP_SSL") == "true",
	sslopts: [],
	tls: System.get_env("LDAP_TLS") == "true",
	tlsopts: [],
	base: System.get_env("LDAP_BASE") \|\| "dc=example,dc=com",
	uid: System.get_env("LDAP_UID") \|\| "cn"

	oauth_consumer_strategies =
	System.get_env("OAUTH_CONSUMER_STRATEGIES")
	\|> to_string()
	\|> String.split()
	\|> Enum.map(&hd(String.split(&1, ":")))

	ueberauth_providers =
	for strategy <- oauth_consumer_strategies do
	strategy_module_name = "Elixir.Ueberauth.Strategy.#{String.capitalize(strategy)}"
	strategy_module = String.to_atom(strategy_module_name)
	{String.to_atom(strategy), {strategy_module, [callback_params: ["state"]]}}
	end

	config :ueberauth,
	Ueberauth,
	base_path: "/oauth",
	providers: ueberauth_providers

	config :pleroma, :auth, oauth_consumer_strategies: oauth_consumer_strategies

	config :pleroma, Pleroma.Emails.Mailer, adapter: Swoosh.Adapters.Sendmail, enabled: false

	config :pleroma, Pleroma.Emails.UserEmail,
	logo: nil,
	styling: %{
	link_color: "#d8a070",
	background_color: "#2C3645",
	content_background_color: "#1B2635",
	header_color: "#d8a070",
	text_color: "#b9b9ba",
	text_muted_color: "#b9b9ba"
	}

	config :pleroma, Pleroma.Emails.NewUsersDigestEmail, enabled: false

	-config :prometheus, Pleroma.Web.Endpoint.MetricsExporter,
	- enabled: false,
	- auth: false,
	- ip_whitelist: [],
	- path: "/api/pleroma/app_metrics",
	- format: :text
	+config :pleroma, Pleroma.PromEx,
	+ disabled: false,
	+ manual_metrics_start_delay: :no_delay,
	+ drop_metrics_groups: [],
	+ grafana: [
	+ host: System.get_env("GRAFANA_HOST", "http://localhost:3000"),
	+ auth_token: System.get_env("GRAFANA_TOKEN"),
	+ upload_dashboards_on_start: false,
	+ folder_name: "BEAM",
	+ annotate_app_lifecycle: true
	+ ],
	+ metrics_server: [
	+ port: 4021,
	+ path: "/metrics",
	+ protocol: :http,
	+ pool_size: 5,
	+ cowboy_opts: [],
	+ auth_strategy: :none
	+ ],
	+ datasource: "Prometheus"

	config :pleroma, Pleroma.ScheduledActivity,
	daily_user_limit: 25,
	total_user_limit: 300,
	enabled: true

	config :pleroma, :email_notifications,
	digest: %{
	active: false,
	interval: 7,
	inactivity_threshold: 7
	}

	config :pleroma, :oauth2,
	token_expires_in: 3600 * 24 * 365 * 100,
	issue_new_refresh_token: true,
	clean_expired_tokens: false

	config :pleroma, :database, rum_enabled: false

	config :pleroma, :features, improved_hashtag_timeline: :auto

	config :pleroma, :populate_hashtags_table, fault_rate_allowance: 0.01

	config :pleroma, :delete_context_objects, fault_rate_allowance: 0.01

	config :pleroma, :env, Mix.env()

	config :http_signatures,
	adapter: Pleroma.Signature

	config :pleroma, :rate_limit,
	authentication: {60_000, 15},
	timeline: {500, 3},
	search: [{1000, 10}, {1000, 30}],
	app_account_creation: {1_800_000, 25},
	relations_actions: {10_000, 10},
	relation_id_action: {60_000, 2},
	statuses_actions: {10_000, 15},
	status_id_action: {60_000, 3},
	password_reset: {1_800_000, 5},
	account_confirmation_resend: {8_640_000, 5},
	ap_routes: {60_000, 15}

	config :pleroma, Pleroma.Workers.PurgeExpiredActivity, enabled: true, min_lifetime: 600

	config :pleroma, Pleroma.Web.Plugs.RemoteIp,
	enabled: true,
	headers: ["x-forwarded-for"],
	proxies: [],
	reserved: [
	"127.0.0.0/8",
	"::1/128",
	"fc00::/7",
	"10.0.0.0/8",
	"172.16.0.0/12",
	"192.168.0.0/16"
	]

	config :pleroma, :static_fe, enabled: false

	# Example of frontend configuration
	# This example will make us serve the primary frontend from the
	# frontends directory within your `:pleroma, :instance, static_dir`.
	# e.g., instance/static/frontends/pleroma/develop/
	#
	# With no frontend configuration, the bundled files from the `static` directory will
	# be used.
	#
	# config :pleroma, :frontends,
	# primary: %{"name" => "pleroma-fe", "ref" => "develop"},
	# admin: %{"name" => "admin-fe", "ref" => "stable"},
	# available: %{...}

	config :pleroma, :frontends,
	available: %{
	"kenoma" => %{
	"name" => "kenoma",
	"git" => "https://git.pleroma.social/lambadalambda/kenoma",
	"build_url" =>
	"https://git.pleroma.social/lambadalambda/kenoma/-/jobs/artifacts/${ref}/download?job=build",
	"ref" => "master"
	},
	"pleroma-fe" => %{
	"name" => "pleroma-fe",
	"git" => "https://git.pleroma.social/pleroma/pleroma-fe",
	"build_url" =>
	"https://git.pleroma.social/pleroma/pleroma-fe/-/jobs/artifacts/${ref}/download?job=build",
	"ref" => "develop"
	},
	"fedi-fe" => %{
	"name" => "fedi-fe",
	"git" => "https://git.pleroma.social/pleroma/fedi-fe",
	"build_url" =>
	"https://git.pleroma.social/pleroma/fedi-fe/-/jobs/artifacts/${ref}/download?job=build_release",
	"ref" => "master",
	"custom-http-headers" => [
	{"service-worker-allowed", "/"}
	]
	},
	"admin-fe" => %{
	"name" => "admin-fe",
	"git" => "https://git.pleroma.social/pleroma/admin-fe",
	"build_url" =>
	"https://git.pleroma.social/pleroma/admin-fe/-/jobs/artifacts/${ref}/download?job=build",
	"ref" => "develop"
	},
	"soapbox" => %{
	"name" => "soapbox",
	"git" => "https://gitlab.com/soapbox-pub/soapbox",
	"build_url" =>
	"https://gitlab.com/soapbox-pub/soapbox/-/jobs/artifacts/${ref}/download?job=build-production",
	"ref" => "v3.0.0-beta.1",
	"build_dir" => "static"
	},
	"glitch-lily" => %{
	"name" => "glitch-lily",
	"git" => "https://lily-is.land/infra/glitch-lily",
	"build_url" =>
	"https://lily-is.land/infra/glitch-lily/-/jobs/artifacts/${ref}/download?job=build",
	"ref" => "servant",
	"build_dir" => "public"
	}
	}

	config :pleroma, :web_cache_ttl,
	activity_pub: nil,
	activity_pub_question: 30_000

	config :pleroma, :modules, runtime_dir: "instance/modules"

	config :pleroma, configurable_from_database: false

	config :pleroma, Pleroma.Repo,
	parameters: [gin_fuzzy_search_limit: "500"],
	prepare: :unnamed

	config :pleroma, :connections_pool,
	reclaim_multiplier: 0.1,
	connection_acquisition_wait: 250,
	connection_acquisition_retries: 5,
	max_connections: 250,
	max_idle_time: 30_000,
	retry: 0,
	connect_timeout: 5_000

	config :pleroma, :pools,
	federation: [
	size: 50,
	max_waiting: 10,
	recv_timeout: 10_000
	],
	media: [
	size: 50,
	max_waiting: 20,
	recv_timeout: 15_000
	],
	upload: [
	size: 25,
	max_waiting: 5,
	recv_timeout: 15_000
	],
	default: [
	size: 10,
	max_waiting: 2,
	recv_timeout: 5_000
	]

	config :pleroma, :hackney_pools,
	federation: [
	max_connections: 50,
	timeout: 150_000
	],
	media: [
	max_connections: 50,
	timeout: 150_000
	],
	upload: [
	max_connections: 25,
	timeout: 300_000
	]

	config :pleroma, :majic_pool, size: 2

	private_instance? = :if_instance_is_private

	config :pleroma, :restrict_unauthenticated,
	timelines: %{local: private_instance?, federated: private_instance?},
	profiles: %{local: private_instance?, remote: private_instance?},
	activities: %{local: private_instance?, remote: private_instance?}

	config :pleroma, Pleroma.Web.ApiSpec.CastAndValidate, strict: false

	config :pleroma, :mrf,
	policies: [
	Pleroma.Web.ActivityPub.MRF.ObjectAgePolicy,
	Pleroma.Web.ActivityPub.MRF.TagPolicy,
	Pleroma.Web.ActivityPub.MRF.InlineQuotePolicy
	],
	transparency: true,
	transparency_exclusions: []

	config :tzdata, :http_client, Pleroma.HTTP.Tzdata

	config :ex_aws, http_client: Pleroma.HTTP.ExAws

	config :web_push_encryption, http_client: Pleroma.HTTP.WebPush

	config :pleroma, :instances_favicons, enabled: false

	config :floki, :html_parser, Floki.HTMLParser.FastHtml

	config :pleroma, Pleroma.Web.Auth.Authenticator, Pleroma.Web.Auth.PleromaAuthenticator

	config :pleroma, Pleroma.User.Backup,
	purge_after_days: 30,
	limit_days: 7,
	dir: nil,
	process_wait_time: 30_000,
	process_chunk_size: 100

	config :pleroma, ConcurrentLimiter, [
	{Pleroma.Web.RichMedia.Helpers, [max_running: 5, max_waiting: 5]},
	{Pleroma.Web.ActivityPub.MRF.MediaProxyWarmingPolicy, [max_running: 5, max_waiting: 5]},
	{Pleroma.Search, [max_running: 30, max_waiting: 50]}
	]

	config :pleroma, Pleroma.Web.WebFinger, domain: nil, update_nickname_on_user_fetch: true

	config :pleroma, Pleroma.Search, module: Pleroma.Search.DatabaseSearch

	config :pleroma, Pleroma.Search.Meilisearch,
	url: "http://127.0.0.1:7700/",
	private_key: nil,
	initial_indexing_chunk_size: 100_000

	# Import environment specific config. This must remain at the bottom
	# of this file so it overrides the configuration defined above.
	import_config "#{Mix.env()}.exs"
	diff --git a/config/description.exs b/config/description.exs
	index b152981c4..27e7f7e9b 100644
	--- a/config/description.exs
	+++ b/config/description.exs
	@@ -1,3513 +1,3519 @@
	import Config

	websocket_config = [
	path: "/websocket",
	serializer: [
	{Phoenix.Socket.V1.JSONSerializer, "~> 1.0.0"},
	{Phoenix.Socket.V2.JSONSerializer, "~> 2.0.0"}
	],
	timeout: 60_000,
	transport_log: false,
	compress: false
	]

	installed_frontend_options = [
	%{
	key: "name",
	label: "Name",
	type: :string,
	description:
	"Name of the installed frontend. Valid config must include both `Name` and `Reference` values."
	},
	%{
	key: "ref",
	label: "Reference",
	type: :string,
	description:
	"Reference of the installed frontend to be used. Valid config must include both `Name` and `Reference` values."
	}
	]

	frontend_options = [
	%{
	key: "name",
	label: "Name",
	type: :string,
	description: "Name of the frontend."
	},
	%{
	key: "ref",
	label: "Reference",
	type: :string,
	description: "Reference of the frontend to be used."
	},
	%{
	key: "git",
	label: "Git Repository URL",
	type: :string,
	description: "URL of the git repository of the frontend"
	},
	%{
	key: "build_url",
	label: "Build URL",
	type: :string,
	description:
	"Either an url to a zip file containing the frontend or a template to build it by inserting the `ref`. The string `${ref}` will be replaced by the configured `ref`.",
	example: "https://some.url/builds/${ref}.zip"
	},
	%{
	key: "build_dir",
	label: "Build directory",
	type: :string,
	description: "The directory inside the zip file "
	},
	%{
	key: "custom-http-headers",
	label: "Custom HTTP headers",
	type: {:list, :string},
	description: "The custom HTTP headers for the frontend"
	}
	]

	config :pleroma, :config_description, [
	%{
	group: :pleroma,
	key: Pleroma.Upload,
	type: :group,
	description: "Upload general settings",
	children: [
	%{
	key: :uploader,
	type: :module,
	description: "Module which will be used for uploads",
	suggestions: {:list_behaviour_implementations, Pleroma.Uploaders.Uploader}
	},
	%{
	key: :filters,
	type: {:list, :module},
	description:
	"List of filter modules for uploads. Module names are shortened (removed leading `Pleroma.Upload.Filter.` part), but on adding custom module you need to use full name.",
	suggestions: {:list_behaviour_implementations, Pleroma.Upload.Filter}
	},
	%{
	key: :link_name,
	type: :boolean,
	description:
	"If enabled, a name parameter will be added to the URL of the upload. For example `https://instance.tld/media/imagehash.png?name=realname.png`."
	},
	%{
	key: :base_url,
	label: "Base URL",
	type: :string,
	description:
	"Base URL for the uploads. Required if you use a CDN or host attachments under a different domain.",
	suggestions: [
	"https://cdn-host.com"
	]
	},
	%{
	key: :proxy_remote,
	type: :boolean,
	description: """
	Proxy requests to the remote uploader.\n
	Useful if media upload endpoint is not internet accessible.
	"""
	},
	%{
	key: :filename_display_max_length,
	type: :integer,
	description: "Set max length of a filename to display. 0 = no limit. Default: 30"
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Uploaders.Local,
	type: :group,
	description: "Local uploader-related settings",
	children: [
	%{
	key: :uploads,
	type: :string,
	description: "Path where user's uploads will be saved",
	suggestions: [
	"uploads"
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Uploaders.S3,
	type: :group,
	description: "S3 uploader-related settings",
	children: [
	%{
	key: :bucket,
	type: :string,
	description: "S3 bucket",
	suggestions: [
	"bucket"
	]
	},
	%{
	key: :bucket_namespace,
	type: :string,
	description: "S3 bucket namespace",
	suggestions: ["pleroma"]
	},
	%{
	key: :truncated_namespace,
	type: :string,
	description:
	"If you use S3 compatible service such as Digital Ocean Spaces or CDN, set folder name or \"\" etc." <>
	" For example, when using CDN to S3 virtual host format, set \"\". At this time, write CNAME to CDN in Upload base_url."
	},
	%{
	key: :streaming_enabled,
	type: :boolean,
	description:
	"Enable streaming uploads, when enabled the file will be sent to the server in chunks as it's being read. This may be unsupported by some providers, try disabling this if you have upload problems."
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Upload.Filter.Mogrify,
	type: :group,
	description: "Uploads mogrify filter settings",
	children: [
	%{
	key: :args,
	type: [:string, {:list, :string}, {:list, :tuple}],
	description:
	"List of actions for the mogrify command. It's possible to add self-written settings as string. " <>
	"For example `auto-orient, strip, {\"resize\", \"3840x1080>\"}` value will be parsed into valid list of the settings.",
	suggestions: [
	"strip",
	"auto-orient",
	{"implode", "1"}
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Upload.Filter.AnonymizeFilename,
	type: :group,
	description: "Filter replaces the filename of the upload",
	children: [
	%{
	key: :text,
	type: :string,
	description:
	"Text to replace filenames in links. If no setting, {random}.extension will be used. You can get the original" <>
	" filename extension by using {extension}, for example custom-file-name.{extension}.",
	suggestions: [
	"custom-file-name.{extension}"
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Emails.Mailer,
	type: :group,
	description: "Mailer-related settings",
	children: [
	%{
	key: :enabled,
	label: "Mailer Enabled",
	type: :boolean
	},
	%{
	key: :adapter,
	type: :module,
	description:
	"One of the mail adapters listed in [Swoosh documentation](https://hexdocs.pm/swoosh/Swoosh.html#module-adapters)",
	suggestions: [
	Swoosh.Adapters.AmazonSES,
	Swoosh.Adapters.Dyn,
	Swoosh.Adapters.Gmail,
	Swoosh.Adapters.Mailgun,
	Swoosh.Adapters.Mailjet,
	Swoosh.Adapters.Mandrill,
	Swoosh.Adapters.Postmark,
	Swoosh.Adapters.SMTP,
	Swoosh.Adapters.Sendgrid,
	Swoosh.Adapters.Sendmail,
	Swoosh.Adapters.SocketLabs,
	Swoosh.Adapters.SparkPost
	]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.SMTP},
	key: :relay,
	type: :string,
	description: "Hostname or IP address",
	suggestions: ["smtp.example.com"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.SMTP},
	key: :port,
	type: :integer,
	description: "SMTP port",
	suggestions: ["1025"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.SMTP},
	key: :username,
	type: :string,
	description: "SMTP AUTH username",
	suggestions: ["user@example.com"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.SMTP},
	key: :password,
	type: :string,
	description: "SMTP AUTH password",
	suggestions: ["password"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.SMTP},
	key: :ssl,
	label: "Use SSL",
	type: :boolean,
	description: "Use Implicit SSL/TLS. e.g. port 465"
	},
	%{
	group: {:subgroup, Swoosh.Adapters.SMTP},
	key: :tls,
	label: "STARTTLS Mode",
	type: {:dropdown, :atom},
	description: "Explicit TLS (STARTTLS) enforcement mode",
	suggestions: [:if_available, :always, :never]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.SMTP},
	key: :auth,
	label: "AUTH Mode",
	type: {:dropdown, :atom},
	description: "SMTP AUTH enforcement mode",
	suggestions: [:if_available, :always, :never]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.SMTP},
	key: :retries,
	type: :integer,
	description: "SMTP temporary (4xx) error retries",
	suggestions: [1]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.Sendgrid},
	key: :api_key,
	label: "SendGrid API Key",
	type: :string,
	suggestions: ["YOUR_API_KEY"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.Sendmail},
	key: :cmd_path,
	type: :string,
	suggestions: ["/usr/bin/sendmail"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.Sendmail},
	key: :cmd_args,
	type: :string,
	suggestions: ["-N delay,failure,success"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.Sendmail},
	key: :qmail,
	label: "Qmail compat mode",
	type: :boolean
	},
	%{
	group: {:subgroup, Swoosh.Adapters.Mandrill},
	key: :api_key,
	label: "Mandrill API Key",
	type: :string,
	suggestions: ["YOUR_API_KEY"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.Mailgun},
	key: :api_key,
	label: "Mailgun API Key",
	type: :string,
	suggestions: ["YOUR_API_KEY"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.Mailgun},
	key: :domain,
	type: :string,
	suggestions: ["YOUR_DOMAIN_NAME"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.Mailjet},
	key: :api_key,
	label: "MailJet Public API Key",
	type: :string,
	suggestions: ["MJ_APIKEY_PUBLIC"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.Mailjet},
	key: :secret,
	label: "MailJet Private API Key",
	type: :string,
	suggestions: ["MJ_APIKEY_PRIVATE"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.Postmark},
	key: :api_key,
	label: "Postmark API Key",
	type: :string,
	suggestions: ["X-Postmark-Server-Token"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.SparkPost},
	key: :api_key,
	label: "SparkPost API key",
	type: :string,
	suggestions: ["YOUR_API_KEY"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.SparkPost},
	key: :endpoint,
	type: :string,
	suggestions: ["https://api.sparkpost.com/api/v1"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.AmazonSES},
	key: :access_key,
	label: "AWS Access Key",
	type: :string,
	suggestions: ["AWS_ACCESS_KEY"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.AmazonSES},
	key: :secret,
	label: "AWS Secret Key",
	type: :string,
	suggestions: ["AWS_SECRET_KEY"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.AmazonSES},
	key: :region,
	label: "AWS Region",
	type: :string,
	suggestions: ["us-east-1", "us-east-2"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.Dyn},
	key: :api_key,
	label: "Dyn API Key",
	type: :string,
	suggestions: ["apikey"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.SocketLabs},
	key: :api_key,
	label: "SocketLabs API Key",
	type: :string,
	suggestions: ["INJECTION_API_KEY"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.SocketLabs},
	key: :server_id,
	label: "Server ID",
	type: :string,
	suggestions: ["SERVER_ID"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.Gmail},
	key: :access_token,
	label: "GMail API Access Token",
	type: :string,
	suggestions: ["GMAIL_API_ACCESS_TOKEN"]
	}
	]
	},
	%{
	group: :pleroma,
	key: :uri_schemes,
	label: "URI Schemes",
	type: :group,
	description: "URI schemes related settings",
	children: [
	%{
	key: :valid_schemes,
	type: {:list, :string},
	description: "List of the scheme part that is considered valid to be an URL",
	suggestions: [
	"https",
	"http",
	"dat",
	"dweb",
	"gopher",
	"hyper",
	"ipfs",
	"ipns",
	"irc",
	"ircs",
	"magnet",
	"mailto",
	"mumble",
	"ssb",
	"xmpp"
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: :features,
	type: :group,
	description: "Customizable features",
	children: [
	%{
	key: :improved_hashtag_timeline,
	type: {:dropdown, :atom},
	description:
	"Setting to force toggle / force disable improved hashtags timeline. `:enabled` forces hashtags to be fetched from `hashtags` table for hashtags timeline. `:disabled` forces object-embedded hashtags to be used (slower). Keep it `:auto` for automatic behaviour (it is auto-set to `:enabled` [unless overridden] when HashtagsTableMigrator completes).",
	suggestions: [:auto, :enabled, :disabled]
	}
	]
	},
	%{
	group: :pleroma,
	key: :populate_hashtags_table,
	type: :group,
	description: "`populate_hashtags_table` background migration settings",
	children: [
	%{
	key: :fault_rate_allowance,
	type: :float,
	description:
	"Max accepted rate of objects that failed in the migration. Any value from 0.0 which tolerates no errors to 1.0 which will enable the feature even if hashtags transfer failed for all records.",
	suggestions: [0.01]
	},
	%{
	key: :sleep_interval_ms,
	type: :integer,
	description:
	"Sleep interval between each chunk of processed records in order to decrease the load on the system (defaults to 0 and should be keep default on most instances)."
	}
	]
	},
	%{
	group: :pleroma,
	key: :delete_context_objects,
	type: :group,
	description: "`delete_context_objects` background migration settings",
	children: [
	%{
	key: :fault_rate_allowance,
	type: :float,
	description:
	"Max accepted rate of objects that failed in the migration. Any value from 0.0 which tolerates no errors to 1.0 which will enable the feature even if context object deletion failed for all records.",
	suggestions: [0.01]
	},
	%{
	key: :sleep_interval_ms,
	type: :integer,
	description:
	"Sleep interval between each chunk of processed records in order to decrease the load on the system (defaults to 0 and should be keep default on most instances)."
	}
	]
	},
	%{
	group: :pleroma,
	key: :instance,
	type: :group,
	description: "Instance-related settings",
	children: [
	%{
	key: :name,
	type: :string,
	description: "Name of the instance",
	suggestions: [
	"Pleroma"
	]
	},
	%{
	key: :email,
	label: "Admin Email Address",
	type: :string,
	description: "Email used to reach an Administrator/Moderator of the instance",
	suggestions: [
	"email@example.com"
	]
	},
	%{
	key: :notify_email,
	label: "Sender Email Address",
	type: :string,
	description: "Envelope FROM address for mail sent via Pleroma",
	suggestions: [
	"notify@example.com"
	]
	},
	%{
	key: :description,
	type: :string,
	description:
	"The instance's description. It can be seen in nodeinfo and `/api/v1/instance`",
	suggestions: [
	"Very cool instance"
	]
	},
	%{
	key: :short_description,
	type: :string,
	description:
	"Shorter version of instance description. It can be seen on `/api/v1/instance`",
	suggestions: [
	"Cool instance"
	]
	},
	%{
	key: :limit,
	type: :integer,
	description: "Posts character limit (CW/Subject included in the counter)",
	suggestions: [
	5_000
	]
	},
	%{
	key: :remote_limit,
	type: :integer,
	description: "Hard character limit beyond which remote posts will be dropped",
	suggestions: [
	100_000
	]
	},
	%{
	key: :max_media_attachments,
	type: :integer,
	description: "Maximum number of post media attachments",
	suggestions: [
	1_000_000
	]
	},
	%{
	key: :upload_limit,
	type: :integer,
	description: "File size limit of uploads (except for avatar, background, banner)",
	suggestions: [
	16_000_000
	]
	},
	%{
	key: :avatar_upload_limit,
	type: :integer,
	description: "File size limit of user's profile avatars",
	suggestions: [
	2_000_000
	]
	},
	%{
	key: :background_upload_limit,
	type: :integer,
	description: "File size limit of user's profile backgrounds",
	suggestions: [
	4_000_000
	]
	},
	%{
	key: :banner_upload_limit,
	type: :integer,
	description: "File size limit of user's profile banners",
	suggestions: [
	4_000_000
	]
	},
	%{
	key: :poll_limits,
	type: :map,
	description: "A map with poll limits for local polls",
	suggestions: [
	%{
	max_options: 20,
	max_option_chars: 200,
	min_expiration: 0,
	max_expiration: 31_536_000
	}
	],
	children: [
	%{
	key: :max_options,
	type: :integer,
	description: "Maximum number of options",
	suggestions: [20]
	},
	%{
	key: :max_option_chars,
	type: :integer,
	description: "Maximum number of characters per option",
	suggestions: [200]
	},
	%{
	key: :min_expiration,
	type: :integer,
	description: "Minimum expiration time (in seconds)",
	suggestions: [0]
	},
	%{
	key: :max_expiration,
	type: :integer,
	description: "Maximum expiration time (in seconds)",
	suggestions: [3600]
	}
	]
	},
	%{
	key: :registrations_open,
	type: :boolean,
	description:
	"Enable registrations for anyone. Invitations require this setting to be disabled."
	},
	%{
	key: :invites_enabled,
	type: :boolean,
	description:
	"Enable user invitations for admins (depends on `registrations_open` being disabled)"
	},
	%{
	key: :account_activation_required,
	type: :boolean,
	description: "Require users to confirm their emails before signing in"
	},
	%{
	key: :account_approval_required,
	type: :boolean,
	description: "Require users to be manually approved by an admin before signing in"
	},
	%{
	key: :federating,
	type: :boolean,
	description: "Enable federation with other instances"
	},
	%{
	key: :federation_incoming_replies_max_depth,
	label: "Fed. incoming replies max depth",
	type: :integer,
	description:
	"Max. depth of reply-to and reply activities fetching on incoming federation, to prevent out-of-memory situations while" <>
	" fetching very long threads. If set to `nil`, threads of any depth will be fetched. Lower this value if you experience out-of-memory crashes.",
	suggestions: [
	100
	]
	},
	%{
	key: :federation_reachability_timeout_days,
	label: "Fed. reachability timeout days",
	type: :integer,
	description:
	"Timeout (in days) of each external federation target being unreachable prior to pausing federating to it",
	suggestions: [
	7
	]
	},
	%{
	key: :allow_relay,
	type: :boolean,
	description:
	"Permits remote instances to subscribe to all public posts of your instance. (Important!) This may increase the visibility of your instance."
	},
	%{
	key: :public,
	type: :boolean,
	description:
	"Makes the client API in authenticated mode-only except for user-profiles." <>
	" Useful for disabling the Local Timeline and The Whole Known Network. " <>
	" Note: when setting to `false`, please also check `:restrict_unauthenticated` setting."
	},
	%{
	key: :quarantined_instances,
	type: {:list, :tuple},
	key_placeholder: "instance",
	value_placeholder: "reason",
	description:
	"List of ActivityPub instances where private (DMs, followers-only) activities will not be sent and the reason for doing so",
	suggestions: [
	{"quarantined.com", "Reason"},
	{"*.quarantined.com", "Reason"}
	]
	},
	%{
	key: :static_dir,
	type: :string,
	description: "Instance static directory",
	suggestions: [
	"instance/static/"
	]
	},
	%{
	key: :allowed_post_formats,
	type: {:list, :string},
	description: "MIME-type list of formats allowed to be posted (transformed into HTML)",
	suggestions: [
	"text/plain",
	"text/html",
	"text/markdown",
	"text/bbcode"
	]
	},
	%{
	key: :extended_nickname_format,
	type: :boolean,
	description:
	"Enable to use extended local nicknames format (allows underscores/dashes)." <>
	" This will break federation with older software for theses nicknames."
	},
	%{
	key: :cleanup_attachments,
	type: :boolean,
	description: """
	Enable to remove associated attachments when status is removed.
	This will not affect duplicates and attachments without status.
	Enabling this will increase load to database when deleting statuses on larger instances.
	"""
	},
	%{
	key: :max_pinned_statuses,
	type: :integer,
	description: "The maximum number of pinned statuses. 0 will disable the feature.",
	suggestions: [
	0,
	1,
	3
	]
	},
	%{
	key: :max_endorsed_users,
	type: :integer,
	description: "The maximum number of recommended accounts. 0 will disable the feature.",
	suggestions: [
	0,
	1,
	3
	]
	},
	%{
	key: :autofollowed_nicknames,
	type: {:list, :string},
	description:
	"Set to nicknames of (local) users that every new user should automatically follow"
	},
	%{
	key: :autofollowing_nicknames,
	type: {:list, :string},
	description:
	"Set to nicknames of (local) users that automatically follows every newly registered user"
	},
	%{
	key: :attachment_links,
	type: :boolean,
	description: "Enable to automatically add attachment link text to statuses"
	},
	%{
	key: :max_report_comment_size,
	type: :integer,
	description: "The maximum size of the report comment. Default: 1000.",
	suggestions: [
	1_000
	]
	},
	%{
	key: :report_strip_status,
	label: "Report strip status",
	type: :boolean,
	description:
	"Strip associated statuses in reports to ids when closed/resolved, otherwise keep a copy"
	},
	%{
	key: :safe_dm_mentions,
	label: "Safe DM mentions",
	type: :boolean,
	description:
	"If enabled, only mentions at the beginning of a post will be used to address people in direct messages." <>
	" This is to prevent accidental mentioning of people when talking about them (e.g. \"@admin please keep an eye on @bad_actor\")." <>
	" Default: disabled"
	},
	%{
	key: :healthcheck,
	type: :boolean,
	description: "If enabled, system data will be shown on `/api/pleroma/healthcheck`"
	},
	%{
	key: :remote_post_retention_days,
	type: :integer,
	description:
	"The default amount of days to retain remote posts when pruning the database",
	suggestions: [
	90
	]
	},
	%{
	key: :user_bio_length,
	type: :integer,
	description: "A user bio maximum length. Default: 5000.",
	suggestions: [
	5_000
	]
	},
	%{
	key: :user_name_length,
	type: :integer,
	description: "A user name maximum length. Default: 100.",
	suggestions: [
	100
	]
	},
	%{
	key: :skip_thread_containment,
	type: :boolean,
	description: "Skip filtering out broken threads. Default: enabled."
	},
	%{
	key: :limit_to_local_content,
	type: {:dropdown, :atom},
	description:
	"Limit unauthenticated users to search for local statutes and users only. Default: `:unauthenticated`.",
	suggestions: [
	:unauthenticated,
	:all,
	false
	]
	},
	%{
	key: :max_account_fields,
	type: :integer,
	description: "The maximum number of custom fields in the user profile. Default: 10.",
	suggestions: [
	10
	]
	},
	%{
	key: :max_remote_account_fields,
	type: :integer,
	description:
	"The maximum number of custom fields in the remote user profile. Default: 20.",
	suggestions: [
	20
	]
	},
	%{
	key: :account_field_name_length,
	type: :integer,
	description: "An account field name maximum length. Default: 512.",
	suggestions: [
	512
	]
	},
	%{
	key: :account_field_value_length,
	type: :integer,
	description: "An account field value maximum length. Default: 2048.",
	suggestions: [
	2048
	]
	},
	%{
	key: :registration_reason_length,
	type: :integer,
	description: "Maximum registration reason length. Default: 500.",
	suggestions: [
	500
	]
	},
	%{
	key: :external_user_synchronization,
	type: :boolean,
	description: "Enabling following/followers counters synchronization for external users"
	},
	%{
	key: :multi_factor_authentication,
	type: :keyword,
	description: "Multi-factor authentication settings",
	suggestions: [
	[
	totp: [digits: 6, period: 30],
	backup_codes: [number: 5, length: 16]
	]
	],
	children: [
	%{
	key: :totp,
	label: "TOTP settings",
	type: :keyword,
	description: "TOTP settings",
	suggestions: [digits: 6, period: 30],
	children: [
	%{
	key: :digits,
	type: :integer,
	suggestions: [6],
	description:
	"Determines the length of a one-time pass-code, in characters. Defaults to 6 characters."
	},
	%{
	key: :period,
	type: :integer,
	suggestions: [30],
	description:
	"A period for which the TOTP code will be valid, in seconds. Defaults to 30 seconds."
	}
	]
	},
	%{
	key: :backup_codes,
	type: :keyword,
	description: "MFA backup codes settings",
	suggestions: [number: 5, length: 16],
	children: [
	%{
	key: :number,
	type: :integer,
	suggestions: [5],
	description: "Number of backup codes to generate."
	},
	%{
	key: :length,
	type: :integer,
	suggestions: [16],
	description:
	"Determines the length of backup one-time pass-codes, in characters. Defaults to 16 characters."
	}
	]
	}
	]
	},
	%{
	key: :instance_thumbnail,
	type: {:string, :image},
	description:
	"The instance thumbnail can be any image that represents your instance and is used by some apps or services when they display information about your instance.",
	suggestions: ["/instance/thumbnail.jpeg"]
	},
	+ %{
	+ key: :favicon,
	+ type: {:string, :image},
	+ description: "Favicon of the instance",
	+ suggestions: ["/favicon.png"]
	+ },
	%{
	key: :show_reactions,
	type: :boolean,
	description: "Let favourites and emoji reactions be viewed through the API."
	},
	%{
	key: :profile_directory,
	type: :boolean,
	description: "Enable profile directory."
	},
	%{
	key: :admin_privileges,
	type: {:list, :atom},
	suggestions: [
	:users_read,
	:users_manage_invites,
	:users_manage_activation_state,
	:users_manage_tags,
	:users_manage_credentials,
	:users_delete,
	:messages_read,
	:messages_delete,
	:instances_delete,
	:reports_manage_reports,
	:moderation_log_read,
	:announcements_manage_announcements,
	:emoji_manage_emoji,
	:statistics_read
	],
	description:
	"What extra privileges to allow admins (e.g. updating user credentials, get password reset token, delete users, index and read private statuses and chats)"
	},
	%{
	key: :moderator_privileges,
	type: {:list, :atom},
	suggestions: [
	:users_read,
	:users_manage_invites,
	:users_manage_activation_state,
	:users_manage_tags,
	:users_manage_credentials,
	:users_delete,
	:messages_read,
	:messages_delete,
	:instances_delete,
	:reports_manage_reports,
	:moderation_log_read,
	:announcements_manage_announcements,
	:emoji_manage_emoji,
	:statistics_read
	],
	description:
	"What extra privileges to allow moderators (e.g. updating user credentials, get password reset token, delete users, index and read private statuses and chats)"
	},
	%{
	key: :birthday_required,
	type: :boolean,
	description: "Require users to enter their birthday."
	},
	%{
	key: :birthday_min_age,
	type: :integer,
	description:
	"Minimum required age (in days) for users to create account. Only used if birthday is required.",
	suggestions: [6570]
	},
	%{
	key: :languages,
	type: {:list, :string},
	description:
	"Languages to be exposed in /api/v1/instance. Should be in the format of BCP47 language codes.",
	suggestions: [
	"en"
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: :welcome,
	type: :group,
	description: "Welcome messages settings",
	children: [
	%{
	key: :direct_message,
	type: :keyword,
	descpiption: "Direct message settings",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enables sending a direct message to newly registered users"
	},
	%{
	key: :message,
	type: :string,
	description: "A message that will be sent to newly registered users",
	suggestions: [
	"Hi, @username! Welcome on board!"
	]
	},
	%{
	key: :sender_nickname,
	type: :string,
	description: "The nickname of the local user that sends a welcome message",
	suggestions: [
	"lain"
	]
	}
	]
	},
	%{
	key: :chat_message,
	type: :keyword,
	descpiption: "Chat message settings",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enables sending a chat message to newly registered users"
	},
	%{
	key: :message,
	type: :string,
	description:
	"A message that will be sent to newly registered users as a chat message",
	suggestions: [
	"Hello, welcome on board!"
	]
	},
	%{
	key: :sender_nickname,
	type: :string,
	description: "The nickname of the local user that sends a welcome chat message",
	suggestions: [
	"lain"
	]
	}
	]
	},
	%{
	key: :email,
	type: :keyword,
	descpiption: "Email message settings",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enables sending an email to newly registered users"
	},
	%{
	key: :sender,
	type: [:string, :tuple],
	description:
	"Email address and/or nickname that will be used to send the welcome email.",
	suggestions: [
	{"Pleroma App", "welcome@pleroma.app"}
	]
	},
	%{
	key: :subject,
	type: :string,
	description:
	"Subject of the welcome email. EEX template with user and instance_name variables can be used.",
	suggestions: ["Welcome to <%= instance_name%>"]
	},
	%{
	key: :html,
	type: :string,
	description:
	"HTML content of the welcome email. EEX template with user and instance_name variables can be used.",
	suggestions: ["<h1>Hello <%= user.name%>. Welcome to <%= instance_name%></h1>"]
	},
	%{
	key: :text,
	type: :string,
	description:
	"Text content of the welcome email. EEX template with user and instance_name variables can be used.",
	suggestions: ["Hello <%= user.name%>. \n Welcome to <%= instance_name%>\n"]
	}
	]
	}
	]
	},
	%{
	group: :logger,
	type: :group,
	description: "Logger-related settings",
	children: [
	%{
	key: :backends,
	type: [:atom, :tuple, :module],
	description:
	"Where logs will be sent, :console - send logs to stdout, { ExSyslogger, :ex_syslogger } - to syslog, Quack.Logger - to Slack.",
	suggestions: [:console, {ExSyslogger, :ex_syslogger}, Quack.Logger]
	}
	]
	},
	%{
	group: :logger,
	type: :group,
	key: :ex_syslogger,
	label: "ExSyslogger",
	description: "ExSyslogger-related settings",
	children: [
	%{
	key: :level,
	type: {:dropdown, :atom},
	description: "Log level",
	suggestions: [:debug, :info, :warn, :error]
	},
	%{
	key: :ident,
	type: :string,
	description:
	"A string that's prepended to every message, and is typically set to the app name",
	suggestions: ["pleroma"]
	},
	%{
	key: :format,
	type: :string,
	description: "Default: \"$date $time [$level] $levelpad$node $metadata $message\"",
	suggestions: ["$metadata[$level] $message"]
	},
	%{
	key: :metadata,
	type: {:list, :atom},
	suggestions: [:request_id]
	}
	]
	},
	%{
	group: :logger,
	type: :group,
	key: :console,
	label: "Console Logger",
	description: "Console logger settings",
	children: [
	%{
	key: :level,
	type: {:dropdown, :atom},
	description: "Log level",
	suggestions: [:debug, :info, :warn, :error]
	},
	%{
	key: :format,
	type: :string,
	description: "Default: \"$date $time [$level] $levelpad$node $metadata $message\"",
	suggestions: ["$metadata[$level] $message"]
	},
	%{
	key: :metadata,
	type: {:list, :atom},
	suggestions: [:request_id]
	}
	]
	},
	%{
	group: :pleroma,
	key: :frontend_configurations,
	type: :group,
	description:
	"This form can be used to configure a keyword list that keeps the configuration data for any " <>
	"kind of frontend. By default, settings for pleroma_fe are configured. If you want to " <>
	"add your own configuration your settings all fields must be complete.",
	children: [
	%{
	key: :pleroma_fe,
	label: "Pleroma FE",
	type: :map,
	description: "Settings for Pleroma FE",
	suggestions: [
	%{
	alwaysShowSubjectInput: true,
	background: "/static/aurora_borealis.jpg",
	collapseMessageWithSubject: false,
	greentext: false,
	hideFilteredStatuses: false,
	hideMutedPosts: false,
	hidePostStats: false,
	hideSitename: false,
	hideUserStats: false,
	loginMethod: "password",
	logo: "/static/logo.svg",
	logoMargin: ".1em",
	logoMask: true,
	minimalScopesMode: false,
	noAttachmentLinks: false,
	nsfwCensorImage: "/static/img/nsfw.74818f9.png",
	postContentType: "text/plain",
	redirectRootLogin: "/main/friends",
	redirectRootNoLogin: "/main/all",
	scopeCopy: true,
	sidebarRight: false,
	showFeaturesPanel: true,
	showInstanceSpecificPanel: false,
	subjectLineBehavior: "email",
	theme: "pleroma-dark",
	webPushNotifications: false
	}
	],
	children: [
	%{
	key: :alwaysShowSubjectInput,
	label: "Always show subject input",
	type: :boolean,
	description: "When disabled, auto-hide the subject field if it's empty"
	},
	%{
	key: :background,
	type: {:string, :image},
	description:
	"URL of the background, unless viewing a user profile with a background that is set",
	suggestions: ["/images/city.jpg"]
	},
	%{
	key: :collapseMessageWithSubject,
	label: "Collapse message with subject",
	type: :boolean,
	description:
	"When a message has a subject (aka Content Warning), collapse it by default"
	},
	%{
	key: :greentext,
	label: "Greentext",
	type: :boolean,
	description: "Enables green text on lines prefixed with the > character"
	},
	%{
	key: :hideFilteredStatuses,
	label: "Hide Filtered Statuses",
	type: :boolean,
	description: "Hides filtered statuses from timelines"
	},
	%{
	key: :hideMutedPosts,
	label: "Hide Muted Posts",
	type: :boolean,
	description: "Hides muted statuses from timelines"
	},
	%{
	key: :hidePostStats,
	label: "Hide post stats",
	type: :boolean,
	description: "Hide notices statistics (repeats, favorites, ...)"
	},
	%{
	key: :hideSitename,
	label: "Hide Sitename",
	type: :boolean,
	description: "Hides instance name from PleromaFE banner"
	},
	%{
	key: :hideUserStats,
	label: "Hide user stats",
	type: :boolean,
	description:
	"Hide profile statistics (posts, posts per day, followers, followings, ...)"
	},
	%{
	key: :logo,
	type: {:string, :image},
	description: "URL of the logo, defaults to Pleroma's logo",
	suggestions: ["/static/logo.svg"]
	},
	%{
	key: :logoMargin,
	label: "Logo margin",
	type: :string,
	description:
	"Allows you to adjust vertical margins between logo boundary and navbar borders. " <>
	"The idea is that to have logo's image without any extra margins and instead adjust them to your need in layout.",
	suggestions: [".1em"]
	},
	%{
	key: :logoMask,
	label: "Logo mask",
	type: :boolean,
	description:
	"By default it assumes logo used will be monochrome with alpha channel to be compatible with both light and dark themes. " <>
	"If you want a colorful logo you must disable logoMask."
	},
	%{
	key: :minimalScopesMode,
	label: "Minimal scopes mode",
	type: :boolean,
	description:
	"Limit scope selection to Direct, User default, and Scope of post replying to. " <>
	"Also prevents replying to a DM with a public post from PleromaFE."
	},
	%{
	key: :nsfwCensorImage,
	label: "NSFW Censor Image",
	type: {:string, :image},
	description:
	"URL of the image to use for hiding NSFW media attachments in the timeline",
	suggestions: ["/static/img/nsfw.74818f9.png"]
	},
	%{
	key: :postContentType,
	label: "Post Content Type",
	type: {:dropdown, :atom},
	description: "Default post formatting option",
	suggestions: ["text/plain", "text/html", "text/markdown", "text/bbcode"]
	},
	%{
	key: :redirectRootNoLogin,
	label: "Redirect root no login",
	type: :string,
	description:
	"Relative URL which indicates where to redirect when a user isn't logged in",
	suggestions: ["/main/all"]
	},
	%{
	key: :redirectRootLogin,
	label: "Redirect root login",
	type: :string,
	description:
	"Relative URL which indicates where to redirect when a user is logged in",
	suggestions: ["/main/friends"]
	},
	%{
	key: :scopeCopy,
	label: "Scope copy",
	type: :boolean,
	description: "Copy the scope (private/unlisted/public) in replies to posts by default"
	},
	%{
	key: :sidebarRight,
	label: "Sidebar on Right",
	type: :boolean,
	description: "Change alignment of sidebar and panels to the right"
	},
	%{
	key: :showFeaturesPanel,
	label: "Show instance features panel",
	type: :boolean,
	description:
	"Enables panel displaying functionality of the instance on the About page"
	},
	%{
	key: :showInstanceSpecificPanel,
	label: "Show instance specific panel",
	type: :boolean,
	description: "Whether to show the instance's custom panel"
	},
	%{
	key: :subjectLineBehavior,
	label: "Subject line behavior",
	type: :string,
	description: "Allows changing the default behaviour of subject lines in replies.
	`email`: copy and preprend re:, as in email,
	`masto`: copy verbatim, as in Mastodon,
	`noop`: don't copy the subject.",
	suggestions: ["email", "masto", "noop"]
	},
	%{
	key: :theme,
	type: :string,
	description: "Which theme to use. Available themes are defined in styles.json",
	suggestions: ["pleroma-dark"]
	}
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: :assets,
	type: :group,
	description:
	"This section configures assets to be used with various frontends. Currently the only option relates to mascots on the mastodon frontend",
	children: [
	%{
	key: :mascots,
	type: {:keyword, :map},
	description:
	"Keyword of mascots, each element must contain both an URL and a mime_type key",
	suggestions: [
	pleroma_fox_tan: %{
	url: "/images/pleroma-fox-tan-smol.png",
	mime_type: "image/png"
	},
	pleroma_fox_tan_shy: %{
	url: "/images/pleroma-fox-tan-shy.png",
	mime_type: "image/png"
	}
	]
	},
	%{
	key: :default_mascot,
	type: :atom,
	description:
	"This will be used as the default mascot on MastoFE. Default: `:pleroma_fox_tan`",
	suggestions: [
	:pleroma_fox_tan
	]
	},
	%{
	key: :default_user_avatar,
	type: {:string, :image},
	description: "URL of the default user avatar",
	suggestions: ["/images/avi.png"]
	}
	]
	},
	%{
	group: :pleroma,
	key: :manifest,
	type: :group,
	description:
	"This section describe PWA manifest instance-specific values. Currently this option relate only for MastoFE.",
	children: [
	%{
	key: :icons,
	type: {:list, :map},
	description: "Describe the icons of the app",
	suggestion: [
	%{
	src: "/static/logo.png"
	},
	%{
	src: "/static/icon.png",
	type: "image/png"
	},
	%{
	src: "/static/icon.ico",
	sizes: "72x72 96x96 128x128 256x256"
	}
	]
	},
	%{
	key: :theme_color,
	type: :string,
	description: "Describe the theme color of the app",
	suggestions: ["#282c37", "mediumpurple"]
	},
	%{
	key: :background_color,
	type: :string,
	description: "Describe the background color of the app",
	suggestions: ["#191b22", "aliceblue"]
	}
	]
	},
	%{
	group: :pleroma,
	key: :media_proxy,
	type: :group,
	description: "Media proxy",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enables proxying of remote media via the instance's proxy"
	},
	%{
	key: :base_url,
	label: "Base URL",
	type: :string,
	description:
	"The base URL to access a user-uploaded file. Useful when you want to proxy the media files via another host/CDN fronts.",
	suggestions: ["https://example.com"]
	},
	%{
	key: :invalidation,
	type: :keyword,
	descpiption: "",
	suggestions: [
	enabled: true,
	provider: Pleroma.Web.MediaProxy.Invalidation.Script
	],
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enables media cache object invalidation."
	},
	%{
	key: :provider,
	type: :module,
	description: "Module which will be used to purge objects from the cache.",
	suggestions: [
	Pleroma.Web.MediaProxy.Invalidation.Script,
	Pleroma.Web.MediaProxy.Invalidation.Http
	]
	}
	]
	},
	%{
	key: :proxy_opts,
	label: "Advanced MediaProxy Options",
	type: :keyword,
	description: "Internal Pleroma.ReverseProxy settings",
	suggestions: [
	redirect_on_failure: false,
	max_body_length: 25 * 1_048_576,
	max_read_duration: 30_000
	],
	children: [
	%{
	key: :redirect_on_failure,
	type: :boolean,
	description: """
	Redirects the client to the origin server upon encountering HTTP errors.\n
	Note that files larger than Max Body Length will trigger an error. (e.g., Peertube videos)\n\n
	WARNING: This setting will allow larger files to be accessed, but exposes the\n
	IP addresses of your users to the other servers, bypassing the MediaProxy.
	"""
	},
	%{
	key: :max_body_length,
	type: :integer,
	description:
	"Maximum file size (in bytes) allowed through the Pleroma MediaProxy cache."
	},
	%{
	key: :max_read_duration,
	type: :integer,
	description: "Timeout (in milliseconds) of GET request to the remote URI."
	}
	]
	},
	%{
	key: :whitelist,
	type: {:list, :string},
	description: "List of hosts with scheme to bypass the MediaProxy",
	suggestions: ["http://example.com"]
	}
	]
	},
	%{
	group: :pleroma,
	key: :media_preview_proxy,
	type: :group,
	description: "Media preview proxy",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description:
	"Enables proxying of remote media preview to the instance's proxy. Requires enabled media proxy."
	},
	%{
	key: :thumbnail_max_width,
	type: :integer,
	description:
	"Max width of preview thumbnail for images (video preview always has original dimensions)."
	},
	%{
	key: :thumbnail_max_height,
	type: :integer,
	description:
	"Max height of preview thumbnail for images (video preview always has original dimensions)."
	},
	%{
	key: :image_quality,
	type: :integer,
	description: "Quality of the output. Ranges from 0 (min quality) to 100 (max quality)."
	},
	%{
	key: :min_content_length,
	type: :integer,
	description:
	"Min content length (in bytes) to perform preview. Media smaller in size will be served without thumbnailing."
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Web.MediaProxy.Invalidation.Http,
	type: :group,
	description: "HTTP invalidate settings",
	children: [
	%{
	key: :method,
	type: :atom,
	description: "HTTP method of request. Default: :purge"
	},
	%{
	key: :headers,
	type: {:keyword, :string},
	description: "HTTP headers of request",
	suggestions: [{"x-refresh", 1}]
	},
	%{
	key: :options,
	type: :keyword,
	description: "Request options",
	children: [
	%{
	key: :params,
	type: {:map, :string}
	}
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Web.MediaProxy.Invalidation.Script,
	type: :group,
	description: "Invalidation script settings",
	children: [
	%{
	key: :script_path,
	type: :string,
	description: "Path to executable script which will purge cached items.",
	suggestions: ["./installation/nginx-cache-purge.sh.example"]
	},
	%{
	key: :url_format,
	label: "URL Format",
	type: :string,
	description:
	"Optional URL format preprocessing. Only required for Apache's htcacheclean.",
	suggestions: [":htcacheclean"]
	}
	]
	},
	%{
	group: :pleroma,
	key: :gopher,
	type: :group,
	description: "Gopher settings",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enables the gopher interface"
	},
	%{
	key: :ip,
	label: "IP",
	type: :tuple,
	description: "IP address to bind to",
	suggestions: [{0, 0, 0, 0}]
	},
	%{
	key: :port,
	type: :integer,
	description: "Port to bind to",
	suggestions: [9999]
	},
	%{
	key: :dstport,
	type: :integer,
	description: "Port advertised in URLs (optional, defaults to port)",
	suggestions: [9999]
	}
	]
	},
	%{
	group: :pleroma,
	key: :activitypub,
	label: "ActivityPub",
	type: :group,
	description: "ActivityPub-related settings",
	children: [
	%{
	key: :unfollow_blocked,
	type: :boolean,
	description: "Whether blocks result in people getting unfollowed"
	},
	%{
	key: :outgoing_blocks,
	type: :boolean,
	description: "Whether to federate blocks to other instances"
	},
	%{
	key: :blockers_visible,
	type: :boolean,
	description: "Whether a user can see someone who has blocked them"
	},
	%{
	key: :sign_object_fetches,
	type: :boolean,
	description: "Sign object fetches with HTTP signatures"
	},
	%{
	key: :authorized_fetch_mode,
	type: :boolean,
	description: "Require HTTP signatures for AP fetches"
	},
	%{
	key: :note_replies_output_limit,
	type: :integer,
	description:
	"The number of Note replies' URIs to be included with outgoing federation (`5` to match Mastodon hardcoded value, `0` to disable the output)"
	},
	%{
	key: :follow_handshake_timeout,
	type: :integer,
	description: "Following handshake timeout",
	suggestions: [500]
	}
	]
	},
	%{
	group: :pleroma,
	key: :http_security,
	label: "HTTP security",
	type: :group,
	description: "HTTP security settings",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Whether the managed content security policy is enabled"
	},
	%{
	key: :sts,
	label: "STS",
	type: :boolean,
	description: "Whether to additionally send a Strict-Transport-Security header"
	},
	%{
	key: :sts_max_age,
	label: "STS max age",
	type: :integer,
	description: "The maximum age for the Strict-Transport-Security header if sent",
	suggestions: [31_536_000]
	},
	%{
	key: :ct_max_age,
	label: "CT max age",
	type: :integer,
	description: "The maximum age for the Expect-CT header if sent",
	suggestions: [2_592_000]
	},
	%{
	key: :referrer_policy,
	type: :string,
	description: "The referrer policy to use, either \"same-origin\" or \"no-referrer\"",
	suggestions: ["same-origin", "no-referrer"]
	},
	%{
	key: :report_uri,
	label: "Report URI",
	type: :string,
	description: "Adds the specified URL to report-uri and report-to group in CSP header",
	suggestions: ["https://example.com/report-uri"]
	}
	]
	},
	%{
	group: :web_push_encryption,
	key: :vapid_details,
	label: "Vapid Details",
	type: :group,
	description:
	"Web Push Notifications configuration. You can use the mix task mix web_push.gen.keypair to generate it.",
	children: [
	%{
	key: :subject,
	type: :string,
	description:
	"A mailto link for the administrative contact." <>
	" It's best if this email is not a personal email address, but rather a group email to the instance moderation team.",
	suggestions: ["mailto:moderators@pleroma.com"]
	},
	%{
	key: :public_key,
	type: :string,
	description: "VAPID public key",
	suggestions: ["Public key"]
	},
	%{
	key: :private_key,
	type: :string,
	description: "VAPID private key",
	suggestions: ["Private key"]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Captcha,
	type: :group,
	description: "Captcha-related settings",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Whether the captcha should be shown on registration"
	},
	%{
	key: :method,
	type: :module,
	description: "The method/service to use for captcha",
	suggestions: [Pleroma.Captcha.Kocaptcha, Pleroma.Captcha.Native]
	},
	%{
	key: :seconds_valid,
	type: :integer,
	description: "The time in seconds for which the captcha is valid",
	suggestions: [60]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Captcha.Kocaptcha,
	type: :group,
	description:
	"Kocaptcha is a very simple captcha service with a single API endpoint, the source code is" <>
	" here: https://github.com/koto-bank/kocaptcha. The default endpoint (https://captcha.kotobank.ch) is hosted by the developer.",
	children: [
	%{
	key: :endpoint,
	type: :string,
	description: "The kocaptcha endpoint to use",
	suggestions: ["https://captcha.kotobank.ch"]
	}
	]
	},
	%{
	group: :pleroma,
	label: "Pleroma Admin Token",
	type: :group,
	description:
	"Allows setting a token that can be used to authenticate requests with admin privileges without a normal user account token. Append the `admin_token` parameter to requests to utilize it. (Please reconsider using HTTP Basic Auth or OAuth-based authentication if possible)",
	children: [
	%{
	key: :admin_token,
	type: :string,
	description: "Admin token",
	suggestions: [
	"Please use a high entropy string or UUID"
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: Oban,
	type: :group,
	description:
	"[Oban](https://github.com/sorentwo/oban) asynchronous job processor configuration.",
	children: [
	%{
	key: :log,
	type: {:dropdown, :atom},
	description: "Logs verbose mode",
	suggestions: [false, :error, :warn, :info, :debug]
	},
	%{
	key: :queues,
	type: {:keyword, :integer},
	description:
	"Background jobs queues (keys: queues, values: max numbers of concurrent jobs)",
	suggestions: [
	activity_expiration: 10,
	attachments_cleanup: 5,
	background: 5,
	federator_incoming: 50,
	federator_outgoing: 50,
	mailer: 10,
	scheduled_activities: 10,
	transmogrifier: 20,
	web_push: 50
	],
	children: [
	%{
	key: :activity_expiration,
	type: :integer,
	description: "Activity expiration queue",
	suggestions: [10]
	},
	%{
	key: :backup,
	type: :integer,
	description: "Backup queue",
	suggestions: [1]
	},
	%{
	key: :attachments_cleanup,
	type: :integer,
	description: "Attachment deletion queue",
	suggestions: [5]
	},
	%{
	key: :background,
	type: :integer,
	description: "Background queue",
	suggestions: [5]
	},
	%{
	key: :federator_incoming,
	type: :integer,
	description: "Incoming federation queue",
	suggestions: [50]
	},
	%{
	key: :federator_outgoing,
	type: :integer,
	description: "Outgoing federation queue",
	suggestions: [50]
	},
	%{
	key: :mailer,
	type: :integer,
	description: "Email sender queue, see Pleroma.Emails.Mailer",
	suggestions: [10]
	},
	%{
	key: :scheduled_activities,
	type: :integer,
	description: "Scheduled activities queue, see Pleroma.ScheduledActivities",
	suggestions: [10]
	},
	%{
	key: :transmogrifier,
	type: :integer,
	description: "Transmogrifier queue",
	suggestions: [20]
	},
	%{
	key: :web_push,
	type: :integer,
	description: "Web push notifications queue",
	suggestions: [50]
	}
	]
	},
	%{
	key: :crontab,
	type: {:list, :tuple},
	description: "Settings for cron background jobs",
	suggestions: [
	{"0 0 * * 0", Pleroma.Workers.Cron.DigestEmailsWorker},
	{"0 0 * * *", Pleroma.Workers.Cron.NewUsersDigestWorker}
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: :workers,
	type: :group,
	description: "Includes custom worker options not interpretable directly by `Oban`",
	children: [
	%{
	key: :retries,
	type: {:keyword, :integer},
	description: "Max retry attempts for failed jobs, per `Oban` queue",
	suggestions: [
	federator_incoming: 5,
	federator_outgoing: 5
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Web.Metadata,
	type: :group,
	description: "Metadata-related settings",
	children: [
	%{
	key: :providers,
	type: {:list, :module},
	description: "List of metadata providers to enable",
	suggestions: [
	Pleroma.Web.Metadata.Providers.OpenGraph,
	Pleroma.Web.Metadata.Providers.TwitterCard,
	Pleroma.Web.Metadata.Providers.RelMe,
	Pleroma.Web.Metadata.Providers.Feed
	]
	},
	%{
	key: :unfurl_nsfw,
	label: "Unfurl NSFW",
	type: :boolean,
	description: "When enabled NSFW attachments will be shown in previews"
	}
	]
	},
	%{
	group: :pleroma,
	key: :rich_media,
	type: :group,
	description:
	"If enabled the instance will parse metadata from attached links to generate link previews",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enables RichMedia parsing of URLs"
	},
	%{
	key: :ignore_hosts,
	type: {:list, :string},
	description: "List of hosts which will be ignored by the metadata parser",
	suggestions: ["accounts.google.com", "xss.website"]
	},
	%{
	key: :ignore_tld,
	label: "Ignore TLD",
	type: {:list, :string},
	description: "List TLDs (top-level domains) which will ignore for parse metadata",
	suggestions: ["local", "localdomain", "lan"]
	},
	%{
	key: :parsers,
	type: {:list, :module},
	description:
	"List of Rich Media parsers. Module names are shortened (removed leading `Pleroma.Web.RichMedia.Parsers.` part), but on adding custom module you need to use full name.",
	suggestions: [
	Pleroma.Web.RichMedia.Parsers.OEmbed,
	Pleroma.Web.RichMedia.Parsers.TwitterCard
	]
	},
	%{
	key: :ttl_setters,
	label: "TTL setters",
	type: {:list, :module},
	description:
	"List of rich media TTL setters. Module names are shortened (removed leading `Pleroma.Web.RichMedia.Parser.` part), but on adding custom module you need to use full name.",
	suggestions: [
	Pleroma.Web.RichMedia.Parser.TTL.AwsSignedUrl
	]
	},
	%{
	key: :failure_backoff,
	type: :integer,
	description:
	"Amount of milliseconds after request failure, during which the request will not be retried.",
	suggestions: [60_000]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Formatter,
	label: "Linkify",
	type: :group,
	description:
	"Configuration for Pleroma's link formatter which parses mentions, hashtags, and URLs.",
	children: [
	%{
	key: :class,
	type: [:string, :boolean],
	description: "Specify the class to be added to the generated link. Disable to clear.",
	suggestions: ["auto-linker", false]
	},
	%{
	key: :rel,
	type: [:string, :boolean],
	description: "Override the rel attribute. Disable to clear.",
	suggestions: ["ugc", "noopener noreferrer", false]
	},
	%{
	key: :new_window,
	type: :boolean,
	description: "Link URLs will open in a new window/tab."
	},
	%{
	key: :truncate,
	type: [:integer, :boolean],
	description:
	"Set to a number to truncate URLs longer than the number. Truncated URLs will end in `...`",
	suggestions: [15, false]
	},
	%{
	key: :strip_prefix,
	type: :boolean,
	description: "Strip the scheme prefix."
	},
	%{
	key: :extra,
	type: :boolean,
	description: "Link URLs with rarely used schemes (magnet, ipfs, irc, etc.)"
	},
	%{
	key: :validate_tld,
	type: [:atom, :boolean],
	description:
	"Set to false to disable TLD validation for URLs/emails. Can be set to :no_scheme to validate TLDs only for URLs without a scheme (e.g `example.com` will be validated, but `http://example.loki` won't)",
	suggestions: [:no_scheme, true]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.ScheduledActivity,
	type: :group,
	description: "Scheduled activities settings",
	children: [
	%{
	key: :daily_user_limit,
	type: :integer,
	description:
	"The number of scheduled activities a user is allowed to create in a single day. Default: 25.",
	suggestions: [25]
	},
	%{
	key: :total_user_limit,
	type: :integer,
	description:
	"The number of scheduled activities a user is allowed to create in total. Default: 300.",
	suggestions: [300]
	},
	%{
	key: :enabled,
	type: :boolean,
	description: "Whether scheduled activities are sent to the job queue to be executed"
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Workers.PurgeExpiredActivity,
	type: :group,
	description: "Expired activities settings",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enables expired activities addition & deletion"
	},
	%{
	key: :min_lifetime,
	type: :integer,
	description: "Minimum lifetime for ephemeral activity (in seconds)",
	suggestions: [600]
	}
	]
	},
	%{
	group: :pleroma,
	label: "Pleroma Authenticator",
	type: :group,
	description: "Authenticator",
	children: [
	%{
	key: Pleroma.Web.Auth.Authenticator,
	type: :module,
	suggestions: [Pleroma.Web.Auth.PleromaAuthenticator, Pleroma.Web.Auth.LDAPAuthenticator]
	}
	]
	},
	%{
	group: :pleroma,
	key: :ldap,
	label: "LDAP",
	type: :group,
	description:
	"Use LDAP for user authentication. When a user logs in to the Pleroma instance, the name and password" <>
	" will be verified by trying to authenticate (bind) to a LDAP server." <>
	" If a user exists in the LDAP directory but there is no account with the same name yet on the" <>
	" Pleroma instance then a new Pleroma account will be created with the same name as the LDAP user name.",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enables LDAP authentication"
	},
	%{
	key: :host,
	type: :string,
	description: "LDAP server hostname",
	suggestions: ["localhosts"]
	},
	%{
	key: :port,
	type: :integer,
	description: "LDAP port, e.g. 389 or 636",
	suggestions: [389, 636]
	},
	%{
	key: :ssl,
	label: "SSL",
	type: :boolean,
	description: "Enable to use SSL, usually implies the port 636"
	},
	%{
	key: :sslopts,
	label: "SSL options",
	type: :keyword,
	description: "Additional SSL options",
	suggestions: [cacertfile: "path/to/file/with/PEM/cacerts", verify: :verify_peer],
	children: [
	%{
	key: :cacertfile,
	type: :string,
	description: "Path to file with PEM encoded cacerts",
	suggestions: ["path/to/file/with/PEM/cacerts"]
	},
	%{
	key: :verify,
	type: :atom,
	description: "Type of cert verification",
	suggestions: [:verify_peer]
	}
	]
	},
	%{
	key: :tls,
	label: "TLS",
	type: :boolean,
	description: "Enable to use STARTTLS, usually implies the port 389"
	},
	%{
	key: :tlsopts,
	label: "TLS options",
	type: :keyword,
	description: "Additional TLS options",
	suggestions: [cacertfile: "path/to/file/with/PEM/cacerts", verify: :verify_peer],
	children: [
	%{
	key: :cacertfile,
	type: :string,
	description: "Path to file with PEM encoded cacerts",
	suggestions: ["path/to/file/with/PEM/cacerts"]
	},
	%{
	key: :verify,
	type: :atom,
	description: "Type of cert verification",
	suggestions: [:verify_peer]
	}
	]
	},
	%{
	key: :base,
	type: :string,
	description: "LDAP base, e.g. \"dc=example,dc=com\"",
	suggestions: ["dc=example,dc=com"]
	},
	%{
	key: :uid,
	label: "UID",
	type: :string,
	description:
	"LDAP attribute name to authenticate the user, e.g. when \"cn\", the filter will be \"cn=username,base\"",
	suggestions: ["cn"]
	}
	]
	},
	%{
	group: :pleroma,
	key: :auth,
	type: :group,
	description: "Authentication / authorization settings",
	children: [
	%{
	key: :enforce_oauth_admin_scope_usage,
	label: "Enforce OAuth admin scope usage",
	type: :boolean,
	description:
	"OAuth admin scope requirement toggle. " <>
	"If enabled, admin actions explicitly demand admin OAuth scope(s) presence in OAuth token " <>
	"(client app must support admin scopes). If disabled and token doesn't have admin scope(s), " <>
	"`is_admin` user flag grants access to admin-specific actions."
	},
	%{
	key: :auth_template,
	type: :string,
	description:
	"Authentication form template. By default it's `show.html` which corresponds to `lib/pleroma/web/templates/o_auth/o_auth/show.html.ee`.",
	suggestions: ["show.html"]
	},
	%{
	key: :oauth_consumer_template,
	label: "OAuth consumer template",
	type: :string,
	description:
	"OAuth consumer mode authentication form template. By default it's `consumer.html` which corresponds to" <>
	" `lib/pleroma/web/templates/o_auth/o_auth/consumer.html.eex`.",
	suggestions: ["consumer.html"]
	},
	%{
	key: :oauth_consumer_strategies,
	label: "OAuth consumer strategies",
	type: {:list, :string},
	description:
	"The list of enabled OAuth consumer strategies. By default it's set by OAUTH_CONSUMER_STRATEGIES environment variable." <>
	" Each entry in this space-delimited string should be of format \"strategy\" or \"strategy:dependency\"" <>
	" (e.g. twitter or keycloak:ueberauth_keycloak_strategy in case dependency is named differently than ueberauth_<strategy>).",
	suggestions: ["twitter", "keycloak:ueberauth_keycloak_strategy"]
	}
	]
	},
	%{
	group: :pleroma,
	key: :email_notifications,
	type: :group,
	description: "Email notifications settings",
	children: [
	%{
	key: :digest,
	type: :map,
	description:
	"emails of \"what you've missed\" for users who have been inactive for a while",
	suggestions: [
	%{
	active: false,
	schedule: "0 0 * * 0",
	interval: 7,
	inactivity_threshold: 7
	}
	],
	children: [
	%{
	key: :active,
	label: "Enabled",
	type: :boolean,
	description: "Globally enable or disable digest emails"
	},
	%{
	key: :schedule,
	type: :string,
	description:
	"When to send digest email, in crontab format. \"0 0 0\" is the default, meaning \"once a week at midnight on Sunday morning\".",
	suggestions: ["0 0 * * 0"]
	},
	%{
	key: :interval,
	type: :integer,
	description: "Minimum interval between digest emails to one user",
	suggestions: [7]
	},
	%{
	key: :inactivity_threshold,
	type: :integer,
	description: "Minimum user inactivity threshold",
	suggestions: [7]
	}
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Emails.UserEmail,
	type: :group,
	description: "Email template settings",
	children: [
	%{
	key: :logo,
	type: {:string, :image},
	description: "A path to a custom logo. Set it to `nil` to use the default Pleroma logo.",
	suggestions: ["some/path/logo.png"]
	},
	%{
	key: :styling,
	type: :map,
	description: "A map with color settings for email templates.",
	suggestions: [
	%{
	link_color: "#d8a070",
	background_color: "#2C3645",
	content_background_color: "#1B2635",
	header_color: "#d8a070",
	text_color: "#b9b9ba",
	text_muted_color: "#b9b9ba"
	}
	],
	children: [
	%{
	key: :link_color,
	type: :string,
	suggestions: ["#d8a070"]
	},
	%{
	key: :background_color,
	type: :string,
	suggestions: ["#2C3645"]
	},
	%{
	key: :content_background_color,
	type: :string,
	suggestions: ["#1B2635"]
	},
	%{
	key: :header_color,
	type: :string,
	suggestions: ["#d8a070"]
	},
	%{
	key: :text_color,
	type: :string,
	suggestions: ["#b9b9ba"]
	},
	%{
	key: :text_muted_color,
	type: :string,
	suggestions: ["#b9b9ba"]
	}
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Emails.NewUsersDigestEmail,
	type: :group,
	description: "New users admin email digest",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enables new users admin digest email when `true`"
	}
	]
	},
	%{
	group: :pleroma,
	key: :oauth2,
	label: "OAuth2",
	type: :group,
	description: "Configure OAuth 2 provider capabilities",
	children: [
	%{
	key: :token_expires_in,
	type: :integer,
	description: "The lifetime in seconds of the access token",
	suggestions: [2_592_000]
	},
	%{
	key: :issue_new_refresh_token,
	type: :boolean,
	description:
	"Keeps old refresh token or generate new refresh token when to obtain an access token"
	},
	%{
	key: :clean_expired_tokens,
	type: :boolean,
	description: "Enable a background job to clean expired OAuth tokens. Default: disabled."
	}
	]
	},
	%{
	group: :pleroma,
	key: :emoji,
	type: :group,
	children: [
	%{
	key: :shortcode_globs,
	type: {:list, :string},
	description: "Location of custom emoji files. * can be used as a wildcard.",
	suggestions: ["/emoji/custom/*/.png"]
	},
	%{
	key: :pack_extensions,
	type: {:list, :string},
	description:
	"A list of file extensions for emojis, when no emoji.txt for a pack is present",
	suggestions: [".png", ".gif"]
	},
	%{
	key: :groups,
	type: {:keyword, {:list, :string}},
	description:
	"Emojis are ordered in groups (tags). This is an array of key-value pairs where the key is the group name" <>
	" and the value is the location or array of locations. * can be used as a wildcard.",
	suggestions: [
	Custom: ["/emoji/.png", "/emoji//.png"]
	]
	},
	%{
	key: :default_manifest,
	type: :string,
	description:
	"Location of the JSON-manifest. This manifest contains information about the emoji-packs you can download." <>
	" Currently only one manifest can be added (no arrays).",
	suggestions: ["https://git.pleroma.social/pleroma/emoji-index/raw/master/index.json"]
	},
	%{
	key: :shared_pack_cache_seconds_per_file,
	label: "Shared pack cache s/file",
	type: :integer,
	descpiption:
	"When an emoji pack is shared, the archive is created and cached in memory" <>
	" for this amount of seconds multiplied by the number of files.",
	suggestions: [60]
	}
	]
	},
	%{
	group: :pleroma,
	key: :rate_limit,
	type: :group,
	description:
	"Rate limit settings. This is an advanced feature enabled only for :authentication by default.",
	children: [
	%{
	key: :search,
	type: [:tuple, {:list, :tuple}],
	description: "For the search requests (account & status search etc.)",
	suggestions: [{1000, 10}, [{10_000, 10}, {10_000, 50}]]
	},
	%{
	key: :timeline,
	type: [:tuple, {:list, :tuple}],
	description: "For requests to timelines (each timeline has it's own limiter)",
	suggestions: [{1000, 10}, [{10_000, 10}, {10_000, 50}]]
	},
	%{
	key: :app_account_creation,
	type: [:tuple, {:list, :tuple}],
	description: "For registering user accounts from the same IP address",
	suggestions: [{1000, 10}, [{10_000, 10}, {10_000, 50}]]
	},
	%{
	key: :relations_actions,
	type: [:tuple, {:list, :tuple}],
	description: "For actions on relationships with all users (follow, unfollow)",
	suggestions: [{1000, 10}, [{10_000, 10}, {10_000, 50}]]
	},
	%{
	key: :relation_id_action,
	label: "Relation ID action",
	type: [:tuple, {:list, :tuple}],
	description: "For actions on relation with a specific user (follow, unfollow)",
	suggestions: [{1000, 10}, [{10_000, 10}, {10_000, 50}]]
	},
	%{
	key: :statuses_actions,
	type: [:tuple, {:list, :tuple}],
	description:
	"For create / delete / fav / unfav / reblog / unreblog actions on any statuses",
	suggestions: [{1000, 10}, [{10_000, 10}, {10_000, 50}]]
	},
	%{
	key: :status_id_action,
	label: "Status ID action",
	type: [:tuple, {:list, :tuple}],
	description:
	"For fav / unfav or reblog / unreblog actions on the same status by the same user",
	suggestions: [{1000, 10}, [{10_000, 10}, {10_000, 50}]]
	},
	%{
	key: :authentication,
	type: [:tuple, {:list, :tuple}],
	description: "For authentication create / password check / user existence check requests",
	suggestions: [{60_000, 15}]
	}
	]
	},
	%{
	group: :mime,
	label: "Mime Types",
	type: :group,
	description: "Mime Types settings",
	children: [
	%{
	key: :types,
	type: :map,
	suggestions: [
	%{
	"application/xml" => ["xml"],
	"application/xrd+xml" => ["xrd+xml"],
	"application/jrd+json" => ["jrd+json"],
	"application/activity+json" => ["activity+json"],
	"application/ld+json" => ["activity+json"]
	}
	],
	children: [
	%{
	key: "application/xml",
	type: {:list, :string},
	suggestions: ["xml"]
	},
	%{
	key: "application/xrd+xml",
	type: {:list, :string},
	suggestions: ["xrd+xml"]
	},
	%{
	key: "application/jrd+json",
	type: {:list, :string},
	suggestions: ["jrd+json"]
	},
	%{
	key: "application/activity+json",
	type: {:list, :string},
	suggestions: ["activity+json"]
	},
	%{
	key: "application/ld+json",
	type: {:list, :string},
	suggestions: ["activity+json"]
	}
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: :shout,
	type: :group,
	description: "Pleroma shout settings",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enables the backend Shoutbox chat feature."
	},
	%{
	key: :limit,
	type: :integer,
	description: "Shout message character limit.",
	suggestions: [
	5_000
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: :http,
	label: "HTTP",
	type: :group,
	description: "HTTP settings",
	children: [
	%{
	key: :proxy_url,
	label: "Proxy URL",
	type: [:string, :tuple],
	description: "Proxy URL",
	suggestions: ["localhost:9020", {:socks5, :localhost, 3090}]
	},
	%{
	key: :send_user_agent,
	type: :boolean
	},
	%{
	key: :user_agent,
	type: [:string, :atom],
	description:
	"What user agent to use. Must be a string or an atom `:default`. Default value is `:default`.",
	suggestions: ["Pleroma", :default]
	},
	%{
	key: :adapter,
	type: :keyword,
	description: "Adapter specific options",
	suggestions: [],
	children: [
	%{
	key: :ssl_options,
	type: :keyword,
	label: "SSL Options",
	description: "SSL options for HTTP adapter",
	children: [
	%{
	key: :versions,
	type: {:list, :atom},
	description: "List of TLS version to use",
	suggestions: [:tlsv1, ":tlsv1.1", ":tlsv1.2", ":tlsv1.3"]
	}
	]
	}
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: :markup,
	label: "Markup Settings",
	type: :group,
	children: [
	%{
	key: :allow_inline_images,
	type: :boolean
	},
	%{
	key: :allow_headings,
	type: :boolean
	},
	%{
	key: :allow_tables,
	type: :boolean
	},
	%{
	key: :allow_fonts,
	type: :boolean
	},
	%{
	key: :scrub_policy,
	type: {:list, :module},
	description:
	"Module names are shortened (removed leading `Pleroma.HTML.` part), but on adding custom module you need to use full name.",
	suggestions: [Pleroma.HTML.Transform.MediaProxy, Pleroma.HTML.Scrubber.Default]
	}
	]
	},
	%{
	group: :pleroma,
	key: :user,
	type: :group,
	children: [
	%{
	key: :deny_follow_blocked,
	type: :boolean
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.User,
	type: :group,
	children: [
	%{
	key: :restricted_nicknames,
	type: {:list, :string},
	description: "List of nicknames users may not register with.",
	suggestions: [
	".well-known",
	"~",
	"about",
	"activities",
	"api",
	"auth",
	"check_password",
	"dev",
	"friend-requests",
	"inbox",
	"internal",
	"main",
	"media",
	"nodeinfo",
	"notice",
	"oauth",
	"objects",
	"ostatus_subscribe",
	"pleroma",
	"proxy",
	"push",
	"registration",
	"relay",
	"settings",
	"status",
	"tag",
	"user-search",
	"user_exists",
	"users",
	"web"
	]
	},
	%{
	key: :email_blacklist,
	type: {:list, :string},
	description: "List of email domains users may not register with.",
	suggestions: ["mailinator.com", "maildrop.cc"]
	}
	]
	},
	%{
	group: :cors_plug,
	label: "CORS plug config",
	type: :group,
	children: [
	%{
	key: :max_age,
	type: :integer,
	suggestions: [86_400]
	},
	%{
	key: :methods,
	type: {:list, :string},
	suggestions: ["POST", "PUT", "DELETE", "GET", "PATCH", "OPTIONS"]
	},
	%{
	key: :expose,
	type: {:list, :string},
	suggestions: [
	"Link",
	"X-RateLimit-Reset",
	"X-RateLimit-Limit",
	"X-RateLimit-Remaining",
	"X-Request-Id",
	"Idempotency-Key"
	]
	},
	%{
	key: :credentials,
	type: :boolean
	},
	%{
	key: :headers,
	type: {:list, :string},
	suggestions: ["Authorization", "Content-Type", "Idempotency-Key"]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Web.Plugs.RemoteIp,
	type: :group,
	description: """
	`Pleroma.Web.Plugs.RemoteIp` is a shim to call [`RemoteIp`](https://git.pleroma.social/pleroma/remote_ip) but with runtime configuration.
	If your instance is not behind at least one reverse proxy, you should not enable this plug.
	""",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enable/disable the plug. Default: disabled."
	},
	%{
	key: :headers,
	type: {:list, :string},
	description: """
	A list of strings naming the HTTP headers to use when deriving the true client IP. Default: `["x-forwarded-for"]`.
	"""
	},
	%{
	key: :proxies,
	type: {:list, :string},
	description:
	"A list of upstream proxy IP subnets in CIDR notation from which we will parse the content of `headers`. Defaults to `[]`. IPv4 entries without a bitmask will be assumed to be /32 and IPv6 /128."
	},
	%{
	key: :reserved,
	type: {:list, :string},
	description: """
	A list of reserved IP subnets in CIDR notation which should be ignored if found in `headers`. Defaults to `["127.0.0.0/8", "::1/128", "fc00::/7", "10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16"]`
	"""
	}
	]
	},
	%{
	group: :pleroma,
	key: :web_cache_ttl,
	label: "Web cache TTL",
	type: :group,
	description:
	"The expiration time for the web responses cache. Values should be in milliseconds or `nil` to disable expiration.",
	children: [
	%{
	key: :activity_pub,
	type: :integer,
	description:
	"Activity pub routes (except question activities). Default: `nil` (no expiration).",
	suggestions: [nil]
	},
	%{
	key: :activity_pub_question,
	type: :integer,
	description: "Activity pub routes (question activities). Default: `30_000` (30 seconds).",
	suggestions: [30_000]
	}
	]
	},
	%{
	group: :pleroma,
	key: :static_fe,
	label: "Static FE",
	type: :group,
	description:
	"Render profiles and posts using server-generated HTML that is viewable without using JavaScript",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enables the rendering of static HTML. Default: disabled."
	}
	]
	},
	%{
	group: :pleroma,
	key: :feed,
	type: :group,
	description: "Configure feed rendering",
	children: [
	%{
	key: :post_title,
	type: :map,
	description: "Configure title rendering",
	children: [
	%{
	key: :max_length,
	type: :integer,
	description: "Maximum number of characters before truncating title",
	suggestions: [100]
	},
	%{
	key: :omission,
	type: :string,
	description: "Replacement which will be used after truncating string",
	suggestions: ["..."]
	}
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: :mrf_follow_bot,
	tab: :mrf,
	related_policy: "Pleroma.Web.ActivityPub.MRF.FollowBotPolicy",
	label: "MRF FollowBot Policy",
	type: :group,
	description: "Automatically follows newly discovered accounts.",
	children: [
	%{
	key: :follower_nickname,
	type: :string,
	description: "The name of the bot account to use for following newly discovered users.",
	suggestions: ["followbot"]
	}
	]
	},
	%{
	group: :pleroma,
	key: :modules,
	type: :group,
	description: "Custom Runtime Modules",
	children: [
	%{
	key: :runtime_dir,
	type: :string,
	description: "A path to custom Elixir modules (such as MRF policies)."
	}
	]
	},
	%{
	group: :pleroma,
	key: :streamer,
	type: :group,
	description: "Settings for notifications streamer",
	children: [
	%{
	key: :workers,
	type: :integer,
	description: "Number of workers to send notifications",
	suggestions: [3]
	},
	%{
	key: :overflow_workers,
	type: :integer,
	description: "Maximum number of workers created if pool is empty",
	suggestions: [2]
	}
	]
	},
	%{
	group: :pleroma,
	key: :connections_pool,
	type: :group,
	description: "Advanced settings for `Gun` connections pool",
	children: [
	%{
	key: :connection_acquisition_wait,
	type: :integer,
	description:
	"Timeout to acquire a connection from pool. The total max time is this value multiplied by the number of retries. Default: 250ms.",
	suggestions: [250]
	},
	%{
	key: :connection_acquisition_retries,
	type: :integer,
	description:
	"Number of attempts to acquire the connection from the pool if it is overloaded. Default: 5",
	suggestions: [5]
	},
	%{
	key: :max_connections,
	type: :integer,
	description: "Maximum number of connections in the pool. Default: 250 connections.",
	suggestions: [250]
	},
	%{
	key: :connect_timeout,
	type: :integer,
	description: "Timeout while `gun` will wait until connection is up. Default: 5000ms.",
	suggestions: [5000]
	},
	%{
	key: :reclaim_multiplier,
	type: :integer,
	description:
	"Multiplier for the number of idle connection to be reclaimed if the pool is full. For example if the pool maxes out at 250 connections and this setting is set to 0.3, the pool will reclaim at most 75 idle connections if it's overloaded. Default: 0.1",
	suggestions: [0.1]
	}
	]
	},
	%{
	group: :pleroma,
	key: :pools,
	type: :group,
	description: "Advanced settings for `Gun` workers pools",
	children:
	Enum.map([:federation, :media, :upload, :default], fn pool_name ->
	%{
	key: pool_name,
	type: :keyword,
	description: "Settings for #{pool_name} pool.",
	children: [
	%{
	key: :size,
	type: :integer,
	description: "Maximum number of concurrent requests in the pool.",
	suggestions: [50]
	},
	%{
	key: :max_waiting,
	type: :integer,
	description:
	"Maximum number of requests waiting for other requests to finish. After this number is reached, the pool will start returning errrors when a new request is made",
	suggestions: [10]
	},
	%{
	key: :recv_timeout,
	type: :integer,
	description: "Timeout for the pool while gun will wait for response",
	suggestions: [10_000]
	}
	]
	}
	end)
	},
	%{
	group: :pleroma,
	key: :hackney_pools,
	type: :group,
	description: "Advanced settings for `Hackney` connections pools",
	children: [
	%{
	key: :federation,
	type: :keyword,
	description: "Settings for federation pool.",
	children: [
	%{
	key: :max_connections,
	type: :integer,
	description: "Number workers in the pool.",
	suggestions: [50]
	},
	%{
	key: :timeout,
	type: :integer,
	description: "Timeout while `hackney` will wait for response.",
	suggestions: [150_000]
	}
	]
	},
	%{
	key: :media,
	type: :keyword,
	description: "Settings for media pool.",
	children: [
	%{
	key: :max_connections,
	type: :integer,
	description: "Number workers in the pool.",
	suggestions: [50]
	},
	%{
	key: :timeout,
	type: :integer,
	description: "Timeout while `hackney` will wait for response.",
	suggestions: [150_000]
	}
	]
	},
	%{
	key: :upload,
	type: :keyword,
	description: "Settings for upload pool.",
	children: [
	%{
	key: :max_connections,
	type: :integer,
	description: "Number workers in the pool.",
	suggestions: [25]
	},
	%{
	key: :timeout,
	type: :integer,
	description: "Timeout while `hackney` will wait for response.",
	suggestions: [300_000]
	}
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: :restrict_unauthenticated,
	label: "Restrict Unauthenticated",
	type: :group,
	description:
	"Disallow viewing timelines, user profiles and statuses for unauthenticated users.",
	children: [
	%{
	key: :timelines,
	type: :map,
	description: "Settings for public and federated timelines.",
	children: [
	%{
	key: :local,
	type: :boolean,
	description: "Disallow view public timeline."
	},
	%{
	key: :federated,
	type: :boolean,
	description: "Disallow view federated timeline."
	}
	]
	},
	%{
	key: :profiles,
	type: :map,
	description: "Settings for user profiles.",
	children: [
	%{
	key: :local,
	type: :boolean,
	description: "Disallow view local user profiles."
	},
	%{
	key: :remote,
	type: :boolean,
	description: "Disallow view remote user profiles."
	}
	]
	},
	%{
	key: :activities,
	type: :map,
	description: "Settings for statuses.",
	children: [
	%{
	key: :local,
	type: :boolean,
	description: "Disallow view local statuses."
	},
	%{
	key: :remote,
	type: :boolean,
	description: "Disallow view remote statuses."
	}
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Web.ApiSpec.CastAndValidate,
	type: :group,
	children: [
	%{
	key: :strict,
	type: :boolean,
	description:
	"Enables strict input validation (useful in development, not recommended in production)"
	}
	]
	},
	%{
	group: :pleroma,
	key: :instances_favicons,
	type: :group,
	description: "Control favicons for instances",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Allow/disallow displaying and getting instances favicons"
	}
	]
	},
	%{
	group: :ex_aws,
	key: :s3,
	type: :group,
	descriptions: "S3 service related settings",
	children: [
	%{
	key: :access_key_id,
	type: :string,
	description: "S3 access key ID",
	suggestions: ["AKIAQ8UKHTGIYN7DMWWJ"]
	},
	%{
	key: :secret_access_key,
	type: :string,
	description: "Secret access key",
	suggestions: ["JFGt+fgH1UQ7vLUQjpW+WvjTdV/UNzVxcwn7DkaeFKtBS5LvoXvIiME4NQBsT6ZZ"]
	},
	%{
	key: :host,
	type: :string,
	description: "S3 host",
	suggestions: ["s3.eu-central-1.amazonaws.com"]
	},
	%{
	key: :region,
	type: :string,
	description: "S3 region (for AWS)",
	suggestions: ["us-east-1"]
	}
	]
	},
	%{
	group: :pleroma,
	key: :frontends,
	type: :group,
	description: "Installed frontends management",
	children: [
	%{
	key: :primary,
	type: :map,
	description: "Primary frontend, the one that is served for all pages by default",
	children: installed_frontend_options
	},
	%{
	key: :admin,
	type: :map,
	description: "Admin frontend",
	children: installed_frontend_options
	},
	%{
	key: :available,
	type: :map,
	description:
	"A map containing available frontends and parameters for their installation.",
	children: frontend_options
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Web.Preload,
	type: :group,
	description: "Preload-related settings",
	children: [
	%{
	key: :providers,
	type: {:list, :module},
	description: "List of preload providers to enable",
	suggestions: [
	Pleroma.Web.Preload.Providers.Instance,
	Pleroma.Web.Preload.Providers.User,
	Pleroma.Web.Preload.Providers.Timelines,
	Pleroma.Web.Preload.Providers.StatusNet
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: :majic_pool,
	type: :group,
	description: "Majic/libmagic configuration",
	children: [
	%{
	key: :size,
	type: :integer,
	description: "Number of majic workers to start.",
	suggestions: [2]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.User.Backup,
	type: :group,
	description: "Account Backup",
	children: [
	%{
	key: :purge_after_days,
	type: :integer,
	description: "Remove backup achives after N days",
	suggestions: [30]
	},
	%{
	key: :limit_days,
	type: :integer,
	description: "Limit user to export not more often than once per N days",
	suggestions: [7]
	},
	%{
	key: :process_wait_time,
	type: :integer,
	label: "Process Wait Time",
	description:
	"The amount of time to wait for backup to report progress, in milliseconds. If no progress is received from the backup job for that much time, terminate it and deem it failed.",
	suggestions: [30_000]
	},
	%{
	key: :process_chunk_size,
	type: :integer,
	label: "Process Chunk Size",
	description: "The number of activities to fetch in the backup job for each chunk.",
	suggestions: [100]
	}
	]
	},
	%{
	group: :prometheus,
	key: Pleroma.Web.Endpoint.MetricsExporter,
	type: :group,
	description: "Prometheus app metrics endpoint configuration",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "[Pleroma extension] Enables app metrics endpoint."
	},
	%{
	key: :ip_whitelist,
	label: "IP Whitelist",
	type: [{:list, :string}, {:list, :charlist}, {:list, :tuple}],
	description: "Restrict access of app metrics endpoint to the specified IP addresses."
	},
	%{
	key: :auth,
	type: [:boolean, :tuple],
	description: "Enables HTTP Basic Auth for app metrics endpoint.",
	suggestion: [false, {:basic, "myusername", "mypassword"}]
	},
	%{
	key: :path,
	type: :string,
	description: "App metrics endpoint URI path.",
	suggestions: ["/api/pleroma/app_metrics"]
	},
	%{
	key: :format,
	type: :atom,
	description: "App metrics endpoint output format.",
	suggestions: [:text, :protobuf]
	}
	]
	},
	%{
	group: :pleroma,
	key: ConcurrentLimiter,
	type: :group,
	description: "Limits configuration for background tasks.",
	children: [
	%{
	key: Pleroma.Web.RichMedia.Helpers,
	type: :keyword,
	description: "Concurrent limits configuration for getting RichMedia for activities.",
	suggestions: [max_running: 5, max_waiting: 5],
	children: [
	%{
	key: :max_running,
	type: :integer,
	description: "Max running concurrently jobs.",
	suggestion: [5]
	},
	%{
	key: :max_waiting,
	type: :integer,
	description: "Max waiting jobs.",
	suggestion: [5]
	}
	]
	},
	%{
	key: Pleroma.Web.ActivityPub.MRF.MediaProxyWarmingPolicy,
	type: :keyword,
	description: "Concurrent limits configuration for MediaProxyWarmingPolicy.",
	suggestions: [max_running: 5, max_waiting: 5],
	children: [
	%{
	key: :max_running,
	type: :integer,
	description: "Max running concurrently jobs.",
	suggestion: [5]
	},
	%{
	key: :max_waiting,
	type: :integer,
	description: "Max waiting jobs.",
	suggestion: [5]
	}
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Search,
	type: :group,
	description: "General search settings.",
	children: [
	%{
	key: :module,
	type: :keyword,
	description: "Selected search module.",
	suggestion: [Pleroma.Search.DatabaseSearch, Pleroma.Search.Meilisearch]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Search.Meilisearch,
	type: :group,
	description: "Meilisearch settings.",
	children: [
	%{
	key: :url,
	type: :string,
	description: "Meilisearch URL.",
	suggestion: ["http://127.0.0.1:7700/"]
	},
	%{
	key: :private_key,
	type: :string,
	description:
	"Private key for meilisearch authentication, or `nil` to disable private key authentication.",
	suggestion: [nil]
	},
	%{
	key: :initial_indexing_chunk_size,
	type: :int,
	description:
	"Amount of posts in a batch when running the initial indexing operation. Should probably not be more than 100000" <>
	" since there's a limit on maximum insert size",
	suggestion: [100_000]
	}
	]
	}
	]
	diff --git a/docs/administration/frontends-management.md b/docs/administration/frontends-management.md
	new file mode 100644
	index 000000000..f982c4bca
	--- /dev/null
	+++ b/docs/administration/frontends-management.md
	@@ -0,0 +1,71 @@
	+# Managing installed frontends
	+
	+Pleroma lets you install multiple frontends including multiple versions of same frontend. Right now it's only possible to switch which frontend is the default, but in the future it would be possible for user to select which frontend they prefer to use.
	+
	+As of 2.6.0 there are two ways of managing frontends - through PleromaFE's Admin Dashboard (preferred, easier method) or through AdminFE (clunky but also works on versions older than 2.6.0).
	+
	+!!! note
	+ Managing frontends through UI requires [in-database configuration](../configuration/howto_database_config.md) to be enabled (default on newer instances but might be off on older ones).
	+
	+## How it works
	+
	+When installing frontends, it creates a folder in [static directory](../configuration/static_dir.md) that follows this pattern: `/frontends/${front-end name}/${front-end version}/`, puts contents of the built frontend in there. Then when accessing the server backend checks what front-end name and version are set to be default and serves index.html and assets from appropriate path.
	+
	+!!! warning
	+
	+ If you've been putting your frontend build directly into static dir as an antiquated way of serving custom frontend, this system will not work and will still serve the custom index.html you put in there. You can still serve custom frontend builds if you put your build into `/frontends/$name/$version` instead and set the "default frontend" fields appropriately.
	+
	+Currently, there is no backup system, i.e. when installing `master` version it _will_ overwrite installed `master` version, for now if you want to keep previous version you should back it up manually, i.e. running `cp -r ./frontends/pleroma-fe/master ./frontends/pleroma-fe/master_old` in your static dir.
	+
	+## Managing front-ends through Admin Dashboard
	+
	+Open up Admin Dashboard (gauge icon in top bar, same as where link to AdminFE was),__
	+![location of Admin Dashboard icon](../assets/admin_dash_location.png)
	+switch to "Front-ends" tab.
	+![screenshot of Front-ends tab](../assets/frontends_tab.png)
	+This page is designed to be self-explanatory and easy to use, while avoiding issues and pitfalls of AdminFE, but it's also early in development, everything is subject to change.
	+
	+!!! warning
	+ This goes without saying, but if you set default frontend to anything except >2.6.0 version of PleromaFE you'll lose the access to Admin Dashboard and will have to use AdminFE to get it back. See below on how to use AdminFE.
	+
	+### Limitations
	+
	+Currently the list of available for install frontends is essentially hard-coded in backend's configuration, each providing only one version, with exception for PleromaFE which overrides 'pleroma-fe' to also include `develop` version. There is no way to manually install build with a URL (coming soon) nor add more available frontends to the repository (it's broken).
	+
	+There is also no way to tell if there is an update available or not, for now you should watch for [announcements](https://pleroma.social/announcements/) of new PleromaFE stable releases to see if there is new stable version. For `develop` version it's up to you whether you want to follow the development process or just reinstall it periodically hoping for new stuff.
	+
	+## Using AdminFE to manage frontends
	+
	+Access AdminFE either directly by going to `/pleroma/admin` of your instance or by opening Admin Dashboard and clicking the link at the bottom of the window
	+![link to open old AdminFE](../assets/old_adminfe_link.png)
	+
	+
	+Go to Settings -> Frontend.
	+
	+### Installing front-ends
	+
	+At the very top of the page there's a list of available frontends and button to install custom front-end
	+
	+!!! tip
	+ Remember to click "Submit" in bottom right corner to save your changes!
	+
	+!!! bug
	+ Available Frontends section lets you _install_ frontends but NOT update/reinstall them. It's only useful for installing a frontend once.
	+
	+Due to aforementioned bug, preferred way of installing frontends in AdminFE is by clicking the "Install another frontend"
	+![screenshot of admin-fe with instructions on how to install a frontend](../assets/way_to_install_frontends.png)
	+and filling in the fields. Unfortunately AdminFE does not provide the raw data necessary for you to fill those fields, so your best bet is to see what backend returns in browser's devtools or refer to the [source code](https://git.pleroma.social/pleroma/pleroma/-/blob/develop/config/config.exs?ref_type=heads#L742-791). For the most part, only Name, Ref (i.e. version) and Build URL fields are required, although some frontends might also require Build Directory to work.
	+
	+For pleroma-fe you can use either `master` or `develop` refs, or potentially any ref in GitLab that has artifacts for `build` job, but that's outside scope of this document.
	+
	+### Selecting default frontend
	+
	+Scroll page waaaaay down, search for "Frontends" section, subtitled "Installed frontends management", change the name and reference of the "Primary" frontend.
	+![screenshot of admin-fe with instructions on how to install a frontend](../assets/primary_frontend_section.png)
	+
	+
	+!!! danger
	+ If you change "Admin" frontend name/reference you risk losing access to AdminFE as well.
	+
	+!!! warning
	+ Don't put anything into the "Available" section as it will break the list of available frontends completely, including the "add another frontend" button. If you accidentally put something in there, click the trashbin icon next to "Available" to reset it and restore the frontends list.
	diff --git a/docs/assets/admin_dash_location.png b/docs/assets/admin_dash_location.png
	new file mode 100644
	index 000000000..4e1d110e7
	Binary files /dev/null and b/docs/assets/admin_dash_location.png differ
	diff --git a/docs/assets/frontends_tab.png b/docs/assets/frontends_tab.png
	new file mode 100644
	index 000000000..f7c66adab
	Binary files /dev/null and b/docs/assets/frontends_tab.png differ
	diff --git a/docs/assets/old_adminfe_link.png b/docs/assets/old_adminfe_link.png
	new file mode 100644
	index 000000000..5ea6a486c
	Binary files /dev/null and b/docs/assets/old_adminfe_link.png differ
	diff --git a/docs/assets/primary_frontend_section.png b/docs/assets/primary_frontend_section.png
	new file mode 100644
	index 000000000..14c3de41b
	Binary files /dev/null and b/docs/assets/primary_frontend_section.png differ
	diff --git a/docs/assets/way_to_install_frontends.png b/docs/assets/way_to_install_frontends.png
	new file mode 100644
	index 000000000..a90ff2b5d
	Binary files /dev/null and b/docs/assets/way_to_install_frontends.png differ
	diff --git a/docs/installation/freebsd_en.md b/docs/installation/freebsd_en.md
	index 50ed30d74..02513daf2 100644
	--- a/docs/installation/freebsd_en.md
	+++ b/docs/installation/freebsd_en.md
	@@ -1,222 +1,223 @@
	# Installing on FreeBSD

	This document was written for FreeBSD 12.1, but should be work on future releases.

	{! backend/installation/generic_dependencies.include !}

	## Installing software used in this guide

	This assumes the target system has `pkg(8)`.

	```
	-# pkg install elixir postgresql12-server postgresql12-client postgresql12-contrib git-lite sudo nginx gmake acme.sh cmake
	+# pkg install elixir postgresql12-server postgresql12-client postgresql12-contrib git-lite sudo nginx gmake acme.sh cmake vips
	```

	Copy the rc.d scripts to the right directory:

	Setup the required services to automatically start at boot, using `sysrc(8)`.

	```
	# sysrc nginx_enable=YES
	# sysrc postgresql_enable=YES
	```

	## Initialize postgres

	```
	# service postgresql initdb
	# service postgresql start
	```

	### Install media / graphics packages (optional, see [`docs/installation/optional/media_graphics_packages.md`](../installation/optional/media_graphics_packages.md))

	```shell
	# pkg install imagemagick ffmpeg p5-Image-ExifTool
	```

	## Configuring Pleroma

	Create a user for Pleroma:

	```
	# pw add user pleroma -m
	# echo 'export LC_ALL="en_US.UTF-8"' >> /home/pleroma/.profile
	+# echo 'export VIX_COMPILATION_MODE=PLATFORM_PROVIDED_LIBVIPS' >> /home/pleroma/.profile
	# su -l pleroma
	```

	Clone the repository:

	```
	$ cd $HOME # Should be the same as /home/pleroma
	$ git clone -b stable https://git.pleroma.social/pleroma/pleroma.git
	```

	Configure Pleroma. Note that you need a domain name at this point:

	```
	$ cd /home/pleroma/pleroma
	$ mix deps.get # Enter "y" when asked to install Hex
	$ MIX_ENV=prod mix pleroma.instance gen # You will be asked a few questions here.
	$ cp config/generated_config.exs config/prod.secret.exs
	```

	Since Postgres is configured, we can now initialize the database. There should
	now be a file in `config/setup_db.psql` that makes this easier. Edit it, and
	change the password to a password of your choice. Make sure it is secure, since
	it'll be protecting your database. As root, you can now initialize the database:

	```
	# cd /home/pleroma/pleroma
	# sudo -Hu postgres -g postgres psql -f config/setup_db.psql
	```

	Postgres allows connections from all users without a password by default. To
	fix this, edit `/var/db/postgres/data12/pg_hba.conf`. Change every `trust` to
	`password`.

	Once this is done, restart Postgres with:
	```
	# service postgresql restart
	```

	Run the database migrations.

	Back as the pleroma user, run the following to implement any database migrations.

	```
	# su -l pleroma
	$ cd /home/pleroma/pleroma
	$ MIX_ENV=prod mix ecto.migrate
	```

	You will need to do this whenever you update with `git pull`:

	## Configuring acme.sh

	We'll be using acme.sh in Stateless Mode for TLS certificate renewal.

	First, as root, allow the user `acme` to have access to the acme log file, as follows:

	```
	# touch /var/log/acme.sh.log
	# chown acme:acme /var/log/acme.sh.log
	# chmod 600 /var/log/acme.sh.log
	```

	Next, obtain your account fingerprint:

	```
	# sudo -Hu acme -g acme acme.sh --register-account
	```

	You need to add the following to your nginx configuration for the server
	running on port 80:

	```
	location ~ ^/\.well-known/acme-challenge/([-_a-zA-Z0-9]+)$ {
	default_type text/plain;
	return 200 "$1.6fXAG9VyG0IahirPEU2ZerUtItW2DHzDzD9wZaEKpqd";
	}
	```

	Replace the string after after `$1.` with your fingerprint.

	Start nginx:

	```
	# service nginx start
	```

	It should now be possible to issue a cert (replace `example.com`
	with your domain name):

	```
	# sudo -Hu acme -g acme acme.sh --issue -d example.com --stateless
	```

	Let's add auto-renewal to `/etc/crontab`
	(replace `example.com` with your domain):

	```
	/usr/local/bin/sudo -Hu acme -g acme /usr/local/sbin/acme.sh -r -d example.com --stateless
	```

	### Configuring nginx

	FreeBSD's default nginx configuration does not contain an include directive, which is
	typically used for multiple sites. Therefore, you will need to first create the required
	directory as follows:


	```
	# mkdir -p /usr/local/etc/nginx/sites-available
	```

	Next, add an `include` directive to `/usr/local/etc/nginx/nginx.conf`, within the `http {}`
	block, as follows:


	```
	http {
	...
	include /usr/local/etc/nginx/sites-available/*;
	}
	```

	As root, copy `/home/pleroma/pleroma/installation/pleroma.nginx` to
	`/usr/local/etc/nginx/sites-available/pleroma.nginx`.

	Edit the defaults of `/usr/local/etc/nginx/sites-available/pleroma.nginx`:

	* Change `ssl_trusted_certificate` to `/var/db/acme/certs/example.tld/example.tld.cer`.
	* Change `ssl_certificate` to `/var/db/acme/certs/example.tld/fullchain.cer`.
	* Change `ssl_certificate_key` to `/var/db/acme/certs/example.tld/example.tld.key`.
	* Change all references of `example.tld` to your instance's domain name.

	#### (Strongly recommended) serve media on another domain

	Refer to the [Hardening your instance](../configuration/hardening.md) document on how to serve media on another domain. We STRONGLY RECOMMEND you to do this to minimize attack vectors.

	## Creating a startup script for Pleroma

	Pleroma will need to compile when it initially starts, which typically takes a longer
	period of time. Therefore, it is good practice to initially run pleroma from the
	command-line before utilizing the rc.d script. That is done as follows:

	```
	# su -l pleroma
	$ cd $HOME/pleroma
	$ MIX_ENV=prod mix phx.server
	```

	Copy the startup script to the correct location and make sure it's executable:

	```
	# cp /home/pleroma/pleroma/installation/freebsd/rc.d/pleroma /usr/local/etc/rc.d/pleroma
	# chmod +x /usr/local/etc/rc.d/pleroma
	```

	Update the `/etc/rc.conf` and start pleroma with the following commands:

	```
	# sysrc pleroma_enable=YES
	# service pleroma start
	```

	#### Create your first user

	If your instance is up and running, you can create your first user with administrative rights with the following task:

	```shell
	sudo -Hu pleroma MIX_ENV=prod mix pleroma.user new <username> <your@emailaddress> --admin
	```
	## Conclusion

	Restart nginx with `# service nginx restart` and you should be up and running.

	Make sure your time is in sync, or other instances will receive your posts with
	incorrect timestamps. You should have ntpd running.

	## Questions

	Questions about the installation or didn’t it work as it should be, ask in [#pleroma:libera.chat](https://matrix.to/#/#pleroma:libera.chat) via Matrix or #pleroma on libera.chat via IRC.
	diff --git a/docs/installation/generic_dependencies.include b/docs/installation/generic_dependencies.include
	index dcaacfdfd..3365a36a8 100644
	--- a/docs/installation/generic_dependencies.include
	+++ b/docs/installation/generic_dependencies.include
	@@ -1,16 +1,16 @@
	## Required dependencies

	-* PostgreSQL 9.6+
	-* Elixir 1.10+
	-* Erlang OTP 22.2+
	+* PostgreSQL >=9.6
	+* Elixir >=1.11.0 <1.15
	+* Erlang OTP >=22.2.0 <26
	* git
	* file / libmagic
	-* gcc (clang might also work)
	+* gcc or clang
	* GNU make
	* CMake

	## Optional dependencies

	* ImageMagick
	* FFmpeg
	* exiftool
	diff --git a/lib/pleroma/application.ex b/lib/pleroma/application.ex
	index 7bbc132f1..52cd6e9a9 100644
	--- a/lib/pleroma/application.ex
	+++ b/lib/pleroma/application.ex
	@@ -1,339 +1,316 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Application do
	use Application

	import Cachex.Spec

	alias Pleroma.Config

	require Logger

	@name Mix.Project.config()[:name]
	@version Mix.Project.config()[:version]
	@repository Mix.Project.config()[:source_url]
	@mix_env Mix.env()

	def name, do: @name
	def version, do: @version
	def named_version, do: @name <> " " <> @version
	def repository, do: @repository

	def user_agent do
	if Process.whereis(Pleroma.Web.Endpoint) do
	case Config.get([:http, :user_agent], :default) do
	:default ->
	info = "#{Pleroma.Web.Endpoint.url()} <#{Config.get([:instance, :email], "")}>"
	named_version() <> "; " <> info

	custom ->
	custom
	end
	else
	# fallback, if endpoint is not started yet
	"Pleroma Data Loader"
	end
	end

	# See http://elixir-lang.org/docs/stable/elixir/Application.html
	# for more information on OTP Applications
	def start(_type, _args) do
	# Scrubbers are compiled at runtime and therefore will cause a conflict
	# every time the application is restarted, so we disable module
	# conflicts at runtime
	Code.compiler_options(ignore_module_conflict: true)
	# Disable warnings_as_errors at runtime, it breaks Phoenix live reload
	# due to protocol consolidation warnings
	Code.compiler_options(warnings_as_errors: false)
	Pleroma.Telemetry.Logger.attach()
	Config.Holder.save_default()
	Pleroma.HTML.compile_scrubbers()
	Pleroma.Config.Oban.warn()
	Config.DeprecationWarnings.warn()
	Pleroma.Web.Plugs.HTTPSecurityPlug.warn_if_disabled()
	Pleroma.ApplicationRequirements.verify!()
	- setup_instrumenters()
	load_custom_modules()
	Pleroma.Docs.JSON.compile()
	limiters_setup()

	adapter = Application.get_env(:tesla, :adapter)

	if match?({Tesla.Adapter.Finch, _}, adapter) do
	Logger.info("Starting Finch")
	Finch.start_link(name: MyFinch)
	end

	if adapter == Tesla.Adapter.Gun do
	if version = Pleroma.OTPVersion.version() do
	[major, minor] =
	version
	\|> String.split(".")
	\|> Enum.map(&String.to_integer/1)
	\|> Enum.take(2)

	if (major == 22 and minor < 2) or major < 22 do
	raise "
	!!!OTP VERSION WARNING!!!
	You are using gun adapter with OTP version #{version}, which doesn't support correct handling of unordered certificates chains. Please update your Erlang/OTP to at least 22.2.
	"
	end
	else
	raise "
	!!!OTP VERSION WARNING!!!
	To support correct handling of unordered certificates chains - OTP version must be > 22.2.
	"
	end
	end

	# Define workers and child supervisors to be supervised
	children =
	[
	+ Pleroma.PromEx,
	Pleroma.Repo,
	Config.TransferTask,
	Pleroma.Emoji,
	Pleroma.Web.Plugs.RateLimiter.Supervisor,
	{Task.Supervisor, name: Pleroma.TaskSupervisor}
	] ++
	cachex_children() ++
	http_children(adapter, @mix_env) ++
	[
	Pleroma.Stats,
	Pleroma.JobQueueMonitor,
	{Majic.Pool, [name: Pleroma.MajicPool, pool_size: Config.get([:majic_pool, :size], 2)]},
	{Oban, Config.get(Oban)},
	Pleroma.Web.Endpoint
	] ++
	task_children(@mix_env) ++
	dont_run_in_test(@mix_env) ++
	shout_child(shout_enabled?()) ++
	[Pleroma.Gopher.Server]

	# See http://elixir-lang.org/docs/stable/elixir/Supervisor.html
	# for other strategies and supported options
	# If we have a lot of caches, default max_restarts can cause test
	# resets to fail.
	# Go for the default 3 unless we're in test
	max_restarts =
	if @mix_env == :test do
	100
	else
	3
	end

	opts = [strategy: :one_for_one, name: Pleroma.Supervisor, max_restarts: max_restarts]
	result = Supervisor.start_link(children, opts)

	set_postgres_server_version()

	result
	end

	defp set_postgres_server_version do
	version =
	with %{rows: [[version]]} <- Ecto.Adapters.SQL.query!(Pleroma.Repo, "show server_version"),
	{num, _} <- Float.parse(version) do
	num
	else
	e ->
	Logger.warn(
	"Could not get the postgres version: #{inspect(e)}.\nSetting the default value of 9.6"
	)

	9.6
	end

	:persistent_term.put({Pleroma.Repo, :postgres_version}, version)
	end

	def load_custom_modules do
	dir = Config.get([:modules, :runtime_dir])

	if dir && File.exists?(dir) do
	dir
	\|> Pleroma.Utils.compile_dir()
	\|> case do
	{:error, _errors, _warnings} ->
	raise "Invalid custom modules"

	{:ok, modules, _warnings} ->
	if @mix_env != :test do
	Enum.each(modules, fn mod ->
	Logger.info("Custom module loaded: #{inspect(mod)}")
	end)
	end

	:ok
	end
	end
	end

	- defp setup_instrumenters do
	- require Prometheus.Registry
	-
	- if Application.get_env(:prometheus, Pleroma.Repo.Instrumenter) do
	- :ok =
	- :telemetry.attach(
	- "prometheus-ecto",
	- [:pleroma, :repo, :query],
	- &Pleroma.Repo.Instrumenter.handle_event/4,
	- %{}
	- )
	-
	- Pleroma.Repo.Instrumenter.setup()
	- end
	-
	- Pleroma.Web.Endpoint.MetricsExporter.setup()
	- Pleroma.Web.Endpoint.PipelineInstrumenter.setup()
	-
	- # Note: disabled until prometheus-phx is integrated into prometheus-phoenix:
	- # Pleroma.Web.Endpoint.Instrumenter.setup()
	- PrometheusPhx.setup()
	- end
	-
	defp cachex_children do
	[
	build_cachex("used_captcha", ttl_interval: seconds_valid_interval()),
	build_cachex("user", default_ttl: 25_000, ttl_interval: 1000, limit: 2500),
	build_cachex("object", default_ttl: 25_000, ttl_interval: 1000, limit: 2500),
	build_cachex("rich_media", default_ttl: :timer.minutes(120), limit: 5000),
	build_cachex("scrubber", limit: 2500),
	build_cachex("scrubber_management", limit: 2500),
	build_cachex("idempotency", expiration: idempotency_expiration(), limit: 2500),
	build_cachex("web_resp", limit: 2500),
	build_cachex("emoji_packs", expiration: emoji_packs_expiration(), limit: 10),
	build_cachex("failed_proxy_url", limit: 2500),
	build_cachex("banned_urls", default_ttl: :timer.hours(24 * 30), limit: 5_000),
	build_cachex("chat_message_id_idempotency_key",
	expiration: chat_message_id_idempotency_key_expiration(),
	limit: 500_000
	),
	build_cachex("rel_me", limit: 2500)
	]
	end

	defp emoji_packs_expiration,
	do: expiration(default: :timer.seconds(5 * 60), interval: :timer.seconds(60))

	defp idempotency_expiration,
	do: expiration(default: :timer.seconds(6 * 60 * 60), interval: :timer.seconds(60))

	defp chat_message_id_idempotency_key_expiration,
	do: expiration(default: :timer.minutes(2), interval: :timer.seconds(60))

	defp seconds_valid_interval,
	do: :timer.seconds(Config.get!([Pleroma.Captcha, :seconds_valid]))

	@spec build_cachex(String.t(), keyword()) :: map()
	def build_cachex(type, opts),
	do: %{
	id: String.to_atom("cachex_" <> type),
	start: {Cachex, :start_link, [String.to_atom(type <> "_cache"), opts]},
	type: :worker
	}

	defp shout_enabled?, do: Config.get([:shout, :enabled])

	defp dont_run_in_test(env) when env in [:test, :benchmark], do: []

	defp dont_run_in_test(_) do
	[
	{Registry,
	[
	name: Pleroma.Web.Streamer.registry(),
	keys: :duplicate,
	partitions: System.schedulers_online()
	]}
	] ++ background_migrators()
	end

	defp background_migrators do
	[
	Pleroma.Migrators.HashtagsTableMigrator,
	Pleroma.Migrators.ContextObjectsDeletionMigrator
	]
	end

	defp shout_child(true) do
	[
	Pleroma.Web.ShoutChannel.ShoutChannelState,
	{Phoenix.PubSub, [name: Pleroma.PubSub, adapter: Phoenix.PubSub.PG2]}
	]
	end

	defp shout_child(_), do: []

	defp task_children(:test) do
	[
	%{
	id: :web_push_init,
	start: {Task, :start_link, [&Pleroma.Web.Push.init/0]},
	restart: :temporary
	}
	]
	end

	defp task_children(_) do
	[
	%{
	id: :web_push_init,
	start: {Task, :start_link, [&Pleroma.Web.Push.init/0]},
	restart: :temporary
	},
	%{
	id: :internal_fetch_init,
	start: {Task, :start_link, [&Pleroma.Web.ActivityPub.InternalFetchActor.init/0]},
	restart: :temporary
	}
	]
	end

	# start hackney and gun pools in tests
	defp http_children(_, :test) do
	http_children(Tesla.Adapter.Hackney, nil) ++ http_children(Tesla.Adapter.Gun, nil)
	end

	defp http_children(Tesla.Adapter.Hackney, _) do
	pools = [:federation, :media]

	pools =
	if Config.get([Pleroma.Upload, :proxy_remote]) do
	[:upload \| pools]
	else
	pools
	end

	for pool <- pools do
	options = Config.get([:hackney_pools, pool])
	:hackney_pool.child_spec(pool, options)
	end
	end

	defp http_children(Tesla.Adapter.Gun, _) do
	Pleroma.Gun.ConnectionPool.children() ++
	[{Task, &Pleroma.HTTP.AdapterHelper.Gun.limiter_setup/0}]
	end

	defp http_children(_, _), do: []

	@spec limiters_setup() :: :ok
	def limiters_setup do
	config = Config.get(ConcurrentLimiter, [])

	[
	Pleroma.Web.RichMedia.Helpers,
	Pleroma.Web.ActivityPub.MRF.MediaProxyWarmingPolicy,
	Pleroma.Search
	]
	\|> Enum.each(fn module ->
	mod_config = Keyword.get(config, module, [])

	max_running = Keyword.get(mod_config, :max_running, 5)
	max_waiting = Keyword.get(mod_config, :max_waiting, 5)

	ConcurrentLimiter.new(module, max_running, max_waiting)
	end)
	end
	end
	diff --git a/lib/pleroma/config/transfer_task.ex b/lib/pleroma/config/transfer_task.ex
	index 44a984019..6fd05b0e0 100644
	--- a/lib/pleroma/config/transfer_task.ex
	+++ b/lib/pleroma/config/transfer_task.ex
	@@ -1,196 +1,195 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Config.TransferTask do
	use Task

	alias Pleroma.Config
	alias Pleroma.ConfigDB
	alias Pleroma.Repo

	require Logger

	@type env() :: :test \| :benchmark \| :dev \| :prod

	defp reboot_time_keys,
	do: [
	{:pleroma, :hackney_pools},
	{:pleroma, :shout},
	{:pleroma, Oban},
	{:pleroma, :rate_limit},
	{:pleroma, :markup},
	{:pleroma, :streamer},
	{:pleroma, :pools},
	{:pleroma, :connections_pool}
	]

	defp reboot_time_subkeys,
	do: [
	{:pleroma, Pleroma.Captcha, [:seconds_valid]},
	{:pleroma, Pleroma.Upload, [:proxy_remote]},
	{:pleroma, :instance, [:upload_limit]},
	{:pleroma, :gopher, [:enabled]}
	]

	def start_link(restart_pleroma? \\ true) do
	load_and_update_env([], restart_pleroma?)
	if Config.get(:env) == :test, do: Ecto.Adapters.SQL.Sandbox.checkin(Repo)
	:ignore
	end

	@spec load_and_update_env([ConfigDB.t()], boolean()) :: :ok
	def load_and_update_env(deleted_settings \\ [], restart_pleroma? \\ true) do
	with {_, true} <- {:configurable, Config.get(:configurable_from_database)} do
	# We need to restart applications for loaded settings take effect

	{logger, other} =
	(Repo.all(ConfigDB) ++ deleted_settings)
	\|> Enum.map(&merge_with_default/1)
	\|> Enum.split_with(fn {group, _, _, _} -> group in [:logger] end)

	logger
	\|> Enum.sort()
	\|> Enum.each(&configure/1)

	started_applications = Application.started_applications()

	- # TODO: some problem with prometheus after restart!
	- reject = [nil, :prometheus, :postgrex]
	+ reject = [nil, :postgrex]

	reject =
	if restart_pleroma? do
	reject
	else
	[:pleroma \| reject]
	end

	other
	\|> Enum.map(&update/1)
	\|> Enum.uniq()
	\|> Enum.reject(&(&1 in reject))
	\|> maybe_set_pleroma_last()
	\|> Enum.each(&restart(started_applications, &1, Config.get(:env)))

	:ok
	else
	{:configurable, false} -> Restarter.Pleroma.rebooted()
	end
	end

	defp maybe_set_pleroma_last(apps) do
	# to be ensured that pleroma will be restarted last
	if :pleroma in apps do
	apps
	\|> List.delete(:pleroma)
	\|> List.insert_at(-1, :pleroma)
	else
	Restarter.Pleroma.rebooted()
	apps
	end
	end

	defp merge_with_default(%{group: group, key: key, value: value} = setting) do
	default = Config.Holder.default_config(group, key)

	merged =
	cond do
	Ecto.get_meta(setting, :state) == :deleted -> default
	can_be_merged?(default, value) -> ConfigDB.merge_group(group, key, default, value)
	true -> value
	end

	{group, key, value, merged}
	end

	# change logger configuration in runtime, without restart
	defp configure({_, :backends, _, merged}) do
	# removing current backends
	Enum.each(Application.get_env(:logger, :backends), &Logger.remove_backend/1)

	Enum.each(merged, &Logger.add_backend/1)

	:ok = update_env(:logger, :backends, merged)
	end

	defp configure({_, key, _, merged}) when key in [:console, :ex_syslogger] do
	merged =
	if key == :console do
	put_in(merged[:format], merged[:format] <> "\n")
	else
	merged
	end

	backend =
	if key == :ex_syslogger,
	do: {ExSyslogger, :ex_syslogger},
	else: key

	Logger.configure_backend(backend, merged)
	:ok = update_env(:logger, key, merged)
	end

	defp configure({_, key, _, merged}) do
	Logger.configure([{key, merged}])
	:ok = update_env(:logger, key, merged)
	end

	defp update({group, key, value, merged}) do
	try do
	:ok = update_env(group, key, merged)

	if group != :pleroma or pleroma_need_restart?(group, key, value), do: group
	rescue
	error ->
	error_msg =
	"updating env causes error, group: #{inspect(group)}, key: #{inspect(key)}, value: #{inspect(value)} error: #{inspect(error)}"

	Logger.warn(error_msg)

	nil
	end
	end

	defp update_env(group, key, nil), do: Application.delete_env(group, key)
	defp update_env(group, key, value), do: Application.put_env(group, key, value)

	@spec pleroma_need_restart?(atom(), atom(), any()) :: boolean()
	def pleroma_need_restart?(group, key, value) do
	group_and_key_need_reboot?(group, key) or group_and_subkey_need_reboot?(group, key, value)
	end

	defp group_and_key_need_reboot?(group, key) do
	Enum.any?(reboot_time_keys(), fn {g, k} -> g == group and k == key end)
	end

	defp group_and_subkey_need_reboot?(group, key, value) do
	Keyword.keyword?(value) and
	Enum.any?(reboot_time_subkeys(), fn {g, k, subkeys} ->
	g == group and k == key and
	Enum.any?(Keyword.keys(value), &(&1 in subkeys))
	end)
	end

	defp restart(_, :pleroma, env), do: Restarter.Pleroma.restart_after_boot(env)

	defp restart(started_applications, app, _) do
	with {^app, _, _} <- List.keyfind(started_applications, app, 0),
	:ok <- Application.stop(app) do
	:ok = Application.start(app)
	else
	nil ->
	Logger.warn("#{app} is not started.")

	error ->
	error
	\|> inspect()
	\|> Logger.warn()
	end
	end

	defp can_be_merged?(val1, val2) when is_list(val1) and is_list(val2) do
	Keyword.keyword?(val1) and Keyword.keyword?(val2)
	end

	defp can_be_merged?(_val1, _val2), do: false
	end
	diff --git a/lib/pleroma/docs/generator.ex b/lib/pleroma/docs/generator.ex
	index 6508f1947..456a8fd54 100644
	--- a/lib/pleroma/docs/generator.ex
	+++ b/lib/pleroma/docs/generator.ex
	@@ -1,136 +1,138 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Docs.Generator do
	@callback process(keyword()) :: {:ok, String.t()}

	@spec process(module(), keyword()) :: {:ok, String.t()}
	def process(implementation, descriptions) do
	implementation.process(descriptions)
	end

	@spec list_behaviour_implementations(behaviour :: module()) :: [module()]
	def list_behaviour_implementations(behaviour) do
	:code.all_loaded()
	\|> Enum.filter(fn {module, _} ->
	# This shouldn't be needed as all modules are expected to have module_info/1,
	# but in test enviroments some transient modules `:elixir_compiler_XX`
	# are loaded for some reason (where XX is a random integer).
	+ Code.ensure_loaded(module)
	+
	if function_exported?(module, :module_info, 1) do
	module.module_info(:attributes)
	\|> Keyword.get_values(:behaviour)
	\|> List.flatten()
	\|> Enum.member?(behaviour)
	end
	end)
	\|> Enum.map(fn {module, _} -> module end)
	end

	@doc """
	Converts:
	- atoms to strings with leading `:`
	- module names to strings, without leading `Elixir.`
	- add humanized labels to `keys` if label is not defined, e.g. `:instance` -> `Instance`
	"""
	@spec convert_to_strings([map()]) :: [map()]
	def convert_to_strings(descriptions) do
	Enum.map(descriptions, &format_entity(&1))
	end

	defp format_entity(entity) do
	entity
	\|> format_key()
	\|> Map.put(:group, atom_to_string(entity[:group]))
	\|> format_children()
	end

	defp format_key(%{key: key} = entity) do
	entity
	\|> Map.put(:key, atom_to_string(key))
	\|> Map.put(:label, entity[:label] \|\| humanize(key))
	end

	defp format_key(%{group: group} = entity) do
	Map.put(entity, :label, entity[:label] \|\| humanize(group))
	end

	defp format_key(entity), do: entity

	defp format_children(%{children: children} = entity) do
	Map.put(entity, :children, Enum.map(children, &format_child(&1)))
	end

	defp format_children(entity), do: entity

	defp format_child(%{suggestions: suggestions} = entity) do
	entity
	\|> Map.put(:suggestions, format_suggestions(suggestions))
	\|> format_key()
	\|> format_group()
	\|> format_children()
	end

	defp format_child(entity) do
	entity
	\|> format_key()
	\|> format_group()
	\|> format_children()
	end

	defp format_group(%{group: group} = entity) do
	Map.put(entity, :group, format_suggestion(group))
	end

	defp format_group(entity), do: entity

	defp atom_to_string(entity) when is_binary(entity), do: entity

	defp atom_to_string(entity) when is_atom(entity), do: inspect(entity)

	defp humanize(entity) do
	string = inspect(entity)

	if String.starts_with?(string, ":"),
	do: Phoenix.Naming.humanize(entity),
	else: string
	end

	defp format_suggestions({:list_behaviour_implementations, behaviour}) do
	behaviour
	\|> list_behaviour_implementations()
	\|> format_suggestions()
	end

	defp format_suggestions([]), do: []

	defp format_suggestions([suggestion \| tail]) do
	[format_suggestion(suggestion) \| format_suggestions(tail)]
	end

	defp format_suggestion(entity) when is_atom(entity) do
	atom_to_string(entity)
	end

	defp format_suggestion([head \| tail] = entity) when is_list(entity) do
	[format_suggestion(head) \| format_suggestions(tail)]
	end

	defp format_suggestion(entity) when is_tuple(entity) do
	format_suggestions(Tuple.to_list(entity)) \|> List.to_tuple()
	end

	defp format_suggestion(entity), do: entity
	end

	defimpl Jason.Encoder, for: Tuple do
	def encode(tuple, opts), do: Jason.Encode.list(Tuple.to_list(tuple), opts)
	end

	defimpl Jason.Encoder, for: [Regex, Function] do
	def encode(term, opts), do: Jason.Encode.string(inspect(term), opts)
	end

	defimpl String.Chars, for: Regex do
	def to_string(term), do: inspect(term)
	end
	diff --git a/lib/pleroma/helpers/media_helper.ex b/lib/pleroma/helpers/media_helper.ex
	index 24c845fcd..07dfea55b 100644
	--- a/lib/pleroma/helpers/media_helper.ex
	+++ b/lib/pleroma/helpers/media_helper.ex
	@@ -1,162 +1,131 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Helpers.MediaHelper do
	@moduledoc """
	Handles common media-related operations.
	"""

	alias Pleroma.HTTP
	+ alias Vix.Vips.Operation

	require Logger

	def missing_dependencies do
	- Enum.reduce([imagemagick: "convert", ffmpeg: "ffmpeg"], [], fn {sym, executable}, acc ->
	+ Enum.reduce([ffmpeg: "ffmpeg"], [], fn {sym, executable}, acc ->
	if Pleroma.Utils.command_available?(executable) do
	acc
	else
	[sym \| acc]
	end
	end)
	end

	def image_resize(url, options) do
	- with executable when is_binary(executable) <- System.find_executable("convert"),
	- {:ok, args} <- prepare_image_resize_args(options),
	- {:ok, env} <- HTTP.get(url, [], pool: :media),
	- {:ok, fifo_path} <- mkfifo() do
	- args = List.flatten([fifo_path, args])
	- run_fifo(fifo_path, env, executable, args)
	+ with {:ok, env} <- HTTP.get(url, [], pool: :media),
	+ {:ok, resized} <-
	+ Operation.thumbnail_buffer(env.body, options.max_width,
	+ height: options.max_height,
	+ size: :VIPS_SIZE_DOWN
	+ ) do
	+ if options[:format] == "png" do
	+ Operation.pngsave_buffer(resized, Q: options[:quality])
	+ else
	+ Operation.jpegsave_buffer(resized, Q: options[:quality], interlace: true)
	+ end
	else
	- nil -> {:error, {:convert, :command_not_found}}
	{:error, _} = error -> error
	end
	end

	- defp prepare_image_resize_args(
	- %{max_width: max_width, max_height: max_height, format: "png"} = options
	- ) do
	- quality = options[:quality] \|\| 85
	- resize = Enum.join([max_width, "x", max_height, ">"])
	-
	- args = [
	- "-resize",
	- resize,
	- "-quality",
	- to_string(quality),
	- "png:-"
	- ]
	-
	- {:ok, args}
	- end
	-
	- defp prepare_image_resize_args(%{max_width: max_width, max_height: max_height} = options) do
	- quality = options[:quality] \|\| 85
	- resize = Enum.join([max_width, "x", max_height, ">"])
	-
	- args = [
	- "-interlace",
	- "Plane",
	- "-resize",
	- resize,
	- "-quality",
	- to_string(quality),
	- "jpg:-"
	- ]
	-
	- {:ok, args}
	- end
	-
	- defp prepare_image_resize_args(_), do: {:error, :missing_options}
	-
	# Note: video thumbnail is intentionally not resized (always has original dimensions)
	def video_framegrab(url) do
	with executable when is_binary(executable) <- System.find_executable("ffmpeg"),
	{:ok, env} <- HTTP.get(url, [], pool: :media),
	{:ok, fifo_path} <- mkfifo(),
	args = [
	"-y",
	"-i",
	fifo_path,
	"-vframes",
	"1",
	"-f",
	"mjpeg",
	"-loglevel",
	"error",
	"-"
	] do
	run_fifo(fifo_path, env, executable, args)
	else
	nil -> {:error, {:ffmpeg, :command_not_found}}
	{:error, _} = error -> error
	end
	end

	defp run_fifo(fifo_path, env, executable, args) do
	pid =
	Port.open({:spawn_executable, executable}, [
	:use_stdio,
	:stream,
	:exit_status,
	:binary,
	args: args
	])

	fifo = Port.open(to_charlist(fifo_path), [:eof, :binary, :stream, :out])
	fix = Pleroma.Helpers.QtFastStart.fix(env.body)
	true = Port.command(fifo, fix)
	:erlang.port_close(fifo)
	loop_recv(pid)
	after
	File.rm(fifo_path)
	end

	defp mkfifo do
	path = Path.join(System.tmp_dir!(), "pleroma-media-preview-pipe-#{Ecto.UUID.generate()}")

	case System.cmd("mkfifo", [path]) do
	{_, 0} ->
	spawn(fifo_guard(path))
	{:ok, path}

	{_, err} ->
	{:error, {:fifo_failed, err}}
	end
	end

	defp fifo_guard(path) do
	pid = self()

	fn ->
	ref = Process.monitor(pid)

	receive do
	{:DOWN, ^ref, :process, ^pid, _} ->
	File.rm(path)
	end
	end
	end

	defp loop_recv(pid) do
	loop_recv(pid, <<>>)
	end

	defp loop_recv(pid, acc) do
	receive do
	{^pid, {:data, data}} ->
	loop_recv(pid, acc <> data)

	{^pid, {:exit_status, 0}} ->
	{:ok, acc}

	{^pid, {:exit_status, status}} ->
	{:error, status}
	after
	5000 ->
	:erlang.port_close(pid)
	{:error, :timeout}
	end
	end
	end
	diff --git a/lib/pleroma/instances/instance.ex b/lib/pleroma/instances/instance.ex
	index 9756c66dc..101e5dc88 100644
	--- a/lib/pleroma/instances/instance.ex
	+++ b/lib/pleroma/instances/instance.ex
	@@ -1,318 +1,314 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Instances.Instance do
	@moduledoc "Instance."

	alias Pleroma.Instances
	alias Pleroma.Instances.Instance
	alias Pleroma.Maps
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Workers.BackgroundWorker

	use Ecto.Schema

	import Ecto.Query
	import Ecto.Changeset

	require Logger

	schema "instances" do
	field(:host, :string)
	field(:unreachable_since, :naive_datetime_usec)
	field(:favicon, :string)
	field(:favicon_updated_at, :naive_datetime)

	embeds_one :metadata, Pleroma.Instances.Metadata, primary_key: false do
	field(:software_name, :string)
	field(:software_version, :string)
	field(:software_repository, :string)
	end

	field(:metadata_updated_at, :utc_datetime)

	timestamps()
	end

	defdelegate host(url_or_host), to: Instances

	def changeset(struct, params \\ %{}) do
	struct
	\|> cast(params, __schema__(:fields) -- [:metadata])
	\|> cast_embed(:metadata, with: &metadata_changeset/2)
	\|> validate_required([:host])
	\|> unique_constraint(:host)
	end

	def metadata_changeset(struct, params \\ %{}) do
	struct
	\|> cast(params, [:software_name, :software_version, :software_repository])
	end

	def filter_reachable([]), do: %{}

	def filter_reachable(urls_or_hosts) when is_list(urls_or_hosts) do
	hosts =
	urls_or_hosts
	\|> Enum.map(&(&1 && host(&1)))
	\|> Enum.filter(&(to_string(&1) != ""))

	unreachable_since_by_host =
	Repo.all(
	from(i in Instance,
	where: i.host in ^hosts,
	select: {i.host, i.unreachable_since}
	)
	)
	\|> Map.new(& &1)

	reachability_datetime_threshold = Instances.reachability_datetime_threshold()

	for entry <- Enum.filter(urls_or_hosts, &is_binary/1) do
	host = host(entry)
	unreachable_since = unreachable_since_by_host[host]

	if !unreachable_since \|\|
	NaiveDateTime.compare(unreachable_since, reachability_datetime_threshold) == :gt do
	{entry, unreachable_since}
	end
	end
	\|> Enum.filter(& &1)
	\|> Map.new(& &1)
	end

	def reachable?(url_or_host) when is_binary(url_or_host) do
	!Repo.one(
	from(i in Instance,
	where:
	i.host == ^host(url_or_host) and
	i.unreachable_since <= ^Instances.reachability_datetime_threshold(),
	select: true
	)
	)
	end

	def reachable?(url_or_host) when is_binary(url_or_host), do: true

	def set_reachable(url_or_host) when is_binary(url_or_host) do
	- with host <- host(url_or_host),
	- %Instance{} = existing_record <- Repo.get_by(Instance, %{host: host}) do
	- {:ok, _instance} =
	- existing_record
	- \|> changeset(%{unreachable_since: nil})
	- \|> Repo.update()
	- end
	+ %Instance{host: host(url_or_host)}
	+ \|> changeset(%{unreachable_since: nil})
	+ \|> Repo.insert(on_conflict: {:replace, [:unreachable_since]}, conflict_target: :host)
	end

	def set_reachable(_), do: {:error, nil}

	def set_unreachable(url_or_host, unreachable_since \\ nil)

	def set_unreachable(url_or_host, unreachable_since) when is_binary(url_or_host) do
	unreachable_since = parse_datetime(unreachable_since) \|\| NaiveDateTime.utc_now()
	host = host(url_or_host)
	existing_record = Repo.get_by(Instance, %{host: host})

	changes = %{unreachable_since: unreachable_since}

	cond do
	is_nil(existing_record) ->
	%Instance{}
	\|> changeset(Map.put(changes, :host, host))
	\|> Repo.insert()

	existing_record.unreachable_since &&
	NaiveDateTime.compare(existing_record.unreachable_since, unreachable_since) != :gt ->
	{:ok, existing_record}

	true ->
	existing_record
	\|> changeset(changes)
	\|> Repo.update()
	end
	end

	def set_unreachable(_, _), do: {:error, nil}

	def get_consistently_unreachable do
	reachability_datetime_threshold = Instances.reachability_datetime_threshold()

	from(i in Instance,
	where: ^reachability_datetime_threshold > i.unreachable_since,
	order_by: i.unreachable_since,
	select: {i.host, i.unreachable_since}
	)
	\|> Repo.all()
	end

	defp parse_datetime(datetime) when is_binary(datetime) do
	NaiveDateTime.from_iso8601(datetime)
	end

	defp parse_datetime(datetime), do: datetime

	def get_or_update_favicon(%URI{host: host} = instance_uri) do
	existing_record = Repo.get_by(Instance, %{host: host})
	now = NaiveDateTime.utc_now()

	if existing_record && existing_record.favicon_updated_at &&
	NaiveDateTime.diff(now, existing_record.favicon_updated_at) < 86_400 do
	existing_record.favicon
	else
	favicon = scrape_favicon(instance_uri)

	if existing_record do
	existing_record
	\|> changeset(%{favicon: favicon, favicon_updated_at: now})
	\|> Repo.update()
	else
	%Instance{}
	\|> changeset(%{host: host, favicon: favicon, favicon_updated_at: now})
	\|> Repo.insert()
	end

	favicon
	end
	rescue
	e ->
	Logger.warn("Instance.get_or_update_favicon(\"#{host}\") error: #{inspect(e)}")
	nil
	end

	defp scrape_favicon(%URI{} = instance_uri) do
	try do
	with {_, true} <- {:reachable, reachable?(instance_uri.host)},
	{:ok, %Tesla.Env{body: html}} <-
	Pleroma.HTTP.get(to_string(instance_uri), [{"accept", "text/html"}], pool: :media),
	{_, [favicon_rel \| _]} when is_binary(favicon_rel) <-
	{:parse,
	html \|> Floki.parse_document!() \|> Floki.attribute("link[rel=icon]", "href")},
	{_, favicon} when is_binary(favicon) <-
	{:merge, URI.merge(instance_uri, favicon_rel) \|> to_string()} do
	favicon
	else
	{:reachable, false} ->
	Logger.debug(
	"Instance.scrape_favicon(\"#{to_string(instance_uri)}\") ignored unreachable host"
	)

	nil

	_ ->
	nil
	end
	rescue
	e ->
	Logger.warn(
	"Instance.scrape_favicon(\"#{to_string(instance_uri)}\") error: #{inspect(e)}"
	)

	nil
	end
	end

	def get_or_update_metadata(%URI{host: host} = instance_uri) do
	existing_record = Repo.get_by(Instance, %{host: host})
	now = NaiveDateTime.utc_now()

	if existing_record && existing_record.metadata_updated_at &&
	NaiveDateTime.diff(now, existing_record.metadata_updated_at) < 86_400 do
	existing_record.metadata
	else
	metadata = scrape_metadata(instance_uri)

	if existing_record do
	existing_record
	\|> changeset(%{metadata: metadata, metadata_updated_at: now})
	\|> Repo.update()
	else
	%Instance{}
	\|> changeset(%{host: host, metadata: metadata, metadata_updated_at: now})
	\|> Repo.insert()
	end

	metadata
	end
	end

	defp get_nodeinfo_uri(well_known) do
	links = Map.get(well_known, "links", [])

	nodeinfo21 =
	Enum.find(links, &(&1["rel"] == "http://nodeinfo.diaspora.software/ns/schema/2.1"))["href"]

	nodeinfo20 =
	Enum.find(links, &(&1["rel"] == "http://nodeinfo.diaspora.software/ns/schema/2.0"))["href"]

	cond do
	is_binary(nodeinfo21) -> {:ok, nodeinfo21}
	is_binary(nodeinfo20) -> {:ok, nodeinfo20}
	true -> {:error, :no_links}
	end
	end

	defp scrape_metadata(%URI{} = instance_uri) do
	try do
	with {_, true} <- {:reachable, reachable?(instance_uri.host)},
	{:ok, %Tesla.Env{body: well_known_body}} <-
	instance_uri
	\|> URI.merge("/.well-known/nodeinfo")
	\|> to_string()
	\|> Pleroma.HTTP.get([{"accept", "application/json"}]),
	{:ok, well_known_json} <- Jason.decode(well_known_body),
	{:ok, nodeinfo_uri} <- get_nodeinfo_uri(well_known_json),
	{:ok, %Tesla.Env{body: nodeinfo_body}} <-
	Pleroma.HTTP.get(nodeinfo_uri, [{"accept", "application/json"}]),
	{:ok, nodeinfo} <- Jason.decode(nodeinfo_body) do
	# Can extract more metadata from NodeInfo but need to be careful about it's size,
	# can't just dump the entire thing
	software = Map.get(nodeinfo, "software", %{})

	%{
	software_name: software["name"],
	software_version: software["version"]
	}
	\|> Maps.put_if_present(:software_repository, software["repository"])
	else
	{:reachable, false} ->
	Logger.debug(
	"Instance.scrape_metadata(\"#{to_string(instance_uri)}\") ignored unreachable host"
	)

	nil

	_ ->
	nil
	end
	rescue
	e ->
	Logger.warn(
	"Instance.scrape_metadata(\"#{to_string(instance_uri)}\") error: #{inspect(e)}"
	)

	nil
	end
	end

	@doc """
	Deletes all users from an instance in a background task, thus also deleting
	all of those users' activities and notifications.
	"""
	def delete_users_and_activities(host) when is_binary(host) do
	BackgroundWorker.enqueue("delete_instance", %{"host" => host})
	end

	def perform(:delete_instance, host) when is_binary(host) do
	User.Query.build(%{nickname: "@#{host}"})
	\|> Repo.chunk_stream(100, :batches)
	\|> Stream.each(fn users ->
	users
	\|> Enum.each(fn user ->
	User.perform(:delete, user)
	end)
	end)
	\|> Stream.run()
	end
	end
	diff --git a/lib/pleroma/prom_ex.ex b/lib/pleroma/prom_ex.ex
	new file mode 100644
	index 000000000..6608708b7
	--- /dev/null
	+++ b/lib/pleroma/prom_ex.ex
	@@ -0,0 +1,49 @@
	+defmodule Pleroma.PromEx do
	+ use PromEx, otp_app: :pleroma
	+
	+ alias PromEx.Plugins
	+
	+ @impl true
	+ def plugins do
	+ [
	+ # PromEx built in plugins
	+ Plugins.Application,
	+ Plugins.Beam,
	+ {Plugins.Phoenix, router: Pleroma.Web.Router, endpoint: Pleroma.Web.Endpoint},
	+ Plugins.Ecto,
	+ Plugins.Oban
	+ # Plugins.PhoenixLiveView,
	+ # Plugins.Absinthe,
	+ # Plugins.Broadway,
	+
	+ # Add your own PromEx metrics plugins
	+ # Pleroma.Users.PromExPlugin
	+ ]
	+ end
	+
	+ @impl true
	+ def dashboard_assigns do
	+ [
	+ datasource_id: Pleroma.Config.get([Pleroma.PromEx, :datasource]),
	+ default_selected_interval: "30s"
	+ ]
	+ end
	+
	+ @impl true
	+ def dashboards do
	+ [
	+ # PromEx built in Grafana dashboards
	+ {:prom_ex, "application.json"},
	+ {:prom_ex, "beam.json"},
	+ {:prom_ex, "phoenix.json"},
	+ {:prom_ex, "ecto.json"},
	+ {:prom_ex, "oban.json"}
	+ # {:prom_ex, "phoenix_live_view.json"},
	+ # {:prom_ex, "absinthe.json"},
	+ # {:prom_ex, "broadway.json"},
	+
	+ # Add your dashboard definitions here with the format: {:otp_app, "path_in_priv"}
	+ # {:pleroma, "/grafana_dashboards/user_metrics.json"}
	+ ]
	+ end
	+end
	diff --git a/lib/pleroma/repo.ex b/lib/pleroma/repo.ex
	index 515b0c1ff..a50a59b3b 100644
	--- a/lib/pleroma/repo.ex
	+++ b/lib/pleroma/repo.ex
	@@ -1,97 +1,95 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Repo do
	use Ecto.Repo,
	otp_app: :pleroma,
	adapter: Ecto.Adapters.Postgres,
	migration_timestamps: [type: :naive_datetime_usec]

	import Ecto.Query
	require Logger

	- defmodule Instrumenter, do: use(Prometheus.EctoInstrumenter)
	-
	@doc """
	Dynamically loads the repository url from the
	DATABASE_URL environment variable.
	"""
	def init(_, opts) do
	{:ok, Keyword.put(opts, :url, System.get_env("DATABASE_URL"))}
	end

	@doc "find resource based on prepared query"
	@spec find_resource(Ecto.Query.t()) :: {:ok, struct()} \| {:error, :not_found}
	def find_resource(%Ecto.Query{} = query) do
	case __MODULE__.one(query) do
	nil -> {:error, :not_found}
	resource -> {:ok, resource}
	end
	end

	def find_resource(_query), do: {:error, :not_found}

	@doc """
	Gets association from cache or loads if need

	## Examples

	iex> Repo.get_assoc(token, :user)
	%User{}

	"""
	@spec get_assoc(struct(), atom()) :: {:ok, struct()} \| {:error, :not_found}
	def get_assoc(resource, association) do
	case __MODULE__.preload(resource, association) do
	%{^association => assoc} when not is_nil(assoc) -> {:ok, assoc}
	_ -> {:error, :not_found}
	end
	end

	@doc """
	Returns a lazy enumerable that emits all entries from the data store matching the given query.

	`returns_as` use to group records. use the `batches` option to fetch records in bulk.

	## Examples

	# fetch records one-by-one
	iex> Pleroma.Repo.chunk_stream(Pleroma.Activity.Queries.by_actor(ap_id), 500)

	# fetch records in bulk
	iex> Pleroma.Repo.chunk_stream(Pleroma.Activity.Queries.by_actor(ap_id), 500, :batches)
	"""
	@spec chunk_stream(Ecto.Query.t(), integer(), atom()) :: Enumerable.t()
	def chunk_stream(query, chunk_size, returns_as \\ :one, query_options \\ []) do
	# We don't actually need start and end functions of resource streaming,
	# but it seems to be the only way to not fetch records one-by-one and
	# have individual records be the elements of the stream, instead of
	# lists of records
	Stream.resource(
	fn -> 0 end,
	fn
	last_id ->
	query
	\|> order_by(asc: :id)
	\|> where([r], r.id > ^last_id)
	\|> limit(^chunk_size)
	\|> all(query_options)
	\|> case do
	[] ->
	{:halt, last_id}

	records ->
	last_id = List.last(records).id

	if returns_as == :one do
	{records, last_id}
	else
	{[records], last_id}
	end
	end
	end,
	fn _ -> :ok end
	)
	end
	end
	diff --git a/lib/pleroma/upload/filter/analyze_metadata.ex b/lib/pleroma/upload/filter/analyze_metadata.ex
	index 9a76a998b..e510ae3e6 100644
	--- a/lib/pleroma/upload/filter/analyze_metadata.ex
	+++ b/lib/pleroma/upload/filter/analyze_metadata.ex
	@@ -1,83 +1,105 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Upload.Filter.AnalyzeMetadata do
	@moduledoc """
	Extracts metadata about the upload, such as width/height
	"""
	require Logger

	+ alias Vix.Vips.Image
	+ alias Vix.Vips.Operation
	+
	@behaviour Pleroma.Upload.Filter

	@spec filter(Pleroma.Upload.t()) ::
	{:ok, :filtered, Pleroma.Upload.t()} \| {:ok, :noop} \| {:error, String.t()}
	def filter(%Pleroma.Upload{tempfile: file, content_type: "image" <> _} = upload) do
	try do
	- image =
	- file
	- \|> Mogrify.open()
	- \|> Mogrify.verbose()
	+ {:ok, image} = Image.new_from_file(file)
	+ {width, height} = {Image.width(image), Image.height(image)}

	upload =
	upload
	- \|> Map.put(:width, image.width)
	- \|> Map.put(:height, image.height)
	- \|> Map.put(:blurhash, get_blurhash(file))
	+ \|> Map.put(:width, width)
	+ \|> Map.put(:height, height)
	+ \|> Map.put(:blurhash, get_blurhash(image))

	{:ok, :filtered, upload}
	rescue
	e in ErlangError ->
	Logger.warn("#{__MODULE__}: #{inspect(e)}")
	{:ok, :noop}
	end
	end

	def filter(%Pleroma.Upload{tempfile: file, content_type: "video" <> _} = upload) do
	try do
	result = media_dimensions(file)

	upload =
	upload
	\|> Map.put(:width, result.width)
	\|> Map.put(:height, result.height)

	{:ok, :filtered, upload}
	rescue
	e in ErlangError ->
	Logger.warn("#{__MODULE__}: #{inspect(e)}")
	{:ok, :noop}
	end
	end

	def filter(_), do: {:ok, :noop}

	defp get_blurhash(file) do
	- with {:ok, blurhash} <- :eblurhash.magick(file) do
	+ with {:ok, blurhash} <- vips_blurhash(file) do
	blurhash
	else
	_ -> nil
	end
	end

	defp media_dimensions(file) do
	with executable when is_binary(executable) <- System.find_executable("ffprobe"),
	args = [
	"-v",
	"error",
	"-show_entries",
	"stream=width,height",
	"-of",
	"csv=p=0:s=x",
	file
	],
	{result, 0} <- System.cmd(executable, args),
	[width, height] <-
	String.split(String.trim(result), "x") \|> Enum.map(&String.to_integer(&1)) do
	%{width: width, height: height}
	else
	nil -> {:error, {:ffprobe, :command_not_found}}
	- {:error, _} = error -> error
	+ error -> {:error, error}
	+ end
	+ end
	+
	+ defp vips_blurhash(%Vix.Vips.Image{} = image) do
	+ with {:ok, resized_image} <- Operation.thumbnail_image(image, 100),
	+ {height, width} <- {Image.height(resized_image), Image.width(resized_image)},
	+ max <- max(height, width),
	+ {x, y} <- {max(round(width * 5 / max), 1), max(round(height * 5 / max), 1)} do
	+ {:ok, rgb} =
	+ if Image.has_alpha?(resized_image) do
	+ # remove alpha channel
	+ resized_image
	+ \|> Operation.extract_band!(0, n: 3)
	+ \|> Image.write_to_binary()
	+ else
	+ Image.write_to_binary(resized_image)
	+ end
	+
	+ Blurhash.encode(rgb, width, height, x, y)
	+ else
	+ _ -> nil
	end
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/mrf.ex b/lib/pleroma/web/activity_pub/mrf.ex
	index ff9f84497..69054e25b 100644
	--- a/lib/pleroma/web/activity_pub/mrf.ex
	+++ b/lib/pleroma/web/activity_pub/mrf.ex
	@@ -1,217 +1,221 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.MRF do
	require Logger

	@behaviour Pleroma.Web.ActivityPub.MRF.PipelineFiltering

	@mrf_config_descriptions [
	%{
	group: :pleroma,
	key: :mrf,
	tab: :mrf,
	label: "MRF",
	type: :group,
	description: "General MRF settings",
	children: [
	%{
	key: :policies,
	type: [:module, {:list, :module}],
	description:
	"A list of MRF policies enabled. Module names are shortened (removed leading `Pleroma.Web.ActivityPub.MRF.` part), but on adding custom module you need to use full name.",
	suggestions: {:list_behaviour_implementations, Pleroma.Web.ActivityPub.MRF.Policy}
	},
	%{
	key: :transparency,
	label: "MRF transparency",
	type: :boolean,
	description:
	"Make the content of your Message Rewrite Facility settings public (via nodeinfo)"
	},
	%{
	key: :transparency_exclusions,
	label: "MRF transparency exclusions",
	type: {:list, :tuple},
	key_placeholder: "instance",
	value_placeholder: "reason",
	description:
	"Exclude specific instance names from MRF transparency. The use of the exclusions feature will be disclosed in nodeinfo as a boolean value. You can also provide a reason for excluding these instance names. The instances and reasons won't be publicly disclosed.",
	suggestions: [
	"exclusion.com"
	]
	}
	]
	}
	]

	@default_description %{
	label: "",
	description: ""
	}

	@required_description_keys [:key, :related_policy]

	def filter_one(policy, message) do
	+ Code.ensure_loaded(policy)
	+
	should_plug_history? =
	if function_exported?(policy, :history_awareness, 0) do
	policy.history_awareness()
	else
	:manual
	end
	\|> Kernel.==(:auto)

	if not should_plug_history? do
	policy.filter(message)
	else
	main_result = policy.filter(message)

	with {_, {:ok, main_message}} <- {:main, main_result},
	{_,
	%{
	"formerRepresentations" => %{
	"orderedItems" => [_ \| _]
	}
	}} = {_, object} <- {:object, message["object"]},
	{_, {:ok, new_history}} <-
	{:history,
	Pleroma.Object.Updater.for_each_history_item(
	object["formerRepresentations"],
	object,
	fn item ->
	with {:ok, filtered} <- policy.filter(Map.put(message, "object", item)) do
	{:ok, filtered["object"]}
	else
	e -> e
	end
	end
	)} do
	{:ok, put_in(main_message, ["object", "formerRepresentations"], new_history)}
	else
	{:main, _} -> main_result
	{:object, _} -> main_result
	{:history, e} -> e
	end
	end
	end

	def filter(policies, %{} = message) do
	policies
	\|> Enum.reduce({:ok, message}, fn
	policy, {:ok, message} -> filter_one(policy, message)
	_, error -> error
	end)
	end

	def filter(%{} = object), do: get_policies() \|> filter(object)

	@impl true
	def pipeline_filter(%{} = message, meta) do
	object = meta[:object_data]
	ap_id = message["object"]

	if object && ap_id do
	with {:ok, message} <- filter(Map.put(message, "object", object)) do
	meta = Keyword.put(meta, :object_data, message["object"])
	{:ok, Map.put(message, "object", ap_id), meta}
	else
	{err, message} -> {err, message, meta}
	end
	else
	{err, message} = filter(message)

	{err, message, meta}
	end
	end

	def get_policies do
	Pleroma.Config.get([:mrf, :policies], [])
	\|> get_policies()
	\|> Enum.concat([Pleroma.Web.ActivityPub.MRF.HashtagPolicy])
	end

	defp get_policies(policy) when is_atom(policy), do: [policy]
	defp get_policies(policies) when is_list(policies), do: policies
	defp get_policies(_), do: []

	@spec subdomains_regex([String.t()]) :: [Regex.t()]
	def subdomains_regex(domains) when is_list(domains) do
	for domain <- domains, do: ~r(^#{String.replace(domain, ".", "(.\\.)*")}$)i
	end

	@spec subdomain_match?([Regex.t()], String.t()) :: boolean()
	def subdomain_match?(domains, host) do
	Enum.any?(domains, fn domain -> Regex.match?(domain, host) end)
	end

	@spec instance_list_from_tuples([{String.t(), String.t()}]) :: [String.t()]
	def instance_list_from_tuples(list) do
	Enum.map(list, fn {instance, _} -> instance end)
	end

	def describe(policies) do
	{:ok, policy_configs} =
	policies
	\|> Enum.reduce({:ok, %{}}, fn
	policy, {:ok, data} ->
	{:ok, policy_data} = policy.describe()
	{:ok, Map.merge(data, policy_data)}

	_, error ->
	error
	end)

	mrf_policies =
	get_policies()
	\|> Enum.map(fn policy -> to_string(policy) \|> String.split(".") \|> List.last() end)

	exclusions = Pleroma.Config.get([:mrf, :transparency_exclusions])

	base =
	%{
	mrf_policies: mrf_policies,
	exclusions: length(exclusions) > 0
	}
	\|> Map.merge(policy_configs)

	{:ok, base}
	end

	def describe, do: get_policies() \|> describe()

	def config_descriptions do
	Pleroma.Web.ActivityPub.MRF.Policy
	\|> Pleroma.Docs.Generator.list_behaviour_implementations()
	\|> config_descriptions()
	end

	def config_descriptions(policies) do
	Enum.reduce(policies, @mrf_config_descriptions, fn policy, acc ->
	+ Code.ensure_loaded(policy)
	+
	if function_exported?(policy, :config_description, 0) do
	description =
	@default_description
	\|> Map.merge(policy.config_description)
	\|> Map.put(:group, :pleroma)
	\|> Map.put(:tab, :mrf)
	\|> Map.put(:type, :group)

	if Enum.all?(@required_description_keys, &Map.has_key?(description, &1)) do
	[description \| acc]
	else
	Logger.warn(
	"#{policy} config description doesn't have one or all required keys #{inspect(@required_description_keys)}"
	)

	acc
	end
	else
	Logger.debug(
	"#{policy} is excluded from config descriptions, because does not implement `config_description/0` method."
	)

	acc
	end
	end)
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/utils.ex b/lib/pleroma/web/activity_pub/utils.ex
	index 437220077..b32f19740 100644
	--- a/lib/pleroma/web/activity_pub/utils.ex
	+++ b/lib/pleroma/web/activity_pub/utils.ex
	@@ -1,935 +1,938 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Utils do
	alias Ecto.Changeset
	alias Ecto.UUID
	alias Pleroma.Activity
	alias Pleroma.Config
	+ alias Pleroma.EctoType.ActivityPub.ObjectValidators.ObjectID
	alias Pleroma.Maps
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.AdminAPI.AccountView
	alias Pleroma.Web.Endpoint
	alias Pleroma.Web.Router.Helpers

	import Ecto.Query

	require Logger
	require Pleroma.Constants

	@supported_object_types [
	"Article",
	"Note",
	"Event",
	"Video",
	"Page",
	"Question",
	"Answer",
	"Audio",
	"Image"
	]
	@strip_status_report_states ~w(closed resolved)
	@supported_report_states ~w(open closed resolved)
	@valid_visibilities ~w(public unlisted private direct)

	def as_local_public, do: Endpoint.url() <> "/#Public"

	# Some implementations send the actor URI as the actor field, others send the entire actor object,
	# so figure out what the actor's URI is based on what we have.
	def get_ap_id(%{"id" => id} = _), do: id
	def get_ap_id(id), do: id

	def normalize_params(params) do
	Map.put(params, "actor", get_ap_id(params["actor"]))
	end

	@spec determine_explicit_mentions(map()) :: [any]
	def determine_explicit_mentions(%{"tag" => tag}) when is_list(tag) do
	Enum.flat_map(tag, fn
	%{"type" => "Mention", "href" => href} -> [href]
	_ -> []
	end)
	end

	def determine_explicit_mentions(%{"tag" => tag} = object) when is_map(tag) do
	object
	\|> Map.put("tag", [tag])
	\|> determine_explicit_mentions()
	end

	def determine_explicit_mentions(_), do: []

	@spec label_in_collection?(any(), any()) :: boolean()
	defp label_in_collection?(ap_id, coll) when is_binary(coll), do: ap_id == coll
	defp label_in_collection?(ap_id, coll) when is_list(coll), do: ap_id in coll
	defp label_in_collection?(_, _), do: false

	@spec label_in_message?(String.t(), map()) :: boolean()
	def label_in_message?(label, params),
	do:
	[params["to"], params["cc"], params["bto"], params["bcc"]]
	\|> Enum.any?(&label_in_collection?(label, &1))

	@spec unaddressed_message?(map()) :: boolean()
	def unaddressed_message?(params),
	do:
	[params["to"], params["cc"], params["bto"], params["bcc"]]
	\|> Enum.all?(&is_nil(&1))

	@spec recipient_in_message(User.t(), User.t(), map()) :: boolean()
	def recipient_in_message(%User{ap_id: ap_id} = recipient, %User{} = actor, params),
	do:
	label_in_message?(ap_id, params) \|\| unaddressed_message?(params) \|\|
	User.following?(recipient, actor)

	defp extract_list(target) when is_binary(target), do: [target]
	defp extract_list(lst) when is_list(lst), do: lst
	defp extract_list(_), do: []

	def maybe_splice_recipient(ap_id, params) do
	need_splice? =
	!label_in_collection?(ap_id, params["to"]) &&
	!label_in_collection?(ap_id, params["cc"])

	if need_splice? do
	cc = [ap_id \| extract_list(params["cc"])]

	params
	\|> Map.put("cc", cc)
	\|> Maps.safe_put_in(["object", "cc"], cc)
	else
	params
	end
	end

	def make_json_ld_header do
	%{
	"@context" => [
	"https://www.w3.org/ns/activitystreams",
	"#{Endpoint.url()}/schemas/litepub-0.1.jsonld",
	%{
	"@language" => "und"
	}
	]
	}
	end

	def make_date do
	DateTime.utc_now() \|> DateTime.to_iso8601()
	end

	def generate_activity_id do
	generate_id("activities")
	end

	def generate_context_id do
	generate_id("contexts")
	end

	def generate_object_id do
	Helpers.o_status_url(Endpoint, :object, UUID.generate())
	end

	def generate_id(type) do
	"#{Endpoint.url()}/#{type}/#{UUID.generate()}"
	end

	def get_notified_from_object(%{"type" => type} = object) when type in @supported_object_types do
	fake_create_activity = %{
	"to" => object["to"],
	"cc" => object["cc"],
	"type" => "Create",
	"object" => object
	}

	get_notified_from_object(fake_create_activity)
	end

	def get_notified_from_object(object) do
	Notification.get_notified_from_activity(%Activity{data: object}, false)
	end

	def maybe_create_context(context), do: context \|\| generate_id("contexts")

	@doc """
	Enqueues an activity for federation if it's local
	"""
	@spec maybe_federate(any()) :: :ok
	def maybe_federate(%Activity{local: true, data: %{"type" => type}} = activity) do
	outgoing_blocks = Config.get([:activitypub, :outgoing_blocks])

	with true <- Config.get!([:instance, :federating]),
	true <- type != "Block" \|\| outgoing_blocks,
	false <- Visibility.is_local_public?(activity) do
	Pleroma.Web.Federator.publish(activity)
	end

	:ok
	end

	def maybe_federate(_), do: :ok

	@doc """
	Adds an id and a published data if they aren't there,
	also adds it to an included object
	"""
	@spec lazy_put_activity_defaults(map(), boolean) :: map()
	def lazy_put_activity_defaults(map, fake? \\ false)

	def lazy_put_activity_defaults(map, true) do
	map
	\|> Map.put_new("id", "pleroma:fakeid")
	\|> Map.put_new_lazy("published", &make_date/0)
	\|> Map.put_new("context", "pleroma:fakecontext")
	\|> lazy_put_object_defaults(true)
	end

	def lazy_put_activity_defaults(map, _fake?) do
	context = maybe_create_context(map["context"])

	map
	\|> Map.put_new_lazy("id", &generate_activity_id/0)
	\|> Map.put_new_lazy("published", &make_date/0)
	\|> Map.put_new("context", context)
	\|> lazy_put_object_defaults(false)
	end

	# Adds an id and published date if they aren't there.
	#
	@spec lazy_put_object_defaults(map(), boolean()) :: map()
	defp lazy_put_object_defaults(%{"object" => map} = activity, true)
	when is_map(map) do
	object =
	map
	\|> Map.put_new("id", "pleroma:fake_object_id")
	\|> Map.put_new_lazy("published", &make_date/0)
	\|> Map.put_new("context", activity["context"])
	\|> Map.put_new("fake", true)

	%{activity \| "object" => object}
	end

	defp lazy_put_object_defaults(%{"object" => map} = activity, _)
	when is_map(map) do
	object =
	map
	\|> Map.put_new_lazy("id", &generate_object_id/0)
	\|> Map.put_new_lazy("published", &make_date/0)
	\|> Map.put_new("context", activity["context"])

	%{activity \| "object" => object}
	end

	defp lazy_put_object_defaults(activity, _), do: activity

	@doc """
	Inserts a full object if it is contained in an activity.
	"""
	def insert_full_object(%{"object" => %{"type" => type} = object_data} = map)
	when type in @supported_object_types do
	with {:ok, object} <- Object.create(object_data) do
	map = Map.put(map, "object", object.data["id"])

	{:ok, map, object}
	end
	end

	def insert_full_object(map), do: {:ok, map, nil}

	#### Like-related helpers

	@doc """
	Returns an existing like if a user already liked an object
	"""
	@spec get_existing_like(String.t(), map()) :: Activity.t() \| nil
	def get_existing_like(actor, %{data: %{"id" => id}}) do
	actor
	\|> Activity.Queries.by_actor()
	\|> Activity.Queries.by_object_id(id)
	\|> Activity.Queries.by_type("Like")
	\|> limit(1)
	\|> Repo.one()
	end

	@doc """
	Returns like activities targeting an object
	"""
	def get_object_likes(%{data: %{"id" => id}}) do
	id
	\|> Activity.Queries.by_object_id()
	\|> Activity.Queries.by_type("Like")
	\|> Repo.all()
	end

	@spec make_like_data(User.t(), map(), String.t()) :: map()
	def make_like_data(
	%User{ap_id: ap_id} = actor,
	%{data: %{"actor" => object_actor_id, "id" => id}} = object,
	activity_id
	) do
	object_actor = User.get_cached_by_ap_id(object_actor_id)

	to =
	if Visibility.is_public?(object) do
	[actor.follower_address, object.data["actor"]]
	else
	[object.data["actor"]]
	end

	cc =
	(object.data["to"] ++ (object.data["cc"] \|\| []))
	\|> List.delete(actor.ap_id)
	\|> List.delete(object_actor.follower_address)

	%{
	"type" => "Like",
	"actor" => ap_id,
	"object" => id,
	"to" => to,
	"cc" => cc,
	"context" => object.data["context"]
	}
	\|> Maps.put_if_present("id", activity_id)
	end

	def make_emoji_reaction_data(user, object, emoji, activity_id) do
	make_like_data(user, object, activity_id)
	\|> Map.put("type", "EmojiReact")
	\|> Map.put("content", emoji)
	end

	@spec update_element_in_object(String.t(), list(any), Object.t(), integer() \| nil) ::
	{:ok, Object.t()} \| {:error, Ecto.Changeset.t()}
	def update_element_in_object(property, element, object, count \\ nil) do
	length =
	count \|\|
	length(element)

	data =
	Map.merge(
	object.data,
	%{"#{property}_count" => length, "#{property}s" => element}
	)

	object
	\|> Changeset.change(data: data)
	\|> Object.update_and_set_cache()
	end

	@spec add_emoji_reaction_to_object(Activity.t(), Object.t()) ::
	{:ok, Object.t()} \| {:error, Ecto.Changeset.t()}

	def add_emoji_reaction_to_object(
	%Activity{data: %{"content" => emoji, "actor" => actor}} = activity,
	object
	) do
	reactions = get_cached_emoji_reactions(object)
	emoji = Pleroma.Emoji.maybe_strip_name(emoji)
	url = maybe_emoji_url(emoji, activity)

	new_reactions =
	case Enum.find_index(reactions, fn [candidate, _, candidate_url] ->
	if is_nil(candidate_url) do
	emoji == candidate
	else
	url == candidate_url
	end
	end) do
	nil ->
	reactions ++ [[emoji, [actor], url]]

	index ->
	List.update_at(
	reactions,
	index,
	fn [emoji, users, url] -> [emoji, Enum.uniq([actor \| users]), url] end
	)
	end

	count = emoji_count(new_reactions)

	update_element_in_object("reaction", new_reactions, object, count)
	end

	defp maybe_emoji_url(
	name,
	%Activity{
	data: %{
	"tag" => [
	%{"type" => "Emoji", "name" => name, "icon" => %{"url" => url}}
	]
	}
	}
	),
	do: url

	defp maybe_emoji_url(_, _), do: nil

	def emoji_count(reactions_list) do
	Enum.reduce(reactions_list, 0, fn [_, users, _], acc -> acc + length(users) end)
	end

	def remove_emoji_reaction_from_object(
	%Activity{data: %{"content" => emoji, "actor" => actor}} = activity,
	object
	) do
	emoji = Pleroma.Emoji.maybe_strip_name(emoji)
	reactions = get_cached_emoji_reactions(object)
	url = maybe_emoji_url(emoji, activity)

	new_reactions =
	case Enum.find_index(reactions, fn [candidate, _, candidate_url] ->
	if is_nil(candidate_url) do
	emoji == candidate
	else
	url == candidate_url
	end
	end) do
	nil ->
	reactions

	index ->
	List.update_at(
	reactions,
	index,
	fn [emoji, users, url] -> [emoji, List.delete(users, actor), url] end
	)
	\|> Enum.reject(fn [_, users, _] -> Enum.empty?(users) end)
	end

	count = emoji_count(new_reactions)
	update_element_in_object("reaction", new_reactions, object, count)
	end

	def get_cached_emoji_reactions(object) do
	Object.get_emoji_reactions(object)
	end

	@spec add_like_to_object(Activity.t(), Object.t()) ::
	{:ok, Object.t()} \| {:error, Ecto.Changeset.t()}
	def add_like_to_object(%Activity{data: %{"actor" => actor}}, object) do
	[actor \| fetch_likes(object)]
	\|> Enum.uniq()
	\|> update_likes_in_object(object)
	end

	@spec remove_like_from_object(Activity.t(), Object.t()) ::
	{:ok, Object.t()} \| {:error, Ecto.Changeset.t()}
	def remove_like_from_object(%Activity{data: %{"actor" => actor}}, object) do
	object
	\|> fetch_likes()
	\|> List.delete(actor)
	\|> update_likes_in_object(object)
	end

	defp update_likes_in_object(likes, object) do
	update_element_in_object("like", likes, object)
	end

	defp fetch_likes(object) do
	if is_list(object.data["likes"]) do
	object.data["likes"]
	else
	[]
	end
	end

	#### Follow-related helpers

	@doc """
	Updates a follow activity's state (for locked accounts).
	"""
	@spec update_follow_state_for_all(Activity.t(), String.t()) :: {:ok, Activity \| nil}
	def update_follow_state_for_all(
	%Activity{data: %{"actor" => actor, "object" => object}} = activity,
	state
	) do
	"Follow"
	\|> Activity.Queries.by_type()
	\|> Activity.Queries.by_actor(actor)
	\|> Activity.Queries.by_object_id(object)
	\|> where(fragment("data->>'state' = 'pending'") or fragment("data->>'state' = 'accept'"))
	\|> update(set: [data: fragment("jsonb_set(data, '{state}', ?)", ^state)])
	\|> Repo.update_all([])

	activity = Activity.get_by_id(activity.id)

	{:ok, activity}
	end

	def update_follow_state(
	%Activity{} = activity,
	state
	) do
	new_data = Map.put(activity.data, "state", state)
	changeset = Changeset.change(activity, data: new_data)

	with {:ok, activity} <- Repo.update(changeset) do
	{:ok, activity}
	end
	end

	@doc """
	Makes a follow activity data for the given follower and followed
	"""
	def make_follow_data(
	%User{ap_id: follower_id},
	%User{ap_id: followed_id} = _followed,
	activity_id
	) do
	%{
	"type" => "Follow",
	"actor" => follower_id,
	"to" => [followed_id],
	"cc" => [Pleroma.Constants.as_public()],
	"object" => followed_id,
	"state" => "pending"
	}
	\|> Maps.put_if_present("id", activity_id)
	end

	def fetch_latest_follow(%User{ap_id: follower_id}, %User{ap_id: followed_id}) do
	"Follow"
	\|> Activity.Queries.by_type()
	\|> where(actor: ^follower_id)
	# this is to use the index
	\|> Activity.Queries.by_object_id(followed_id)
	\|> order_by([activity], fragment("? desc nulls last", activity.id))
	\|> limit(1)
	\|> Repo.one()
	end

	def fetch_latest_undo(%User{ap_id: ap_id}) do
	"Undo"
	\|> Activity.Queries.by_type()
	\|> where(actor: ^ap_id)
	\|> order_by([activity], fragment("? desc nulls last", activity.id))
	\|> limit(1)
	\|> Repo.one()
	end

	def get_latest_reaction(internal_activity_id, %{ap_id: ap_id}, emoji) do
	%{data: %{"object" => object_ap_id}} = Activity.get_by_id(internal_activity_id)
	emoji = Pleroma.Emoji.maybe_quote(emoji)

	"EmojiReact"
	\|> Activity.Queries.by_type()
	\|> where(actor: ^ap_id)
	\|> custom_emoji_discriminator(emoji)
	\|> Activity.Queries.by_object_id(object_ap_id)
	\|> order_by([activity], fragment("? desc nulls last", activity.id))
	\|> limit(1)
	\|> Repo.one()
	end

	defp custom_emoji_discriminator(query, emoji) do
	if String.contains?(emoji, "@") do
	stripped = Pleroma.Emoji.maybe_strip_name(emoji)
	[name, domain] = String.split(stripped, "@")
	domain_pattern = "%/" <> domain <> "/%"
	emoji_pattern = Pleroma.Emoji.maybe_quote(name)

	query
	\|> where([activity], fragment("?->>'content' = ?
	AND EXISTS (
	SELECT FROM jsonb_array_elements(?->'tag') elem
	WHERE elem->>'id' ILIKE ?
	)", activity.data, ^emoji_pattern, activity.data, ^domain_pattern))
	else
	query
	\|> where([activity], fragment("?->>'content' = ?", activity.data, ^emoji))
	end
	end

	#### Announce-related helpers

	@doc """
	Returns an existing announce activity if the notice has already been announced
	"""
	@spec get_existing_announce(String.t(), map()) :: Activity.t() \| nil
	def get_existing_announce(actor, %{data: %{"id" => ap_id}}) do
	"Announce"
	\|> Activity.Queries.by_type()
	\|> where(actor: ^actor)
	# this is to use the index
	\|> Activity.Queries.by_object_id(ap_id)
	\|> Repo.one()
	end

	@doc """
	Make announce activity data for the given actor and object
	"""
	# for relayed messages, we only want to send to subscribers
	def make_announce_data(
	%User{ap_id: ap_id} = user,
	%Object{data: %{"id" => id}} = object,
	activity_id,
	false
	) do
	%{
	"type" => "Announce",
	"actor" => ap_id,
	"object" => id,
	"to" => [user.follower_address],
	"cc" => [],
	"context" => object.data["context"]
	}
	\|> Maps.put_if_present("id", activity_id)
	end

	def make_announce_data(
	%User{ap_id: ap_id} = user,
	%Object{data: %{"id" => id}} = object,
	activity_id,
	true
	) do
	%{
	"type" => "Announce",
	"actor" => ap_id,
	"object" => id,
	"to" => [user.follower_address, object.data["actor"]],
	"cc" => [Pleroma.Constants.as_public()],
	"context" => object.data["context"]
	}
	\|> Maps.put_if_present("id", activity_id)
	end

	def make_undo_data(
	%User{ap_id: actor, follower_address: follower_address},
	%Activity{
	data: %{"id" => undone_activity_id, "context" => context},
	actor: undone_activity_actor
	},
	activity_id \\ nil
	) do
	%{
	"type" => "Undo",
	"actor" => actor,
	"object" => undone_activity_id,
	"to" => [follower_address, undone_activity_actor],
	"cc" => [Pleroma.Constants.as_public()],
	"context" => context
	}
	\|> Maps.put_if_present("id", activity_id)
	end

	@spec add_announce_to_object(Activity.t(), Object.t()) ::
	{:ok, Object.t()} \| {:error, Ecto.Changeset.t()}
	def add_announce_to_object(
	%Activity{data: %{"actor" => actor}},
	object
	) do
	unless actor \|> User.get_cached_by_ap_id() \|> User.invisible?() do
	announcements = take_announcements(object)

	with announcements <- Enum.uniq([actor \| announcements]) do
	update_element_in_object("announcement", announcements, object)
	end
	else
	{:ok, object}
	end
	end

	def add_announce_to_object(_, object), do: {:ok, object}

	@spec remove_announce_from_object(Activity.t(), Object.t()) ::
	{:ok, Object.t()} \| {:error, Ecto.Changeset.t()}
	def remove_announce_from_object(%Activity{data: %{"actor" => actor}}, object) do
	with announcements <- List.delete(take_announcements(object), actor) do
	update_element_in_object("announcement", announcements, object)
	end
	end

	defp take_announcements(%{data: %{"announcements" => announcements}} = _)
	when is_list(announcements),
	do: announcements

	defp take_announcements(_), do: []

	#### Unfollow-related helpers

	def make_unfollow_data(follower, followed, follow_activity, activity_id) do
	%{
	"type" => "Undo",
	"actor" => follower.ap_id,
	"to" => [followed.ap_id],
	"object" => follow_activity.data
	}
	\|> Maps.put_if_present("id", activity_id)
	end

	#### Block-related helpers
	@spec fetch_latest_block(User.t(), User.t()) :: Activity.t() \| nil
	def fetch_latest_block(%User{ap_id: blocker_id}, %User{ap_id: blocked_id}) do
	"Block"
	\|> Activity.Queries.by_type()
	\|> where(actor: ^blocker_id)
	# this is to use the index
	\|> Activity.Queries.by_object_id(blocked_id)
	\|> order_by([activity], fragment("? desc nulls last", activity.id))
	\|> limit(1)
	\|> Repo.one()
	end

	def make_block_data(blocker, blocked, activity_id) do
	%{
	"type" => "Block",
	"actor" => blocker.ap_id,
	"to" => [blocked.ap_id],
	"object" => blocked.ap_id
	}
	\|> Maps.put_if_present("id", activity_id)
	end

	#### Create-related helpers

	def make_create_data(params, additional) do
	published = params.published \|\| make_date()

	%{
	"type" => "Create",
	"to" => params.to \|> Enum.uniq(),
	"actor" => params.actor.ap_id,
	"object" => params.object,
	"published" => published,
	"context" => params.context
	}
	\|> Map.merge(additional)
	end

	#### Listen-related helpers
	def make_listen_data(params, additional) do
	published = params.published \|\| make_date()

	%{
	"type" => "Listen",
	"to" => params.to \|> Enum.uniq(),
	"actor" => params.actor.ap_id,
	"object" => params.object,
	"published" => published,
	"context" => params.context
	}
	\|> Map.merge(additional)
	end

	#### Flag-related helpers
	@spec make_flag_data(map(), map()) :: map()
	def make_flag_data(%{actor: actor, context: context, content: content} = params, additional) do
	%{
	"type" => "Flag",
	"actor" => actor.ap_id,
	"content" => content,
	"object" => build_flag_object(params),
	"context" => context,
	"state" => "open"
	}
	\|> Map.merge(additional)
	end

	def make_flag_data(_, _), do: %{}

	defp build_flag_object(%{account: account, statuses: statuses}) do
	[account.ap_id \| build_flag_object(%{statuses: statuses})]
	end

	defp build_flag_object(%{statuses: statuses}) do
	Enum.map(statuses \|\| [], &build_flag_object/1)
	end

	defp build_flag_object(%Activity{} = activity) do
	object = Object.normalize(activity, fetch: false)

	# Do not allow people to report Creates. Instead, report the Object that is Created.
	if activity.data["type"] != "Create" do
	build_flag_object_with_actor_and_id(
	object,
	User.get_by_ap_id(activity.data["actor"]),
	activity.data["id"]
	)
	else
	build_flag_object(object)
	end
	end

	defp build_flag_object(%Object{} = object) do
	actor = User.get_by_ap_id(object.data["actor"])
	build_flag_object_with_actor_and_id(object, actor, object.data["id"])
	end

	defp build_flag_object(act) when is_map(act) or is_binary(act) do
	id =
	case act do
	%Activity{} = act -> act.data["id"]
	act when is_map(act) -> act["id"]
	act when is_binary(act) -> act
	end

	case Activity.get_by_ap_id_with_object(id) do
	%Activity{object: object} = _ ->
	build_flag_object(object)

	nil ->
	if %Object{} = object = Object.get_by_ap_id(id) do
	build_flag_object(object)
	else
	%{"id" => id, "deleted" => true}
	end
	end
	end

	defp build_flag_object(_), do: []

	defp build_flag_object_with_actor_and_id(%Object{data: data}, actor, id) do
	%{
	"type" => "Note",
	"id" => id,
	"content" => data["content"],
	"published" => data["published"],
	"actor" =>
	AccountView.render(
	"show.json",
	%{user: actor, skip_visibility_check: true}
	)
	}
	end

	#### Report-related helpers
	def get_reports(params, page, page_size) do
	params =
	params
	\|> Map.put(:type, "Flag")
	\|> Map.put(:skip_preload, true)
	\|> Map.put(:preload_report_notes, true)
	\|> Map.put(:total, true)
	\|> Map.put(:limit, page_size)
	\|> Map.put(:offset, (page - 1) * page_size)

	ActivityPub.fetch_activities([], params, :offset)
	end

	defp maybe_strip_report_status(data, state) do
	with true <- Config.get([:instance, :report_strip_status]),
	true <- state in @strip_status_report_states,
	{:ok, stripped_activity} = strip_report_status_data(%Activity{data: data}) do
	data \|> Map.put("object", stripped_activity.data["object"])
	else
	_ -> data
	end
	end

	def update_report_state(%Activity{} = activity, state) when state in @supported_report_states do
	new_data =
	activity.data
	\|> Map.put("state", state)
	\|> maybe_strip_report_status(state)

	activity
	\|> Changeset.change(data: new_data)
	\|> Repo.update()
	end

	def update_report_state(activity_ids, state) when state in @supported_report_states do
	activities_num = length(activity_ids)

	from(a in Activity, where: a.id in ^activity_ids)
	\|> update(set: [data: fragment("jsonb_set(data, '{state}', ?)", ^state)])
	\|> Repo.update_all([])
	\|> case do
	{^activities_num, _} -> :ok
	_ -> {:error, activity_ids}
	end
	end

	def update_report_state(_, _), do: {:error, "Unsupported state"}

	def strip_report_status_data(activity) do
	[actor \| reported_activities] = activity.data["object"]

	stripped_activities =
	- Enum.map(reported_activities, fn
	- act when is_map(act) -> act["id"]
	- act when is_binary(act) -> act
	+ Enum.reduce(reported_activities, [], fn act, acc ->
	+ case ObjectID.cast(act) do
	+ {:ok, act} -> [act \| acc]
	+ _ -> acc
	+ end
	end)

	new_data = put_in(activity.data, ["object"], [actor \| stripped_activities])

	{:ok, %{activity \| data: new_data}}
	end

	def update_activity_visibility(activity, visibility) when visibility in @valid_visibilities do
	[to, cc, recipients] =
	activity
	\|> get_updated_targets(visibility)
	\|> Enum.map(&Enum.uniq/1)

	object_data =
	activity.object.data
	\|> Map.put("to", to)
	\|> Map.put("cc", cc)

	{:ok, object} =
	activity.object
	\|> Object.change(%{data: object_data})
	\|> Object.update_and_set_cache()

	activity_data =
	activity.data
	\|> Map.put("to", to)
	\|> Map.put("cc", cc)

	activity
	\|> Map.put(:object, object)
	\|> Activity.change(%{data: activity_data, recipients: recipients})
	\|> Repo.update()
	end

	def update_activity_visibility(_, _), do: {:error, "Unsupported visibility"}

	defp get_updated_targets(
	%Activity{data: %{"to" => to} = data, recipients: recipients},
	visibility
	) do
	cc = Map.get(data, "cc", [])
	follower_address = User.get_cached_by_ap_id(data["actor"]).follower_address
	public = Pleroma.Constants.as_public()

	case visibility do
	"public" ->
	to = [public \| List.delete(to, follower_address)]
	cc = [follower_address \| List.delete(cc, public)]
	recipients = [public \| recipients]
	[to, cc, recipients]

	"private" ->
	to = [follower_address \| List.delete(to, public)]
	cc = List.delete(cc, public)
	recipients = List.delete(recipients, public)
	[to, cc, recipients]

	"unlisted" ->
	to = [follower_address \| List.delete(to, public)]
	cc = [public \| List.delete(cc, follower_address)]
	recipients = recipients ++ [follower_address, public]
	[to, cc, recipients]

	_ ->
	[to, cc, recipients]
	end
	end

	def get_existing_votes(actor, %{data: %{"id" => id}}) do
	actor
	\|> Activity.Queries.by_actor()
	\|> Activity.Queries.by_type("Create")
	\|> Activity.with_preloaded_object()
	\|> where([a, object: o], fragment("(?)->>'inReplyTo' = ?", o.data, ^to_string(id)))
	\|> where([a, object: o], fragment("(?)->>'type' = 'Answer'", o.data))
	\|> Repo.all()
	end
	end
	diff --git a/lib/pleroma/web/api_spec/operations/pleroma_scrobble_operation.ex b/lib/pleroma/web/api_spec/operations/pleroma_scrobble_operation.ex
	index ca40da930..141b60533 100644
	--- a/lib/pleroma/web/api_spec/operations/pleroma_scrobble_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/pleroma_scrobble_operation.ex
	@@ -1,104 +1,108 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ApiSpec.PleromaScrobbleOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Reference
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.Schemas.Account
	alias Pleroma.Web.ApiSpec.Schemas.VisibilityScope

	import Pleroma.Web.ApiSpec.Helpers

	def open_api_operation(action) do
	operation = String.to_existing_atom("#{action}_operation")
	apply(__MODULE__, operation, [])
	end

	def create_operation do
	%Operation{
	tags: ["Scrobbles"],
	summary: "Creates a new Listen activity for an account",
	security: [%{"oAuth" => ["write"]}],
	operationId: "PleromaAPI.ScrobbleController.create",
	deprecated: true,
	requestBody: request_body("Parameters", create_request(), requried: true),
	responses: %{
	200 => Operation.response("Scrobble", "application/json", scrobble())
	}
	}
	end

	def index_operation do
	%Operation{
	tags: ["Scrobbles"],
	summary: "Requests a list of current and recent Listen activities for an account",
	operationId: "PleromaAPI.ScrobbleController.index",
	deprecated: true,
	parameters: [
	%Reference{"$ref": "#/components/parameters/accountIdOrNickname"} \| pagination_params()
	],
	security: [%{"oAuth" => ["read"]}],
	responses: %{
	200 =>
	Operation.response("Array of Scrobble", "application/json", %Schema{
	type: :array,
	items: scrobble()
	})
	}
	}
	end

	defp create_request do
	%Schema{
	type: :object,
	required: [:title],
	properties: %{
	title: %Schema{type: :string, description: "The title of the media playing"},
	album: %Schema{type: :string, description: "The album of the media playing"},
	artist: %Schema{type: :string, description: "The artist of the media playing"},
	length: %Schema{type: :integer, description: "The length of the media playing"},
	+ externalLink: %Schema{type: :string, description: "A URL referencing the media playing"},
	visibility: %Schema{
	allOf: [VisibilityScope],
	default: "public",
	description: "Scrobble visibility"
	}
	},
	example: %{
	"title" => "Some Title",
	"artist" => "Some Artist",
	"album" => "Some Album",
	- "length" => 180_000
	+ "length" => 180_000,
	+ "externalLink" => "https://www.last.fm/music/Some+Artist/_/Some+Title"
	}
	}
	end

	defp scrobble do
	%Schema{
	type: :object,
	properties: %{
	id: %Schema{type: :string},
	account: Account,
	title: %Schema{type: :string, description: "The title of the media playing"},
	album: %Schema{type: :string, description: "The album of the media playing"},
	artist: %Schema{type: :string, description: "The artist of the media playing"},
	+ externalLink: %Schema{type: :string, description: "A URL referencing the media playing"},
	length: %Schema{
	type: :integer,
	description: "The length of the media playing",
	nullable: true
	},
	created_at: %Schema{type: :string, format: :"date-time"}
	},
	example: %{
	"id" => "1234",
	"account" => Account.schema().example,
	"title" => "Some Title",
	"artist" => "Some Artist",
	"album" => "Some Album",
	"length" => 180_000,
	+ "externalLink" => "https://www.last.fm/music/Some+Artist/_/Some+Title",
	"created_at" => "2019-09-28T12:40:45.000Z"
	}
	}
	end
	end
	diff --git a/lib/pleroma/web/common_api/activity_draft.ex b/lib/pleroma/web/common_api/activity_draft.ex
	index ca1329284..8910ad5b8 100644
	--- a/lib/pleroma/web/common_api/activity_draft.ex
	+++ b/lib/pleroma/web/common_api/activity_draft.ex
	@@ -1,316 +1,316 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.CommonAPI.ActivityDraft do
	alias Pleroma.Activity
	alias Pleroma.Conversation.Participation
	alias Pleroma.Object
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils

	import Pleroma.Web.Gettext
	import Pleroma.Web.Utils.Guards, only: [not_empty_string: 1]

	defstruct valid?: true,
	errors: [],
	user: nil,
	params: %{},
	status: nil,
	summary: nil,
	full_payload: nil,
	attachments: [],
	in_reply_to: nil,
	in_reply_to_conversation: nil,
	quote_post: nil,
	visibility: nil,
	expires_at: nil,
	extra: nil,
	emoji: %{},
	content_html: nil,
	mentions: [],
	tags: [],
	to: [],
	cc: [],
	context: nil,
	sensitive: false,
	object: nil,
	preview?: false,
	changes: %{}

	def new(user, params) do
	%__MODULE__{user: user}
	\|> put_params(params)
	end

	def create(user, params) do
	user
	\|> new(params)
	\|> status()
	\|> summary()
	\|> with_valid(&attachments/1)
	\|> full_payload()
	\|> expires_at()
	\|> poll()
	\|> with_valid(&in_reply_to/1)
	\|> with_valid(&in_reply_to_conversation/1)
	\|> with_valid(&quote_post/1)
	\|> with_valid(&visibility/1)
	\|> with_valid(&quoting_visibility/1)
	\|> content()
	\|> with_valid(&to_and_cc/1)
	\|> with_valid(&context/1)
	\|> sensitive()
	\|> with_valid(&object/1)
	\|> preview?()
	\|> with_valid(&changes/1)
	\|> validate()
	end

	def listen(user, params) do
	user
	\|> new(params)
	\|> visibility()
	\|> to_and_cc()
	\|> context()
	\|> listen_object()
	\|> with_valid(&changes/1)
	\|> validate()
	end

	defp listen_object(draft) do
	object =
	draft.params
	- \|> Map.take([:album, :artist, :title, :length])
	+ \|> Map.take([:album, :artist, :title, :length, :externalLink])
	\|> Map.new(fn {key, value} -> {to_string(key), value} end)
	\|> Map.put("type", "Audio")
	\|> Map.put("to", draft.to)
	\|> Map.put("cc", draft.cc)
	\|> Map.put("actor", draft.user.ap_id)

	%__MODULE__{draft \| object: object}
	end

	defp put_params(draft, params) do
	params = Map.put_new(params, :in_reply_to_status_id, params[:in_reply_to_id])
	%__MODULE__{draft \| params: params}
	end

	defp status(%{params: %{status: status}} = draft) do
	%__MODULE__{draft \| status: String.trim(status)}
	end

	defp summary(%{params: params} = draft) do
	%__MODULE__{draft \| summary: Map.get(params, :spoiler_text, "")}
	end

	defp full_payload(%{status: status, summary: summary} = draft) do
	full_payload = String.trim(status <> summary)

	case Utils.validate_character_limit(full_payload, draft.attachments) do
	:ok -> %__MODULE__{draft \| full_payload: full_payload}
	{:error, message} -> add_error(draft, message)
	end
	end

	defp attachments(%{params: params} = draft) do
	attachments = Utils.attachments_from_ids(params, draft.user)
	draft = %__MODULE__{draft \| attachments: attachments}

	case Utils.validate_attachments_count(attachments) do
	:ok -> draft
	{:error, message} -> add_error(draft, message)
	end
	end

	defp in_reply_to(%{params: %{in_reply_to_status_id: ""}} = draft), do: draft

	defp in_reply_to(%{params: %{in_reply_to_status_id: id}} = draft) when is_binary(id) do
	%__MODULE__{draft \| in_reply_to: Activity.get_by_id(id)}
	end

	defp in_reply_to(%{params: %{in_reply_to_status_id: %Activity{} = in_reply_to}} = draft) do
	%__MODULE__{draft \| in_reply_to: in_reply_to}
	end

	defp in_reply_to(draft), do: draft

	defp quote_post(%{params: %{quote_id: id}} = draft) when not_empty_string(id) do
	case Activity.get_by_id_with_object(id) do
	%Activity{} = activity ->
	%__MODULE__{draft \| quote_post: activity}

	_ ->
	draft
	end
	end

	defp quote_post(draft), do: draft

	defp in_reply_to_conversation(draft) do
	in_reply_to_conversation = Participation.get(draft.params[:in_reply_to_conversation_id])
	%__MODULE__{draft \| in_reply_to_conversation: in_reply_to_conversation}
	end

	defp visibility(%{params: params} = draft) do
	case CommonAPI.get_visibility(params, draft.in_reply_to, draft.in_reply_to_conversation) do
	{visibility, "direct"} when visibility != "direct" ->
	add_error(draft, dgettext("errors", "The message visibility must be direct"))

	{visibility, _} ->
	%__MODULE__{draft \| visibility: visibility}
	end
	end

	defp can_quote?(_draft, _object, visibility) when visibility in ~w(public unlisted local) do
	true
	end

	defp can_quote?(draft, object, "private") do
	draft.user.ap_id == object.data["actor"]
	end

	defp can_quote?(_, _, _) do
	false
	end

	defp quoting_visibility(%{quote_post: %Activity{}} = draft) do
	with %Object{} = object <- Object.normalize(draft.quote_post, fetch: false),
	true <- can_quote?(draft, object, Visibility.get_visibility(object)) do
	draft
	else
	_ -> add_error(draft, dgettext("errors", "Cannot quote private message"))
	end
	end

	defp quoting_visibility(draft), do: draft

	defp expires_at(draft) do
	case CommonAPI.check_expiry_date(draft.params[:expires_in]) do
	{:ok, expires_at} -> %__MODULE__{draft \| expires_at: expires_at}
	{:error, message} -> add_error(draft, message)
	end
	end

	defp poll(draft) do
	case Utils.make_poll_data(draft.params) do
	{:ok, {poll, poll_emoji}} ->
	%__MODULE__{draft \| extra: poll, emoji: Map.merge(draft.emoji, poll_emoji)}

	{:error, message} ->
	add_error(draft, message)
	end
	end

	defp content(%{mentions: mentions} = draft) do
	{content_html, mentioned_users, tags} = Utils.make_content_html(draft)

	mentioned_ap_ids =
	Enum.map(mentioned_users, fn {_, mentioned_user} -> mentioned_user.ap_id end)

	mentions =
	mentions
	\|> Kernel.++(mentioned_ap_ids)
	\|> Utils.get_addressed_users(draft.params[:to])

	%__MODULE__{draft \| content_html: content_html, mentions: mentions, tags: tags}
	end

	defp to_and_cc(draft) do
	{to, cc} = Utils.get_to_and_cc(draft)
	%__MODULE__{draft \| to: to, cc: cc}
	end

	defp context(draft) do
	context = Utils.make_context(draft.in_reply_to, draft.in_reply_to_conversation)
	%__MODULE__{draft \| context: context}
	end

	defp sensitive(draft) do
	sensitive = draft.params[:sensitive]
	%__MODULE__{draft \| sensitive: sensitive}
	end

	defp object(draft) do
	emoji = Map.merge(Pleroma.Emoji.Formatter.get_emoji_map(draft.full_payload), draft.emoji)

	# Sometimes people create posts with subject containing emoji,
	# since subjects are usually copied this will result in a broken
	# subject when someone replies from an instance that does not have
	# the emoji or has it under different shortcode. This is an attempt
	# to mitigate this by copying emoji from inReplyTo if they are present
	# in the subject.
	summary_emoji =
	with %Activity{} <- draft.in_reply_to,
	%Object{data: %{"tag" => [_ \| _] = tag}} <- Object.normalize(draft.in_reply_to) do
	Enum.reduce(tag, %{}, fn
	%{"type" => "Emoji", "name" => name, "icon" => %{"url" => url}}, acc ->
	if String.contains?(draft.summary, name) do
	Map.put(acc, name, url)
	else
	acc
	end

	_, acc ->
	acc
	end)
	else
	_ -> %{}
	end

	emoji = Map.merge(emoji, summary_emoji)

	{:ok, note_data, _meta} = Builder.note(draft)

	object =
	note_data
	\|> Map.put("emoji", emoji)
	\|> Map.put("source", %{
	"content" => draft.status,
	"mediaType" => Utils.get_content_type(draft.params[:content_type])
	})
	\|> Map.put("generator", draft.params[:generator])

	%__MODULE__{draft \| object: object}
	end

	defp preview?(draft) do
	preview? = Pleroma.Web.Utils.Params.truthy_param?(draft.params[:preview])
	%__MODULE__{draft \| preview?: preview?}
	end

	defp changes(draft) do
	direct? = draft.visibility == "direct"
	additional = %{"cc" => draft.cc, "directMessage" => direct?}

	additional =
	case draft.expires_at do
	%DateTime{} = expires_at -> Map.put(additional, "expires_at", expires_at)
	_ -> additional
	end

	changes =
	%{
	to: draft.to,
	actor: draft.user,
	context: draft.context,
	object: draft.object,
	additional: additional
	}
	\|> Utils.maybe_add_list_data(draft.user, draft.visibility)

	%__MODULE__{draft \| changes: changes}
	end

	defp with_valid(%{valid?: true} = draft, func), do: func.(draft)
	defp with_valid(draft, _func), do: draft

	defp add_error(draft, message) do
	%__MODULE__{draft \| valid?: false, errors: [message \| draft.errors]}
	end

	defp validate(%{valid?: true} = draft), do: {:ok, draft}
	defp validate(%{errors: [message \| _]}), do: {:error, message}
	end
	diff --git a/lib/pleroma/web/endpoint.ex b/lib/pleroma/web/endpoint.ex
	index 65dd72c49..307fa069e 100644
	--- a/lib/pleroma/web/endpoint.ex
	+++ b/lib/pleroma/web/endpoint.ex
	@@ -1,212 +1,171 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Endpoint do
	use Phoenix.Endpoint, otp_app: :pleroma

	require Pleroma.Constants

	alias Pleroma.Config

	socket("/socket", Pleroma.Web.UserSocket,
	websocket: [
	path: "/websocket",
	serializer: [
	{Phoenix.Socket.V1.JSONSerializer, "~> 1.0.0"},
	{Phoenix.Socket.V2.JSONSerializer, "~> 2.0.0"}
	],
	timeout: 60_000,
	transport_log: false,
	compress: false
	],
	longpoll: false
	)

	socket("/live", Phoenix.LiveView.Socket)

	plug(Plug.Telemetry, event_prefix: [:phoenix, :endpoint])

	plug(Pleroma.Web.Plugs.SetLocalePlug)
	plug(CORSPlug)
	plug(Pleroma.Web.Plugs.HTTPSecurityPlug)
	plug(Pleroma.Web.Plugs.UploadedMedia)

	@static_cache_control "public, no-cache"

	# InstanceStatic needs to be before Plug.Static to be able to override shipped-static files
	# If you're adding new paths to `only:` you'll need to configure them in InstanceStatic as well
	# Cache-control headers are duplicated in case we turn off etags in the future
	plug(
	Pleroma.Web.Plugs.InstanceStatic,
	at: "/",
	from: :pleroma,
	only: ["emoji", "images"],
	gzip: true,
	cache_control_for_etags: "public, max-age=1209600",
	headers: %{
	"cache-control" => "public, max-age=1209600"
	}
	)

	plug(Pleroma.Web.Plugs.InstanceStatic,
	at: "/",
	gzip: true,
	cache_control_for_etags: @static_cache_control,
	headers: %{
	"cache-control" => @static_cache_control
	}
	)

	# Careful! No `only` restriction here, as we don't know what frontends contain.
	plug(Pleroma.Web.Plugs.FrontendStatic,
	at: "/",
	frontend_type: :primary,
	gzip: true,
	cache_control_for_etags: @static_cache_control,
	headers: %{
	"cache-control" => @static_cache_control
	}
	)

	plug(Plug.Static.IndexHtml, at: "/pleroma/admin/")

	plug(Pleroma.Web.Plugs.FrontendStatic,
	at: "/pleroma/admin",
	frontend_type: :admin,
	gzip: true,
	cache_control_for_etags: @static_cache_control,
	headers: %{
	"cache-control" => @static_cache_control
	}
	)

	# Serve at "/" the static files from "priv/static" directory.
	#
	# You should set gzip to true if you are running phoenix.digest
	# when deploying your static files in production.
	plug(
	Plug.Static,
	at: "/",
	from: :pleroma,
	only: Pleroma.Constants.static_only_files(),
	# credo:disable-for-previous-line Credo.Check.Readability.MaxLineLength
	gzip: true,
	cache_control_for_etags: @static_cache_control,
	headers: %{
	"cache-control" => @static_cache_control
	}
	)

	plug(Plug.Static,
	at: "/pleroma/admin/",
	from: {:pleroma, "priv/static/adminfe/"}
	)

	# Code reloading can be explicitly enabled under the
	# :code_reloader configuration of your endpoint.
	if code_reloading? do
	plug(Phoenix.CodeReloader)
	end

	plug(Pleroma.Web.Plugs.TrailingFormatPlug)
	plug(Plug.RequestId)
	plug(Plug.Logger, log: :debug)

	plug(Plug.Parsers,
	parsers: [:urlencoded, Pleroma.Web.Multipart, :json],
	pass: ["/"],
	json_decoder: Jason,
	# Note: this is compile-time only, won't work for database-config
	length: Config.get([:instance, :upload_limit]),
	body_reader: {Pleroma.Web.Plugs.DigestPlug, :read_body, []}
	)

	plug(Plug.MethodOverride)
	plug(Plug.Head)

	secure_cookies = Config.get([__MODULE__, :secure_cookie_flag])

	cookie_name =
	if secure_cookies,
	do: "__Host-pleroma_key",
	else: "pleroma_key"

	extra =
	Config.get([__MODULE__, :extra_cookie_attrs])
	\|> Enum.join(";")

	# The session will be stored in the cookie and signed,
	# this means its contents can be read but not tampered with.
	# Set :encryption_salt if you would also like to encrypt it.
	plug(
	Plug.Session,
	store: :cookie,
	key: cookie_name,
	signing_salt: Config.get([__MODULE__, :signing_salt], "CqaoopA2"),
	http_only: true,
	secure: secure_cookies,
	extra: extra
	)

	plug(Pleroma.Web.Plugs.RemoteIp)

	- defmodule Instrumenter do
	- use Prometheus.PhoenixInstrumenter
	- end
	-
	- defmodule PipelineInstrumenter do
	- use Prometheus.PlugPipelineInstrumenter
	- end
	-
	- defmodule MetricsExporter do
	- use Prometheus.PlugExporter
	- end
	-
	- defmodule MetricsExporterCaller do
	- @behaviour Plug
	-
	- def init(opts), do: opts
	-
	- def call(conn, opts) do
	- prometheus_config = Application.get_env(:prometheus, MetricsExporter, [])
	- ip_whitelist = List.wrap(prometheus_config[:ip_whitelist])
	-
	- cond do
	- !prometheus_config[:enabled] ->
	- conn
	-
	- ip_whitelist != [] and
	- !Enum.find(ip_whitelist, fn ip ->
	- Pleroma.Helpers.InetHelper.parse_address(ip) == {:ok, conn.remote_ip}
	- end) ->
	- conn
	-
	- true ->
	- MetricsExporter.call(conn, opts)
	- end
	- end
	- end
	-
	- plug(PipelineInstrumenter)
	-
	- plug(MetricsExporterCaller)
	-
	plug(Pleroma.Web.Router)

	@doc """
	Dynamically loads configuration from the system environment
	on startup.

	It receives the endpoint configuration from the config files
	and must return the updated configuration.
	"""
	def load_from_system_env(config) do
	port = System.get_env("PORT") \|\| raise "expected the PORT environment variable to be set"
	{:ok, Keyword.put(config, :http, [:inet6, port: port])}
	end

	def websocket_url do
	String.replace_leading(url(), "http", "ws")
	end
	end
	diff --git a/lib/pleroma/web/fallback/redirect_controller.ex b/lib/pleroma/web/fallback/redirect_controller.ex
	index 1a86f7a53..4a0885fab 100644
	--- a/lib/pleroma/web/fallback/redirect_controller.ex
	+++ b/lib/pleroma/web/fallback/redirect_controller.ex
	@@ -1,110 +1,125 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Fallback.RedirectController do
	use Pleroma.Web, :controller

	require Logger

	alias Pleroma.User
	alias Pleroma.Web.Metadata
	alias Pleroma.Web.Preload

	def api_not_implemented(conn, _params) do
	conn
	\|> put_status(404)
	\|> json(%{error: "Not implemented"})
	end

	+ def add_generated_metadata(page_content, extra \\ "") do
	+ title = "<title>#{Pleroma.Config.get([:instance, :name])}</title>"
	+ favicon = "<link rel='icon' href='#{Pleroma.Config.get([:instance, :favicon])}'>"
	+ manifest = "<link rel='manifest' href='/manifest.json'>"
	+
	+ page_content
	+ \|> String.replace(
	+ "<!--server-generated-meta-->",
	+ title <> favicon <> manifest <> extra
	+ )
	+ end
	+
	def redirector(conn, _params, code \\ 200) do
	+ {:ok, index_content} = File.read(index_file_path())
	+
	+ response =
	+ index_content
	+ \|> add_generated_metadata()
	+
	conn
	\|> put_resp_content_type("text/html")
	- \|> send_file(code, index_file_path())
	+ \|> send_resp(code, response)
	end

	def redirector_with_meta(conn, %{"maybe_nickname_or_id" => maybe_nickname_or_id} = params) do
	with %User{} = user <- User.get_cached_by_nickname_or_id(maybe_nickname_or_id) do
	redirector_with_meta(conn, %{user: user})
	else
	nil ->
	redirector(conn, params)
	end
	end

	def redirector_with_meta(conn, params) do
	{:ok, index_content} = File.read(index_file_path())
	-
	tags = build_tags(conn, params)
	preloads = preload_data(conn, params)
	- title = "<title>#{Pleroma.Config.get([:instance, :name])}</title>"

	response =
	index_content
	- \|> String.replace("<!--server-generated-meta-->", tags <> preloads <> title)
	+ \|> add_generated_metadata(tags <> preloads)

	conn
	\|> put_resp_content_type("text/html")
	\|> send_resp(200, response)
	end

	def redirector_with_preload(conn, %{"path" => ["pleroma", "admin"]}) do
	redirect(conn, to: "/pleroma/admin/")
	end

	def redirector_with_preload(conn, params) do
	{:ok, index_content} = File.read(index_file_path())
	preloads = preload_data(conn, params)
	- title = "<title>#{Pleroma.Config.get([:instance, :name])}</title>"

	response =
	index_content
	- \|> String.replace("<!--server-generated-meta-->", preloads <> title)
	+ \|> add_generated_metadata(preloads)

	conn
	\|> put_resp_content_type("text/html")
	\|> send_resp(200, response)
	end

	def registration_page(conn, params) do
	redirector(conn, params)
	end

	def empty(conn, _params) do
	conn
	\|> put_status(204)
	\|> text("")
	end

	defp index_file_path do
	Pleroma.Web.Plugs.InstanceStatic.file_path("index.html")
	end

	defp build_tags(conn, params) do
	try do
	Metadata.build_tags(params)
	rescue
	e ->
	Logger.error(
	"Metadata rendering for #{conn.request_path} failed.\n" <>
	Exception.format(:error, e, __STACKTRACE__)
	)

	""
	end
	end

	defp preload_data(conn, params) do
	try do
	Preload.build_tags(conn, params)
	rescue
	e ->
	Logger.error(
	"Preloading for #{conn.request_path} failed.\n" <>
	Exception.format(:error, e, __STACKTRACE__)
	)

	""
	end
	end
	end
	diff --git a/lib/pleroma/web/pleroma_api/views/scrobble_view.ex b/lib/pleroma/web/pleroma_api/views/scrobble_view.ex
	index a5985fb2a..edf0a2390 100644
	--- a/lib/pleroma/web/pleroma_api/views/scrobble_view.ex
	+++ b/lib/pleroma/web/pleroma_api/views/scrobble_view.ex
	@@ -1,37 +1,38 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.PleromaAPI.ScrobbleView do
	use Pleroma.Web, :view

	require Pleroma.Constants

	alias Pleroma.Activity
	alias Pleroma.HTML
	alias Pleroma.Object
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.MastodonAPI.AccountView

	def render("show.json", %{activity: %Activity{data: %{"type" => "Listen"}} = activity} = opts) do
	object = Object.normalize(activity, fetch: false)

	user = CommonAPI.get_user(activity.data["actor"])
	created_at = Utils.to_masto_date(activity.data["published"])

	%{
	id: activity.id,
	account: AccountView.render("show.json", %{user: user, for: opts[:for]}),
	created_at: created_at,
	title: object.data["title"] \|> HTML.strip_tags(),
	artist: object.data["artist"] \|> HTML.strip_tags(),
	album: object.data["album"] \|> HTML.strip_tags(),
	+ externalLink: object.data["externalLink"],
	length: object.data["length"]
	}
	end

	def render("index.json", opts) do
	safe_render_many(opts.activities, __MODULE__, "show.json", opts)
	end
	end
	diff --git a/lib/pleroma/web/router.ex b/lib/pleroma/web/router.ex
	index 9abad65b0..eb8576b02 100644
	--- a/lib/pleroma/web/router.ex
	+++ b/lib/pleroma/web/router.ex
	@@ -1,1018 +1,1023 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Router do
	use Pleroma.Web, :router
	import Phoenix.LiveDashboard.Router

	pipeline :accepts_html do
	plug(:accepts, ["html"])
	end

	pipeline :accepts_html_xml do
	plug(:accepts, ["html", "xml", "rss", "atom"])
	end

	pipeline :accepts_html_json do
	plug(:accepts, ["html", "activity+json", "json"])
	end

	pipeline :accepts_html_xml_json do
	plug(:accepts, ["html", "xml", "rss", "atom", "activity+json", "json"])
	end

	pipeline :accepts_xml_rss_atom do
	plug(:accepts, ["xml", "rss", "atom"])
	end

	pipeline :browser do
	plug(:accepts, ["html"])
	plug(:fetch_session)
	end

	pipeline :oauth do
	plug(:fetch_session)
	plug(Pleroma.Web.Plugs.OAuthPlug)
	plug(Pleroma.Web.Plugs.UserEnabledPlug)
	plug(Pleroma.Web.Plugs.EnsureUserTokenAssignsPlug)
	end

	# Note: expects _user_ authentication (user-unbound app-bound tokens don't qualify)
	pipeline :expect_user_authentication do
	plug(Pleroma.Web.Plugs.ExpectAuthenticatedCheckPlug)
	end

	# Note: expects public instance or _user_ authentication (user-unbound tokens don't qualify)
	pipeline :expect_public_instance_or_user_authentication do
	plug(Pleroma.Web.Plugs.ExpectPublicOrAuthenticatedCheckPlug)
	end

	pipeline :authenticate do
	plug(Pleroma.Web.Plugs.OAuthPlug)
	plug(Pleroma.Web.Plugs.BasicAuthDecoderPlug)
	plug(Pleroma.Web.Plugs.UserFetcherPlug)
	plug(Pleroma.Web.Plugs.AuthenticationPlug)
	end

	pipeline :after_auth do
	plug(Pleroma.Web.Plugs.UserEnabledPlug)
	plug(Pleroma.Web.Plugs.SetUserSessionIdPlug)
	plug(Pleroma.Web.Plugs.EnsureUserTokenAssignsPlug)
	plug(Pleroma.Web.Plugs.UserTrackingPlug)
	end

	pipeline :base_api do
	plug(:accepts, ["json"])
	plug(:fetch_session)
	plug(:authenticate)
	plug(OpenApiSpex.Plug.PutApiSpec, module: Pleroma.Web.ApiSpec)
	end

	pipeline :no_auth_or_privacy_expectations_api do
	plug(:base_api)
	plug(:after_auth)
	plug(Pleroma.Web.Plugs.IdempotencyPlug)
	end

	# Pipeline for app-related endpoints (no user auth checks — app-bound tokens must be supported)
	pipeline :app_api do
	plug(:no_auth_or_privacy_expectations_api)
	end

	pipeline :api do
	plug(:expect_public_instance_or_user_authentication)
	plug(:no_auth_or_privacy_expectations_api)
	end

	pipeline :authenticated_api do
	plug(:expect_user_authentication)
	plug(:no_auth_or_privacy_expectations_api)
	plug(Pleroma.Web.Plugs.EnsureAuthenticatedPlug)
	end

	pipeline :admin_api do
	plug(:expect_user_authentication)
	plug(:base_api)
	plug(Pleroma.Web.Plugs.AdminSecretAuthenticationPlug)
	plug(:after_auth)
	plug(Pleroma.Web.Plugs.EnsureAuthenticatedPlug)
	plug(Pleroma.Web.Plugs.UserIsStaffPlug)
	plug(Pleroma.Web.Plugs.IdempotencyPlug)
	end

	pipeline :require_admin do
	plug(Pleroma.Web.Plugs.UserIsAdminPlug)
	end

	pipeline :require_privileged_role_users_delete do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :users_delete)
	end

	pipeline :require_privileged_role_users_manage_credentials do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :users_manage_credentials)
	end

	pipeline :require_privileged_role_messages_read do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :messages_read)
	end

	pipeline :require_privileged_role_users_manage_tags do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :users_manage_tags)
	end

	pipeline :require_privileged_role_users_manage_activation_state do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :users_manage_activation_state)
	end

	pipeline :require_privileged_role_users_manage_invites do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :users_manage_invites)
	end

	pipeline :require_privileged_role_reports_manage_reports do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :reports_manage_reports)
	end

	pipeline :require_privileged_role_users_read do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :users_read)
	end

	pipeline :require_privileged_role_messages_delete do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :messages_delete)
	end

	pipeline :require_privileged_role_emoji_manage_emoji do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :emoji_manage_emoji)
	end

	pipeline :require_privileged_role_instances_delete do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :instances_delete)
	end

	pipeline :require_privileged_role_moderation_log_read do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :moderation_log_read)
	end

	pipeline :require_privileged_role_statistics_read do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :statistics_read)
	end

	pipeline :require_privileged_role_announcements_manage_announcements do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :announcements_manage_announcements)
	end

	pipeline :pleroma_html do
	plug(:browser)
	plug(:authenticate)
	plug(Pleroma.Web.Plugs.EnsureUserTokenAssignsPlug)
	end

	pipeline :well_known do
	plug(:accepts, ["json", "jrd+json", "xml", "xrd+xml"])
	end

	pipeline :config do
	plug(:accepts, ["json", "xml"])
	plug(OpenApiSpex.Plug.PutApiSpec, module: Pleroma.Web.ApiSpec)
	end

	pipeline :pleroma_api do
	plug(:accepts, ["html", "json"])
	plug(OpenApiSpex.Plug.PutApiSpec, module: Pleroma.Web.ApiSpec)
	end

	pipeline :mailbox_preview do
	plug(:accepts, ["html"])

	plug(:put_secure_browser_headers, %{
	"content-security-policy" =>
	"default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval'; style-src 'self' 'unsafe-inline' 'unsafe-eval'"
	})
	end

	pipeline :http_signature do
	plug(Pleroma.Web.Plugs.HTTPSignaturePlug)
	plug(Pleroma.Web.Plugs.MappedSignatureToIdentityPlug)
	end

	pipeline :static_fe do
	plug(Pleroma.Web.Plugs.StaticFEPlug)
	end

	scope "/api/v1/pleroma", Pleroma.Web.TwitterAPI do
	pipe_through(:pleroma_api)

	get("/password_reset/:token", PasswordController, :reset, as: :reset_password)
	post("/password_reset", PasswordController, :do_reset, as: :reset_password)
	get("/emoji", UtilController, :emoji)
	get("/captcha", UtilController, :captcha)
	get("/healthcheck", UtilController, :healthcheck)
	post("/remote_interaction", UtilController, :remote_interaction)
	end

	+ scope "/api/v1/pleroma", Pleroma.Web.PleromaAPI do
	+ pipe_through(:pleroma_api)
	+
	+ get("/federation_status", InstancesController, :show)
	+ end
	+
	scope "/api/v1/pleroma", Pleroma.Web do
	pipe_through(:pleroma_api)
	post("/uploader_callback/:upload_path", UploaderController, :callback)
	end

	# AdminAPI: only admins can perform these actions
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through([:admin_api, :require_admin])

	get("/users/:nickname/permission_group", AdminAPIController, :right_get)
	get("/users/:nickname/permission_group/:permission_group", AdminAPIController, :right_get)

	post("/users/:nickname/permission_group/:permission_group", AdminAPIController, :right_add)

	delete(
	"/users/:nickname/permission_group/:permission_group",
	AdminAPIController,
	:right_delete
	)

	post("/users/permission_group/:permission_group", AdminAPIController, :right_add_multiple)

	delete(
	"/users/permission_group/:permission_group",
	AdminAPIController,
	:right_delete_multiple
	)

	post("/users/follow", UserController, :follow)
	post("/users/unfollow", UserController, :unfollow)
	post("/users", UserController, :create)

	patch("/users/suggest", UserController, :suggest)
	patch("/users/unsuggest", UserController, :unsuggest)

	get("/relay", RelayController, :index)
	post("/relay", RelayController, :follow)
	delete("/relay", RelayController, :unfollow)

	get("/instance_document/:name", InstanceDocumentController, :show)
	patch("/instance_document/:name", InstanceDocumentController, :update)
	delete("/instance_document/:name", InstanceDocumentController, :delete)

	get("/config", ConfigController, :show)
	post("/config", ConfigController, :update)
	get("/config/descriptions", ConfigController, :descriptions)
	get("/need_reboot", AdminAPIController, :need_reboot)
	get("/restart", AdminAPIController, :restart)

	get("/oauth_app", OAuthAppController, :index)
	post("/oauth_app", OAuthAppController, :create)
	patch("/oauth_app/:id", OAuthAppController, :update)
	delete("/oauth_app/:id", OAuthAppController, :delete)

	get("/media_proxy_caches", MediaProxyCacheController, :index)
	post("/media_proxy_caches/delete", MediaProxyCacheController, :delete)
	post("/media_proxy_caches/purge", MediaProxyCacheController, :purge)

	get("/frontends", FrontendController, :index)
	post("/frontends/install", FrontendController, :install)

	post("/backups", AdminAPIController, :create_backup)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_announcements_manage_announcements)

	get("/announcements", AnnouncementController, :index)
	post("/announcements", AnnouncementController, :create)
	get("/announcements/:id", AnnouncementController, :show)
	patch("/announcements/:id", AnnouncementController, :change)
	delete("/announcements/:id", AnnouncementController, :delete)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_users_delete)

	delete("/users", UserController, :delete)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_users_manage_credentials)

	get("/users/:nickname/password_reset", AdminAPIController, :get_password_reset)
	get("/users/:nickname/credentials", AdminAPIController, :show_user_credentials)
	patch("/users/:nickname/credentials", AdminAPIController, :update_user_credentials)
	put("/users/disable_mfa", AdminAPIController, :disable_mfa)
	patch("/users/force_password_reset", AdminAPIController, :force_password_reset)
	patch("/users/confirm_email", AdminAPIController, :confirm_email)
	patch("/users/resend_confirmation_email", AdminAPIController, :resend_confirmation_email)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_messages_read)

	get("/users/:nickname/statuses", AdminAPIController, :list_user_statuses)
	get("/users/:nickname/chats", AdminAPIController, :list_user_chats)

	get("/statuses", StatusController, :index)

	get("/chats/:id", ChatController, :show)
	get("/chats/:id/messages", ChatController, :messages)

	get("/instances/:instance/statuses", InstanceController, :list_statuses)

	get("/statuses/:id", StatusController, :show)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_users_manage_tags)

	put("/users/tag", AdminAPIController, :tag_users)
	delete("/users/tag", AdminAPIController, :untag_users)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_users_manage_activation_state)

	patch("/users/:nickname/toggle_activation", UserController, :toggle_activation)
	patch("/users/activate", UserController, :activate)
	patch("/users/deactivate", UserController, :deactivate)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_users_manage_invites)

	patch("/users/approve", UserController, :approve)
	post("/users/invite_token", InviteController, :create)
	get("/users/invites", InviteController, :index)
	post("/users/revoke_invite", InviteController, :revoke)
	post("/users/email_invite", InviteController, :email)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_reports_manage_reports)

	get("/reports", ReportController, :index)
	get("/reports/:id", ReportController, :show)
	patch("/reports", ReportController, :update)
	post("/reports/:id/notes", ReportController, :notes_create)
	delete("/reports/:report_id/notes/:id", ReportController, :notes_delete)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_users_read)

	get("/users", UserController, :index)
	get("/users/:nickname", UserController, :show)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_messages_delete)

	put("/statuses/:id", StatusController, :update)
	delete("/statuses/:id", StatusController, :delete)

	delete("/chats/:id/messages/:message_id", ChatController, :delete_message)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_emoji_manage_emoji)

	post("/reload_emoji", AdminAPIController, :reload_emoji)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_instances_delete)

	delete("/instances/:instance", InstanceController, :delete)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_moderation_log_read)

	get("/moderation_log", AdminAPIController, :list_log)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_statistics_read)

	get("/stats", AdminAPIController, :stats)
	end

	scope "/api/v1/pleroma/emoji", Pleroma.Web.PleromaAPI do
	scope "/pack" do
	pipe_through(:require_privileged_role_emoji_manage_emoji)

	post("/", EmojiPackController, :create)
	patch("/", EmojiPackController, :update)
	delete("/", EmojiPackController, :delete)
	end

	scope "/pack" do
	pipe_through(:api)

	get("/", EmojiPackController, :show)
	end

	# Modifying packs
	scope "/packs" do
	pipe_through(:require_privileged_role_emoji_manage_emoji)

	get("/import", EmojiPackController, :import_from_filesystem)
	get("/remote", EmojiPackController, :remote)
	post("/download", EmojiPackController, :download)

	post("/files", EmojiFileController, :create)
	patch("/files", EmojiFileController, :update)
	delete("/files", EmojiFileController, :delete)
	end

	# Pack info / downloading
	scope "/packs" do
	pipe_through(:api)

	get("/", EmojiPackController, :index)
	get("/archive", EmojiPackController, :archive)
	end
	end

	scope "/", Pleroma.Web.TwitterAPI do
	pipe_through(:pleroma_html)

	post("/main/ostatus", UtilController, :remote_subscribe)
	get("/main/ostatus", UtilController, :show_subscribe_form)
	get("/ostatus_subscribe", RemoteFollowController, :follow)
	post("/ostatus_subscribe", RemoteFollowController, :do_follow)
	end

	scope "/api/pleroma", Pleroma.Web.TwitterAPI do
	pipe_through(:authenticated_api)

	post("/change_email", UtilController, :change_email)
	post("/change_password", UtilController, :change_password)
	post("/delete_account", UtilController, :delete_account)
	put("/notification_settings", UtilController, :update_notificaton_settings)
	post("/disable_account", UtilController, :disable_account)
	post("/move_account", UtilController, :move_account)

	put("/aliases", UtilController, :add_alias)
	get("/aliases", UtilController, :list_aliases)
	delete("/aliases", UtilController, :delete_alias)
	end

	scope "/api/pleroma", Pleroma.Web.PleromaAPI do
	pipe_through(:authenticated_api)

	post("/mutes_import", UserImportController, :mutes)
	post("/blocks_import", UserImportController, :blocks)
	post("/follow_import", UserImportController, :follow)

	get("/accounts/mfa", TwoFactorAuthenticationController, :settings)
	get("/accounts/mfa/backup_codes", TwoFactorAuthenticationController, :backup_codes)
	get("/accounts/mfa/setup/:method", TwoFactorAuthenticationController, :setup)
	post("/accounts/mfa/confirm/:method", TwoFactorAuthenticationController, :confirm)
	delete("/accounts/mfa/:method", TwoFactorAuthenticationController, :disable)
	end

	scope "/oauth", Pleroma.Web.OAuth do
	# Note: use /api/v1/accounts/verify_credentials for userinfo of signed-in user

	get("/registration_details", OAuthController, :registration_details)

	post("/mfa/verify", MFAController, :verify, as: :mfa_verify)
	get("/mfa", MFAController, :show)

	scope [] do
	pipe_through(:oauth)

	get("/authorize", OAuthController, :authorize)
	post("/authorize", OAuthController, :create_authorization)
	end

	scope [] do
	pipe_through(:fetch_session)

	post("/token", OAuthController, :token_exchange)
	post("/revoke", OAuthController, :token_revoke)
	post("/mfa/challenge", MFAController, :challenge)
	end

	scope [] do
	pipe_through(:browser)

	get("/prepare_request", OAuthController, :prepare_request)
	get("/:provider", OAuthController, :request)
	get("/:provider/callback", OAuthController, :callback)
	post("/register", OAuthController, :register)
	end
	end

	scope "/api/v1/pleroma", Pleroma.Web.PleromaAPI do
	pipe_through(:api)

	get("/apps", AppController, :index)
	get("/statuses/:id/reactions/:emoji", EmojiReactionController, :index)
	get("/statuses/:id/reactions", EmojiReactionController, :index)
	end

	scope "/api/v0/pleroma", Pleroma.Web.PleromaAPI do
	pipe_through(:authenticated_api)
	get("/reports", ReportController, :index)
	get("/reports/:id", ReportController, :show)
	end

	scope "/api/v1/pleroma", Pleroma.Web.PleromaAPI do
	scope [] do
	pipe_through(:authenticated_api)

	post("/chats/by-account-id/:id", ChatController, :create)
	get("/chats", ChatController, :index)
	get("/chats/:id", ChatController, :show)
	get("/chats/:id/messages", ChatController, :messages)
	post("/chats/:id/messages", ChatController, :post_chat_message)
	delete("/chats/:id/messages/:message_id", ChatController, :delete_message)
	post("/chats/:id/read", ChatController, :mark_as_read)
	post("/chats/:id/messages/:message_id/read", ChatController, :mark_message_as_read)

	get("/conversations/:id/statuses", ConversationController, :statuses)
	get("/conversations/:id", ConversationController, :show)
	post("/conversations/read", ConversationController, :mark_as_read)
	patch("/conversations/:id", ConversationController, :update)

	put("/statuses/:id/reactions/:emoji", EmojiReactionController, :create)
	delete("/statuses/:id/reactions/:emoji", EmojiReactionController, :delete)
	post("/notifications/read", NotificationController, :mark_as_read)

	get("/mascot", MascotController, :show)
	put("/mascot", MascotController, :update)

	post("/scrobble", ScrobbleController, :create)

	get("/backups", BackupController, :index)
	post("/backups", BackupController, :create)
	end

	scope [] do
	pipe_through(:api)
	get("/accounts/:id/favourites", AccountController, :favourites)
	get("/accounts/:id/endorsements", AccountController, :endorsements)

	get("/statuses/:id/quotes", StatusController, :quotes)
	end

	scope [] do
	pipe_through(:authenticated_api)

	post("/accounts/:id/subscribe", AccountController, :subscribe)
	post("/accounts/:id/unsubscribe", AccountController, :unsubscribe)

	get("/birthdays", AccountController, :birthdays)
	end

	scope [] do
	pipe_through(:authenticated_api)

	get("/settings/:app", SettingsController, :show)
	patch("/settings/:app", SettingsController, :update)
	end

	post("/accounts/confirmation_resend", AccountController, :confirmation_resend)
	end

	scope "/api/v1/pleroma", Pleroma.Web.PleromaAPI do
	pipe_through(:api)
	get("/accounts/:id/scrobbles", ScrobbleController, :index)
	- get("/federation_status", InstancesController, :show)
	end

	scope "/api/v2/pleroma", Pleroma.Web.PleromaAPI do
	scope [] do
	pipe_through(:authenticated_api)
	get("/chats", ChatController, :index2)
	end
	end

	scope "/api/v1", Pleroma.Web.MastodonAPI do
	pipe_through(:authenticated_api)

	get("/accounts/verify_credentials", AccountController, :verify_credentials)
	patch("/accounts/update_credentials", AccountController, :update_credentials)

	get("/accounts/relationships", AccountController, :relationships)
	get("/accounts/:id/lists", AccountController, :lists)
	get("/accounts/:id/identity_proofs", AccountController, :identity_proofs)
	get("/endorsements", AccountController, :endorsements)
	get("/blocks", AccountController, :blocks)
	get("/mutes", AccountController, :mutes)

	post("/follows", AccountController, :follow_by_uri)
	post("/accounts/:id/follow", AccountController, :follow)
	post("/accounts/:id/unfollow", AccountController, :unfollow)
	post("/accounts/:id/block", AccountController, :block)
	post("/accounts/:id/unblock", AccountController, :unblock)
	post("/accounts/:id/mute", AccountController, :mute)
	post("/accounts/:id/unmute", AccountController, :unmute)
	post("/accounts/:id/note", AccountController, :note)
	post("/accounts/:id/pin", AccountController, :endorse)
	post("/accounts/:id/unpin", AccountController, :unendorse)
	post("/accounts/:id/remove_from_followers", AccountController, :remove_from_followers)

	get("/conversations", ConversationController, :index)
	post("/conversations/:id/read", ConversationController, :mark_as_read)
	delete("/conversations/:id", ConversationController, :delete)

	get("/domain_blocks", DomainBlockController, :index)
	post("/domain_blocks", DomainBlockController, :create)
	delete("/domain_blocks", DomainBlockController, :delete)

	get("/filters", FilterController, :index)

	post("/filters", FilterController, :create)
	get("/filters/:id", FilterController, :show)
	put("/filters/:id", FilterController, :update)
	delete("/filters/:id", FilterController, :delete)

	get("/follow_requests", FollowRequestController, :index)
	post("/follow_requests/:id/authorize", FollowRequestController, :authorize)
	post("/follow_requests/:id/reject", FollowRequestController, :reject)

	get("/lists", ListController, :index)
	get("/lists/:id", ListController, :show)
	get("/lists/:id/accounts", ListController, :list_accounts)

	delete("/lists/:id", ListController, :delete)
	post("/lists", ListController, :create)
	put("/lists/:id", ListController, :update)
	post("/lists/:id/accounts", ListController, :add_to_list)
	delete("/lists/:id/accounts", ListController, :remove_from_list)

	get("/markers", MarkerController, :index)
	post("/markers", MarkerController, :upsert)

	post("/media", MediaController, :create)
	get("/media/:id", MediaController, :show)
	put("/media/:id", MediaController, :update)

	get("/notifications", NotificationController, :index)
	get("/notifications/:id", NotificationController, :show)

	post("/notifications/:id/dismiss", NotificationController, :dismiss)
	post("/notifications/clear", NotificationController, :clear)
	delete("/notifications/destroy_multiple", NotificationController, :destroy_multiple)
	# Deprecated: was removed in Mastodon v3, use `/notifications/:id/dismiss` instead
	post("/notifications/dismiss", NotificationController, :dismiss_via_body)

	post("/polls/:id/votes", PollController, :vote)

	post("/reports", ReportController, :create)

	get("/scheduled_statuses", ScheduledActivityController, :index)
	get("/scheduled_statuses/:id", ScheduledActivityController, :show)

	put("/scheduled_statuses/:id", ScheduledActivityController, :update)
	delete("/scheduled_statuses/:id", ScheduledActivityController, :delete)

	# Unlike `GET /api/v1/accounts/:id/favourites`, demands authentication
	get("/favourites", StatusController, :favourites)
	get("/bookmarks", StatusController, :bookmarks)

	post("/statuses", StatusController, :create)
	put("/statuses/:id", StatusController, :update)
	delete("/statuses/:id", StatusController, :delete)
	post("/statuses/:id/reblog", StatusController, :reblog)
	post("/statuses/:id/unreblog", StatusController, :unreblog)
	post("/statuses/:id/favourite", StatusController, :favourite)
	post("/statuses/:id/unfavourite", StatusController, :unfavourite)
	post("/statuses/:id/pin", StatusController, :pin)
	post("/statuses/:id/unpin", StatusController, :unpin)
	post("/statuses/:id/bookmark", StatusController, :bookmark)
	post("/statuses/:id/unbookmark", StatusController, :unbookmark)
	post("/statuses/:id/mute", StatusController, :mute_conversation)
	post("/statuses/:id/unmute", StatusController, :unmute_conversation)

	post("/push/subscription", SubscriptionController, :create)
	get("/push/subscription", SubscriptionController, :show)
	put("/push/subscription", SubscriptionController, :update)
	delete("/push/subscription", SubscriptionController, :delete)

	get("/suggestions", SuggestionController, :index)
	delete("/suggestions/:account_id", SuggestionController, :dismiss)

	get("/timelines/home", TimelineController, :home)
	get("/timelines/direct", TimelineController, :direct)
	get("/timelines/list/:list_id", TimelineController, :list)

	get("/announcements", AnnouncementController, :index)
	post("/announcements/:id/dismiss", AnnouncementController, :mark_read)
	end

	scope "/api/v1", Pleroma.Web.MastodonAPI do
	pipe_through(:app_api)

	post("/apps", AppController, :create)
	get("/apps/verify_credentials", AppController, :verify_credentials)
	end

	scope "/api/v1", Pleroma.Web.MastodonAPI do
	pipe_through(:api)

	get("/accounts/search", SearchController, :account_search)
	get("/search", SearchController, :search)

	get("/accounts/lookup", AccountController, :lookup)

	get("/accounts/:id/statuses", AccountController, :statuses)
	get("/accounts/:id/followers", AccountController, :followers)
	get("/accounts/:id/following", AccountController, :following)
	get("/accounts/:id", AccountController, :show)

	post("/accounts", AccountController, :create)

	get("/instance", InstanceController, :show)
	get("/instance/peers", InstanceController, :peers)

	get("/statuses", StatusController, :index)
	get("/statuses/:id", StatusController, :show)
	get("/statuses/:id/context", StatusController, :context)
	get("/statuses/:id/card", StatusController, :card)
	get("/statuses/:id/favourited_by", StatusController, :favourited_by)
	get("/statuses/:id/reblogged_by", StatusController, :reblogged_by)
	get("/statuses/:id/history", StatusController, :show_history)
	get("/statuses/:id/source", StatusController, :show_source)

	get("/custom_emojis", CustomEmojiController, :index)

	get("/trends", MastodonAPIController, :empty_array)

	get("/timelines/public", TimelineController, :public)
	get("/timelines/tag/:tag", TimelineController, :hashtag)

	get("/polls/:id", PollController, :show)

	get("/directory", DirectoryController, :index)
	end

	scope "/api/v2", Pleroma.Web.MastodonAPI do
	pipe_through(:api)
	get("/search", SearchController, :search2)

	post("/media", MediaController, :create2)

	get("/suggestions", SuggestionController, :index2)
	end

	scope "/api", Pleroma.Web do
	pipe_through(:config)

	get("/pleroma/frontend_configurations", TwitterAPI.UtilController, :frontend_configurations)
	end

	scope "/api", Pleroma.Web do
	pipe_through(:api)

	get(
	"/account/confirm_email/:user_id/:token",
	TwitterAPI.Controller,
	:confirm_email,
	as: :confirm_email
	)
	end

	scope "/api" do
	pipe_through(:base_api)

	get("/openapi", OpenApiSpex.Plug.RenderSpec, [])
	end

	scope "/api", Pleroma.Web, as: :authenticated_twitter_api do
	pipe_through(:authenticated_api)

	get("/oauth_tokens", TwitterAPI.Controller, :oauth_tokens)
	delete("/oauth_tokens/:id", TwitterAPI.Controller, :revoke_token)
	end

	scope "/", Pleroma.Web do
	# Note: html format is supported only if static FE is enabled
	# Note: http signature is only considered for json requests (no auth for non-json requests)
	pipe_through([:accepts_html_json, :http_signature, :static_fe])

	get("/objects/:uuid", OStatus.OStatusController, :object)
	get("/activities/:uuid", OStatus.OStatusController, :activity)
	get("/notice/:id", OStatus.OStatusController, :notice)

	# Mastodon compatibility routes
	get("/users/:nickname/statuses/:id", OStatus.OStatusController, :object)
	get("/users/:nickname/statuses/:id/activity", OStatus.OStatusController, :activity)
	end

	scope "/", Pleroma.Web do
	# Note: html format is supported only if static FE is enabled
	# Note: http signature is only considered for json requests (no auth for non-json requests)
	pipe_through([:accepts_html_xml_json, :http_signature, :static_fe])

	# Note: returns user _profile_ for json requests, redirects to user _feed_ for non-json ones
	get("/users/:nickname", Feed.UserController, :feed_redirect, as: :user_feed)
	end

	scope "/", Pleroma.Web do
	pipe_through([:accepts_html_xml])

	get("/users/:nickname/feed", Feed.UserController, :feed, as: :user_feed)
	end

	scope "/", Pleroma.Web do
	pipe_through(:accepts_html)
	get("/notice/:id/embed_player", OStatus.OStatusController, :notice_player)
	end

	scope "/", Pleroma.Web do
	pipe_through(:accepts_xml_rss_atom)
	get("/tags/:tag", Feed.TagController, :feed, as: :tag_feed)
	end

	scope "/", Pleroma.Web do
	pipe_through(:browser)
	get("/mailer/unsubscribe/:token", Mailer.SubscriptionController, :unsubscribe)
	end

	pipeline :ap_service_actor do
	plug(:accepts, ["activity+json", "json"])
	end

	# Server to Server (S2S) AP interactions
	pipeline :activitypub do
	plug(:ap_service_actor)
	plug(:http_signature)
	end

	# Client to Server (C2S) AP interactions
	pipeline :activitypub_client do
	plug(:ap_service_actor)
	plug(:fetch_session)
	plug(:authenticate)
	plug(:after_auth)
	end

	scope "/", Pleroma.Web.ActivityPub do
	pipe_through([:activitypub_client])

	get("/api/ap/whoami", ActivityPubController, :whoami)
	get("/users/:nickname/inbox", ActivityPubController, :read_inbox)

	get("/users/:nickname/outbox", ActivityPubController, :outbox)
	post("/users/:nickname/outbox", ActivityPubController, :update_outbox)
	post("/api/ap/upload_media", ActivityPubController, :upload_media)

	# The following two are S2S as well, see `ActivityPub.fetch_follow_information_for_user/1`:
	get("/users/:nickname/followers", ActivityPubController, :followers)
	get("/users/:nickname/following", ActivityPubController, :following)
	get("/users/:nickname/collections/featured", ActivityPubController, :pinned)
	end

	scope "/", Pleroma.Web.ActivityPub do
	pipe_through(:activitypub)
	post("/inbox", ActivityPubController, :inbox)
	post("/users/:nickname/inbox", ActivityPubController, :inbox)
	end

	scope "/relay", Pleroma.Web.ActivityPub do
	pipe_through(:ap_service_actor)

	get("/", ActivityPubController, :relay)

	scope [] do
	pipe_through(:http_signature)
	post("/inbox", ActivityPubController, :inbox)
	end

	get("/following", ActivityPubController, :relay_following)
	get("/followers", ActivityPubController, :relay_followers)
	end

	scope "/internal/fetch", Pleroma.Web.ActivityPub do
	pipe_through(:ap_service_actor)

	get("/", ActivityPubController, :internal_fetch)
	post("/inbox", ActivityPubController, :inbox)
	end

	scope "/.well-known", Pleroma.Web do
	pipe_through(:well_known)

	get("/host-meta", WebFinger.WebFingerController, :host_meta)
	get("/webfinger", WebFinger.WebFingerController, :webfinger)
	get("/nodeinfo", Nodeinfo.NodeinfoController, :schemas)
	end

	scope "/nodeinfo", Pleroma.Web do
	get("/:version", Nodeinfo.NodeinfoController, :nodeinfo)
	end

	scope "/", Pleroma.Web do
	pipe_through(:api)

	get("/manifest.json", ManifestController, :show)
	end

	scope "/", Pleroma.Web do
	pipe_through(:pleroma_html)

	post("/auth/password", TwitterAPI.PasswordController, :request)
	end

	scope "/proxy/", Pleroma.Web do
	get("/preview/:sig/:url", MediaProxy.MediaProxyController, :preview)
	get("/preview/:sig/:url/:filename", MediaProxy.MediaProxyController, :preview)
	get("/:sig/:url", MediaProxy.MediaProxyController, :remote)
	get("/:sig/:url/:filename", MediaProxy.MediaProxyController, :remote)
	end

	if Pleroma.Config.get(:env) == :dev do
	scope "/dev" do
	pipe_through([:mailbox_preview])

	forward("/mailbox", Plug.Swoosh.MailboxPreview, base_path: "/dev/mailbox")
	end
	end

	scope "/" do
	pipe_through([:pleroma_html, :authenticate, :require_admin])
	live_dashboard("/phoenix/live_dashboard")
	end

	# Test-only routes needed to test action dispatching and plug chain execution
	if Pleroma.Config.get(:env) == :test do
	@test_actions [
	:do_oauth_check,
	:fallback_oauth_check,
	:skip_oauth_check,
	:fallback_oauth_skip_publicity_check,
	:skip_oauth_skip_publicity_check,
	:missing_oauth_check_definition
	]

	scope "/test/api", Pleroma.Tests do
	pipe_through(:api)

	for action <- @test_actions do
	get("/#{action}", AuthTestController, action)
	end
	end

	scope "/test/authenticated_api", Pleroma.Tests do
	pipe_through(:authenticated_api)

	for action <- @test_actions do
	get("/#{action}", AuthTestController, action)
	end
	end
	end

	scope "/", Pleroma.Web.MongooseIM do
	get("/user_exists", MongooseIMController, :user_exists)
	get("/check_password", MongooseIMController, :check_password)
	end

	scope "/", Pleroma.Web.Fallback do
	get("/registration/:token", RedirectController, :registration_page)
	get("/:maybe_nickname_or_id", RedirectController, :redirector_with_meta)
	match(:, "/api/pleroma/path", LegacyPleromaApiRerouterPlug, [])
	get("/api/*path", RedirectController, :api_not_implemented)
	get("/*path", RedirectController, :redirector_with_preload)

	options("/*path", RedirectController, :empty)
	end

	def get_api_routes do
	Phoenix.Router.routes(__MODULE__)
	\|> Enum.reject(fn r -> r.plug == Pleroma.Web.Fallback.RedirectController end)
	\|> Enum.map(fn r ->
	r.path
	\|> String.split("/", trim: true)
	\|> List.first()
	end)
	\|> Enum.uniq()
	end
	end
	diff --git a/mix.exs b/mix.exs
	index 4fd2df2d0..99074b433 100644
	--- a/mix.exs
	+++ b/mix.exs
	@@ -1,357 +1,348 @@
	defmodule Pleroma.Mixfile do
	use Mix.Project

	def project do
	[
	app: :pleroma,
	version: version("2.6.50"),
	elixir: "~> 1.11",
	elixirc_paths: elixirc_paths(Mix.env()),
	compilers: Mix.compilers(),
	elixirc_options: [warnings_as_errors: warnings_as_errors()],
	xref: [exclude: [:eldap]],
	start_permanent: Mix.env() == :prod,
	aliases: aliases(),
	deps: deps(),
	test_coverage: [tool: :covertool, summary: true],
	# Docs
	name: "Pleroma",
	homepage_url: "https://pleroma.social/",
	source_url: "https://git.pleroma.social/pleroma/pleroma",
	docs: [
	source_url_pattern:
	"https://git.pleroma.social/pleroma/pleroma/blob/develop/%{path}#L%{line}",
	logo: "priv/static/images/logo.png",
	extras: ["README.md", "CHANGELOG.md"] ++ Path.wildcard("docs/*/.md"),
	groups_for_extras: [
	"Installation manuals": Path.wildcard("docs/installation/*.md"),
	Configuration: Path.wildcard("docs/config/*.md"),
	Administration: Path.wildcard("docs/admin/*.md"),
	"Pleroma's APIs and Mastodon API extensions": Path.wildcard("docs/api/*.md")
	],
	main: "readme",
	output: "priv/static/doc"
	],
	releases: [
	pleroma: [
	include_executables_for: [:unix],
	applications: [ex_syslogger: :load, syslog: :load, eldap: :transient],
	steps: [:assemble, &put_otp_version/1, &copy_files/1, &copy_nginx_config/1],
	config_providers: [{Pleroma.Config.ReleaseRuntimeProvider, []}]
	]
	]
	]
	end

	def put_otp_version(%{path: target_path} = release) do
	File.write!(
	Path.join([target_path, "OTP_VERSION"]),
	Pleroma.OTPVersion.version()
	)

	release
	end

	def copy_files(%{path: target_path} = release) do
	File.cp_r!("./rel/files", target_path)
	release
	end

	def copy_nginx_config(%{path: target_path} = release) do
	File.cp!(
	"./installation/pleroma.nginx",
	Path.join([target_path, "installation", "pleroma.nginx"])
	)

	release
	end

	# Configuration for the OTP application.
	#
	# Type `mix help compile.app` for more information.
	def application do
	[
	mod: {Pleroma.Application, []},
	extra_applications: [
	:logger,
	:runtime_tools,
	:comeonin,
	:fast_sanitize,
	:os_mon,
	:ssl
	],
	included_applications: [:ex_syslogger]
	]
	end

	# Specifies which paths to compile per environment.
	defp elixirc_paths(:benchmark), do: ["lib", "benchmarks", "priv/scrubbers"]
	defp elixirc_paths(:test), do: ["lib", "test/support"]
	defp elixirc_paths(_), do: ["lib"]

	defp warnings_as_errors, do: System.get_env("CI") == "true"

	# Specifies OAuth dependencies.
	defp oauth_deps do
	oauth_strategy_packages =
	System.get_env("OAUTH_CONSUMER_STRATEGIES")
	\|> to_string()
	\|> String.split()
	\|> Enum.map(fn strategy_entry ->
	with [_strategy, dependency] <- String.split(strategy_entry, ":") do
	dependency
	else
	[strategy] -> "ueberauth_#{strategy}"
	end
	end)

	for s <- oauth_strategy_packages, do: {String.to_atom(s), ">= 0.0.0"}
	end

	# Specifies your project dependencies.
	#
	# Type `mix help deps` for examples and options.
	defp deps do
	[
	{:phoenix, "~> 1.7.3"},
	{:phoenix_ecto, "~> 4.4"},
	{:ecto_sql, "~> 3.10"},
	{:ecto_enum, "~> 1.4"},
	{:postgrex, ">= 0.0.0"},
	{:phoenix_html, "~> 3.3"},
	{:phoenix_live_reload, "~> 1.3.3", only: :dev},
	{:phoenix_live_view, "~> 0.19.0"},
	{:phoenix_live_dashboard, "~> 0.8.0"},
	{:telemetry_metrics, "~> 0.6"},
	{:telemetry_poller, "~> 1.0"},
	{:tzdata, "~> 1.0.3"},
	{:plug_cowboy, "~> 2.5"},
	# oban 2.14 requires Elixir 1.12+
	{:oban, "~> 2.13.4"},
	{:gettext, "~> 0.20"},
	{:bcrypt_elixir, "~> 2.2"},
	{:trailing_format_plug, "~> 0.0.7"},
	{:fast_sanitize, "~> 0.2.0"},
	{:html_entities, "~> 0.5", override: true},
	{:calendar, "~> 1.0"},
	{:cachex, "~> 3.2"},
	{:poison, "~> 3.0", override: true},
	{:tesla, "~> 1.4.0", override: true},
	{:castore, "~> 0.1"},
	{:cowlib, "~> 2.9", override: true},
	{:gun, "~> 2.0.0-rc.1", override: true},
	- {:finch, "~> 0.10.0"},
	+ {:finch, "~> 0.15"},
	{:jason, "~> 1.2"},
	- {:mogrify, "~> 0.9.1"},
	+ {:mogrify, "~> 0.8.0"},
	{:ex_aws, "~> 2.1.6"},
	{:ex_aws_s3, "~> 2.0"},
	{:sweet_xml, "~> 0.7.2"},
	# earmark 1.4.23 requires Elixir 1.12+
	{:earmark, "1.4.22"},
	{:bbcode_pleroma, "~> 0.2.0"},
	{:cors_plug, "~> 2.0"},
	{:web_push_encryption, "~> 0.3.1"},
	# swoosh 1.11.2+ requires Elixir 1.12+
	{:swoosh, "~> 1.10.0"},
	{:phoenix_swoosh, "~> 1.1"},
	{:gen_smtp, "~> 0.13"},
	{:ex_syslogger, "~> 1.4"},
	{:floki, "~> 0.27"},
	{:timex, "~> 3.6"},
	{:ueberauth, "~> 0.4"},
	{:linkify, "~> 0.5.3"},
	{:http_signatures, "~> 0.1.1"},
	{:telemetry, "~> 1.0.0", override: true},
	{:poolboy, "~> 1.5"},
	- {:prometheus, "~> 4.6"},
	- {:prometheus_ex,
	- git: "https://github.com/lanodan/prometheus.ex.git",
	- branch: "fix/elixir-1.14",
	- override: true},
	- {:prometheus_plugs, "~> 1.1"},
	- {:prometheus_phoenix, "~> 1.3"},
	- # Note: once `prometheus_phx` is integrated into `prometheus_phoenix`, remove the former:
	- {:prometheus_phx,
	- git: "https://git.pleroma.social/pleroma/elixir-libraries/prometheus-phx.git",
	- branch: "no-logging"},
	- {:prometheus_ecto, "~> 1.4"},
	+ {:prom_ex, "~> 1.9"},
	{:recon, "~> 2.5"},
	{:joken, "~> 2.0"},
	{:pot, "~> 1.0"},
	{:ex_const, "~> 0.2"},
	{:plug_static_index_html, "~> 1.0.0"},
	{:flake_id, "~> 0.1.0"},
	{:concurrent_limiter, "~> 0.1.1"},
	{:remote_ip,
	git: "https://git.pleroma.social/pleroma/remote_ip.git",
	ref: "b647d0deecaa3acb140854fe4bda5b7e1dc6d1c8"},
	{:captcha,
	git: "https://git.pleroma.social/pleroma/elixir-libraries/elixir-captcha.git",
	- ref: "e0f16822d578866e186a0974d65ad58cddc1e2ab"},
	+ ref: "90f6ce7672f70f56708792a98d98bd05176c9176"},
	{:restarter, path: "./restarter"},
	{:majic, "~> 1.0"},
	- {:eblurhash, "~> 1.2.2"},
	{:open_api_spex, "~> 3.16"},
	{:ecto_psql_extras, "~> 0.6"},
	+ {:vix, "~> 0.25.0"},
	+ {:elixir_make, "~> 0.7.7", override: true},
	+ {:blurhash, "~> 0.1.0", hex: :rinpatch_blurhash},

	## dev & test
	{:ex_doc, "~> 0.22", only: :dev, runtime: false},
	{:ex_machina, "~> 2.4", only: :test},
	{:credo, "~> 1.6", only: [:dev, :test], runtime: false},
	{:mock, "~> 0.3.5", only: :test},
	{:covertool, "~> 2.0", only: :test},
	{:hackney, "~> 1.18.0", override: true},
	{:mox, "~> 1.0", only: :test},
	{:websockex, "~> 0.4.3", only: :test},
	{:benchee, "~> 1.0", only: :benchmark}
	] ++ oauth_deps()
	end

	# Aliases are shortcuts or tasks specific to the current project.
	# For example, to create, migrate and run the seeds file at once:
	#
	# $ mix ecto.setup
	#
	# See the documentation for `Mix` for more info on aliases.
	defp aliases do
	[
	"ecto.migrate": ["pleroma.ecto.migrate"],
	"ecto.rollback": ["pleroma.ecto.rollback"],
	"ecto.setup": ["ecto.create", "ecto.migrate", "run priv/repo/seeds.exs"],
	"ecto.reset": ["ecto.drop", "ecto.setup"],
	test: ["ecto.create --quiet", "ecto.migrate", "test"],
	docs: ["pleroma.docs", "docs"],
	analyze: ["credo --strict --only=warnings,todo,fixme,consistency,readability"],
	copyright: &add_copyright/1,
	"copyright.bump": &bump_copyright/1
	]
	end

	# Builds a version string made of:
	# * the application version
	# * a pre-release if ahead of the tag: the describe string (-count-commithash)
	# * branch name
	# * build metadata:
	# * a build name if `PLEROMA_BUILD_NAME` or `:pleroma, :build_name` is defined
	# * the mix environment if different than prod
	defp version(version) do
	identifier_filter = ~r/[^0-9a-z\-]+/i

	git_available? = match?({_output, 0}, System.cmd("sh", ["-c", "command -v git"]))
	dotgit_present? = File.exists?(".git")

	git_pre_release =
	if git_available? and dotgit_present? do
	{tag, tag_err} =
	System.cmd("git", ["describe", "--tags", "--abbrev=0"], stderr_to_stdout: true)

	{describe, describe_err} = System.cmd("git", ["describe", "--tags", "--abbrev=8"])
	{commit_hash, commit_hash_err} = System.cmd("git", ["rev-parse", "--short", "HEAD"])

	# Pre-release version, denoted from patch version with a hyphen
	cond do
	tag_err == 0 and describe_err == 0 ->
	describe
	\|> String.trim()
	\|> String.replace(String.trim(tag), "")
	\|> String.trim_leading("-")
	\|> String.trim()

	commit_hash_err == 0 ->
	"0-g" <> String.trim(commit_hash)

	true ->
	nil
	end
	end

	# Branch name as pre-release version component, denoted with a dot
	branch_name =
	with true <- git_available?,
	true <- dotgit_present?,
	{branch_name, 0} <- System.cmd("git", ["rev-parse", "--abbrev-ref", "HEAD"]),
	branch_name <- String.trim(branch_name),
	branch_name <- System.get_env("PLEROMA_BUILD_BRANCH") \|\| branch_name,
	true <-
	!Enum.any?(["master", "HEAD", "release/", "stable"], fn name ->
	String.starts_with?(name, branch_name)
	end) do
	branch_name =
	branch_name
	\|> String.trim()
	\|> String.replace(identifier_filter, "-")

	branch_name
	else
	_ -> ""
	end

	build_name =
	cond do
	name = Application.get_env(:pleroma, :build_name) -> name
	name = System.get_env("PLEROMA_BUILD_NAME") -> name
	true -> nil
	end

	env_name = if Mix.env() != :prod, do: to_string(Mix.env())
	env_override = System.get_env("PLEROMA_BUILD_ENV")

	env_name =
	case env_override do
	nil -> env_name
	env_override when env_override in ["", "prod"] -> nil
	env_override -> env_override
	end

	# Pre-release version, denoted by appending a hyphen
	# and a series of dot separated identifiers
	pre_release =
	[git_pre_release, branch_name]
	\|> Enum.filter(fn string -> string && string != "" end)
	\|> Enum.join(".")
	\|> (fn
	"" -> nil
	string -> "-" <> String.replace(string, identifier_filter, "-")
	end).()

	# Build metadata, denoted with a plus sign
	build_metadata =
	[build_name, env_name]
	\|> Enum.filter(fn string -> string && string != "" end)
	\|> Enum.join(".")
	\|> (fn
	"" -> nil
	string -> "+" <> String.replace(string, identifier_filter, "-")
	end).()

	[version, pre_release, build_metadata]
	\|> Enum.filter(fn string -> string && string != "" end)
	\|> Enum.join()
	end

	defp add_copyright(_) do
	year = NaiveDateTime.utc_now().year
	template = ~s[\
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-#{year} Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	] \|> String.replace("\n", "\\n")

	find = "find lib test priv -type f \$ -name '.ex' -or -name '.exs' \$ -exec "
	grep = "grep -L '# Copyright © [0-9\-]* Pleroma' {} \\;"
	xargs = "xargs -n1 sed -i'' '1s;^;#{template};'"

	:os.cmd(String.to_charlist("#{find}#{grep} \| #{xargs}"))
	end

	defp bump_copyright(_) do
	year = NaiveDateTime.utc_now().year
	find = "find lib test priv -type f \$ -name '.ex' -or -name '.exs' \$"

	xargs =
	"xargs sed -i'' 's;# Copyright © [0-9\-]* Pleroma.*$;# Copyright © 2017-#{year} Pleroma Authors <https://pleroma.social/>;'"

	:os.cmd(String.to_charlist("#{find} \| #{xargs}"))
	end
	end
	diff --git a/mix.lock b/mix.lock
	index 7922a8eb1..a5afb46d5 100644
	--- a/mix.lock
	+++ b/mix.lock
	@@ -1,139 +1,145 @@
	%{
	"accept": {:hex, :accept, "0.3.5", "b33b127abca7cc948bbe6caa4c263369abf1347cfa9d8e699c6d214660f10cd1", [:rebar3], [], "hexpm", "11b18c220bcc2eab63b5470c038ef10eb6783bcb1fcdb11aa4137defa5ac1bb8"},
	"base62": {:hex, :base62, "1.2.2", "85c6627eb609317b70f555294045895ffaaeb1758666ab9ef9ca38865b11e629", [:mix], [{:custom_base, "~> 0.2.1", [hex: :custom_base, repo: "hexpm", optional: false]}], "hexpm", "d41336bda8eaa5be197f1e4592400513ee60518e5b9f4dcf38f4b4dae6f377bb"},
	"bbcode_pleroma": {:hex, :bbcode_pleroma, "0.2.0", "d36f5bca6e2f62261c45be30fa9b92725c0655ad45c99025cb1c3e28e25803ef", [:mix], [{:nimble_parsec, "~> 0.5", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "19851074419a5fedb4ef49e1f01b30df504bb5dbb6d6adfc135238063bebd1c3"},
	"bcrypt_elixir": {:hex, :bcrypt_elixir, "2.3.1", "5114d780459a04f2b4aeef52307de23de961b69e13a5cd98a911e39fda13f420", [:make, :mix], [{:comeonin, "~> 5.3", [hex: :comeonin, repo: "hexpm", optional: false]}, {:elixir_make, "~> 0.6", [hex: :elixir_make, repo: "hexpm", optional: false]}], "hexpm", "42182d5f46764def15bf9af83739e3bf4ad22661b1c34fc3e88558efced07279"},
	"benchee": {:hex, :benchee, "1.1.0", "f3a43817209a92a1fade36ef36b86e1052627fd8934a8b937ac9ab3a76c43062", [:mix], [{:deep_merge, "~> 1.0", [hex: :deep_merge, repo: "hexpm", optional: false]}, {:statistex, "~> 1.0", [hex: :statistex, repo: "hexpm", optional: false]}], "hexpm", "7da57d545003165a012b587077f6ba90b89210fd88074ce3c60ce239eb5e6d93"},
	+ "blurhash": {:hex, :rinpatch_blurhash, "0.1.0", "01a888b0f5f1f382ab52e4396f01831cbe8486ea5828604c90f4dac533d39a4b", [:mix], [{:mogrify, "~> 0.8.0", [hex: :mogrify, repo: "hexpm", optional: true]}], "hexpm", "19911a5dcbb0acb9710169a72f702bce6cb048822b12de566ccd82b2cc42b907"},
	"bunt": {:hex, :bunt, "0.2.1", "e2d4792f7bc0ced7583ab54922808919518d0e57ee162901a16a1b6664ef3b14", [:mix], [], "hexpm", "a330bfb4245239787b15005e66ae6845c9cd524a288f0d141c148b02603777a5"},
	"cachex": {:hex, :cachex, "3.6.0", "14a1bfbeee060dd9bec25a5b6f4e4691e3670ebda28c8ba2884b12fe30b36bf8", [:mix], [{:eternal, "~> 1.2", [hex: :eternal, repo: "hexpm", optional: false]}, {:jumper, "~> 1.0", [hex: :jumper, repo: "hexpm", optional: false]}, {:sleeplocks, "~> 1.1", [hex: :sleeplocks, repo: "hexpm", optional: false]}, {:unsafe, "~> 1.0", [hex: :unsafe, repo: "hexpm", optional: false]}], "hexpm", "ebf24e373883bc8e0c8d894a63bbe102ae13d918f790121f5cfe6e485cc8e2e2"},
	"calendar": {:hex, :calendar, "1.0.0", "f52073a708528482ec33d0a171954ca610fe2bd28f1e871f247dc7f1565fa807", [:mix], [{:tzdata, "~> 0.5.20 or ~> 0.1.201603 or ~> 1.0", [hex: :tzdata, repo: "hexpm", optional: false]}], "hexpm", "990e9581920c82912a5ee50e62ff5ef96da6b15949a2ee4734f935fdef0f0a6f"},
	- "captcha": {:git, "https://git.pleroma.social/pleroma/elixir-libraries/elixir-captcha.git", "e0f16822d578866e186a0974d65ad58cddc1e2ab", [ref: "e0f16822d578866e186a0974d65ad58cddc1e2ab"]},
	+ "captcha": {:git, "https://git.pleroma.social/pleroma/elixir-libraries/elixir-captcha.git", "90f6ce7672f70f56708792a98d98bd05176c9176", [ref: "90f6ce7672f70f56708792a98d98bd05176c9176"]},
	"castore": {:hex, :castore, "0.1.22", "4127549e411bedd012ca3a308dede574f43819fe9394254ca55ab4895abfa1a2", [:mix], [], "hexpm", "c17576df47eb5aa1ee40cc4134316a99f5cad3e215d5c77b8dd3cfef12a22cac"},
	+ "cc_precompiler": {:hex, :cc_precompiler, "0.1.9", "e8d3364f310da6ce6463c3dd20cf90ae7bbecbf6c5203b98bf9b48035592649b", [:mix], [{:elixir_make, "~> 0.7", [hex: :elixir_make, repo: "hexpm", optional: false]}], "hexpm", "9dcab3d0f3038621f1601f13539e7a9ee99843862e66ad62827b0c42b2f58a54"},
	"certifi": {:hex, :certifi, "2.9.0", "6f2a475689dd47f19fb74334859d460a2dc4e3252a3324bd2111b8f0429e7e21", [:rebar3], [], "hexpm", "266da46bdb06d6c6d35fde799bcb28d36d985d424ad7c08b5bb48f5b5cdd4641"},
	"combine": {:hex, :combine, "0.10.0", "eff8224eeb56498a2af13011d142c5e7997a80c8f5b97c499f84c841032e429f", [:mix], [], "hexpm", "1b1dbc1790073076580d0d1d64e42eae2366583e7aecd455d1215b0d16f2451b"},
	"comeonin": {:hex, :comeonin, "5.3.3", "2c564dac95a35650e9b6acfe6d2952083d8a08e4a89b93a481acb552b325892e", [:mix], [], "hexpm", "3e38c9c2cb080828116597ca8807bb482618a315bfafd98c90bc22a821cc84df"},
	"concurrent_limiter": {:hex, :concurrent_limiter, "0.1.1", "43ae1dc23edda1ab03dd66febc739c4ff710d047bb4d735754909f9a474ae01c", [:mix], [{:telemetry, "~> 0.3", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "53968ff238c0fbb4d7ed76ddb1af0be6f3b2f77909f6796e249e737c505a16eb"},
	"connection": {:hex, :connection, "1.1.0", "ff2a49c4b75b6fb3e674bfc5536451607270aac754ffd1bdfe175abe4a6d7a68", [:mix], [], "hexpm", "722c1eb0a418fbe91ba7bd59a47e28008a189d47e37e0e7bb85585a016b2869c"},
	"cors_plug": {:hex, :cors_plug, "2.0.3", "316f806d10316e6d10f09473f19052d20ba0a0ce2a1d910ddf57d663dac402ae", [:mix], [{:plug, "~> 1.8", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "ee4ae1418e6ce117fc42c2ba3e6cbdca4e95ecd2fe59a05ec6884ca16d469aea"},
	"covertool": {:hex, :covertool, "2.0.6", "4a291b4e3449025b0595d8f44c8d7635d4f48f033be2ce88d22a329f36f94a91", [:rebar3], [], "hexpm", "5db3fcd82180d8ea4ad857d4d1ab21a8d31b5aee0d60d2f6c0f9e25a411d1e21"},
	"cowboy": {:hex, :cowboy, "2.10.0", "ff9ffeff91dae4ae270dd975642997afe2a1179d94b1887863e43f681a203e26", [:make, :rebar3], [{:cowlib, "2.12.1", [hex: :cowlib, repo: "hexpm", optional: false]}, {:ranch, "1.8.0", [hex: :ranch, repo: "hexpm", optional: false]}], "hexpm", "3afdccb7183cc6f143cb14d3cf51fa00e53db9ec80cdcd525482f5e99bc41d6b"},
	"cowboy_telemetry": {:hex, :cowboy_telemetry, "0.4.0", "f239f68b588efa7707abce16a84d0d2acf3a0f50571f8bb7f56a15865aae820c", [:rebar3], [{:cowboy, "~> 2.7", [hex: :cowboy, repo: "hexpm", optional: false]}, {:telemetry, "~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "7d98bac1ee4565d31b62d59f8823dfd8356a169e7fcbb83831b8a5397404c9de"},
	"cowlib": {:hex, :cowlib, "2.12.1", "a9fa9a625f1d2025fe6b462cb865881329b5caff8f1854d1cbc9f9533f00e1e1", [:make, :rebar3], [], "hexpm", "163b73f6367a7341b33c794c4e88e7dbfe6498ac42dcd69ef44c5bc5507c8db0"},
	"credo": {:hex, :credo, "1.7.0", "6119bee47272e85995598ee04f2ebbed3e947678dee048d10b5feca139435f75", [:mix], [{:bunt, "~> 0.2.1", [hex: :bunt, repo: "hexpm", optional: false]}, {:file_system, "~> 0.2.8", [hex: :file_system, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}], "hexpm", "6839fcf63d1f0d1c0f450abc8564a57c43d644077ab96f2934563e68b8a769d7"},
	"crontab": {:hex, :crontab, "1.1.8", "2ce0e74777dfcadb28a1debbea707e58b879e6aa0ffbf9c9bb540887bce43617", [:mix], [{:ecto, "~> 1.0 or ~> 2.0 or ~> 3.0", [hex: :ecto, repo: "hexpm", optional: true]}], "hexpm"},
	"custom_base": {:hex, :custom_base, "0.2.1", "4a832a42ea0552299d81652aa0b1f775d462175293e99dfbe4d7dbaab785a706", [:mix], [], "hexpm", "8df019facc5ec9603e94f7270f1ac73ddf339f56ade76a721eaa57c1493ba463"},
	"db_connection": {:hex, :db_connection, "2.6.0", "77d835c472b5b67fc4f29556dee74bf511bbafecdcaf98c27d27fa5918152086", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "c2f992d15725e721ec7fbc1189d4ecdb8afef76648c746a8e1cad35e3b8a35f3"},
	"decimal": {:hex, :decimal, "2.1.1", "5611dca5d4b2c3dd497dec8f68751f1f1a54755e8ed2a966c2633cf885973ad6", [:mix], [], "hexpm", "53cfe5f497ed0e7771ae1a475575603d77425099ba5faef9394932b35020ffcc"},
	"deep_merge": {:hex, :deep_merge, "1.0.0", "b4aa1a0d1acac393bdf38b2291af38cb1d4a52806cf7a4906f718e1feb5ee961", [:mix], [], "hexpm", "ce708e5f094b9cd4e8f2be4f00d2f4250c4095be93f8cd6d018c753894885430"},
	"earmark": {:hex, :earmark, "1.4.22", "ea3e45c6359446dc308be0a64ce82a03260d973de7d0625a762e6d352ff57958", [:mix], [{:earmark_parser, "~> 1.4.23", [hex: :earmark_parser, repo: "hexpm", optional: false]}], "hexpm", "1caf5145665a42fd76d5317286b0c171861fb1c04f86ab103dde76868814fdfb"},
	"earmark_parser": {:hex, :earmark_parser, "1.4.32", "fa739a0ecfa34493de19426681b23f6814573faee95dfd4b4aafe15a7b5b32c6", [:mix], [], "hexpm", "b8b0dd77d60373e77a3d7e8afa598f325e49e8663a51bcc2b88ef41838cca755"},
	- "eblurhash": {:hex, :eblurhash, "1.2.2", "7da4255aaea984b31bb71155f673257353b0e0554d0d30dcf859547e74602582", [:rebar3], [], "hexpm", "8c20ca00904de023a835a9dcb7b7762fed32264c85a80c3cafa85288e405044c"},
	+ "eblurhash": {:git, "https://github.com/zotonic/eblurhash.git", "bc37ceb426ef021ee9927fb249bb93f7059194ab", [ref: "bc37ceb426ef021ee9927fb249bb93f7059194ab"]},
	"ecto": {:hex, :ecto, "3.10.3", "eb2ae2eecd210b4eb8bece1217b297ad4ff824b4384c0e3fdd28aaf96edd6135", [:mix], [{:decimal, "~> 1.6 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "44bec74e2364d491d70f7e42cd0d690922659d329f6465e89feb8a34e8cd3433"},
	"ecto_enum": {:hex, :ecto_enum, "1.4.0", "d14b00e04b974afc69c251632d1e49594d899067ee2b376277efd8233027aec8", [:mix], [{:ecto, ">= 3.0.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:ecto_sql, "> 3.0.0", [hex: :ecto_sql, repo: "hexpm", optional: false]}, {:mariaex, ">= 0.0.0", [hex: :mariaex, repo: "hexpm", optional: true]}, {:postgrex, ">= 0.0.0", [hex: :postgrex, repo: "hexpm", optional: true]}], "hexpm", "8fb55c087181c2b15eee406519dc22578fa60dd82c088be376d0010172764ee4"},
	"ecto_psql_extras": {:hex, :ecto_psql_extras, "0.7.14", "7a20cfe913b0476542b43870e67386461258734896035e3f284039fd18bd4c4c", [:mix], [{:ecto_sql, "~> 3.7", [hex: :ecto_sql, repo: "hexpm", optional: false]}, {:postgrex, "~> 0.16.0 or ~> 0.17.0", [hex: :postgrex, repo: "hexpm", optional: false]}, {:table_rex, "~> 3.1.1", [hex: :table_rex, repo: "hexpm", optional: false]}], "hexpm", "22f5f98592dd597db9416fcef00effae0787669fdcb6faf447e982b553798e98"},
	"ecto_sql": {:hex, :ecto_sql, "3.10.2", "6b98b46534b5c2f8b8b5f03f126e75e2a73c64f3c071149d32987a5378b0fdbd", [:mix], [{:db_connection, "~> 2.4.1 or ~> 2.5", [hex: :db_connection, repo: "hexpm", optional: false]}, {:ecto, "~> 3.10.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:myxql, "~> 0.6.0", [hex: :myxql, repo: "hexpm", optional: true]}, {:postgrex, "~> 0.16.0 or ~> 0.17.0 or ~> 1.0", [hex: :postgrex, repo: "hexpm", optional: true]}, {:tds, "~> 2.1.1 or ~> 2.2", [hex: :tds, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.0 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "68c018debca57cb9235e3889affdaec7a10616a4e3a80c99fa1d01fdafaa9007"},
	"eimp": {:hex, :eimp, "1.0.14", "fc297f0c7e2700457a95a60c7010a5f1dcb768a083b6d53f49cd94ab95a28f22", [:rebar3], [{:p1_utils, "1.0.18", [hex: :p1_utils, repo: "hexpm", optional: false]}], "hexpm", "501133f3112079b92d9e22da8b88bf4f0e13d4d67ae9c15c42c30bd25ceb83b6"},
	- "elixir_make": {:hex, :elixir_make, "0.6.3", "bc07d53221216838d79e03a8019d0839786703129599e9619f4ab74c8c096eac", [:mix], [], "hexpm", "f5cbd651c5678bcaabdbb7857658ee106b12509cd976c2c2fca99688e1daf716"},
	+ "elixir_make": {:hex, :elixir_make, "0.7.7", "7128c60c2476019ed978210c245badf08b03dbec4f24d05790ef791da11aa17c", [:mix], [{:castore, "~> 0.1 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: true]}], "hexpm", "5bc19fff950fad52bbe5f211b12db9ec82c6b34a9647da0c2224b8b8464c7e6c"},
	"esbuild": {:hex, :esbuild, "0.5.0", "d5bb08ff049d7880ee3609ed5c4b864bd2f46445ea40b16b4acead724fb4c4a3", [:mix], [{:castore, ">= 0.0.0", [hex: :castore, repo: "hexpm", optional: false]}], "hexpm", "f183a0b332d963c4cfaf585477695ea59eef9a6f2204fdd0efa00e099694ffe5"},
	"eternal": {:hex, :eternal, "1.2.2", "d1641c86368de99375b98d183042dd6c2b234262b8d08dfd72b9eeaafc2a1abd", [:mix], [], "hexpm", "2c9fe32b9c3726703ba5e1d43a1d255a4f3f2d8f8f9bc19f094c7cb1a7a9e782"},
	"ex_aws": {:hex, :ex_aws, "2.1.9", "dc4865ecc20a05190a34a0ac5213e3e5e2b0a75a0c2835e923ae7bfeac5e3c31", [:mix], [{:configparser_ex, "~> 4.0", [hex: :configparser_ex, repo: "hexpm", optional: true]}, {:hackney, "~> 1.9", [hex: :hackney, repo: "hexpm", optional: true]}, {:jason, "~> 1.1", [hex: :jason, repo: "hexpm", optional: true]}, {:jsx, "~> 3.0", [hex: :jsx, repo: "hexpm", optional: true]}, {:sweet_xml, "~> 0.6", [hex: :sweet_xml, repo: "hexpm", optional: true]}], "hexpm", "3e6c776703c9076001fbe1f7c049535f042cb2afa0d2cbd3b47cbc4e92ac0d10"},
	"ex_aws_s3": {:hex, :ex_aws_s3, "2.4.0", "ce8decb6b523381812798396bc0e3aaa62282e1b40520125d1f4eff4abdff0f4", [:mix], [{:ex_aws, "~> 2.0", [hex: :ex_aws, repo: "hexpm", optional: false]}, {:sweet_xml, ">= 0.0.0", [hex: :sweet_xml, repo: "hexpm", optional: true]}], "hexpm", "85dda6e27754d94582869d39cba3241d9ea60b6aa4167f9c88e309dc687e56bb"},
	"ex_const": {:hex, :ex_const, "0.2.4", "d06e540c9d834865b012a17407761455efa71d0ce91e5831e86881b9c9d82448", [:mix], [], "hexpm", "96fd346610cc992b8f896ed26a98be82ac4efb065a0578f334a32d60a3ba9767"},
	"ex_doc": {:hex, :ex_doc, "0.29.4", "6257ecbb20c7396b1fe5accd55b7b0d23f44b6aa18017b415cb4c2b91d997729", [:mix], [{:earmark_parser, "~> 1.4.31", [hex: :earmark_parser, repo: "hexpm", optional: false]}, {:makeup_elixir, "~> 0.14", [hex: :makeup_elixir, repo: "hexpm", optional: false]}, {:makeup_erlang, "~> 0.1", [hex: :makeup_erlang, repo: "hexpm", optional: false]}], "hexpm", "2c6699a737ae46cb61e4ed012af931b57b699643b24dabe2400a8168414bc4f5"},
	"ex_machina": {:hex, :ex_machina, "2.7.0", "b792cc3127fd0680fecdb6299235b4727a4944a09ff0fa904cc639272cd92dc7", [:mix], [{:ecto, "~> 2.2 or ~> 3.0", [hex: :ecto, repo: "hexpm", optional: true]}, {:ecto_sql, "~> 3.0", [hex: :ecto_sql, repo: "hexpm", optional: true]}], "hexpm", "419aa7a39bde11894c87a615c4ecaa52d8f107bbdd81d810465186f783245bf8"},
	"ex_syslogger": {:hex, :ex_syslogger, "1.5.2", "72b6aa2d47a236e999171f2e1ec18698740f40af0bd02c8c650bf5f1fd1bac79", [:mix], [{:poison, ">= 1.5.0", [hex: :poison, repo: "hexpm", optional: true]}, {:syslog, "~> 1.1.0", [hex: :syslog, repo: "hexpm", optional: false]}], "hexpm", "ab9fab4136dbc62651ec6f16fa4842f10cf02ab4433fa3d0976c01be99398399"},
	"expo": {:hex, :expo, "0.4.1", "1c61d18a5df197dfda38861673d392e642649a9cef7694d2f97a587b2cfb319b", [:mix], [], "hexpm", "2ff7ba7a798c8c543c12550fa0e2cbc81b95d4974c65855d8d15ba7b37a1ce47"},
	"fast_html": {:hex, :fast_html, "2.0.5", "c61760340606c1077ff1f196f17834056cb1dd3d5cb92a9f2cabf28bc6221c3c", [:make, :mix], [{:elixir_make, "~> 0.4", [hex: :elixir_make, repo: "hexpm", optional: false]}, {:nimble_pool, "~> 0.2.0", [hex: :nimble_pool, repo: "hexpm", optional: false]}], "hexpm", "605f4f4829443c14127694ebabb681778712ceecb4470ec32aa31012330e6506"},
	"fast_sanitize": {:hex, :fast_sanitize, "0.2.3", "67b93dfb34e302bef49fec3aaab74951e0f0602fd9fa99085987af05bd91c7a5", [:mix], [{:fast_html, "~> 2.0", [hex: :fast_html, repo: "hexpm", optional: false]}, {:plug, "~> 1.8", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "e8ad286d10d0386e15d67d0ee125245ebcfbc7d7290b08712ba9013c8c5e56e2"},
	"file_system": {:hex, :file_system, "0.2.10", "fb082005a9cd1711c05b5248710f8826b02d7d1784e7c3451f9c1231d4fc162d", [:mix], [], "hexpm", "41195edbfb562a593726eda3b3e8b103a309b733ad25f3d642ba49696bf715dc"},
	- "finch": {:hex, :finch, "0.10.2", "9ad27d68270d879f73f26604bb2e573d40f29bf0e907064a9a337f90a16a0312", [:mix], [{:castore, "~> 0.1", [hex: :castore, repo: "hexpm", optional: false]}, {:mint, "~> 1.3", [hex: :mint, repo: "hexpm", optional: false]}, {:nimble_options, "~> 0.4.0", [hex: :nimble_options, repo: "hexpm", optional: false]}, {:nimble_pool, "~> 0.2", [hex: :nimble_pool, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "dd8b11b282072cec2ef30852283949c248bd5d2820c88d8acc89402b81db7550"},
	+ "finch": {:hex, :finch, "0.16.0", "40733f02c89f94a112518071c0a91fe86069560f5dbdb39f9150042f44dcfb1a", [:mix], [{:castore, "~> 0.1 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: false]}, {:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:mint, "~> 1.3", [hex: :mint, repo: "hexpm", optional: false]}, {:nimble_options, "~> 0.4 or ~> 1.0", [hex: :nimble_options, repo: "hexpm", optional: false]}, {:nimble_pool, "~> 0.2.6 or ~> 1.0", [hex: :nimble_pool, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "f660174c4d519e5fec629016054d60edd822cdfe2b7270836739ac2f97735ec5"},
	"flake_id": {:hex, :flake_id, "0.1.0", "7716b086d2e405d09b647121a166498a0d93d1a623bead243e1f74216079ccb3", [:mix], [{:base62, "~> 1.2", [hex: :base62, repo: "hexpm", optional: false]}, {:ecto, ">= 2.0.0", [hex: :ecto, repo: "hexpm", optional: true]}], "hexpm", "31fc8090fde1acd267c07c36ea7365b8604055f897d3a53dd967658c691bd827"},
	"floki": {:hex, :floki, "0.34.3", "5e2dcaec5d7c228ce5b1d3501502e308b2d79eb655e4191751a1fe491c37feac", [:mix], [], "hexpm", "9577440eea5b97924b4bf3c7ea55f7b8b6dce589f9b28b096cc294a8dc342341"},
	"gen_smtp": {:hex, :gen_smtp, "0.15.0", "9f51960c17769b26833b50df0b96123605a8024738b62db747fece14eb2fbfcc", [:rebar3], [], "hexpm", "29bd14a88030980849c7ed2447b8db6d6c9278a28b11a44cafe41b791205440f"},
	"gettext": {:hex, :gettext, "0.22.2", "6bfca374de34ecc913a28ba391ca184d88d77810a3e427afa8454a71a51341ac", [:mix], [{:expo, "~> 0.4.0", [hex: :expo, repo: "hexpm", optional: false]}], "hexpm", "8a2d389673aea82d7eae387e6a2ccc12660610080ae7beb19452cfdc1ec30f60"},
	"gun": {:hex, :gun, "2.0.1", "160a9a5394800fcba41bc7e6d421295cf9a7894c2252c0678244948e3336ad73", [:make, :rebar3], [{:cowlib, "2.12.1", [hex: :cowlib, repo: "hexpm", optional: false]}], "hexpm", "a10bc8d6096b9502205022334f719cc9a08d9adcfbfc0dbee9ef31b56274a20b"},
	"hackney": {:hex, :hackney, "1.18.1", "f48bf88f521f2a229fc7bae88cf4f85adc9cd9bcf23b5dc8eb6a1788c662c4f6", [:rebar3], [{:certifi, "~>2.9.0", [hex: :certifi, repo: "hexpm", optional: false]}, {:idna, "~>6.1.0", [hex: :idna, repo: "hexpm", optional: false]}, {:metrics, "~>1.0.0", [hex: :metrics, repo: "hexpm", optional: false]}, {:mimerl, "~>1.1", [hex: :mimerl, repo: "hexpm", optional: false]}, {:parse_trans, "3.3.1", [hex: :parse_trans, repo: "hexpm", optional: false]}, {:ssl_verify_fun, "~>1.1.0", [hex: :ssl_verify_fun, repo: "hexpm", optional: false]}, {:unicode_util_compat, "~>0.7.0", [hex: :unicode_util_compat, repo: "hexpm", optional: false]}], "hexpm", "a4ecdaff44297e9b5894ae499e9a070ea1888c84afdd1fd9b7b2bc384950128e"},
	"hpax": {:hex, :hpax, "0.1.2", "09a75600d9d8bbd064cdd741f21fc06fc1f4cf3d0fcc335e5aa19be1a7235c84", [:mix], [], "hexpm", "2c87843d5a23f5f16748ebe77969880e29809580efdaccd615cd3bed628a8c13"},
	"html_entities": {:hex, :html_entities, "0.5.2", "9e47e70598da7de2a9ff6af8758399251db6dbb7eebe2b013f2bbd2515895c3c", [:mix], [], "hexpm", "c53ba390403485615623b9531e97696f076ed415e8d8058b1dbaa28181f4fdcc"},
	"http_signatures": {:hex, :http_signatures, "0.1.1", "ca7ebc1b61542b163644c8c3b1f0e0f41037d35f2395940d3c6c7deceab41fd8", [:mix], [], "hexpm", "cc3b8a007322cc7b624c0c15eec49ee58ac977254ff529a3c482f681465942a3"},
	"httpoison": {:hex, :httpoison, "1.8.2", "9eb9c63ae289296a544842ef816a85d881d4a31f518a0fec089aaa744beae290", [:mix], [{:hackney, "~> 1.17", [hex: :hackney, repo: "hexpm", optional: false]}], "hexpm", "2bb350d26972e30c96e2ca74a1aaf8293d61d0742ff17f01e0279fef11599921"},
	"idna": {:hex, :idna, "6.1.1", "8a63070e9f7d0c62eb9d9fcb360a7de382448200fbbd1b106cc96d3d8099df8d", [:rebar3], [{:unicode_util_compat, "~>0.7.0", [hex: :unicode_util_compat, repo: "hexpm", optional: false]}], "hexpm", "92376eb7894412ed19ac475e4a86f7b413c1b9fbb5bd16dccd57934157944cea"},
	"inet_cidr": {:hex, :inet_cidr, "1.0.4", "a05744ab7c221ca8e395c926c3919a821eb512e8f36547c062f62c4ca0cf3d6e", [:mix], [], "hexpm", "64a2d30189704ae41ca7dbdd587f5291db5d1dda1414e0774c29ffc81088c1bc"},
	"jason": {:hex, :jason, "1.4.1", "af1504e35f629ddcdd6addb3513c3853991f694921b1b9368b0bd32beb9f1b63", [:mix], [{:decimal, "~> 1.0 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm", "fbb01ecdfd565b56261302f7e1fcc27c4fb8f32d56eab74db621fc154604a7a1"},
	"joken": {:hex, :joken, "2.6.0", "b9dd9b6d52e3e6fcb6c65e151ad38bf4bc286382b5b6f97079c47ade6b1bcc6a", [:mix], [{:jose, "~> 1.11.5", [hex: :jose, repo: "hexpm", optional: false]}], "hexpm", "5a95b05a71cd0b54abd35378aeb1d487a23a52c324fa7efdffc512b655b5aaa7"},
	"jose": {:hex, :jose, "1.11.5", "3bc2d75ffa5e2c941ca93e5696b54978323191988eb8d225c2e663ddfefd515e", [:mix, :rebar3], [], "hexpm", "dcd3b215bafe02ea7c5b23dafd3eb8062a5cd8f2d904fd9caa323d37034ab384"},
	"jumper": {:hex, :jumper, "1.0.1", "3c00542ef1a83532b72269fab9f0f0c82bf23a35e27d278bfd9ed0865cecabff", [:mix], [], "hexpm", "318c59078ac220e966d27af3646026db9b5a5e6703cb2aa3e26bcfaba65b7433"},
	"linkify": {:hex, :linkify, "0.5.3", "5f8143d8f61f5ff08d3aeeff47ef6509492b4948d8f08007fbf66e4d2246a7f2", [:mix], [], "hexpm", "3ef35a1377d47c25506e07c1c005ea9d38d700699d92ee92825f024434258177"},
	"majic": {:hex, :majic, "1.0.0", "37e50648db5f5c2ff0c9fb46454d034d11596c03683807b9fb3850676ffdaab3", [:make, :mix], [{:elixir_make, "~> 0.6.1", [hex: :elixir_make, repo: "hexpm", optional: false]}, {:mime, "~> 1.0", [hex: :mime, repo: "hexpm", optional: false]}, {:nimble_pool, "~> 0.2", [hex: :nimble_pool, repo: "hexpm", optional: false]}, {:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: true]}], "hexpm", "7905858f76650d49695f14ea55cd9aaaee0c6654fa391671d4cf305c275a0a9e"},
	"makeup": {:hex, :makeup, "1.0.5", "d5a830bc42c9800ce07dd97fa94669dfb93d3bf5fcf6ea7a0c67b2e0e4a7f26c", [:mix], [{:nimble_parsec, "~> 0.5 or ~> 1.0", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "cfa158c02d3f5c0c665d0af11512fed3fba0144cf1aadee0f2ce17747fba2ca9"},
	"makeup_elixir": {:hex, :makeup_elixir, "0.14.1", "4f0e96847c63c17841d42c08107405a005a2680eb9c7ccadfd757bd31dabccfb", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}], "hexpm", "f2438b1a80eaec9ede832b5c41cd4f373b38fd7aa33e3b22d9db79e640cbde11"},
	"makeup_erlang": {:hex, :makeup_erlang, "0.1.2", "ad87296a092a46e03b7e9b0be7631ddcf64c790fa68a9ef5323b6cbb36affc72", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}], "hexpm", "f3f5a1ca93ce6e092d92b6d9c049bcda58a3b617a8d888f8e7231c85630e8108"},
	"meck": {:hex, :meck, "0.9.2", "85ccbab053f1db86c7ca240e9fc718170ee5bda03810a6292b5306bf31bae5f5", [:rebar3], [], "hexpm", "81344f561357dc40a8344afa53767c32669153355b626ea9fcbc8da6b3045826"},
	"metrics": {:hex, :metrics, "1.0.1", "25f094dea2cda98213cecc3aeff09e940299d950904393b2a29d191c346a8486", [:rebar3], [], "hexpm", "69b09adddc4f74a40716ae54d140f93beb0fb8978d8636eaded0c31b6f099f16"},
	"mime": {:hex, :mime, "1.6.0", "dabde576a497cef4bbdd60aceee8160e02a6c89250d6c0b29e56c0dfb00db3d2", [:mix], [], "hexpm", "31a1a8613f8321143dde1dafc36006a17d28d02bdfecb9e95a880fa7aabd19a7"},
	"mimerl": {:hex, :mimerl, "1.2.0", "67e2d3f571088d5cfd3e550c383094b47159f3eee8ffa08e64106cdf5e981be3", [:rebar3], [], "hexpm", "f278585650aa581986264638ebf698f8bb19df297f66ad91b18910dfc6e19323"},
	"mint": {:hex, :mint, "1.5.1", "8db5239e56738552d85af398798c80648db0e90f343c8469f6c6d8898944fb6f", [:mix], [{:castore, "~> 0.1.0 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: true]}, {:hpax, "~> 0.1.1", [hex: :hpax, repo: "hexpm", optional: false]}], "hexpm", "4a63e1e76a7c3956abd2c72f370a0d0aecddc3976dea5c27eccbecfa5e7d5b1e"},
	"mochiweb": {:hex, :mochiweb, "2.18.0", "eb55f1db3e6e960fac4e6db4e2db9ec3602cc9f30b86cd1481d56545c3145d2e", [:rebar3], [], "hexpm"},
	"mock": {:hex, :mock, "0.3.8", "7046a306b71db2488ef54395eeb74df0a7f335a7caca4a3d3875d1fc81c884dd", [:mix], [{:meck, "~> 0.9.2", [hex: :meck, repo: "hexpm", optional: false]}], "hexpm", "7fa82364c97617d79bb7d15571193fc0c4fe5afd0c932cef09426b3ee6fe2022"},
	- "mogrify": {:hex, :mogrify, "0.9.3", "238c782f00271dace01369ad35ae2e9dd020feee3443b9299ea5ea6bed559841", [:mix], [], "hexpm", "0189b1e1de27455f2b9ae8cf88239cefd23d38de9276eb5add7159aea51731e6"},
	+ "mogrify": {:hex, :mogrify, "0.8.0", "3506f3ca3f7b95a155f3b4ef803b5db176f5a0633723e3fe85e0d6399e3b11c8", [:mix], [], "hexpm", "2278d245f07056ea3b586e98801e933695147066fa4cf563f552c1b4f0ff8ad9"},
	"mox": {:hex, :mox, "1.0.2", "dc2057289ac478b35760ba74165b4b3f402f68803dd5aecd3bfd19c183815d64", [:mix], [], "hexpm", "f9864921b3aaf763c8741b5b8e6f908f44566f1e427b2630e89e9a73b981fef2"},
	- "nimble_options": {:hex, :nimble_options, "0.4.0", "c89babbab52221a24b8d1ff9e7d838be70f0d871be823165c94dd3418eea728f", [:mix], [], "hexpm", "e6701c1af326a11eea9634a3b1c62b475339ace9456c1a23ec3bc9a847bca02d"},
	+ "nimble_options": {:hex, :nimble_options, "1.0.2", "92098a74df0072ff37d0c12ace58574d26880e522c22801437151a159392270e", [:mix], [], "hexpm", "fd12a8db2021036ce12a309f26f564ec367373265b53e25403f0ee697380f1b8"},
	"nimble_parsec": {:hex, :nimble_parsec, "0.6.0", "32111b3bf39137144abd7ba1cce0914533b2d16ef35e8abc5ec8be6122944263", [:mix], [], "hexpm", "27eac315a94909d4dc68bc07a4a83e06c8379237c5ea528a9acff4ca1c873c52"},
	"nimble_pool": {:hex, :nimble_pool, "0.2.6", "91f2f4c357da4c4a0a548286c84a3a28004f68f05609b4534526871a22053cde", [:mix], [], "hexpm", "1c715055095d3f2705c4e236c18b618420a35490da94149ff8b580a2144f653f"},
	"nodex": {:git, "https://git.pleroma.social/pleroma/nodex", "cb6730f943cfc6aad674c92161be23a8411f15d1", [ref: "cb6730f943cfc6aad674c92161be23a8411f15d1"]},
	"oban": {:hex, :oban, "2.13.6", "a0cb1bce3bd393770512231fb5a3695fa19fd3af10d7575bf73f837aee7abf43", [:mix], [{:ecto_sql, "~> 3.6", [hex: :ecto_sql, repo: "hexpm", optional: false]}, {:jason, "~> 1.1", [hex: :jason, repo: "hexpm", optional: false]}, {:postgrex, "~> 0.16", [hex: :postgrex, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "3c1c5eb16f377b3cbbf2ea14be24d20e3d91285af9d1ac86260b7c2af5464887"},
	+ "octo_fetch": {:hex, :octo_fetch, "0.3.0", "89ff501d2ac0448556ff1931634a538fe6d6cd358ba827ce1747e6a42a46efbf", [:mix], [{:castore, "~> 0.1 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: false]}], "hexpm", "c07e44f2214ab153743b7b3182f380798d0b294b1f283811c1e30cff64096d3d"},
	"open_api_spex": {:hex, :open_api_spex, "3.17.3", "ada8e352eb786050dd639db2439d3316e92f3798eb2abd051f55bb9af825b37e", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:plug, "~> 1.7", [hex: :plug, repo: "hexpm", optional: false]}, {:poison, "~> 3.0 or ~> 4.0 or ~> 5.0", [hex: :poison, repo: "hexpm", optional: true]}, {:ymlr, "~> 2.0 or ~> 3.0", [hex: :ymlr, repo: "hexpm", optional: true]}], "hexpm", "165db21a85ca83cffc8e7c8890f35b354eddda8255de7404a2848ed652b9f0fe"},
	"parse_trans": {:hex, :parse_trans, "3.3.1", "16328ab840cc09919bd10dab29e431da3af9e9e7e7e6f0089dd5a2d2820011d8", [:rebar3], [], "hexpm", "07cd9577885f56362d414e8c4c4e6bdf10d43a8767abb92d24cbe8b24c54888b"},
	"pbkdf2_elixir": {:hex, :pbkdf2_elixir, "1.2.1", "9cbe354b58121075bd20eb83076900a3832324b7dd171a6895fab57b6bb2752c", [:mix], [{:comeonin, "~> 5.3", [hex: :comeonin, repo: "hexpm", optional: false]}], "hexpm", "d3b40a4a4630f0b442f19eca891fcfeeee4c40871936fed2f68e1c4faa30481f"},
	"phoenix": {:hex, :phoenix, "1.7.10", "02189140a61b2ce85bb633a9b6fd02dff705a5f1596869547aeb2b2b95edd729", [:mix], [{:castore, ">= 0.0.0", [hex: :castore, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix_pubsub, "~> 2.1", [hex: :phoenix_pubsub, repo: "hexpm", optional: false]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}, {:phoenix_view, "~> 2.0", [hex: :phoenix_view, repo: "hexpm", optional: true]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.6", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:plug_crypto, "~> 1.2 or ~> 2.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:websock_adapter, "~> 0.5.3", [hex: :websock_adapter, repo: "hexpm", optional: false]}], "hexpm", "cf784932e010fd736d656d7fead6a584a4498efefe5b8227e9f383bf15bb79d0"},
	"phoenix_ecto": {:hex, :phoenix_ecto, "4.4.2", "b21bd01fdeffcfe2fab49e4942aa938b6d3e89e93a480d4aee58085560a0bc0d", [:mix], [{:ecto, "~> 3.5", [hex: :ecto, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 2.14.2 or ~> 3.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:plug, "~> 1.9", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "70242edd4601d50b69273b057ecf7b684644c19ee750989fd555625ae4ce8f5d"},
	"phoenix_html": {:hex, :phoenix_html, "3.3.3", "380b8fb45912b5638d2f1d925a3771b4516b9a78587249cabe394e0a5d579dc9", [:mix], [{:plug, "~> 1.5", [hex: :plug, repo: "hexpm", optional: true]}], "hexpm", "923ebe6fec6e2e3b3e569dfbdc6560de932cd54b000ada0208b5f45024bdd76c"},
	"phoenix_live_dashboard": {:hex, :phoenix_live_dashboard, "0.8.3", "7ff51c9b6609470f681fbea20578dede0e548302b0c8bdf338b5a753a4f045bf", [:mix], [{:ecto, "~> 3.6.2 or ~> 3.7", [hex: :ecto, repo: "hexpm", optional: true]}, {:ecto_mysql_extras, "~> 0.5", [hex: :ecto_mysql_extras, repo: "hexpm", optional: true]}, {:ecto_psql_extras, "~> 0.7", [hex: :ecto_psql_extras, repo: "hexpm", optional: true]}, {:ecto_sqlite3_extras, "~> 1.1.7 or ~> 1.2.0", [hex: :ecto_sqlite3_extras, repo: "hexpm", optional: true]}, {:mime, "~> 1.6 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:phoenix_live_view, "~> 0.19 or ~> 1.0", [hex: :phoenix_live_view, repo: "hexpm", optional: false]}, {:telemetry_metrics, "~> 0.6 or ~> 1.0", [hex: :telemetry_metrics, repo: "hexpm", optional: false]}], "hexpm", "f9470a0a8bae4f56430a23d42f977b5a6205fdba6559d76f932b876bfaec652d"},
	"phoenix_live_reload": {:hex, :phoenix_live_reload, "1.3.3", "3a53772a6118d5679bf50fc1670505a290e32a1d195df9e069d8c53ab040c054", [:mix], [{:file_system, "~> 0.2.1 or ~> 0.3", [hex: :file_system, repo: "hexpm", optional: false]}, {:phoenix, "~> 1.4", [hex: :phoenix, repo: "hexpm", optional: false]}], "hexpm", "766796676e5f558dbae5d1bdb066849673e956005e3730dfd5affd7a6da4abac"},
	"phoenix_live_view": {:hex, :phoenix_live_view, "0.19.5", "6e730595e8e9b8c5da230a814e557768828fd8dfeeb90377d2d8dbb52d4ec00a", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix, "~> 1.6.15 or ~> 1.7.0", [hex: :phoenix, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 3.3", [hex: :phoenix_html, repo: "hexpm", optional: false]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}, {:phoenix_view, "~> 2.0", [hex: :phoenix_view, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.2 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "b2eaa0dd3cfb9bd7fb949b88217df9f25aed915e986a28ad5c8a0d054e7ca9d3"},
	"phoenix_pubsub": {:hex, :phoenix_pubsub, "2.1.3", "3168d78ba41835aecad272d5e8cd51aa87a7ac9eb836eabc42f6e57538e3731d", [:mix], [], "hexpm", "bba06bc1dcfd8cb086759f0edc94a8ba2bc8896d5331a1e2c2902bf8e36ee502"},
	"phoenix_swoosh": {:hex, :phoenix_swoosh, "1.2.0", "a544d83fde4a767efb78f45404a74c9e37b2a9c5ea3339692e65a6966731f935", [:mix], [{:finch, "~> 0.8", [hex: :finch, repo: "hexpm", optional: true]}, {:hackney, "~> 1.10", [hex: :hackney, repo: "hexpm", optional: true]}, {:phoenix, "~> 1.6", [hex: :phoenix, repo: "hexpm", optional: true]}, {:phoenix_html, "~> 3.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:phoenix_view, "~> 1.0 or ~> 2.0", [hex: :phoenix_view, repo: "hexpm", optional: false]}, {:swoosh, "~> 1.5", [hex: :swoosh, repo: "hexpm", optional: false]}], "hexpm", "e88d117251e89a16b92222415a6d87b99a96747ddf674fc5c7631de734811dba"},
	"phoenix_template": {:hex, :phoenix_template, "1.0.3", "32de561eefcefa951aead30a1f94f1b5f0379bc9e340bb5c667f65f1edfa4326", [:mix], [{:phoenix_html, "~> 2.14.2 or ~> 3.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}], "hexpm", "16f4b6588a4152f3cc057b9d0c0ba7e82ee23afa65543da535313ad8d25d8e2c"},
	"phoenix_view": {:hex, :phoenix_view, "2.0.3", "4d32c4817fce933693741deeb99ef1392619f942633dde834a5163124813aad3", [:mix], [{:phoenix_html, "~> 2.14.2 or ~> 3.0 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}], "hexpm", "cd34049af41be2c627df99cd4eaa71fc52a328c0c3d8e7d4aa28f880c30e7f64"},
	"plug": {:hex, :plug, "1.15.1", "b7efd81c1a1286f13efb3f769de343236bd8b7d23b4a9f40d3002fc39ad8f74c", [:mix], [{:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_crypto, "~> 1.1.1 or ~> 1.2 or ~> 2.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.3 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "459497bd94d041d98d948054ec6c0b76feacd28eec38b219ca04c0de13c79d30"},
	"plug_cowboy": {:hex, :plug_cowboy, "2.6.1", "9a3bbfceeb65eff5f39dab529e5cd79137ac36e913c02067dba3963a26efe9b2", [:mix], [{:cowboy, "~> 2.7", [hex: :cowboy, repo: "hexpm", optional: false]}, {:cowboy_telemetry, "~> 0.3", [hex: :cowboy_telemetry, repo: "hexpm", optional: false]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "de36e1a21f451a18b790f37765db198075c25875c64834bcc82d90b309eb6613"},
	"plug_crypto": {:hex, :plug_crypto, "2.0.0", "77515cc10af06645abbfb5e6ad7a3e9714f805ae118fa1a70205f80d2d70fe73", [:mix], [], "hexpm", "53695bae57cc4e54566d993eb01074e4d894b65a3766f1c43e2c61a1b0f45ea9"},
	"plug_static_index_html": {:hex, :plug_static_index_html, "1.0.0", "840123d4d3975585133485ea86af73cb2600afd7f2a976f9f5fd8b3808e636a0", [:mix], [{:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "79fd4fcf34d110605c26560cbae8f23c603ec4158c08298bd4360fdea90bb5cf"},
	"poison": {:hex, :poison, "3.1.0", "d9eb636610e096f86f25d9a46f35a9facac35609a7591b3be3326e99a0484665", [:mix], [], "hexpm", "fec8660eb7733ee4117b85f55799fd3833eb769a6df71ccf8903e8dc5447cfce"},
	"poolboy": {:hex, :poolboy, "1.5.2", "392b007a1693a64540cead79830443abf5762f5d30cf50bc95cb2c1aaafa006b", [:rebar3], [], "hexpm", "dad79704ce5440f3d5a3681c8590b9dc25d1a561e8f5a9c995281012860901e3"},
	"postgrex": {:hex, :postgrex, "0.17.3", "c92cda8de2033a7585dae8c61b1d420a1a1322421df84da9a82a6764580c503d", [:mix], [{:db_connection, "~> 2.1", [hex: :db_connection, repo: "hexpm", optional: false]}, {:decimal, "~> 1.5 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:table, "~> 0.1.0", [hex: :table, repo: "hexpm", optional: true]}], "hexpm", "946cf46935a4fdca7a81448be76ba3503cff082df42c6ec1ff16a4bdfbfb098d"},
	"pot": {:hex, :pot, "1.0.2", "13abb849139fdc04ab8154986abbcb63bdee5de6ed2ba7e1713527e33df923dd", [:rebar3], [], "hexpm", "78fe127f5a4f5f919d6ea5a2a671827bd53eb9d37e5b4128c0ad3df99856c2e0"},
	- "prom_ex": {:hex, :prom_ex, "1.7.1", "39331ee3fe6f9a8587d8208bf9274a253bb80281700e127dd18786cda5e08c37", [:mix], [{:absinthe, ">= 1.6.0", [hex: :absinthe, repo: "hexpm", optional: true]}, {:broadway, ">= 1.0.2", [hex: :broadway, repo: "hexpm", optional: true]}, {:ecto, ">= 3.5.0", [hex: :ecto, repo: "hexpm", optional: true]}, {:finch, "~> 0.10.2", [hex: :finch, repo: "hexpm", optional: false]}, {:jason, "~> 1.2", [hex: :jason, repo: "hexpm", optional: false]}, {:oban, ">= 2.4.0", [hex: :oban, repo: "hexpm", optional: true]}, {:phoenix, ">= 1.5.0", [hex: :phoenix, repo: "hexpm", optional: true]}, {:phoenix_live_view, ">= 0.14.0", [hex: :phoenix_live_view, repo: "hexpm", optional: true]}, {:plug, ">= 1.12.1", [hex: :plug, repo: "hexpm", optional: true]}, {:plug_cowboy, "~> 2.5.1", [hex: :plug_cowboy, repo: "hexpm", optional: false]}, {:telemetry, "~> 1.0.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:telemetry_metrics, "~> 0.6.1", [hex: :telemetry_metrics, repo: "hexpm", optional: false]}, {:telemetry_metrics_prometheus_core, "~> 1.0.2", [hex: :telemetry_metrics_prometheus_core, repo: "hexpm", optional: false]}, {:telemetry_poller, "~> 1.0.0", [hex: :telemetry_poller, repo: "hexpm", optional: false]}], "hexpm", "4c978872b88a929833925a0f4d0561824804c671fdd04581e765509ed0a6ed08"},
	+ "prom_ex": {:hex, :prom_ex, "1.9.0", "63e6dda6c05cdeec1f26c48443dcc38ffd2118b3665ae8d2bd0e5b79f2aea03e", [:mix], [{:absinthe, ">= 1.6.0", [hex: :absinthe, repo: "hexpm", optional: true]}, {:broadway, ">= 1.0.2", [hex: :broadway, repo: "hexpm", optional: true]}, {:ecto, ">= 3.5.0", [hex: :ecto, repo: "hexpm", optional: true]}, {:finch, "~> 0.15", [hex: :finch, repo: "hexpm", optional: false]}, {:jason, "~> 1.2", [hex: :jason, repo: "hexpm", optional: false]}, {:oban, ">= 2.4.0", [hex: :oban, repo: "hexpm", optional: true]}, {:octo_fetch, "~> 0.3", [hex: :octo_fetch, repo: "hexpm", optional: false]}, {:phoenix, ">= 1.5.0", [hex: :phoenix, repo: "hexpm", optional: true]}, {:phoenix_live_view, ">= 0.14.0", [hex: :phoenix_live_view, repo: "hexpm", optional: true]}, {:plug, ">= 1.12.1", [hex: :plug, repo: "hexpm", optional: true]}, {:plug_cowboy, "~> 2.5", [hex: :plug_cowboy, repo: "hexpm", optional: false]}, {:telemetry, ">= 1.0.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:telemetry_metrics, "~> 0.6", [hex: :telemetry_metrics, repo: "hexpm", optional: false]}, {:telemetry_metrics_prometheus_core, "~> 1.0", [hex: :telemetry_metrics_prometheus_core, repo: "hexpm", optional: false]}, {:telemetry_poller, "~> 1.0", [hex: :telemetry_poller, repo: "hexpm", optional: false]}], "hexpm", "01f3d4f69ec93068219e686cc65e58a29c42bea5429a8ff4e2121f19db178ee6"},
	"prometheus": {:hex, :prometheus, "4.10.0", "792adbf0130ff61b5fa8826f013772af24b6e57b984445c8d602c8a0355704a1", [:mix, :rebar3], [{:quantile_estimator, "~> 0.2.1", [hex: :quantile_estimator, repo: "hexpm", optional: false]}], "hexpm", "2a99bb6dce85e238c7236fde6b0064f9834dc420ddbd962aac4ea2a3c3d59384"},
	"prometheus_ecto": {:hex, :prometheus_ecto, "1.4.3", "3dd4da1812b8e0dbee81ea58bb3b62ed7588f2eae0c9e97e434c46807ff82311", [:mix], [{:ecto, "~> 2.0 or ~> 3.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:prometheus_ex, "~> 1.1 or ~> 2.0 or ~> 3.0", [hex: :prometheus_ex, repo: "hexpm", optional: false]}], "hexpm", "8d66289f77f913b37eda81fd287340c17e61a447549deb28efc254532b2bed82"},
	"prometheus_ex": {:git, "https://github.com/lanodan/prometheus.ex.git", "31f7fbe4b71b79ba27efc2a5085746c4011ceb8f", [branch: "fix/elixir-1.14"]},
	"prometheus_phoenix": {:hex, :prometheus_phoenix, "1.3.0", "c4b527e0b3a9ef1af26bdcfbfad3998f37795b9185d475ca610fe4388fdd3bb5", [:mix], [{:phoenix, "~> 1.4", [hex: :phoenix, repo: "hexpm", optional: false]}, {:prometheus_ex, "~> 1.3 or ~> 2.0 or ~> 3.0", [hex: :prometheus_ex, repo: "hexpm", optional: false]}], "hexpm", "c4d1404ac4e9d3d963da601db2a7d8ea31194f0017057fabf0cfb9bf5a6c8c75"},
	"prometheus_phx": {:git, "https://git.pleroma.social/pleroma/elixir-libraries/prometheus-phx.git", "9cd8f248c9381ffedc799905050abce194a97514", [branch: "no-logging"]},
	"prometheus_plugs": {:hex, :prometheus_plugs, "1.1.5", "25933d48f8af3a5941dd7b621c889749894d8a1082a6ff7c67cc99dec26377c5", [:mix], [{:accept, "~> 0.1", [hex: :accept, repo: "hexpm", optional: false]}, {:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: false]}, {:prometheus_ex, "~> 1.1 or ~> 2.0 or ~> 3.0", [hex: :prometheus_ex, repo: "hexpm", optional: false]}, {:prometheus_process_collector, "~> 1.1", [hex: :prometheus_process_collector, repo: "hexpm", optional: true]}], "hexpm", "0273a6483ccb936d79ca19b0ab629aef0dba958697c94782bb728b920dfc6a79"},
	"quantile_estimator": {:hex, :quantile_estimator, "0.2.1", "ef50a361f11b5f26b5f16d0696e46a9e4661756492c981f7b2229ef42ff1cd15", [:rebar3], [], "hexpm", "282a8a323ca2a845c9e6f787d166348f776c1d4a41ede63046d72d422e3da946"},
	"ranch": {:hex, :ranch, "1.8.0", "8c7a100a139fd57f17327b6413e4167ac559fbc04ca7448e9be9057311597a1d", [:make, :rebar3], [], "hexpm", "49fbcfd3682fab1f5d109351b61257676da1a2fdbe295904176d5e521a2ddfe5"},
	"recon": {:hex, :recon, "2.5.3", "739107b9050ea683c30e96de050bc59248fd27ec147696f79a8797ff9fa17153", [:mix, :rebar3], [], "hexpm", "6c6683f46fd4a1dfd98404b9f78dcabc7fcd8826613a89dcb984727a8c3099d7"},
	"remote_ip": {:git, "https://git.pleroma.social/pleroma/remote_ip.git", "b647d0deecaa3acb140854fe4bda5b7e1dc6d1c8", [ref: "b647d0deecaa3acb140854fe4bda5b7e1dc6d1c8"]},
	+ "rustler": {:hex, :rustler, "0.30.0", "cefc49922132b072853fa9b0ca4dc2ffcb452f68fb73b779042b02d545e097fb", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:toml, "~> 0.6", [hex: :toml, repo: "hexpm", optional: false]}], "hexpm", "9ef1abb6a7dda35c47cfc649e6a5a61663af6cf842a55814a554a84607dee389"},
	"sleeplocks": {:hex, :sleeplocks, "1.1.2", "d45aa1c5513da48c888715e3381211c859af34bee9b8290490e10c90bb6ff0ca", [:rebar3], [], "hexpm", "9fe5d048c5b781d6305c1a3a0f40bb3dfc06f49bf40571f3d2d0c57eaa7f59a5"},
	"ssl_verify_fun": {:hex, :ssl_verify_fun, "1.1.7", "354c321cf377240c7b8716899e182ce4890c5938111a1296add3ec74cf1715df", [:make, :mix, :rebar3], [], "hexpm", "fe4c190e8f37401d30167c8c405eda19469f34577987c76dde613e838bbc67f8"},
	"statistex": {:hex, :statistex, "1.0.0", "f3dc93f3c0c6c92e5f291704cf62b99b553253d7969e9a5fa713e5481cd858a5", [:mix], [], "hexpm", "ff9d8bee7035028ab4742ff52fc80a2aa35cece833cf5319009b52f1b5a86c27"},
	"sweet_xml": {:hex, :sweet_xml, "0.7.3", "debb256781c75ff6a8c5cbf7981146312b66f044a2898f453709a53e5031b45b", [:mix], [], "hexpm", "e110c867a1b3fe74bfc7dd9893aa851f0eed5518d0d7cad76d7baafd30e4f5ba"},
	"swoosh": {:hex, :swoosh, "1.10.3", "32f1531ee3fe4e82da8175c597bf3692938f8152eb981e0cbf57107b6c5924c1", [:mix], [{:cowboy, "~> 1.1 or ~> 2.4", [hex: :cowboy, repo: "hexpm", optional: true]}, {:ex_aws, "~> 2.1", [hex: :ex_aws, repo: "hexpm", optional: true]}, {:finch, "~> 0.6", [hex: :finch, repo: "hexpm", optional: true]}, {:gen_smtp, "~> 0.13 or ~> 1.0", [hex: :gen_smtp, repo: "hexpm", optional: true]}, {:hackney, "~> 1.9", [hex: :hackney, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:mail, "~> 0.2", [hex: :mail, repo: "hexpm", optional: true]}, {:mime, "~> 1.1 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_cowboy, ">= 1.0.0", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.2 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "8b7167d93047bac6e1a1c367bf7d899cf2e4fea0592ee04a70673548ef6091b9"},
	"syslog": {:hex, :syslog, "1.1.0", "6419a232bea84f07b56dc575225007ffe34d9fdc91abe6f1b2f254fd71d8efc2", [:rebar3], [], "hexpm", "4c6a41373c7e20587be33ef841d3de6f3beba08519809329ecc4d27b15b659e1"},
	"table_rex": {:hex, :table_rex, "3.1.1", "0c67164d1714b5e806d5067c1e96ff098ba7ae79413cc075973e17c38a587caa", [:mix], [], "hexpm", "678a23aba4d670419c23c17790f9dcd635a4a89022040df7d5d772cb21012490"},
	"telemetry": {:hex, :telemetry, "1.0.0", "0f453a102cdf13d506b7c0ab158324c337c41f1cc7548f0bc0e130bbf0ae9452", [:rebar3], [], "hexpm", "73bc09fa59b4a0284efb4624335583c528e07ec9ae76aca96ea0673850aec57a"},
	"telemetry_metrics": {:hex, :telemetry_metrics, "0.6.1", "315d9163a1d4660aedc3fee73f33f1d355dcc76c5c3ab3d59e76e3edf80eef1f", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "7be9e0871c41732c233be71e4be11b96e56177bf15dde64a8ac9ce72ac9834c6"},
	- "telemetry_metrics_prometheus_core": {:hex, :telemetry_metrics_prometheus_core, "1.0.2", "c98b1c580de637bfeac00db41b9fb91fb4c3548ee3d512a8ed7299172312eaf3", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:telemetry_metrics, "~> 0.6", [hex: :telemetry_metrics, repo: "hexpm", optional: false]}], "hexpm", "48351a0d56f80e38c997b44232b1043e0a081670d16766eee920e6254175b730"},
	+ "telemetry_metrics_prometheus_core": {:hex, :telemetry_metrics_prometheus_core, "1.1.0", "4e15f6d7dbedb3a4e3aed2262b7e1407f166fcb9c30ca3f96635dfbbef99965c", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:telemetry_metrics, "~> 0.6", [hex: :telemetry_metrics, repo: "hexpm", optional: false]}], "hexpm", "0dd10e7fe8070095df063798f82709b0a1224c31b8baf6278b423898d591a069"},
	"telemetry_poller": {:hex, :telemetry_poller, "1.0.0", "db91bb424e07f2bb6e73926fcafbfcbcb295f0193e0a00e825e589a0a47e8453", [:rebar3], [{:telemetry, "~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "b3a24eafd66c3f42da30fc3ca7dda1e9d546c12250a2d60d7b81d264fbec4f6e"},
	"tesla": {:hex, :tesla, "1.4.4", "bb89aa0c9745190930366f6a2ac612cdf2d0e4d7fff449861baa7875afd797b2", [:mix], [{:castore, "~> 0.1", [hex: :castore, repo: "hexpm", optional: true]}, {:exjsx, ">= 3.0.0", [hex: :exjsx, repo: "hexpm", optional: true]}, {:finch, "~> 0.3", [hex: :finch, repo: "hexpm", optional: true]}, {:fuse, "~> 2.4", [hex: :fuse, repo: "hexpm", optional: true]}, {:gun, "~> 1.3", [hex: :gun, repo: "hexpm", optional: true]}, {:hackney, "~> 1.6", [hex: :hackney, repo: "hexpm", optional: true]}, {:ibrowse, "4.4.0", [hex: :ibrowse, repo: "hexpm", optional: true]}, {:jason, ">= 1.0.0", [hex: :jason, repo: "hexpm", optional: true]}, {:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:mint, "~> 1.0", [hex: :mint, repo: "hexpm", optional: true]}, {:poison, ">= 1.0.0", [hex: :poison, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: true]}], "hexpm", "d5503a49f9dec1b287567ea8712d085947e247cb11b06bc54adb05bfde466457"},
	"timex": {:hex, :timex, "3.7.7", "3ed093cae596a410759104d878ad7b38e78b7c2151c6190340835515d4a46b8a", [:mix], [{:combine, "~> 0.10", [hex: :combine, repo: "hexpm", optional: false]}, {:gettext, "~> 0.10", [hex: :gettext, repo: "hexpm", optional: false]}, {:tzdata, "~> 1.0", [hex: :tzdata, repo: "hexpm", optional: false]}], "hexpm", "0ec4b09f25fe311321f9fc04144a7e3affe48eb29481d7a5583849b6c4dfa0a7"},
	+ "toml": {:hex, :toml, "0.7.0", "fbcd773caa937d0c7a02c301a1feea25612720ac3fa1ccb8bfd9d30d822911de", [:mix], [], "hexpm", "0690246a2478c1defd100b0c9b89b4ea280a22be9a7b313a8a058a2408a2fa70"},
	"trailing_format_plug": {:hex, :trailing_format_plug, "0.0.7", "64b877f912cf7273bed03379936df39894149e35137ac9509117e59866e10e45", [:mix], [{:plug, "> 0.12.0", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "bd4fde4c15f3e993a999e019d64347489b91b7a9096af68b2bdadd192afa693f"},
	"tzdata": {:hex, :tzdata, "1.0.5", "69f1ee029a49afa04ad77801febaf69385f3d3e3d1e4b56b9469025677b89a28", [:mix], [{:hackney, "~> 1.0", [hex: :hackney, repo: "hexpm", optional: false]}], "hexpm", "55519aa2a99e5d2095c1e61cc74c9be69688f8ab75c27da724eb8279ff402a5a"},
	"ueberauth": {:hex, :ueberauth, "0.10.5", "806adb703df87e55b5615cf365e809f84c20c68aa8c08ff8a416a5a6644c4b02", [:mix], [{:plug, "~> 1.5", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "3efd1f31d490a125c7ed453b926f7c31d78b97b8a854c755f5c40064bf3ac9e1"},
	"unicode_util_compat": {:hex, :unicode_util_compat, "0.7.0", "bc84380c9ab48177092f43ac89e4dfa2c6d62b40b8bd132b1059ecc7232f9a78", [:rebar3], [], "hexpm", "25eee6d67df61960cf6a794239566599b09e17e668d3700247bc498638152521"},
	"unsafe": {:hex, :unsafe, "1.0.1", "a27e1874f72ee49312e0a9ec2e0b27924214a05e3ddac90e91727bc76f8613d8", [:mix], [], "hexpm", "6c7729a2d214806450d29766abc2afaa7a2cbecf415be64f36a6691afebb50e5"},
	+ "vix": {:hex, :vix, "0.25.0", "b294ca3140c0357b262d86e9966949949844282b81923bb990668c1ee5a35337", [:make, :mix], [{:castore, "~> 0.1 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: false]}, {:cc_precompiler, "~> 0.1.4 or ~> 0.2", [hex: :cc_precompiler, repo: "hexpm", optional: false]}, {:elixir_make, "~> 0.7.3 or ~> 0.8", [hex: :elixir_make, repo: "hexpm", optional: false]}, {:kino, "~> 0.7", [hex: :kino, repo: "hexpm", optional: true]}], "hexpm", "be09c96982978bc2d0c501a73e0b65ba58ec94c1afb94e3617029d6ce7ae8c3f"},
	"web_push_encryption": {:hex, :web_push_encryption, "0.3.1", "76d0e7375142dfee67391e7690e89f92578889cbcf2879377900b5620ee4708d", [:mix], [{:httpoison, "~> 1.0", [hex: :httpoison, repo: "hexpm", optional: false]}, {:jose, "~> 1.11.1", [hex: :jose, repo: "hexpm", optional: false]}], "hexpm", "4f82b2e57622fb9337559058e8797cb0df7e7c9790793bdc4e40bc895f70e2a2"},
	"websock": {:hex, :websock, "0.5.3", "2f69a6ebe810328555b6fe5c831a851f485e303a7c8ce6c5f675abeb20ebdadc", [:mix], [], "hexpm", "6105453d7fac22c712ad66fab1d45abdf049868f253cf719b625151460b8b453"},
	"websock_adapter": {:hex, :websock_adapter, "0.5.5", "9dfeee8269b27e958a65b3e235b7e447769f66b5b5925385f5a569269164a210", [:mix], [{:bandit, ">= 0.6.0", [hex: :bandit, repo: "hexpm", optional: true]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.6", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:websock, "~> 0.5", [hex: :websock, repo: "hexpm", optional: false]}], "hexpm", "4b977ba4a01918acbf77045ff88de7f6972c2a009213c515a445c48f224ffce9"},
	"websockex": {:hex, :websockex, "0.4.3", "92b7905769c79c6480c02daacaca2ddd49de936d912976a4d3c923723b647bf0", [:mix], [], "hexpm", "95f2e7072b85a3a4cc385602d42115b73ce0b74a9121d0d6dbbf557645ac53e4"},
	}
	diff --git a/priv/repo/migrations/20220905011454_generate_unset_user_keys.exs b/priv/repo/migrations/20220905011454_generate_unset_user_keys.exs
	index 43bc7100b..580c38841 100644
	--- a/priv/repo/migrations/20220905011454_generate_unset_user_keys.exs
	+++ b/priv/repo/migrations/20220905011454_generate_unset_user_keys.exs
	@@ -1,28 +1,36 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	+defmodule User do
	+ use Ecto.Schema
	+
	+ schema "users" do
	+ field(:keys, :string)
	+ field(:local, :boolean, default: true)
	+ end
	+end
	+
	defmodule Pleroma.Repo.Migrations.GenerateUnsetUserKeys do
	use Ecto.Migration
	import Ecto.Query
	alias Pleroma.Keys
	alias Pleroma.Repo
	- alias Pleroma.User

	def change do
	query =
	from(u in User,
	where: u.local == true,
	where: is_nil(u.keys),
	select: u
	)

	Repo.stream(query)
	\|> Enum.each(fn user ->
	with {:ok, pem} <- Keys.generate_rsa_pem() do
	Ecto.Changeset.cast(user, %{keys: pem}, [:keys])
	\|> Repo.update()
	end
	end)
	end
	end
	diff --git a/test/fixtures/png_with_transparency.png b/test/fixtures/png_with_transparency.png
	new file mode 100644
	index 000000000..7963149db
	Binary files /dev/null and b/test/fixtures/png_with_transparency.png differ
	diff --git a/test/pleroma/instances/instance_test.exs b/test/pleroma/instances/instance_test.exs
	index a769f9362..6a718be21 100644
	--- a/test/pleroma/instances/instance_test.exs
	+++ b/test/pleroma/instances/instance_test.exs
	@@ -1,252 +1,244 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Instances.InstanceTest do
	alias Pleroma.Instances
	alias Pleroma.Instances.Instance
	alias Pleroma.Repo
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.Web.CommonAPI

	use Pleroma.DataCase

	import ExUnit.CaptureLog
	import Pleroma.Factory

	setup_all do: clear_config([:instance, :federation_reachability_timeout_days], 1)

	describe "set_reachable/1" do
	test "clears `unreachable_since` of existing matching Instance record having non-nil `unreachable_since`" do
	unreachable_since = NaiveDateTime.to_iso8601(NaiveDateTime.utc_now())
	instance = insert(:instance, unreachable_since: unreachable_since)

	assert {:ok, instance} = Instance.set_reachable(instance.host)
	refute instance.unreachable_since
	end

	test "keeps nil `unreachable_since` of existing matching Instance record having nil `unreachable_since`" do
	instance = insert(:instance, unreachable_since: nil)

	assert {:ok, instance} = Instance.set_reachable(instance.host)
	refute instance.unreachable_since
	end
	-
	- test "does NOT create an Instance record in case of no existing matching record" do
	- host = "domain.org"
	- assert nil == Instance.set_reachable(host)
	-
	- assert [] = Repo.all(Ecto.Query.from(i in Instance))
	- assert Instance.reachable?(host)
	- end
	end

	describe "set_unreachable/1" do
	test "creates new record having `unreachable_since` to current time if record does not exist" do
	assert {:ok, instance} = Instance.set_unreachable("https://domain.com/path")

	instance = Repo.get(Instance, instance.id)
	assert instance.unreachable_since
	assert "domain.com" == instance.host
	end

	test "sets `unreachable_since` of existing record having nil `unreachable_since`" do
	instance = insert(:instance, unreachable_since: nil)
	refute instance.unreachable_since

	assert {:ok, _} = Instance.set_unreachable(instance.host)

	instance = Repo.get(Instance, instance.id)
	assert instance.unreachable_since
	end

	test "does NOT modify `unreachable_since` value of existing record in case it's present" do
	instance =
	insert(:instance, unreachable_since: NaiveDateTime.add(NaiveDateTime.utc_now(), -10))

	assert instance.unreachable_since
	initial_value = instance.unreachable_since

	assert {:ok, _} = Instance.set_unreachable(instance.host)

	instance = Repo.get(Instance, instance.id)
	assert initial_value == instance.unreachable_since
	end
	end

	describe "set_unreachable/2" do
	test "sets `unreachable_since` value of existing record in case it's newer than supplied value" do
	instance =
	insert(:instance, unreachable_since: NaiveDateTime.add(NaiveDateTime.utc_now(), -10))

	assert instance.unreachable_since

	past_value = NaiveDateTime.add(NaiveDateTime.utc_now(), -100)
	assert {:ok, _} = Instance.set_unreachable(instance.host, past_value)

	instance = Repo.get(Instance, instance.id)
	assert past_value == instance.unreachable_since
	end

	test "does NOT modify `unreachable_since` value of existing record in case it's equal to or older than supplied value" do
	instance =
	insert(:instance, unreachable_since: NaiveDateTime.add(NaiveDateTime.utc_now(), -10))

	assert instance.unreachable_since
	initial_value = instance.unreachable_since

	assert {:ok, _} = Instance.set_unreachable(instance.host, NaiveDateTime.utc_now())

	instance = Repo.get(Instance, instance.id)
	assert initial_value == instance.unreachable_since
	end
	end

	describe "get_or_update_favicon/1" do
	test "Scrapes favicon URLs" do
	Tesla.Mock.mock(fn %{url: "https://favicon.example.org/"} ->
	%Tesla.Env{
	status: 200,
	body: ~s[<html><head><link rel="icon" href="/favicon.png"></head></html>]
	}
	end)

	assert "https://favicon.example.org/favicon.png" ==
	Instance.get_or_update_favicon(URI.parse("https://favicon.example.org/"))
	end

	test "Returns nil on too long favicon URLs" do
	long_favicon_url =
	"https://Lorem.ipsum.dolor.sit.amet/consecteturadipiscingelit/Praesentpharetrapurusutaliquamtempus/Mauriseulaoreetarcu/atfacilisisorci/Nullamporttitor/nequesedfeugiatmollis/dolormagnaefficiturlorem/nonpretiumsapienorcieurisus/Nullamveleratsem/Maecenassedaccumsanexnam/favicon.png"

	Tesla.Mock.mock(fn %{url: "https://long-favicon.example.org/"} ->
	%Tesla.Env{
	status: 200,
	body:
	~s[<html><head><link rel="icon" href="] <> long_favicon_url <> ~s["></head></html>]
	}
	end)

	assert capture_log(fn ->
	assert nil ==
	Instance.get_or_update_favicon(
	URI.parse("https://long-favicon.example.org/")
	)
	end) =~
	"Instance.get_or_update_favicon(\"long-favicon.example.org\") error: %Postgrex.Error{"
	end

	test "Handles not getting a favicon URL properly" do
	Tesla.Mock.mock(fn %{url: "https://no-favicon.example.org/"} ->
	%Tesla.Env{
	status: 200,
	body: ~s[<html><head><h1>I wil look down and whisper "GNO.."</h1></head></html>]
	}
	end)

	refute capture_log(fn ->
	assert nil ==
	Instance.get_or_update_favicon(
	URI.parse("https://no-favicon.example.org/")
	)
	end) =~ "Instance.scrape_favicon(\"https://no-favicon.example.org/\") error: "
	end

	test "Doesn't scrapes unreachable instances" do
	instance = insert(:instance, unreachable_since: Instances.reachability_datetime_threshold())
	url = "https://" <> instance.host

	assert capture_log(fn -> assert nil == Instance.get_or_update_favicon(URI.parse(url)) end) =~
	"Instance.scrape_favicon(\"#{url}\") ignored unreachable host"
	end
	end

	describe "get_or_update_metadata/1" do
	test "Scrapes Wildebeest NodeInfo" do
	Tesla.Mock.mock(fn
	%{url: "https://wildebeest.example.org/.well-known/nodeinfo"} ->
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/wildebeest-well-known-nodeinfo.json")
	}

	%{url: "https://wildebeest.example.org/nodeinfo/2.1"} ->
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/wildebeest-nodeinfo21.json")
	}
	end)

	expected = %{
	software_name: "wildebeest",
	software_repository: "https://github.com/cloudflare/wildebeest",
	software_version: "0.0.1"
	}

	assert expected ==
	Instance.get_or_update_metadata(URI.parse("https://wildebeest.example.org/"))

	expected = %Pleroma.Instances.Instance.Pleroma.Instances.Metadata{
	software_name: "wildebeest",
	software_repository: "https://github.com/cloudflare/wildebeest",
	software_version: "0.0.1"
	}

	assert expected ==
	Repo.get_by(Pleroma.Instances.Instance, %{host: "wildebeest.example.org"}).metadata
	end

	test "Scrapes Mastodon NodeInfo" do
	Tesla.Mock.mock(fn
	%{url: "https://mastodon.example.org/.well-known/nodeinfo"} ->
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/mastodon-well-known-nodeinfo.json")
	}

	%{url: "https://mastodon.example.org/nodeinfo/2.0"} ->
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/mastodon-nodeinfo20.json")
	}
	end)

	expected = %{
	software_name: "mastodon",
	software_version: "4.1.0"
	}

	assert expected ==
	Instance.get_or_update_metadata(URI.parse("https://mastodon.example.org/"))
	end
	end

	test "delete_users_and_activities/1 deletes remote instance users and activities" do
	[mario, luigi, _peach, wario] =
	users = [
	insert(:user, nickname: "mario@mushroom.kingdom", name: "Mario"),
	insert(:user, nickname: "luigi@mushroom.kingdom", name: "Luigi"),
	insert(:user, nickname: "peach@mushroom.kingdom", name: "Peach"),
	insert(:user, nickname: "wario@greedville.biz", name: "Wario")
	]

	{:ok, post1} = CommonAPI.post(mario, %{status: "letsa go!"})
	{:ok, post2} = CommonAPI.post(luigi, %{status: "itsa me... luigi"})
	{:ok, post3} = CommonAPI.post(wario, %{status: "WHA-HA-HA!"})

	{:ok, job} = Instance.delete_users_and_activities("mushroom.kingdom")
	:ok = ObanHelpers.perform(job)

	[mario, luigi, peach, wario] = Repo.reload(users)

	refute mario.is_active
	refute luigi.is_active
	refute peach.is_active
	refute peach.name == "Peach"

	assert wario.is_active
	assert wario.name == "Wario"

	assert [nil, nil, %{}] = Repo.reload([post1, post2, post3])
	end
	end
	diff --git a/test/pleroma/upload/filter/analyze_metadata_test.exs b/test/pleroma/upload/filter/analyze_metadata_test.exs
	index b800a4a43..e4ac673b2 100644
	--- a/test/pleroma/upload/filter/analyze_metadata_test.exs
	+++ b/test/pleroma/upload/filter/analyze_metadata_test.exs
	@@ -1,33 +1,47 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Upload.Filter.AnalyzeMetadataTest do
	use Pleroma.DataCase, async: true
	alias Pleroma.Upload.Filter.AnalyzeMetadata

	test "adds the dimensions and blurhash for images" do
	upload = %Pleroma.Upload{
	name: "an… image.jpg",
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	tempfile: Path.absname("test/fixtures/image.jpg")
	}

	{:ok, :filtered, meta} = AnalyzeMetadata.filter(upload)

	assert %{width: 1024, height: 768} = meta
	assert meta.blurhash
	end

	+ test "it blurhashes images with an alpha component" do
	+ upload = %Pleroma.Upload{
	+ name: "an… image.jpg",
	+ content_type: "image/jpeg",
	+ path: Path.absname("test/fixtures/png_with_transparency.png"),
	+ tempfile: Path.absname("test/fixtures/png_with_transparency.png")
	+ }
	+
	+ {:ok, :filtered, meta} = AnalyzeMetadata.filter(upload)
	+
	+ assert %{width: 320, height: 320} = meta
	+ assert meta.blurhash == "eXJi-E:SwCEm5rCmn$+YWYn+15K#5A$xxCi{SiV]s*W:Efa#s.jE-T"
	+ end
	+
	test "adds the dimensions for videos" do
	upload = %Pleroma.Upload{
	name: "coolvideo.mp4",
	content_type: "video/mp4",
	path: Path.absname("test/fixtures/video.mp4"),
	tempfile: Path.absname("test/fixtures/video.mp4")
	}

	assert {:ok, :filtered, %{width: 480, height: 480}} = AnalyzeMetadata.filter(upload)
	end
	end
	diff --git a/test/pleroma/web/activity_pub/utils_test.exs b/test/pleroma/web/activity_pub/utils_test.exs
	index 3f93c872b..9ca21f5d9 100644
	--- a/test/pleroma/web/activity_pub/utils_test.exs
	+++ b/test/pleroma/web/activity_pub/utils_test.exs
	@@ -1,624 +1,659 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.UtilsTest do
	use Pleroma.DataCase, async: true
	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.AdminAPI.AccountView
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	require Pleroma.Constants

	+ describe "strip_report_status_data/1" do
	+ test "does not break on issues with the reported activites" do
	+ reporter = insert(:user)
	+ target_account = insert(:user)
	+ {:ok, activity} = CommonAPI.post(target_account, %{status: "foobar"})
	+ context = Utils.generate_context_id()
	+ content = "foobar"
	+ post_id = activity.data["id"]
	+
	+ res =
	+ Utils.make_flag_data(
	+ %{
	+ actor: reporter,
	+ context: context,
	+ account: target_account,
	+ statuses: [%{"id" => post_id}],
	+ content: content
	+ },
	+ %{}
	+ )
	+
	+ res =
	+ res
	+ \|> Map.put("object", res["object"] ++ [nil, 1, 5, "123"])
	+
	+ {:ok, activity} = Pleroma.Web.ActivityPub.ActivityPub.insert(res)
	+
	+ [user_id, object \| _] = activity.data["object"]
	+
	+ {:ok, stripped} = Utils.strip_report_status_data(activity)
	+
	+ assert stripped.data["object"] == [user_id, object["id"]]
	+ end
	+ end
	+
	describe "fetch the latest Follow" do
	test "fetches the latest Follow activity" do
	%Activity{data: %{"type" => "Follow"}} = activity = insert(:follow_activity)
	follower = User.get_cached_by_ap_id(activity.data["actor"])
	followed = User.get_cached_by_ap_id(activity.data["object"])

	assert activity == Utils.fetch_latest_follow(follower, followed)
	end
	end

	describe "determine_explicit_mentions()" do
	test "works with an object that has mentions" do
	object = %{
	"tag" => [
	%{
	"type" => "Mention",
	"href" => "https://example.com/~alyssa",
	"name" => "Alyssa P. Hacker"
	}
	]
	}

	assert Utils.determine_explicit_mentions(object) == ["https://example.com/~alyssa"]
	end

	test "works with an object that does not have mentions" do
	object = %{
	"tag" => [
	%{"type" => "Hashtag", "href" => "https://example.com/tag/2hu", "name" => "2hu"}
	]
	}

	assert Utils.determine_explicit_mentions(object) == []
	end

	test "works with an object that has mentions and other tags" do
	object = %{
	"tag" => [
	%{
	"type" => "Mention",
	"href" => "https://example.com/~alyssa",
	"name" => "Alyssa P. Hacker"
	},
	%{"type" => "Hashtag", "href" => "https://example.com/tag/2hu", "name" => "2hu"}
	]
	}

	assert Utils.determine_explicit_mentions(object) == ["https://example.com/~alyssa"]
	end

	test "works with an object that has no tags" do
	object = %{}

	assert Utils.determine_explicit_mentions(object) == []
	end

	test "works with an object that has only IR tags" do
	object = %{"tag" => ["2hu"]}

	assert Utils.determine_explicit_mentions(object) == []
	end

	test "works with an object has tags as map" do
	object = %{
	"tag" => %{
	"type" => "Mention",
	"href" => "https://example.com/~alyssa",
	"name" => "Alyssa P. Hacker"
	}
	}

	assert Utils.determine_explicit_mentions(object) == ["https://example.com/~alyssa"]
	end
	end

	describe "make_like_data" do
	setup do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)
	[user: user, other_user: other_user, third_user: third_user]
	end

	test "addresses actor's follower address if the activity is public", %{
	user: user,
	other_user: other_user,
	third_user: third_user
	} do
	expected_to = Enum.sort([user.ap_id, other_user.follower_address])
	expected_cc = Enum.sort(["https://www.w3.org/ns/activitystreams#Public", third_user.ap_id])

	{:ok, activity} =
	CommonAPI.post(user, %{
	status:
	"hey @#{other_user.nickname}, @#{third_user.nickname} how about beering together this weekend?"
	})

	%{"to" => to, "cc" => cc} = Utils.make_like_data(other_user, activity, nil)
	assert Enum.sort(to) == expected_to
	assert Enum.sort(cc) == expected_cc
	end

	test "does not adress actor's follower address if the activity is not public", %{
	user: user,
	other_user: other_user,
	third_user: third_user
	} do
	expected_to = Enum.sort([user.ap_id])
	expected_cc = [third_user.ap_id]

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "@#{other_user.nickname} @#{third_user.nickname} bought a new swimsuit!",
	visibility: "private"
	})

	%{"to" => to, "cc" => cc} = Utils.make_like_data(other_user, activity, nil)
	assert Enum.sort(to) == expected_to
	assert Enum.sort(cc) == expected_cc
	end
	end

	test "make_json_ld_header/0" do
	assert Utils.make_json_ld_header() == %{
	"@context" => [
	"https://www.w3.org/ns/activitystreams",
	"http://localhost:4001/schemas/litepub-0.1.jsonld",
	%{
	"@language" => "und"
	}
	]
	}
	end

	describe "get_existing_votes" do
	test "fetches existing votes" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "How do I pronounce LaTeX?",
	poll: %{
	options: ["laytekh", "lahtekh", "latex"],
	expires_in: 20,
	multiple: true
	}
	})

	object = Object.normalize(activity, fetch: false)
	{:ok, votes, object} = CommonAPI.vote(other_user, object, [0, 1])
	assert Enum.sort(Utils.get_existing_votes(other_user.ap_id, object)) == Enum.sort(votes)
	end

	test "fetches only Create activities" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "Are we living in a society?",
	poll: %{
	options: ["yes", "no"],
	expires_in: 20
	}
	})

	object = Object.normalize(activity, fetch: false)
	{:ok, [vote], object} = CommonAPI.vote(other_user, object, [0])
	{:ok, _activity} = CommonAPI.favorite(user, activity.id)
	[fetched_vote] = Utils.get_existing_votes(other_user.ap_id, object)
	assert fetched_vote.id == vote.id
	end
	end

	describe "update_follow_state_for_all/2" do
	test "updates the state of all Follow activities with the same actor and object" do
	user = insert(:user, is_locked: true)
	follower = insert(:user)

	{:ok, _, _, follow_activity} = CommonAPI.follow(follower, user)
	{:ok, _, _, follow_activity_two} = CommonAPI.follow(follower, user)

	data =
	follow_activity_two.data
	\|> Map.put("state", "accept")

	cng = Ecto.Changeset.change(follow_activity_two, data: data)

	{:ok, follow_activity_two} = Repo.update(cng)

	{:ok, follow_activity_two} =
	Utils.update_follow_state_for_all(follow_activity_two, "accept")

	assert refresh_record(follow_activity).data["state"] == "accept"
	assert refresh_record(follow_activity_two).data["state"] == "accept"
	end

	test "also updates the state of accepted follows" do
	user = insert(:user)
	follower = insert(:user)

	{:ok, _, _, follow_activity} = CommonAPI.follow(follower, user)
	{:ok, _, _, follow_activity_two} = CommonAPI.follow(follower, user)

	{:ok, follow_activity_two} =
	Utils.update_follow_state_for_all(follow_activity_two, "reject")

	assert refresh_record(follow_activity).data["state"] == "reject"
	assert refresh_record(follow_activity_two).data["state"] == "reject"
	end
	end

	describe "update_follow_state/2" do
	test "updates the state of the given follow activity" do
	user = insert(:user, is_locked: true)
	follower = insert(:user)

	{:ok, _, _, follow_activity} = CommonAPI.follow(follower, user)
	{:ok, _, _, follow_activity_two} = CommonAPI.follow(follower, user)

	data =
	follow_activity_two.data
	\|> Map.put("state", "accept")

	cng = Ecto.Changeset.change(follow_activity_two, data: data)

	{:ok, follow_activity_two} = Repo.update(cng)

	{:ok, follow_activity_two} = Utils.update_follow_state(follow_activity_two, "reject")

	assert refresh_record(follow_activity).data["state"] == "pending"
	assert refresh_record(follow_activity_two).data["state"] == "reject"
	end
	end

	describe "update_element_in_object/3" do
	test "updates likes" do
	user = insert(:user)
	activity = insert(:note_activity)
	object = Object.normalize(activity, fetch: false)

	assert {:ok, updated_object} =
	Utils.update_element_in_object(
	"like",
	[user.ap_id],
	object
	)

	assert updated_object.data["likes"] == [user.ap_id]
	assert updated_object.data["like_count"] == 1
	end
	end

	describe "add_like_to_object/2" do
	test "add actor to likes" do
	user = insert(:user)
	user2 = insert(:user)
	object = insert(:note)

	assert {:ok, updated_object} =
	Utils.add_like_to_object(
	%Activity{data: %{"actor" => user.ap_id}},
	object
	)

	assert updated_object.data["likes"] == [user.ap_id]
	assert updated_object.data["like_count"] == 1

	assert {:ok, updated_object2} =
	Utils.add_like_to_object(
	%Activity{data: %{"actor" => user2.ap_id}},
	updated_object
	)

	assert updated_object2.data["likes"] == [user2.ap_id, user.ap_id]
	assert updated_object2.data["like_count"] == 2
	end
	end

	describe "remove_like_from_object/2" do
	test "removes ap_id from likes" do
	user = insert(:user)
	user2 = insert(:user)
	object = insert(:note, data: %{"likes" => [user.ap_id, user2.ap_id], "like_count" => 2})

	assert {:ok, updated_object} =
	Utils.remove_like_from_object(
	%Activity{data: %{"actor" => user.ap_id}},
	object
	)

	assert updated_object.data["likes"] == [user2.ap_id]
	assert updated_object.data["like_count"] == 1
	end
	end

	describe "get_existing_like/2" do
	test "fetches existing like" do
	note_activity = insert(:note_activity)
	assert object = Object.normalize(note_activity, fetch: false)

	user = insert(:user)
	refute Utils.get_existing_like(user.ap_id, object)
	{:ok, like_activity} = CommonAPI.favorite(user, note_activity.id)

	assert ^like_activity = Utils.get_existing_like(user.ap_id, object)
	end
	end

	describe "get_get_existing_announce/2" do
	test "returns nil if announce not found" do
	actor = insert(:user)
	refute Utils.get_existing_announce(actor.ap_id, %{data: %{"id" => "test"}})
	end

	test "fetches existing announce" do
	note_activity = insert(:note_activity)
	assert object = Object.normalize(note_activity, fetch: false)
	actor = insert(:user)

	{:ok, announce} = CommonAPI.repeat(note_activity.id, actor)
	assert Utils.get_existing_announce(actor.ap_id, object) == announce
	end
	end

	describe "fetch_latest_block/2" do
	test "fetches last block activities" do
	user1 = insert(:user)
	user2 = insert(:user)

	assert {:ok, %Activity{} = _} = CommonAPI.block(user1, user2)
	assert {:ok, %Activity{} = _} = CommonAPI.block(user1, user2)
	assert {:ok, %Activity{} = activity} = CommonAPI.block(user1, user2)

	assert Utils.fetch_latest_block(user1, user2) == activity
	end
	end

	describe "recipient_in_message/3" do
	test "returns true when recipient in `to`" do
	recipient = insert(:user)
	actor = insert(:user)
	assert Utils.recipient_in_message(recipient, actor, %{"to" => recipient.ap_id})

	assert Utils.recipient_in_message(
	recipient,
	actor,
	%{"to" => [recipient.ap_id], "cc" => ""}
	)
	end

	test "returns true when recipient in `cc`" do
	recipient = insert(:user)
	actor = insert(:user)
	assert Utils.recipient_in_message(recipient, actor, %{"cc" => recipient.ap_id})

	assert Utils.recipient_in_message(
	recipient,
	actor,
	%{"cc" => [recipient.ap_id], "to" => ""}
	)
	end

	test "returns true when recipient in `bto`" do
	recipient = insert(:user)
	actor = insert(:user)
	assert Utils.recipient_in_message(recipient, actor, %{"bto" => recipient.ap_id})

	assert Utils.recipient_in_message(
	recipient,
	actor,
	%{"bcc" => "", "bto" => [recipient.ap_id]}
	)
	end

	test "returns true when recipient in `bcc`" do
	recipient = insert(:user)
	actor = insert(:user)
	assert Utils.recipient_in_message(recipient, actor, %{"bcc" => recipient.ap_id})

	assert Utils.recipient_in_message(
	recipient,
	actor,
	%{"bto" => "", "bcc" => [recipient.ap_id]}
	)
	end

	test "returns true when message without addresses fields" do
	recipient = insert(:user)
	actor = insert(:user)
	assert Utils.recipient_in_message(recipient, actor, %{"bccc" => recipient.ap_id})

	assert Utils.recipient_in_message(
	recipient,
	actor,
	%{"btod" => "", "bccc" => [recipient.ap_id]}
	)
	end

	test "returns false" do
	recipient = insert(:user)
	actor = insert(:user)
	refute Utils.recipient_in_message(recipient, actor, %{"to" => "ap_id"})
	end
	end

	describe "lazy_put_activity_defaults/2" do
	test "returns map with id and published data" do
	note_activity = insert(:note_activity)
	object = Object.normalize(note_activity, fetch: false)
	res = Utils.lazy_put_activity_defaults(%{"context" => object.data["id"]})
	assert res["context"] == object.data["id"]
	assert res["id"]
	assert res["published"]
	end

	test "returns map with fake id and published data" do
	assert %{
	"context" => "pleroma:fakecontext",
	"id" => "pleroma:fakeid",
	"published" => _
	} = Utils.lazy_put_activity_defaults(%{}, true)
	end

	test "returns activity data with object" do
	note_activity = insert(:note_activity)
	object = Object.normalize(note_activity, fetch: false)

	res =
	Utils.lazy_put_activity_defaults(%{
	"context" => object.data["id"],
	"object" => %{}
	})

	assert res["context"] == object.data["id"]
	assert res["id"]
	assert res["published"]
	assert res["object"]["id"]
	assert res["object"]["published"]
	assert res["object"]["context"] == object.data["id"]
	end
	end

	describe "make_flag_data" do
	test "returns empty map when params is invalid" do
	assert Utils.make_flag_data(%{}, %{}) == %{}
	end

	test "returns map with Flag object" do
	reporter = insert(:user)
	target_account = insert(:user)
	{:ok, activity} = CommonAPI.post(target_account, %{status: "foobar"})
	context = Utils.generate_context_id()
	content = "foobar"

	target_ap_id = target_account.ap_id
	object_ap_id = activity.object.data["id"]

	res =
	Utils.make_flag_data(
	%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [%{"id" => activity.data["id"]}],
	content: content
	},
	%{}
	)

	note_obj = %{
	"type" => "Note",
	"id" => object_ap_id,
	"content" => content,
	"published" => activity.object.data["published"],
	"actor" =>
	AccountView.render("show.json", %{user: target_account, skip_visibility_check: true})
	}

	assert %{
	"type" => "Flag",
	"content" => ^content,
	"context" => ^context,
	"object" => [^target_ap_id, ^note_obj],
	"state" => "open"
	} = res
	end

	test "returns map with Flag object with a non-Create Activity" do
	reporter = insert(:user)
	posting_account = insert(:user)
	target_account = insert(:user)

	{:ok, activity} = CommonAPI.post(posting_account, %{status: "foobar"})
	{:ok, like} = CommonAPI.favorite(target_account, activity.id)
	context = Utils.generate_context_id()
	content = "foobar"

	target_ap_id = target_account.ap_id
	object_ap_id = activity.object.data["id"]

	res =
	Utils.make_flag_data(
	%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [%{"id" => like.data["id"]}],
	content: content
	},
	%{}
	)

	note_obj = %{
	"type" => "Note",
	"id" => object_ap_id,
	"content" => content,
	"published" => activity.object.data["published"],
	"actor" =>
	AccountView.render("show.json", %{user: posting_account, skip_visibility_check: true})
	}

	assert %{
	"type" => "Flag",
	"content" => ^content,
	"context" => ^context,
	"object" => [^target_ap_id, ^note_obj],
	"state" => "open"
	} = res
	end
	end

	describe "add_announce_to_object/2" do
	test "adds actor to announcement" do
	user = insert(:user)
	object = insert(:note)

	activity =
	insert(:note_activity,
	data: %{
	"actor" => user.ap_id,
	"cc" => [Pleroma.Constants.as_public()]
	}
	)

	assert {:ok, updated_object} = Utils.add_announce_to_object(activity, object)
	assert updated_object.data["announcements"] == [user.ap_id]
	assert updated_object.data["announcement_count"] == 1
	end
	end

	describe "remove_announce_from_object/2" do
	test "removes actor from announcements" do
	user = insert(:user)
	user2 = insert(:user)

	object =
	insert(:note,
	data: %{"announcements" => [user.ap_id, user2.ap_id], "announcement_count" => 2}
	)

	activity = insert(:note_activity, data: %{"actor" => user.ap_id})

	assert {:ok, updated_object} = Utils.remove_announce_from_object(activity, object)
	assert updated_object.data["announcements"] == [user2.ap_id]
	assert updated_object.data["announcement_count"] == 1
	end
	end

	describe "get_cached_emoji_reactions/1" do
	test "returns the normalized data or an emtpy list" do
	object = insert(:note)
	assert Utils.get_cached_emoji_reactions(object) == []

	object = insert(:note, data: %{"reactions" => [["x", ["lain"]]]})
	assert Utils.get_cached_emoji_reactions(object) == [["x", ["lain"], nil]]

	object = insert(:note, data: %{"reactions" => %{}})
	assert Utils.get_cached_emoji_reactions(object) == []
	end
	end

	describe "add_emoji_reaction_to_object/1" do
	test "works with legacy 2-tuple format" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	note =
	insert(:note,
	user: user,
	data: %{
	"reactions" => [["😿", [other_user.ap_id]]]
	}
	)

	_activity = insert(:note_activity, user: user, note: note)

	Utils.add_emoji_reaction_to_object(
	%Activity{data: %{"content" => "😿", "actor" => third_user.ap_id}},
	note
	)
	end
	end
	end
	diff --git a/test/pleroma/web/endpoint/metrics_exporter_test.exs b/test/pleroma/web/endpoint/metrics_exporter_test.exs
	deleted file mode 100644
	index ad236d4cb..000000000
	--- a/test/pleroma/web/endpoint/metrics_exporter_test.exs
	+++ /dev/null
	@@ -1,69 +0,0 @@
	-# Pleroma: A lightweight social networking server
	-# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	-# SPDX-License-Identifier: AGPL-3.0-only
	-
	-defmodule Pleroma.Web.Endpoint.MetricsExporterTest do
	- # Modifies AppEnv, has to stay synchronous
	- use Pleroma.Web.ConnCase
	-
	- alias Pleroma.Web.Endpoint.MetricsExporter
	-
	- defp config do
	- Application.get_env(:prometheus, MetricsExporter)
	- end
	-
	- describe "with default config" do
	- test "does NOT expose app metrics", %{conn: conn} do
	- conn
	- \|> get(config()[:path])
	- \|> json_response(404)
	- end
	- end
	-
	- describe "when enabled" do
	- setup do
	- initial_config = config()
	- on_exit(fn -> Application.put_env(:prometheus, MetricsExporter, initial_config) end)
	-
	- Application.put_env(
	- :prometheus,
	- MetricsExporter,
	- Keyword.put(initial_config, :enabled, true)
	- )
	- end
	-
	- test "serves app metrics", %{conn: conn} do
	- conn = get(conn, config()[:path])
	- assert response = response(conn, 200)
	-
	- for metric <- [
	- "http_requests_total",
	- "http_request_duration_microseconds",
	- "phoenix_controller_call_duration",
	- "telemetry_scrape_duration",
	- "erlang_vm_memory_atom_bytes_total"
	- ] do
	- assert response =~ ~r/#{metric}/
	- end
	- end
	-
	- test "when IP whitelist configured, " <>
	- "serves app metrics only if client IP is whitelisted",
	- %{conn: conn} do
	- Application.put_env(
	- :prometheus,
	- MetricsExporter,
	- Keyword.put(config(), :ip_whitelist, ["127.127.127.127", {1, 1, 1, 1}, '255.255.255.255'])
	- )
	-
	- conn
	- \|> get(config()[:path])
	- \|> json_response(404)
	-
	- conn
	- \|> Map.put(:remote_ip, {127, 127, 127, 127})
	- \|> get(config()[:path])
	- \|> response(200)
	- end
	- end
	-end
	diff --git a/test/pleroma/web/fallback_test.exs b/test/pleroma/web/fallback_test.exs
	index 6d11d4f37..ed34d6490 100644
	--- a/test/pleroma/web/fallback_test.exs
	+++ b/test/pleroma/web/fallback_test.exs
	@@ -1,94 +1,89 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.FallbackTest do
	use Pleroma.Web.ConnCase
	import Pleroma.Factory

	- describe "neither preloaded data nor metadata attached to" do
	- test "GET /registration/:token", %{conn: conn} do
	- response = get(conn, "/registration/foo")
	-
	- assert html_response(response, 200) =~ "<!--server-generated-meta-->"
	- end
	-
	- test "GET /*path", %{conn: conn} do
	- assert conn
	- \|> get("/foo")
	- \|> html_response(200) =~ "<!--server-generated-meta-->"
	- end
	- end
	-
	test "GET /*path adds a title", %{conn: conn} do
	clear_config([:instance, :name], "a cool title")

	assert conn
	\|> get("/")
	\|> html_response(200) =~ "<title>a cool title</title>"
	end

	describe "preloaded data and metadata attached to" do
	- test "GET /:maybe_nickname_or_id", %{conn: conn} do
	+ test "GET /:maybe_nickname_or_id with existing user", %{conn: conn} do
	clear_config([:instance, :name], "a cool title")
	-
	user = insert(:user)
	- user_missing = get(conn, "/foo")
	- user_present = get(conn, "/#{user.nickname}")

	- assert html_response(user_missing, 200) =~ "<!--server-generated-meta-->"
	- refute html_response(user_present, 200) =~ "<!--server-generated-meta-->"
	- assert html_response(user_present, 200) =~ "initial-results"
	- assert html_response(user_present, 200) =~ "<title>a cool title</title>"
	+ resp = get(conn, "/#{user.nickname}")
	+
	+ assert html_response(resp, 200) =~ "<title>a cool title</title>"
	+ refute html_response(resp, 200) =~ "<!--server-generated-meta-->"
	+ assert html_response(resp, 200) =~ "initial-results"
	+ end
	+
	+ test "GET /:maybe_nickname_or_id with missing user", %{conn: conn} do
	+ clear_config([:instance, :name], "a cool title")
	+
	+ resp = get(conn, "/foo")
	+
	+ assert html_response(resp, 200) =~ "<title>a cool title</title>"
	+ refute html_response(resp, 200) =~ "initial-results"
	end

	test "GET /*path", %{conn: conn} do
	- assert conn
	+ refute conn
	\|> get("/foo")
	\|> html_response(200) =~ "<!--server-generated-meta-->"

	refute conn
	\|> get("/foo/bar")
	\|> html_response(200) =~ "<!--server-generated-meta-->"
	end
	end

	describe "preloaded data is attached to" do
	test "GET /main/public", %{conn: conn} do
	clear_config([:instance, :name], "a cool title")

	public_page = get(conn, "/main/public")

	refute html_response(public_page, 200) =~ "<!--server-generated-meta-->"
	assert html_response(public_page, 200) =~ "initial-results"
	assert html_response(public_page, 200) =~ "<title>a cool title</title>"
	end

	test "GET /main/all", %{conn: conn} do
	+ clear_config([:instance, :name], "a cool title")
	public_page = get(conn, "/main/all")

	refute html_response(public_page, 200) =~ "<!--server-generated-meta-->"
	assert html_response(public_page, 200) =~ "initial-results"
	+ assert html_response(public_page, 200) =~ "<title>a cool title</title>"
	end
	end

	test "GET /api*path", %{conn: conn} do
	assert conn
	\|> get("/api/foo")
	\|> json_response(404) == %{"error" => "Not implemented"}
	end

	test "GET /pleroma/admin -> /pleroma/admin/", %{conn: conn} do
	assert redirected_to(get(conn, "/pleroma/admin")) =~ "/pleroma/admin/"
	end

	test "OPTIONS /*path", %{conn: conn} do
	assert conn
	\|> options("/foo")
	\|> response(204) == ""

	assert conn
	\|> options("/foo/bar")
	\|> response(204) == ""
	end
	end
	diff --git a/test/pleroma/web/o_status/o_status_controller_test.exs b/test/pleroma/web/o_status/o_status_controller_test.exs
	index 36e581f5e..3e8fcd956 100644
	--- a/test/pleroma/web/o_status/o_status_controller_test.exs
	+++ b/test/pleroma/web/o_status/o_status_controller_test.exs
	@@ -1,346 +1,346 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.OStatus.OStatusControllerTest do
	use Pleroma.Web.ConnCase

	import Pleroma.Factory

	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Endpoint

	require Pleroma.Constants

	setup_all do
	Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	setup do: clear_config([:static_fe, :enabled], false)

	describe "Mastodon compatibility routes" do
	setup %{conn: conn} do
	conn = put_req_header(conn, "accept", "text/html")

	{:ok, object} =
	%{
	"type" => "Note",
	"content" => "hey",
	"id" => Endpoint.url() <> "/users/raymoo/statuses/999999999",
	"actor" => Endpoint.url() <> "/users/raymoo",
	"to" => [Pleroma.Constants.as_public()]
	}
	\|> Object.create()

	{:ok, activity, _} =
	%{
	"id" => object.data["id"] <> "/activity",
	"type" => "Create",
	"object" => object.data["id"],
	"actor" => object.data["actor"],
	"to" => object.data["to"]
	}
	\|> ActivityPub.persist(local: true)

	%{conn: conn, activity: activity}
	end

	test "redirects to /notice/:id for html format", %{conn: conn, activity: activity} do
	conn = get(conn, "/users/raymoo/statuses/999999999")
	assert redirected_to(conn) == "/notice/#{activity.id}"
	end

	test "redirects to /notice/:id for html format for activity", %{
	conn: conn,
	activity: activity
	} do
	conn = get(conn, "/users/raymoo/statuses/999999999/activity")
	assert redirected_to(conn) == "/notice/#{activity.id}"
	end
	end

	# Note: see ActivityPubControllerTest for JSON format tests
	describe "GET /objects/:uuid (text/html)" do
	setup %{conn: conn} do
	conn = put_req_header(conn, "accept", "text/html")
	%{conn: conn}
	end

	test "redirects to /notice/id for html format", %{conn: conn} do
	note_activity = insert(:note_activity)
	object = Object.normalize(note_activity, fetch: false)
	[_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, object.data["id"]))
	url = "/objects/#{uuid}"

	conn = get(conn, url)
	assert redirected_to(conn) == "/notice/#{note_activity.id}"
	end

	test "404s on private objects", %{conn: conn} do
	note_activity = insert(:direct_note_activity)
	object = Object.normalize(note_activity, fetch: false)
	[_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, object.data["id"]))

	conn
	\|> get("/objects/#{uuid}")
	\|> response(404)
	end

	test "404s on non-existing objects", %{conn: conn} do
	conn
	\|> get("/objects/123")
	\|> response(404)
	end
	end

	# Note: see ActivityPubControllerTest for JSON format tests
	describe "GET /activities/:uuid (text/html)" do
	setup %{conn: conn} do
	conn = put_req_header(conn, "accept", "text/html")
	%{conn: conn}
	end

	test "redirects to /notice/id for html format", %{conn: conn} do
	note_activity = insert(:note_activity)
	[_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, note_activity.data["id"]))

	conn = get(conn, "/activities/#{uuid}")
	assert redirected_to(conn) == "/notice/#{note_activity.id}"
	end

	test "404s on private activities", %{conn: conn} do
	note_activity = insert(:direct_note_activity)
	[_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, note_activity.data["id"]))

	conn
	\|> get("/activities/#{uuid}")
	\|> response(404)
	end

	test "404s on nonexistent activities", %{conn: conn} do
	conn
	\|> get("/activities/123")
	\|> response(404)
	end
	end

	describe "GET notice/2" do
	test "redirects to a proper object URL when json requested and the object is local", %{
	conn: conn
	} do
	note_activity = insert(:note_activity)
	expected_redirect_url = Object.normalize(note_activity, fetch: false).data["id"]

	redirect_url =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/notice/#{note_activity.id}")
	\|> redirected_to()

	assert redirect_url == expected_redirect_url
	end

	test "redirects to a proper object URL when json requested and the object is remote", %{
	conn: conn
	} do
	note_activity = insert(:note_activity, local: false)
	expected_redirect_url = Object.normalize(note_activity, fetch: false).data["id"]

	redirect_url =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/notice/#{note_activity.id}")
	\|> redirected_to()

	assert redirect_url == expected_redirect_url
	end

	test "500s when actor not found", %{conn: conn} do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])
	User.invalidate_cache(user)
	Pleroma.Repo.delete(user)

	conn =
	conn
	\|> get("/notice/#{note_activity.id}")

	assert response(conn, 500) == ~S({"error":"Something went wrong"})
	end

	test "render html for redirect for html format", %{conn: conn} do
	note_activity = insert(:note_activity)

	resp =
	conn
	\|> put_req_header("accept", "text/html")
	\|> get("/notice/#{note_activity.id}")
	\|> response(200)

	assert resp =~
	"<meta content=\"#{Pleroma.Web.Endpoint.url()}/notice/#{note_activity.id}\" property=\"og:url\">"

	user = insert(:user)

	{:ok, like_activity} = CommonAPI.favorite(user, note_activity.id)

	assert like_activity.data["type"] == "Like"

	resp =
	conn
	\|> put_req_header("accept", "text/html")
	\|> get("/notice/#{like_activity.id}")
	\|> response(200)

	- assert resp =~ "<!--server-generated-meta-->"
	+ refute resp =~ ~r(<meta content="[^"]*" property="og:url")
	end

	test "404s a private notice", %{conn: conn} do
	note_activity = insert(:direct_note_activity)
	url = "/notice/#{note_activity.id}"

	conn =
	conn
	\|> get(url)

	assert response(conn, 404)
	end

	test "404s a non-existing notice", %{conn: conn} do
	url = "/notice/123"

	conn =
	conn
	\|> get(url)

	assert response(conn, 404)
	end

	test "does not require authentication on non-federating instances", %{
	conn: conn
	} do
	clear_config([:instance, :federating], false)
	note_activity = insert(:note_activity)

	conn
	\|> put_req_header("accept", "text/html")
	\|> get("/notice/#{note_activity.id}")
	\|> response(200)
	end
	end

	describe "GET /notice/:id/embed_player" do
	setup do
	note_activity = insert(:note_activity)
	object = Pleroma.Object.normalize(note_activity, fetch: false)

	object_data =
	Map.put(object.data, "attachment", [
	%{
	"url" => [
	%{
	"href" =>
	"https://peertube.moe/static/webseed/df5f464b-be8d-46fb-ad81-2d4c2d1630e3-480.mp4",
	"mediaType" => "video/mp4",
	"type" => "Link"
	}
	]
	}
	])

	object
	\|> Ecto.Changeset.change(data: object_data)
	\|> Pleroma.Repo.update()

	%{note_activity: note_activity}
	end

	test "renders embed player", %{conn: conn, note_activity: note_activity} do
	conn = get(conn, "/notice/#{note_activity.id}/embed_player")

	assert Plug.Conn.get_resp_header(conn, "x-frame-options") == ["ALLOW"]

	assert Plug.Conn.get_resp_header(
	conn,
	"content-security-policy"
	) == [
	"default-src 'none';style-src 'self' 'unsafe-inline';img-src 'self' data: https:; media-src 'self' https:;"
	]

	assert response(conn, 200) =~
	"<video controls loop><source src=\"https://peertube.moe/static/webseed/df5f464b-be8d-46fb-ad81-2d4c2d1630e3-480.mp4\" type=\"video/mp4\">Your browser does not support video/mp4 playback.</video>"
	end

	test "404s when activity isn't create", %{conn: conn} do
	note_activity = insert(:note_activity, data_attrs: %{"type" => "Like"})

	assert conn
	\|> get("/notice/#{note_activity.id}/embed_player")
	\|> response(404)
	end

	test "404s when activity is direct message", %{conn: conn} do
	note_activity = insert(:note_activity, data_attrs: %{"directMessage" => true})

	assert conn
	\|> get("/notice/#{note_activity.id}/embed_player")
	\|> response(404)
	end

	test "404s when attachment is empty", %{conn: conn} do
	note_activity = insert(:note_activity)
	object = Pleroma.Object.normalize(note_activity, fetch: false)
	object_data = Map.put(object.data, "attachment", [])

	object
	\|> Ecto.Changeset.change(data: object_data)
	\|> Pleroma.Repo.update()

	assert conn
	\|> get("/notice/#{note_activity.id}/embed_player")
	\|> response(404)
	end

	test "404s when attachment isn't audio or video", %{conn: conn} do
	note_activity = insert(:note_activity)
	object = Pleroma.Object.normalize(note_activity, fetch: false)

	object_data =
	Map.put(object.data, "attachment", [
	%{
	"url" => [
	%{
	"href" => "https://peertube.moe/static/webseed/480.jpg",
	"mediaType" => "image/jpg",
	"type" => "Link"
	}
	]
	}
	])

	object
	\|> Ecto.Changeset.change(data: object_data)
	\|> Pleroma.Repo.update()

	conn
	\|> get("/notice/#{note_activity.id}/embed_player")
	\|> response(404)
	end

	test "does not require authentication on non-federating instances", %{
	conn: conn,
	note_activity: note_activity
	} do
	clear_config([:instance, :federating], false)

	conn
	\|> put_req_header("accept", "text/html")
	\|> get("/notice/#{note_activity.id}/embed_player")
	\|> response(200)
	end
	end
	end
	diff --git a/test/pleroma/web/pleroma_api/controllers/instances_controller_test.exs b/test/pleroma/web/pleroma_api/controllers/instances_controller_test.exs
	index 365d26ab1..02afeda67 100644
	--- a/test/pleroma/web/pleroma_api/controllers/instances_controller_test.exs
	+++ b/test/pleroma/web/pleroma_api/controllers/instances_controller_test.exs
	@@ -1,38 +1,40 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.PleromaApi.InstancesControllerTest do
	use Pleroma.Web.ConnCase

	alias Pleroma.Instances

	setup_all do: clear_config([:instance, :federation_reachability_timeout_days], 1)

	setup do
	constant = "http://consistently-unreachable.name/"
	eventual = "http://eventually-unreachable.com/path"

	{:ok, %Pleroma.Instances.Instance{unreachable_since: constant_unreachable}} =
	Instances.set_consistently_unreachable(constant)

	_eventual_unrechable = Instances.set_unreachable(eventual)

	%{constant_unreachable: constant_unreachable, constant: constant}
	end

	test "GET /api/v1/pleroma/federation_status", %{
	conn: conn,
	constant_unreachable: constant_unreachable,
	constant: constant
	} do
	+ clear_config([:instance, :public], false)
	+
	constant_host = URI.parse(constant).host

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> get("/api/v1/pleroma/federation_status")
	\|> json_response_and_validate_schema(200) == %{
	"unreachable" => %{constant_host => to_string(constant_unreachable)}
	}
	end
	end
	diff --git a/test/pleroma/web/pleroma_api/controllers/scrobble_controller_test.exs b/test/pleroma/web/pleroma_api/controllers/scrobble_controller_test.exs
	index 908ce962d..be94a02ad 100644
	--- a/test/pleroma/web/pleroma_api/controllers/scrobble_controller_test.exs
	+++ b/test/pleroma/web/pleroma_api/controllers/scrobble_controller_test.exs
	@@ -1,60 +1,64 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.PleromaAPI.ScrobbleControllerTest do
	use Pleroma.Web.ConnCase, async: true

	alias Pleroma.Web.CommonAPI

	describe "POST /api/v1/pleroma/scrobble" do
	test "works correctly" do
	%{conn: conn} = oauth_access(["write"])

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/pleroma/scrobble", %{
	"title" => "lain radio episode 1",
	"artist" => "lain",
	"album" => "lain radio",
	- "length" => "180000"
	+ "length" => "180000",
	+ "externalLink" => "https://www.last.fm/music/lain/lain+radio/lain+radio+episode+1"
	})

	assert %{"title" => "lain radio episode 1"} = json_response_and_validate_schema(conn, 200)
	end
	end

	describe "GET /api/v1/pleroma/accounts/:id/scrobbles" do
	test "works correctly" do
	%{user: user, conn: conn} = oauth_access(["read"])

	{:ok, _activity} =
	CommonAPI.listen(user, %{
	title: "lain radio episode 1",
	artist: "lain",
	- album: "lain radio"
	+ album: "lain radio",
	+ externalLink: "https://www.last.fm/music/lain/lain+radio/lain+radio+episode+1"
	})

	{:ok, _activity} =
	CommonAPI.listen(user, %{
	title: "lain radio episode 2",
	artist: "lain",
	- album: "lain radio"
	+ album: "lain radio",
	+ externalLink: "https://www.last.fm/music/lain/lain+radio/lain+radio+episode+2"
	})

	{:ok, _activity} =
	CommonAPI.listen(user, %{
	title: "lain radio episode 3",
	artist: "lain",
	- album: "lain radio"
	+ album: "lain radio",
	+ externalLink: "https://www.last.fm/music/lain/lain+radio/lain+radio+episode+3"
	})

	conn = get(conn, "/api/v1/pleroma/accounts/#{user.id}/scrobbles")

	result = json_response_and_validate_schema(conn, 200)

	assert length(result) == 3
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Thu, Oct 29, 2:02 AM (1 h, 29 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1797408
Default Alt Text: (418 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions