app/Controllers/EpisodeController.php

 <?php
 
+declare(strict_types=1);
+
 /**
- * @copyright  2020 Podlibre
+ * @copyright  2020 Ad Aures
  * @license    https://www.gnu.org/licenses/agpl-3.0.en.html AGPL3
  * @link       https://castopod.org/
  */
 
 namespace App\Controllers;
 
-use Analytics\AnalyticsTrait;
 use App\Entities\Episode;
 use App\Entities\Podcast;
+use App\Libraries\NoteObject;
+use App\Libraries\PodcastEpisode;
 use App\Models\EpisodeModel;
 use App\Models\PodcastModel;
+use CodeIgniter\Database\BaseBuilder;
 use CodeIgniter\Exceptions\PageNotFoundException;
 use CodeIgniter\HTTP\ResponseInterface;
-use Config\Services;
+use Config\Embed;
+use Modules\Analytics\AnalyticsTrait;
+use Modules\Fediverse\Objects\OrderedCollectionObject;
+use Modules\Fediverse\Objects\OrderedCollectionPage;
+use Modules\Media\FileManagers\FileManagerInterface;
 use SimpleXMLElement;
 
 class EpisodeController extends BaseController
@@ -33,36 +41,47 @@ class EpisodeController extends BaseController
         }
 
         if (
-            ($this->podcast = (new PodcastModel())->getPodcastByName($params[0],)) === null
+            ! ($podcast = (new PodcastModel())->getPodcastByHandle($params[0])) instanceof Podcast
         ) {
             throw PageNotFoundException::forPageNotFound();
         }
 
+        $this->podcast = $podcast;
+
         if (
-            ($this->episode = (new EpisodeModel())->getEpisodeBySlug($this->podcast->id, $params[1],)) !== null
+            ! ($episode = (new EpisodeModel())->getEpisodeBySlug($params[0], $params[1])) instanceof Episode
         ) {
-            unset($params[1]);
-            unset($params[0]);
-            return $this->{$method}(...$params);
+            throw PageNotFoundException::forPageNotFound();
         }
 
-        throw PageNotFoundException::forPageNotFound();
+        $this->episode = $episode;
+
+        unset($params[1]);
+        unset($params[0]);
+
+        return $this->{$method}(...$params);
     }
 
     public function index(): string
     {
-        // Prevent analytics hit when authenticated
-        if (! can_user_interact()) {
-            $this->registerPodcastWebpageHit($this->episode->podcast_id);
-        }
+        $this->registerPodcastWebpageHit($this->episode->podcast_id);
 
-        $locale = service('request')
-            ->getLocale();
-        $cacheName =
-            "page_podcast#{$this->podcast->id}_episode#{$this->episode->id}_{$locale}" .
-            (can_user_interact() ? '_authenticated' : '');
+        $cacheName = implode(
+            '_',
+            array_filter([
+                'page',
+                "podcast#{$this->podcast->id}",
+                "episode#{$this->episode->id}",
+                service('request')
+                    ->getLocale(),
+                is_unlocked($this->podcast->handle) ? 'unlocked' : null,
+                auth()
+                    ->loggedIn() ? 'authenticated' : null,
+            ]),
+        );
 
         if (! ($cachedView = cache($cacheName))) {
+            set_episode_metatags($this->episode);
             $data = [
                 'podcast' => $this->podcast,
                 'episode' => $this->episode,
@@ -72,15 +91,15 @@ class EpisodeController extends BaseController
                 $this->podcast->id,
             );
 
-            if (can_user_interact()) {
+            if (auth()->loggedIn()) {
                 helper('form');
-                return view('podcast/episode_authenticated', $data);
+
+                return view('episode/comments', $data);
             }
+
             // The page cache is set to a decade so it is deleted manually upon podcast update
-            return view('podcast/episode', $data, [
-                'cache' => $secondsToNextUnpublishedEpisode
-                    ? $secondsToNextUnpublishedEpisode
-                    : DECADE,
+            return view('episode/comments', $data, [
+                'cache'      => $secondsToNextUnpublishedEpisode ?: DECADE,
                 'cache_name' => $cacheName,
             ]);
         }
@@ -88,33 +107,203 @@ class EpisodeController extends BaseController
         return $cachedView;
     }
 
-    public function embeddablePlayer(string $theme = 'light-transparent'): string
+    public function activity(): string
     {
-        header('Content-Security-Policy: frame-ancestors https://* http://*');
+        $this->registerPodcastWebpageHit($this->episode->podcast_id);
 
-        // Prevent analytics hit when authenticated
-        if (! can_user_interact()) {
-            $this->registerPodcastWebpageHit($this->episode->podcast_id);
-        }
+        $cacheName = implode(
+            '_',
+            array_filter([
+                'page',
+                "podcast#{$this->podcast->id}",
+                "episode#{$this->episode->id}",
+                'activity',
+                service('request')
+                    ->getLocale(),
+                is_unlocked($this->podcast->handle) ? 'unlocked' : null,
+                auth()
+                    ->loggedIn() ? 'authenticated' : null,
+            ]),
+        );
+
+        if (! ($cachedView = cache($cacheName))) {
+            set_episode_metatags($this->episode);
+            $data = [
+                'podcast' => $this->podcast,
+                'episode' => $this->episode,
+            ];
+
+            $secondsToNextUnpublishedEpisode = (new EpisodeModel())->getSecondsToNextUnpublishedEpisode(
+                $this->podcast->id,
+            );
 
-        $session = Services::session();
-        $session->start();
-        if (isset($_SERVER['HTTP_REFERER'])) {
-            $session->set('embeddable_player_domain', parse_url($_SERVER['HTTP_REFERER'], PHP_URL_HOST),);
+            if (auth()->loggedIn()) {
+                helper('form');
+
+                return view('episode/activity', $data);
+            }
+
+            // The page cache is set to a decade so it is deleted manually upon podcast update
+            return view('episode/activity', $data, [
+                'cache'      => $secondsToNextUnpublishedEpisode ?: DECADE,
+                'cache_name' => $cacheName,
+            ]);
         }
 
-        $locale = service('request')
-            ->getLocale();
+        return $cachedView;
+    }
 
-        $cacheName = "page_podcast#{$this->podcast->id}_episode#{$this->episode->id}_embeddable_player_{$theme}_{$locale}";
+    public function chapters(): string
+    {
+        $this->registerPodcastWebpageHit($this->episode->podcast_id);
+
+        $cacheName = implode(
+            '_',
+            array_filter([
+                'page',
+                "podcast#{$this->podcast->id}",
+                "episode#{$this->episode->id}",
+                'chapters',
+                service('request')
+                    ->getLocale(),
+                is_unlocked($this->podcast->handle) ? 'unlocked' : null,
+                auth()
+                    ->loggedIn() ? 'authenticated' : null,
+            ]),
+        );
 
         if (! ($cachedView = cache($cacheName))) {
-            $theme = EpisodeModel::$themes[$theme];
+            set_episode_metatags($this->episode);
+            $data = [
+                'podcast' => $this->podcast,
+                'episode' => $this->episode,
+            ];
 
+            // get chapters from json file
+            if (isset($this->episode->chapters->file_key)) {
+                /** @var FileManagerInterface $fileManager */
+                $fileManager = service('file_manager');
+                $episodeChaptersJsonString = (string) $fileManager->getFileContents($this->episode->chapters->file_key);
+
+                $chapters = json_decode($episodeChaptersJsonString, true);
+                $data['chapters'] = $chapters;
+            }
+
+            $secondsToNextUnpublishedEpisode = (new EpisodeModel())->getSecondsToNextUnpublishedEpisode(
+                $this->podcast->id,
+            );
+
+            if (auth()->loggedIn()) {
+                helper('form');
+
+                return view('episode/chapters', $data);
+            }
+
+            // The page cache is set to a decade so it is deleted manually upon podcast update
+            return view('episode/chapters', $data, [
+                'cache'      => $secondsToNextUnpublishedEpisode ?: DECADE,
+                'cache_name' => $cacheName,
+            ]);
+        }
+
+        return $cachedView;
+    }
+
+    public function transcript(): string
+    {
+        $this->registerPodcastWebpageHit($this->episode->podcast_id);
+
+        $cacheName = implode(
+            '_',
+            array_filter([
+                'page',
+                "podcast#{$this->podcast->id}",
+                "episode#{$this->episode->id}",
+                'transcript',
+                service('request')
+                    ->getLocale(),
+                is_unlocked($this->podcast->handle) ? 'unlocked' : null,
+                auth()
+                    ->loggedIn() ? 'authenticated' : null,
+            ]),
+        );
+
+        if (! ($cachedView = cache($cacheName))) {
+            set_episode_metatags($this->episode);
             $data = [
                 'podcast' => $this->podcast,
                 'episode' => $this->episode,
-                'theme' => $theme,
+            ];
+
+            // get transcript from json file
+            if ($this->episode->transcript !== null) {
+                $data['transcript'] = $this->episode->transcript;
+
+                if ($this->episode->transcript->json_key !== null) {
+                    /** @var FileManagerInterface $fileManager */
+                    $fileManager = service('file_manager');
+                    $transcriptJsonString = (string) $fileManager->getFileContents(
+                        $this->episode->transcript->json_key,
+                    );
+
+                    $data['captions'] = json_decode($transcriptJsonString, true);
+                }
+            }
+
+            $secondsToNextUnpublishedEpisode = (new EpisodeModel())->getSecondsToNextUnpublishedEpisode(
+                $this->podcast->id,
+            );
+
+            if (auth()->loggedIn()) {
+                helper('form');
+
+                return view('episode/transcript', $data);
+            }
+
+            // The page cache is set to a decade so it is deleted manually upon podcast update
+            return view('episode/transcript', $data, [
+                'cache'      => $secondsToNextUnpublishedEpisode ?: DECADE,
+                'cache_name' => $cacheName,
+            ]);
+        }
+
+        return $cachedView;
+    }
+
+    public function embed(string $theme = 'light-transparent'): string
+    {
+        header('Content-Security-Policy: frame-ancestors http://*:* https://*:*');
+
+        $this->registerPodcastWebpageHit($this->episode->podcast_id);
+
+        $session = service('session');
+
+        if (service('superglobals')->server('HTTP_REFERER') !== null) {
+            $session->set('embed_domain', parse_url(service('superglobals')->server('HTTP_REFERER'), PHP_URL_HOST));
+        }
+
+        $cacheName = implode(
+            '_',
+            array_filter([
+                'page',
+                "podcast#{$this->podcast->id}",
+                "episode#{$this->episode->id}",
+                'embed',
+                $theme,
+                service('request')
+                    ->getLocale(),
+                is_unlocked($this->podcast->handle) ? 'unlocked' : null,
+            ]),
+        );
+
+        if (! ($cachedView = cache($cacheName))) {
+            $themeData = EpisodeModel::$themes[$theme];
+
+            $data = [
+                'podcast'   => $this->podcast,
+                'episode'   => $this->episode,
+                'theme'     => $theme,
+                'themeData' => $themeData,
             ];
 
             $secondsToNextUnpublishedEpisode = (new EpisodeModel())->getSecondsToNextUnpublishedEpisode(
@@ -122,10 +311,8 @@ class EpisodeController extends BaseController
             );
 
             // The page cache is set to a decade so it is deleted manually upon podcast update
-            return view('embeddable_player', $data, [
-                'cache' => $secondsToNextUnpublishedEpisode
-                    ? $secondsToNextUnpublishedEpisode
-                    : DECADE,
+            return view('embed', $data, [
+                'cache'      => $secondsToNextUnpublishedEpisode ?: DECADE,
                 'cache_name' => $cacheName,
             ]);
         }
@@ -136,30 +323,31 @@ class EpisodeController extends BaseController
     public function oembedJSON(): ResponseInterface
     {
         return $this->response->setJSON([
-            'type' => 'rich',
-            'version' => '1.0',
-            'title' => $this->episode->title,
+            'type'          => 'rich',
+            'version'       => '1.0',
+            'title'         => $this->episode->title,
             'provider_name' => $this->podcast->title,
-            'provider_url' => $this->podcast->link,
-            'author_name' => $this->podcast->title,
-            'author_url' => $this->podcast->link,
-            'html' =>
-                '<iframe src="' .
-                $this->episode->embeddable_player_url .
-                '" width="100%" height="200" frameborder="0" scrolling="no"></iframe>',
-            'width' => 600,
-            'height' => 200,
-            'thumbnail_url' => $this->episode->image->large_url,
+            'provider_url'  => $this->podcast->link,
+            'author_name'   => $this->podcast->title,
+            'author_url'    => $this->podcast->link,
+            'html'          => '<iframe src="' .
+                $this->episode->embed_url .
+                '" width="100%" height="' . config('Embed')->height . '" frameborder="0" scrolling="no"></iframe>',
+            'width' => config('Embed')
+                ->width,
+            'height' => config('Embed')
+                ->height,
+            'thumbnail_url'   => $this->episode->cover->og_url,
             'thumbnail_width' => config('Images')
-                ->largeSize,
+                ->podcastCoverSizes['og']['width'],
             'thumbnail_height' => config('Images')
-                ->largeSize,
+                ->podcastCoverSizes['og']['height'],
         ]);
     }
 
     public function oembedXML(): ResponseInterface
     {
-        $oembed = new SimpleXMLElement("<?xml version='1.0' encoding='utf-8' standalone='yes'?><oembed></oembed>",);
+        $oembed = new SimpleXMLElement("<?xml version='1.0' encoding='utf-8' standalone='yes'?><oembed></oembed>");
 
         $oembed->addChild('type', 'rich');
         $oembed->addChild('version', '1.0');
@@ -168,20 +356,71 @@ class EpisodeController extends BaseController
         $oembed->addChild('provider_url', $this->podcast->link);
         $oembed->addChild('author_name', $this->podcast->title);
         $oembed->addChild('author_url', $this->podcast->link);
-        $oembed->addChild('thumbnail', $this->episode->image->large_url);
-        $oembed->addChild('thumbnail_width', config('Images')->largeSize);
-        $oembed->addChild('thumbnail_height', config('Images')->largeSize);
+        $oembed->addChild('thumbnail', $this->episode->cover->og_url);
+        $oembed->addChild('thumbnail_width', (string) config('Images')->podcastCoverSizes['og']['width']);
+        $oembed->addChild('thumbnail_height', (string) config('Images')->podcastCoverSizes['og']['height']);
         $oembed->addChild(
             'html',
-            htmlentities(
+            htmlspecialchars(
                 '<iframe src="' .
-                    $this->episode->embeddable_player_url .
-                    '" width="100%" height="200" frameborder="0" scrolling="no"></iframe>',
+                    $this->episode->embed_url .
+                    '" width="100%" height="' . config(
+                        Embed::class,
+                    )->height . '" frameborder="0" scrolling="no"></iframe>',
             ),
         );
-        $oembed->addChild('width', '600');
-        $oembed->addChild('height', '200');
+        $oembed->addChild('width', (string) config('Embed')->width);
+        $oembed->addChild('height', (string) config('Embed')->height);
 
+        // @phpstan-ignore-next-line
         return $this->response->setXML($oembed);
     }
+
+    public function episodeObject(): ResponseInterface
+    {
+        $podcastObject = new PodcastEpisode($this->episode);
+
+        return $this->response
+            ->setContentType('application/json')
+            ->setBody($podcastObject->toJSON());
+    }
+
+    public function comments(): ResponseInterface
+    {
+        /**
+         * get comments: aggregated replies from posts referring to the episode
+         */
+        $episodeComments = model('PostModel')
+            ->whereIn('in_reply_to_id', fn (BaseBuilder $builder): BaseBuilder => $builder->select('id')
+                ->from('fediverse_posts')
+                ->where('episode_id', $this->episode->id))
+            ->where('`published_at` <= UTC_TIMESTAMP()', null, false)
+            ->orderBy('published_at', 'ASC');
+
+        $pageNumber = (int) $this->request->getGet('page');
+
+        if ($pageNumber < 1) {
+            $episodeComments->paginate(12);
+            $pager = $episodeComments->pager;
+            $collection = new OrderedCollectionObject(null, $pager);
+        } else {
+            $paginatedComments = $episodeComments->paginate(12, 'default', $pageNumber);
+            $pager = $episodeComments->pager;
+
+            $orderedItems = [];
+            if ($paginatedComments !== null) {
+                foreach ($paginatedComments as $comment) {
+                    $orderedItems[] = (new NoteObject($comment))->toArray();
+                }
+            }
+
+            // @phpstan-ignore-next-line
+            $collection = new OrderedCollectionPage($pager, $orderedItems);
+        }
+
+        return $this->response
+            ->setContentType('application/activity+json')
+            ->setHeader('Access-Control-Allow-Origin', '*')
+            ->setBody($collection->toJSON());
+    }
 }

app/Controllers/EpisodePreviewController.php

+<?php
+
+declare(strict_types=1);
+
+/**
+ * @copyright  2023 Ad Aures
+ * @license    https://www.gnu.org/licenses/agpl-3.0.en.html AGPL3
+ * @link       https://castopod.org/
+ */
+
+namespace App\Controllers;
+
+use App\Entities\Episode;
+use App\Models\EpisodeModel;
+use CodeIgniter\Exceptions\PageNotFoundException;
+use Modules\Media\FileManagers\FileManagerInterface;
+
+class EpisodePreviewController extends BaseController
+{
+    protected Episode $episode;
+
+    public function _remap(string $method, string ...$params): mixed
+    {
+        if (count($params) < 1) {
+            throw PageNotFoundException::forPageNotFound();
+        }
+
+        // find episode by previewUUID
+        $episode = (new EpisodeModel())->getEpisodeByPreviewId($params[0]);
+
+        if (! $episode instanceof Episode) {
+            throw PageNotFoundException::forPageNotFound();
+        }
+
+        $this->episode = $episode;
+
+        if ($episode->publication_status === 'published') {
+            // redirect to episode page
+            return redirect()->route('episode', [$episode->podcast->handle, $episode->slug]);
+        }
+
+        unset($params[0]);
+
+        return $this->{$method}(...$params);
+    }
+
+    public function index(): string
+    {
+        helper('form');
+
+        return view('episode/preview-comments', [
+            'podcast' => $this->episode->podcast,
+            'episode' => $this->episode,
+        ]);
+    }
+
+    public function activity(): string
+    {
+        helper('form');
+
+        return view('episode/preview-activity', [
+            'podcast' => $this->episode->podcast,
+            'episode' => $this->episode,
+        ]);
+    }
+
+    public function chapters(): string
+    {
+        $data = [
+            'podcast' => $this->episode->podcast,
+            'episode' => $this->episode,
+        ];
+
+        if (isset($this->episode->chapters->file_key)) {
+            /** @var FileManagerInterface $fileManager */
+            $fileManager = service('file_manager');
+            $episodeChaptersJsonString = (string) $fileManager->getFileContents($this->episode->chapters->file_key);
+
+            $chapters = json_decode($episodeChaptersJsonString, true);
+            $data['chapters'] = $chapters;
+        }
+
+        helper('form');
+        return view('episode/preview-chapters', $data);
+    }
+
+    public function transcript(): string
+    {
+        // get transcript from json file
+        $data = [
+            'podcast' => $this->episode->podcast,
+            'episode' => $this->episode,
+        ];
+
+        if ($this->episode->transcript !== null) {
+            $data['transcript'] = $this->episode->transcript;
+
+            if ($this->episode->transcript->json_key !== null) {
+                /** @var FileManagerInterface $fileManager */
+                $fileManager = service('file_manager');
+                $transcriptJsonString = (string) $fileManager->getFileContents(
+                    $this->episode->transcript->json_key,
+                );
+
+                $data['captions'] = json_decode($transcriptJsonString, true);
+            }
+        }
+
+        helper('form');
+        return view('episode/preview-transcript', $data);
+    }
+}

app/Controllers/FeedController.php

 <?php
 
+declare(strict_types=1);
+
 /**
- * @copyright  2020 Podlibre
+ * @copyright  2022 Ad Aures
  * @license    https://www.gnu.org/licenses/agpl-3.0.en.html AGPL3
  * @link       https://castopod.org/
  */
 
 namespace App\Controllers;
 
+use App\Entities\Podcast;
 use App\Models\EpisodeModel;
 use App\Models\PodcastModel;
 use CodeIgniter\Controller;
 use CodeIgniter\Exceptions\PageNotFoundException;
+use CodeIgniter\HTTP\IncomingRequest;
 use CodeIgniter\HTTP\ResponseInterface;
 use Exception;
-use Opawg\UserAgentsPhp\UserAgentsRSS;
+use Modules\PremiumPodcasts\Entities\Subscription;
+use Modules\PremiumPodcasts\Models\SubscriptionModel;
+use Opawg\UserAgentsV2Php\UserAgentsRSS;
 
 class FeedController extends Controller
 {
-    public function index(string $podcastName): ResponseInterface
-    {
-        helper('rss');
+    /**
+     * Instance of the main Request object.
+     *
+     * @var IncomingRequest
+     */
+    protected $request;
 
-        $podcast = (new PodcastModel())->where('name', $podcastName)
+    public function index(string $podcastHandle): ResponseInterface
+    {
+        $podcast = (new PodcastModel())->where('handle', $podcastHandle)
             ->first();
-        if (! $podcast) {
+        if (! $podcast instanceof Podcast) {
             throw PageNotFoundException::forPageNotFound();
         }
 
+        // 301 redirect to new feed?
+        $redirectToNewFeed = service('settings')
+            ->get('Podcast.redirect_to_new_feed', 'podcast:' . $podcast->id);
+
+        if ($redirectToNewFeed && $podcast->new_feed_url !== null && filter_var(
+            $podcast->new_feed_url,
+            FILTER_VALIDATE_URL,
+        ) && $podcast->new_feed_url !== current_url()) {
+            return redirect()->to($podcast->new_feed_url, 301);
+        }
+
+        helper(['rss', 'premium_podcasts', 'misc']);
+
         $service = null;
         try {
-            $service = UserAgentsRSS::find($_SERVER['HTTP_USER_AGENT']);
+            $service = UserAgentsRSS::find(service('superglobals')->server('HTTP_USER_AGENT'));
         } catch (Exception $exception) {
             // If things go wrong the show must go on and the user must be able to download the file
-            log_message('critical', $exception);
+            log_message('critical', $exception->getMessage());
         }
 
-        $serviceSlug = null;
+        $serviceSlug = '';
         if ($service) {
             $serviceSlug = $service['slug'];
         }
 
-        $cacheName =
-            "podcast#{$podcast->id}_feed" . ($service ? "_{$serviceSlug}" : '');
+        $subscription = null;
+        $token = $this->request->getGet('token');
+        if ($token) {
+            $subscription = (new SubscriptionModel())->validateSubscription($podcastHandle, $token);
+        }
+
+        $cacheName = implode(
+            '_',
+            array_filter([
+                "podcast#{$podcast->id}",
+                'feed',
+                $service ? $serviceSlug : null,
+                $subscription instanceof Subscription ? "subscription#{$subscription->id}" : null,
+            ]),
+        );
 
         if (! ($found = cache($cacheName))) {
-            $found = get_rss_feed($podcast, $serviceSlug);
+            $found = get_rss_feed($podcast, $serviceSlug, $subscription, $token);
 
             // The page cache is set to expire after next episode publication or a decade by default so it is deleted manually upon podcast update
             $secondsToNextUnpublishedEpisode = (new EpisodeModel())->getSecondsToNextUnpublishedEpisode(
@@ -53,13 +90,7 @@ class FeedController extends Controller
             );
 
             cache()
-                ->save(
-                    $cacheName,
-                    $found,
-                    $secondsToNextUnpublishedEpisode
-                    ? $secondsToNextUnpublishedEpisode
-                    : DECADE,
-                );
+                ->save($cacheName, $found, $secondsToNextUnpublishedEpisode ?: DECADE);
         }
 
         return $this->response->setXML($found);

app/Controllers/HomeController.php

 <?php
 
+declare(strict_types=1);
+
 /**
- * @copyright  2020 Podlibre
+ * @copyright  2020 Ad Aures
  * @license    https://www.gnu.org/licenses/agpl-3.0.en.html AGPL3
  * @link       https://castopod.org/
  */
@@ -9,30 +11,73 @@
 namespace App\Controllers;
 
 use App\Models\PodcastModel;
+use CodeIgniter\Database\Exceptions\DatabaseException;
 use CodeIgniter\HTTP\RedirectResponse;
-use mysqli_sql_exception;
+use CodeIgniter\HTTP\ResponseInterface;
+use Modules\Media\FileManagers\FileManagerInterface;
 
 class HomeController extends BaseController
 {
     public function index(): RedirectResponse | string
     {
-        try {
-            $allPodcasts = (new PodcastModel())->findAll();
-        } catch (mysqli_sql_exception) {
-            // An error was caught when retrieving the podcasts from the database.
-            // Redirecting to install page because it is likely that Castopod Host has not been installed yet.
-            return redirect()->route('install');
-        }
+        $sortOptions = ['activity', 'created_desc', 'created_asc'];
+        $sortBy = in_array($this->request->getGet('sort'), $sortOptions, true) ? $this->request->getGet(
+            'sort',
+        ) : 'activity';
+
+        $allPodcasts = (new PodcastModel())->getAllPodcasts($sortBy);
 
         // check if there's only one podcast to redirect user to it
         if (count($allPodcasts) === 1) {
-            return redirect()->route('podcast-activity', [$allPodcasts[0]->name]);
+            return redirect()->route('podcast-activity', [$allPodcasts[0]->handle]);
         }
 
+        set_home_metatags();
         // default behavior: list all podcasts on home page
         $data = [
             'podcasts' => $allPodcasts,
+            'sortBy'   => $sortBy,
         ];
+
         return view('home', $data);
     }
+
+    public function health(): ResponseInterface
+    {
+        $errors = [];
+
+        try {
+            db_connect();
+        } catch (DatabaseException) {
+            $errors[] = 'Unable to connect to the database.';
+        }
+
+        // --- Can Castopod connect to the cache handler
+        if (config('Cache')->handler !== 'dummy' && cache()->getCacheInfo() === null) {
+            $errors[] = 'Unable connect to the cache handler.';
+        }
+
+        // --- Can Castopod write to storage?
+
+        /** @var FileManagerInterface $fileManager */
+        $fileManager = service('file_manager', false);
+
+        if (! $fileManager->isHealthy()) {
+            $errors[] = 'Problem with file manager.';
+        }
+
+        if ($errors !== []) {
+            return $this->response->setStatusCode(503)
+                ->setJSON([
+                    'code'   => 503,
+                    'errors' => $errors,
+                ]);
+        }
+
+        return $this->response->setStatusCode(200)
+            ->setJSON([
+                'code'    => 200,
+                'message' => '✨ All good!',
+            ]);
+    }
 }

app/Controllers/MapController.php

+<?php
+
+declare(strict_types=1);
+
+/**
+ * @copyright  2020 Ad Aures
+ * @license    https://www.gnu.org/licenses/agpl-3.0.en.html AGPL3
+ * @link       https://castopod.org/
+ */
+
+namespace App\Controllers;
+
+use App\Models\EpisodeModel;
+use CodeIgniter\HTTP\ResponseInterface;
+
+class MapController extends BaseController
+{
+    public function index(): string
+    {
+        $cacheName = implode(
+            '_',
+            array_filter([
+                'page',
+                'map',
+                service('request')
+                    ->getLocale(),
+                auth()
+                    ->loggedIn() ? 'authenticated' : null,
+            ]),
+        );
+
+        if (! ($found = cache($cacheName))) {
+            return view('pages/map', [], [
+                'cache'      => DECADE,
+                'cache_name' => $cacheName,
+            ]);
+        }
+
+        return $found;
+    }
+
+    public function getEpisodesMarkers(): ResponseInterface
+    {
+        $cacheName = 'episodes_markers';
+        if (! ($found = cache($cacheName))) {
+            $episodes = (new EpisodeModel())
+                ->where('`published_at` <= UTC_TIMESTAMP()', null, false)
+                ->where('location_geo is not', null)
+                ->findAll();
+            $found = [];
+            foreach ($episodes as $episode) {
+                $found[] = [
+                    'latitude'      => $episode->location->latitude,
+                    'longitude'     => $episode->location->longitude,
+                    'location_name' => esc($episode->location->name),
+                    'location_url'  => $episode->location->url,
+                    'episode_link'  => $episode->link,
+                    'podcast_link'  => $episode->podcast->link,
+                    'cover_url'     => $episode->cover->thumbnail_url,
+                    'podcast_title' => esc($episode->podcast->title),
+                    'episode_title' => esc($episode->title),
+                ];
+            }
+
+            // The page cache is set to a decade so it is deleted manually upon episode update
+            cache()
+                ->save($cacheName, $found, DECADE);
+        }
+
+        return $this->response->setJSON($found);
+    }
+}

app/Controllers/PageController.php

 <?php
 
+declare(strict_types=1);
+
 /**
- * @copyright  2020 Podlibre
+ * @copyright  2020 Ad Aures
  * @license    https://www.gnu.org/licenses/agpl-3.0.en.html AGPL3
  * @link       https://castopod.org/
  */
@@ -18,28 +20,41 @@ class PageController extends BaseController
 
     public function _remap(string $method, string ...$params): mixed
     {
-        if (count($params) === 0) {
+        if ($params === []) {
             throw PageNotFoundException::forPageNotFound();
         }
 
-        if (
-            $this->page = (new PageModel())->where('slug', $params[0])->first()
-        ) {
-            return $this->{$method}();
+        $page = (new PageModel())->where('slug', $params[0])->first();
+        if (! $page instanceof Page) {
+            throw PageNotFoundException::forPageNotFound();
         }
 
-        throw PageNotFoundException::forPageNotFound();
+        $this->page = $page;
+
+        return $this->{$method}();
     }
 
     public function index(): string
     {
-        $cacheName = "page-{$this->page->slug}";
+        $cacheName = implode(
+            '_',
+            array_filter([
+                'page',
+                $this->page->slug,
+                service('request')
+                    ->getLocale(),
+                auth()
+                    ->loggedIn() ? 'authenticated' : null,
+            ]),
+        );
+
         if (! ($found = cache($cacheName))) {
+            set_page_metatags($this->page);
             $data = [
                 'page' => $this->page,
             ];
 
-            $found = view('page', $data);
+            $found = view('pages/page', $data);
 
             // The page cache is set to a decade so it is deleted manually upon page update
             cache()

app/Controllers/PlatformController.php

-<?php
-
-/**
- * @copyright  2020 Podlibre
- * @license    https://www.gnu.org/licenses/agpl-3.0.en.html AGPL3
- * @link       https://castopod.org/
- */
-
-namespace App\Controllers;
-
-use App\Models\PlatformModel;
-use CodeIgniter\Controller;
-use CodeIgniter\HTTP\ResponseInterface;
-
-/*
- * Provide public access to all platforms so that they can be exported
- */
-class PlatformController extends Controller
-{
-    public function index(): ResponseInterface
-    {
-        $model = new PlatformModel();
-
-        return $this->response->setJSON($model->getPlatforms());
-    }
-}

app/Controllers/PodcastController.php

 <?php
 
+declare(strict_types=1);
+
 /**
- * @copyright  2020 Podlibre
+ * @copyright  2020 Ad Aures
  * @license    https://www.gnu.org/licenses/agpl-3.0.en.html AGPL3
  * @link       https://castopod.org/
  */
 
 namespace App\Controllers;
 
-use Analytics\AnalyticsTrait;
 use App\Entities\Podcast;
+use App\Libraries\PodcastActor;
+use App\Libraries\PodcastEpisode;
 use App\Models\EpisodeModel;
-use App\Models\NoteModel;
 use App\Models\PodcastModel;
+use App\Models\PostModel;
 use CodeIgniter\Exceptions\PageNotFoundException;
+use CodeIgniter\HTTP\ResponseInterface;
+use Modules\Analytics\AnalyticsTrait;
+use Modules\Fediverse\Objects\OrderedCollectionObject;
+use Modules\Fediverse\Objects\OrderedCollectionPage;
 
 class PodcastController extends BaseController
 {
@@ -23,26 +30,35 @@ class PodcastController extends BaseController
 
     public function _remap(string $method, string ...$params): mixed
     {
-        if (count($params) === 0) {
+        if ($params === []) {
             throw PageNotFoundException::forPageNotFound();
         }
 
         if (
-            ($this->podcast = (new PodcastModel())->getPodcastByName($params[0],)) !== null
+            ! ($podcast = (new PodcastModel())->getPodcastByHandle($params[0])) instanceof Podcast
         ) {
-            unset($params[0]);
-            return $this->{$method}(...$params);
+            throw PageNotFoundException::forPageNotFound();
         }
 
-        throw PageNotFoundException::forPageNotFound();
+        $this->podcast = $podcast;
+
+        unset($params[0]);
+
+        return $this->{$method}(...$params);
+    }
+
+    public function podcastActor(): ResponseInterface
+    {
+        $podcastActor = new PodcastActor($this->podcast);
+
+        return $this->response
+            ->setContentType('application/activity+json')
+            ->setBody($podcastActor->toJSON());
     }
 
     public function activity(): string
     {
-        // Prevent analytics hit when authenticated
-        if (! can_user_interact()) {
-            $this->registerPodcastWebpageHit($this->podcast->id);
-        }
+        $this->registerPodcastWebpageHit($this->podcast->id);
 
         $cacheName = implode(
             '_',
@@ -52,20 +68,24 @@ class PodcastController extends BaseController
                 'activity',
                 service('request')
                     ->getLocale(),
-                can_user_interact() ? '_authenticated' : null,
+                is_unlocked($this->podcast->handle) ? 'unlocked' : null,
+                auth()
+                    ->loggedIn() ? 'authenticated' : null,
             ]),
         );
 
         if (! ($cachedView = cache($cacheName))) {
+            set_podcast_metatags($this->podcast, 'activity');
             $data = [
                 'podcast' => $this->podcast,
-                'notes' => (new NoteModel())->getActorPublishedNotes($this->podcast->actor_id,),
+                'posts'   => (new PostModel())->getActorPublishedPosts($this->podcast->actor_id),
             ];
 
             // if user is logged in then send to the authenticated activity view
-            if (can_user_interact()) {
+            if (auth()->loggedIn()) {
                 helper('form');
-                return view('podcast/activity_authenticated', $data);
+
+                return view('podcast/activity', $data);
             }
 
             $secondsToNextUnpublishedEpisode = (new EpisodeModel())->getSecondsToNextUnpublishedEpisode(
@@ -73,9 +93,7 @@ class PodcastController extends BaseController
             );
 
             return view('podcast/activity', $data, [
-                'cache' => $secondsToNextUnpublishedEpisode
-                    ? $secondsToNextUnpublishedEpisode
-                    : DECADE,
+                'cache'      => $secondsToNextUnpublishedEpisode ?: DECADE,
                 'cache_name' => $cacheName,
             ]);
         }
@@ -83,18 +101,62 @@ class PodcastController extends BaseController
         return $cachedView;
     }
 
-    public function episodes(): string
+    public function about(): string
     {
-        // Prevent analytics hit when authenticated
-        if (! can_user_interact()) {
-            $this->registerPodcastWebpageHit($this->podcast->id);
+        $this->registerPodcastWebpageHit($this->podcast->id);
+
+        $cacheName = implode(
+            '_',
+            array_filter([
+                'page',
+                "podcast#{$this->podcast->id}",
+                'about',
+                service('request')
+                    ->getLocale(),
+                is_unlocked($this->podcast->handle) ? 'unlocked' : null,
+                auth()
+                    ->loggedIn() ? 'authenticated' : null,
+            ]),
+        );
+
+        if (! ($cachedView = cache($cacheName))) {
+            $stats = (new EpisodeModel())->getPodcastStats($this->podcast->id);
+
+            set_podcast_metatags($this->podcast, 'about');
+            $data = [
+                'podcast' => $this->podcast,
+                'stats'   => $stats,
+            ];
+
+            // // if user is logged in then send to the authenticated activity view
+            if (auth()->loggedIn()) {
+                helper('form');
+
+                return view('podcast/about', $data);
+            }
+
+            $secondsToNextUnpublishedEpisode = (new EpisodeModel())->getSecondsToNextUnpublishedEpisode(
+                $this->podcast->id,
+            );
+
+            return view('podcast/about', $data, [
+                'cache'      => $secondsToNextUnpublishedEpisode ?: DECADE,
+                'cache_name' => $cacheName,
+            ]);
         }
 
+        return $cachedView;
+    }
+
+    public function episodes(): string
+    {
+        $this->registerPodcastWebpageHit($this->podcast->id);
+
         $yearQuery = $this->request->getGet('year');
         $seasonQuery = $this->request->getGet('season');
 
         if (! $yearQuery && ! $seasonQuery) {
-            $defaultQuery = (new PodcastModel())->getDefaultQuery($this->podcast->id,);
+            $defaultQuery = (new PodcastModel())->getDefaultQuery($this->podcast->id);
             if ($defaultQuery) {
                 if ($defaultQuery['type'] === 'season') {
                     $seasonQuery = $defaultQuery['data']['season_number'];
@@ -114,7 +176,9 @@ class PodcastController extends BaseController
                 $seasonQuery ? 'season' . $seasonQuery : null,
                 service('request')
                     ->getLocale(),
-                can_user_interact() ? '_authenticated' : null,
+                is_unlocked($this->podcast->handle) ? 'unlocked' : null,
+                auth()
+                    ->loggedIn() ? 'authenticated' : null,
             ]),
         );
 
@@ -130,18 +194,17 @@ class PodcastController extends BaseController
                 $isActive = $yearQuery === $year['year'];
                 if ($isActive) {
                     $activeQuery = [
-                        'type' => 'year',
-                        'value' => $year['year'],
-                        'label' => $year['year'],
+                        'type'               => 'year',
+                        'value'              => $year['year'],
+                        'label'              => $year['year'],
                         'number_of_episodes' => $year['number_of_episodes'],
                     ];
                 }
 
                 $episodesNavigation[] = [
-                    'label' => $year['year'],
+                    'label'              => $year['year'],
                     'number_of_episodes' => $year['number_of_episodes'],
-                    'route' =>
-                        route_to('podcast-episodes', $this->podcast->name) .
+                    'route'              => route_to('podcast-episodes', $this->podcast->handle) .
                         '?year=' .
                         $year['year'],
                     'is_active' => $isActive,
@@ -152,7 +215,7 @@ class PodcastController extends BaseController
                 $isActive = $seasonQuery === $season['season_number'];
                 if ($isActive) {
                     $activeQuery = [
-                        'type' => 'season',
+                        'type'  => 'season',
                         'value' => $season['season_number'],
                         'label' => lang('Podcast.season', [
                             'seasonNumber' => $season['season_number'],
@@ -166,19 +229,19 @@ class PodcastController extends BaseController
                         'seasonNumber' => $season['season_number'],
                     ]),
                     'number_of_episodes' => $season['number_of_episodes'],
-                    'route' =>
-                        route_to('podcast-episodes', $this->podcast->name) .
+                    'route'              => route_to('podcast-episodes', $this->podcast->handle) .
                         '?season=' .
                         $season['season_number'],
                     'is_active' => $isActive,
                 ];
             }
 
+            set_podcast_metatags($this->podcast, 'episodes');
             $data = [
-                'podcast' => $this->podcast,
+                'podcast'     => $this->podcast,
                 'episodesNav' => $episodesNavigation,
                 'activeQuery' => $activeQuery,
-                'episodes' => (new EpisodeModel())->getPodcastEpisodes(
+                'episodes'    => (new EpisodeModel())->getPodcastEpisodes(
                     $this->podcast->id,
                     $this->podcast->type,
                     $yearQuery,
@@ -186,22 +249,66 @@ class PodcastController extends BaseController
                 ),
             ];
 
+            if (auth()->loggedIn()) {
+                return view('podcast/episodes', $data);
+            }
+
             $secondsToNextUnpublishedEpisode = (new EpisodeModel())->getSecondsToNextUnpublishedEpisode(
                 $this->podcast->id,
             );
-
-            // if user is logged in then send to the authenticated episodes view
-            if (can_user_interact()) {
-                return view('podcast/episodes_authenticated', $data);
-            }
             return view('podcast/episodes', $data, [
-                'cache' => $secondsToNextUnpublishedEpisode
-                    ? $secondsToNextUnpublishedEpisode
-                    : DECADE,
+                'cache'      => $secondsToNextUnpublishedEpisode ?: DECADE,
                 'cache_name' => $cacheName,
             ]);
         }
 
         return $cachedView;
     }
+
+    public function episodeCollection(): ResponseInterface
+    {
+        if ($this->podcast->type === 'serial') {
+            // podcast is serial
+            $episodes = model('EpisodeModel')
+                ->where('`published_at` <= UTC_TIMESTAMP()', null, false)
+                ->orderBy('season_number DESC, number ASC');
+        } else {
+            $episodes = model('EpisodeModel')
+                ->where('`published_at` <= UTC_TIMESTAMP()', null, false)
+                ->orderBy('published_at', 'DESC');
+        }
+
+        $pageNumber = (int) $this->request->getGet('page');
+
+        if ($pageNumber < 1) {
+            $episodes->paginate(12);
+            $pager = $episodes->pager;
+            $collection = new OrderedCollectionObject(null, $pager);
+        } else {
+            $paginatedEpisodes = $episodes->paginate(12, 'default', $pageNumber);
+            $pager = $episodes->pager;
+
+            $orderedItems = [];
+            if ($paginatedEpisodes !== null) {
+                foreach ($paginatedEpisodes as $episode) {
+                    $orderedItems[] = (new PodcastEpisode($episode))->toArray();
+                }
+            }
+
+            // @phpstan-ignore-next-line
+            $collection = new OrderedCollectionPage($pager, $orderedItems);
+        }
+
+        return $this->response
+            ->setContentType('application/activity+json')
+            ->setBody($collection->toJSON());
+    }
+
+    public function links(): string
+    {
+        set_podcast_metatags($this->podcast, 'links');
+        return view('podcast/links', [
+            'podcast' => $this->podcast,
+        ]);
+    }
 }

app/Controllers/NoteController.php → app/Controllers/PostController.php

 <?php
 
+declare(strict_types=1);
+
 /**
- * @copyright  2020 Podlibre
+ * @copyright  2020 Ad Aures
  * @license    https://www.gnu.org/licenses/agpl-3.0.en.html AGPL3
  * @link       https://castopod.org/
  */
 
 namespace App\Controllers;
 
-use ActivityPub\Controllers\NoteController as ActivityPubNoteController;
-use ActivityPub\Entities\Note as ActivityPubNote;
-use Analytics\AnalyticsTrait;
 use App\Entities\Actor;
-use App\Entities\Note as CastopodNote;
 use App\Entities\Podcast;
+use App\Entities\Post as CastopodPost;
 use App\Models\EpisodeModel;
 use App\Models\PodcastModel;
+use App\Models\PostModel;
 use CodeIgniter\Exceptions\PageNotFoundException;
 use CodeIgniter\HTTP\RedirectResponse;
 use CodeIgniter\HTTP\URI;
 use CodeIgniter\I18n\Time;
+use Modules\Analytics\AnalyticsTrait;
+use Modules\Fediverse\Controllers\PostController as FediversePostController;
+use Override;
 
-class NoteController extends ActivityPubNoteController
+class PostController extends FediversePostController
 {
     use AnalyticsTrait;
 
@@ -30,26 +33,42 @@ class NoteController extends ActivityPubNoteController
     protected Actor $actor;
 
     /**
-     * @var string[]
+     * @var CastopodPost
      */
-    protected $helpers = ['auth', 'activitypub', 'svg', 'components', 'misc'];
+    protected $post;
 
+    /**
+     * @var list<string>
+     */
+    protected $helpers = ['auth', 'fediverse', 'svg', 'components', 'misc', 'seo', 'premium_podcasts'];
+
+    #[Override]
     public function _remap(string $method, string ...$params): mixed
     {
+
         if (
-            ($this->podcast = (new PodcastModel())->getPodcastByName($params[0],)) === null
+            ! ($podcast = (new PodcastModel())->getPodcastByHandle($params[0])) instanceof Podcast
         ) {
             throw PageNotFoundException::forPageNotFound();
         }
 
+        $this->podcast = $podcast;
         $this->actor = $this->podcast->actor;
 
+        if (count($params) <= 1) {
+            unset($params[0]);
+
+            return $this->{$method}(...$params);
+        }
+
         if (
-            count($params) > 1 &&
-            ! ($this->note = model('NoteModel')->getNoteById($params[1]))
+            ! ($post = (new PostModel())->getPostById($params[1])) instanceof CastopodPost
         ) {
             throw PageNotFoundException::forPageNotFound();
         }
+
+        $this->post = $post;
+
         unset($params[0]);
         unset($params[1]);
 
@@ -58,36 +77,35 @@ class NoteController extends ActivityPubNoteController
 
     public function view(): string
     {
-        // Prevent analytics hit when authenticated
-        if (! can_user_interact()) {
-            $this->registerPodcastWebpageHit($this->podcast->id);
-        }
+        $this->registerPodcastWebpageHit($this->podcast->id);
 
         $cacheName = implode(
             '_',
             array_filter([
                 'page',
-                "note#{$this->note->id}",
+                "post#{$this->post->id}",
                 service('request')
                     ->getLocale(),
-                can_user_interact() ? '_authenticated' : null,
+                auth()
+                    ->loggedIn() ? 'authenticated' : null,
             ]),
         );
 
         if (! ($cachedView = cache($cacheName))) {
+            set_post_metatags($this->post);
             $data = [
+                'post'    => $this->post,
                 'podcast' => $this->podcast,
-                'actor' => $this->actor,
-                'note' => $this->note,
             ];
 
             // if user is logged in then send to the authenticated activity view
-            if (can_user_interact()) {
+            if (auth()->loggedIn()) {
                 helper('form');
-                return view('podcast/note_authenticated', $data);
+                return view('post/post', $data);
             }
-            return view('podcast/note', $data, [
-                'cache' => DECADE,
+
+            return view('post/post', $data, [
+                'cache'      => DECADE,
                 'cache_name' => $cacheName,
             ]);
         }
@@ -95,11 +113,12 @@ class NoteController extends ActivityPubNoteController
         return $cachedView;
     }
 
-    public function attemptCreate(): RedirectResponse
+    #[Override]
+    public function createAction(): RedirectResponse
     {
         $rules = [
-            'message' => 'required|max_length[500]',
-            'episode_url' => 'valid_url|permit_empty',
+            'message'     => 'required|max_length[500]',
+            'episode_url' => 'valid_url_strict|permit_empty',
         ];
 
         if (! $this->validate($rules)) {
@@ -109,41 +128,45 @@ class NoteController extends ActivityPubNoteController
                 ->with('errors', $this->validator->getErrors());
         }
 
-        $message = $this->request->getPost('message');
+        $validData = $this->validator->getValidated();
 
-        $newNote = new CastopodNote([
-            'actor_id' => interact_as_actor_id(),
+        $message = $validData['message'];
+
+        $newPost = new CastopodPost([
+            'actor_id'     => interact_as_actor_id(),
             'published_at' => Time::now(),
-            'created_by' => user_id(),
+            'created_by'   => user_id(),
         ]);
 
         // get episode if episodeUrl has been set
-        $episodeUri = $this->request->getPost('episode_url');
+        $episodeUri = $validData['episode_url'];
         if (
             $episodeUri &&
             ($params = extract_params_from_episode_uri(new URI($episodeUri))) &&
-            ($episode = (new EpisodeModel())->getEpisodeBySlug($params['podcastName'], $params['episodeSlug'],))
+            ($episode = (new EpisodeModel())->getEpisodeBySlug($params['podcastHandle'], $params['episodeSlug']))
         ) {
-            $newNote->episode_id = $episode->id;
+            $newPost->episode_id = $episode->id;
         }
 
-        $newNote->message = $message;
+        $newPost->message = $message;
 
+        $postModel = new PostModel();
         if (
-            ! model('NoteModel')
-                ->addNote($newNote, ! (bool) $newNote->episode_id, true,)
+            ! $postModel
+                ->addPost($newPost, ! (bool) $newPost->episode_id, true)
         ) {
             return redirect()
                 ->back()
                 ->withInput()
-                ->with('errors', model('NoteModel')->errors());
+                ->with('errors', $postModel->errors());
         }
 
-        // Note has been successfully created
+        // Post has been successfully created
         return redirect()->back();
     }
 
-    public function attemptReply(): RedirectResponse
+    #[Override]
+    public function replyAction(): RedirectResponse
     {
         $rules = [
             'message' => 'required|max_length[500]',
@@ -156,40 +179,49 @@ class NoteController extends ActivityPubNoteController
                 ->with('errors', $this->validator->getErrors());
         }
 
-        $newNote = new ActivityPubNote([
-            'actor_id' => interact_as_actor_id(),
-            'in_reply_to_id' => $this->note->id,
-            'message' => $this->request->getPost('message'),
-            'published_at' => Time::now(),
-            'created_by' => user_id(),
+        $validData = $this->validator->getValidated();
+
+        $newPost = new CastopodPost([
+            'actor_id'       => interact_as_actor_id(),
+            'in_reply_to_id' => $this->post->id,
+            'message'        => $validData['message'],
+            'published_at'   => Time::now(),
+            'created_by'     => user_id(),
         ]);
 
-        if (! model('NoteModel')->addReply($newNote)) {
+        if ($this->post->episode_id !== null) {
+            $newPost->episode_id = $this->post->episode_id;
+        }
+
+        $postModel = new PostModel();
+        if (! $postModel->addReply($newPost)) {
             return redirect()
                 ->back()
                 ->withInput()
-                ->with('errors', model('NoteModel')->errors());
+                ->with('errors', $postModel->errors());
         }
 
-        // Reply note without preview card has been successfully created
+        // Reply post without preview card has been successfully created
         return redirect()->back();
     }
 
-    public function attemptFavourite(): RedirectResponse
+    #[Override]
+    public function favouriteAction(): RedirectResponse
     {
-        model('FavouriteModel')->toggleFavourite(interact_as_actor(), $this->note,);
+        model('FavouriteModel')->toggleFavourite(interact_as_actor(), $this->post);
 
         return redirect()->back();
     }
 
-    public function attemptReblog(): RedirectResponse
+    #[Override]
+    public function reblogAction(): RedirectResponse
     {
-        model('NoteModel')->toggleReblog(interact_as_actor(), $this->note);
+        (new PostModel())->toggleReblog(interact_as_actor(), $this->post);
 
         return redirect()->back();
     }
 
-    public function attemptAction(): RedirectResponse
+    public function action(): RedirectResponse
     {
         $rules = [
             'action' => 'required|in_list[favourite,reblog,reply]',
@@ -202,51 +234,35 @@ class NoteController extends ActivityPubNoteController
                 ->with('errors', $this->validator->getErrors());
         }
 
-        $action = $this->request->getPost('action');
-        /** @phpstan-ignore-next-line */
-        switch ($action) {
-            case 'favourite':
-                return $this->attemptFavourite();
-            case 'reblog':
-                return $this->attemptReblog();
-            case 'reply':
-                return $this->attemptReply();
-            default:
-                return redirect()
-                    ->back()
-                    ->withInput()
-                    ->with('errors', 'error');
-        }
+        $validData = $this->validator->getValidated();
+
+        $action = $validData['action'];
+        return match ($action) {
+            'favourite' => $this->favouriteAction(),
+            'reblog'    => $this->reblogAction(),
+            'reply'     => $this->replyAction(),
+            default     => redirect()
+                ->back()
+                ->withInput()
+                ->with('errors', 'error'),
+        };
     }
 
-    public function remoteAction(string $action): string
+    public function remoteActionView(string $action): string
     {
-        // Prevent analytics hit when authenticated
-        if (! can_user_interact()) {
-            $this->registerPodcastWebpageHit($this->podcast->id);
-        }
-
-        $cacheName = implode(
-            '_',
-            array_filter(['page', "note#{$this->note->id}", "remote_{$action}", service('request') ->getLocale()]),
-        );
-
-        if (! ($cachedView = cache($cacheName))) {
-            $data = [
-                'podcast' => $this->podcast,
-                'actor' => $this->actor,
-                'note' => $this->note,
-                'action' => $action,
-            ];
-
-            helper('form');
+        $this->registerPodcastWebpageHit($this->podcast->id);
+
+        set_remote_actions_metatags($this->post, $action);
+        $data = [
+            'podcast' => $this->podcast,
+            'actor'   => $this->actor,
+            'post'    => $this->post,
+            'action'  => $action,
+        ];
 
-            return view('podcast/note_remote_action', $data, [
-                'cache' => DECADE,
-                'cache_name' => $cacheName,
-            ]);
-        }
+        helper('form');
 
-        return (string) $cachedView;
+        // NO VIEW CACHING: form has a CSRF token which should change on each request
+        return view('post/remote_action', $data);
     }
 }

app/Controllers/WebmanifestController.php

+<?php
+
+declare(strict_types=1);
+
+/**
+ * @copyright  2020 Ad Aures
+ * @license    https://www.gnu.org/licenses/agpl-3.0.en.html AGPL3
+ * @link       https://castopod.org/
+ */
+
+namespace App\Controllers;
+
+use App\Entities\Podcast;
+use App\Models\PodcastModel;
+use CodeIgniter\Controller;
+use CodeIgniter\Exceptions\PageNotFoundException;
+use CodeIgniter\HTTP\ResponseInterface;
+
+class WebmanifestController extends Controller
+{
+    /**
+     * @var array<string, array<string, string>>
+     */
+    final public const array THEME_COLORS = [
+        'pine' => [
+            'theme'      => '#009486',
+            'background' => '#F0F9F8',
+        ],
+        'lake' => [
+            'theme'      => '#00ACE0',
+            'background' => '#F0F7F9',
+        ],
+        'jacaranda' => [
+            'theme'      => '#562CDD',
+            'background' => '#F2F0F9',
+        ],
+        'crimson' => [
+            'theme'      => '#F24562',
+            'background' => '#F9F0F2',
+        ],
+        'amber' => [
+            'theme'      => '#FF6224',
+            'background' => '#F9F3F0',
+        ],
+        'onyx' => [
+            'theme'      => '#040406',
+            'background' => '#F3F3F7',
+        ],
+    ];
+
+    public function index(): ResponseInterface
+    {
+        helper('misc');
+
+        $webmanifest = [
+            'name'        => esc(service('settings') ->get('App.siteName')),
+            'description' => esc(service('settings') ->get('App.siteDescription')),
+            'lang'        => service('request')
+                ->getLocale(),
+            'start_url'        => base_url(),
+            'display'          => 'standalone',
+            'orientation'      => 'portrait',
+            'theme_color'      => self::THEME_COLORS[service('settings')->get('App.theme')]['theme'],
+            'background_color' => self::THEME_COLORS[service('settings')->get('App.theme')]['background'],
+            'icons'            => [
+                [
+                    'src'   => get_site_icon_url('192'),
+                    'type'  => 'image/png',
+                    'sizes' => '192x192',
+                ],
+                [
+                    'src'   => get_site_icon_url('512'),
+                    'type'  => 'image/png',
+                    'sizes' => '512x512',
+                ],
+            ],
+        ];
+
+        return $this->response->setJSON($webmanifest);
+    }
+
+    public function podcastManifest(string $podcastHandle): ResponseInterface
+    {
+        if (
+            ! ($podcast = (new PodcastModel())->getPodcastByHandle($podcastHandle)) instanceof Podcast
+        ) {
+            throw PageNotFoundException::forPageNotFound();
+        }
+
+        $webmanifest = [
+            'name'             => esc($podcast->title),
+            'short_name'       => $podcast->at_handle,
+            'description'      => $podcast->description,
+            'lang'             => $podcast->language_code,
+            'start_url'        => $podcast->link,
+            'scope'            => '/' . $podcast->at_handle,
+            'display'          => 'standalone',
+            'orientation'      => 'portrait',
+            'theme_color'      => self::THEME_COLORS[service('settings')->get('App.theme')]['theme'],
+            'background_color' => self::THEME_COLORS[service('settings')->get('App.theme')]['background'],
+            'icons'            => [
+                [
+                    'src'   => $podcast->cover->webmanifest192_url,
+                    'type'  => $podcast->cover->webmanifest192_mimetype,
+                    'sizes' => '192x192',
+                ],
+                [
+                    'src'   => $podcast->cover->webmanifest512_url,
+                    'type'  => $podcast->cover->webmanifest512_mimetype,
+                    'sizes' => '512x512',
+                ],
+            ],
+        ];
+
+        return $this->response->setJSON($webmanifest);
+    }
+}

app/Database/Migrations/2020-07-03-191500_add_podcasts_users.php

-<?php
-
-/**
- * Class AddPodcastUsers Creates podcast_users table in database
- *
- * @copyright  2020 Podlibre
- * @license    https://www.gnu.org/licenses/agpl-3.0.en.html AGPL3
- * @link       https://castopod.org/
- */
-
-namespace App\Database\Migrations;
-
-use CodeIgniter\Database\Migration;
-
-class AddPodcastsUsers extends Migration
-{
-    public function up(): void
-    {
-        $this->forge->addField([
-            'podcast_id' => [
-                'type' => 'INT',
-                'unsigned' => true,
-            ],
-            'user_id' => [
-                'type' => 'INT',
-                'unsigned' => true,
-            ],
-            'group_id' => [
-                'type' => 'INT',
-                'unsigned' => true,
-            ],
-        ]);
-        $this->forge->addPrimaryKey(['user_id', 'podcast_id']);
-        $this->forge->addForeignKey('user_id', 'users', 'id', '', 'CASCADE');
-        $this->forge->addForeignKey('podcast_id', 'podcasts', 'id', '', 'CASCADE',);
-        $this->forge->addForeignKey('group_id', 'auth_groups', 'id', '', 'CASCADE',);
-        $this->forge->createTable('podcasts_users');
-    }
-
-    public function down(): void
-    {
-        $this->forge->dropTable('podcasts_users');
-    }
-}

app/Database/Migrations/2021-02-23-100000_add_episode_id_to_notes.php

-<?php
-
-/**
- * Class AddEpisodeIdToNotes Adds episode_id field to activitypub_notes table in database
- *
- * @copyright  2020 Podlibre
- * @license    https://www.gnu.org/licenses/agpl-3.0.en.html AGPL3
- * @link       https://castopod.org/
- */
-
-namespace App\Database\Migrations;
-
-use CodeIgniter\Database\Migration;
-
-class AddEpisodeIdToNotes extends Migration
-{
-    public function up(): void
-    {
-        $prefix = $this->db->getPrefix();
-
-        $createQuery = <<<CODE_SAMPLE
-            ALTER TABLE {$prefix}activitypub_notes
-            ADD COLUMN `episode_id` INT UNSIGNED NULL AFTER `replies_count`,
-            ADD FOREIGN KEY {$prefix}activitypub_notes_episode_id_foreign(episode_id) REFERENCES {$prefix}episodes(id) ON DELETE CASCADE;
-        CODE_SAMPLE;
-        $this->db->query($createQuery);
-    }
-
-    public function down(): void
-    {
-        $this->forge->dropForeignKey('activitypub_notes', 'activitypub_notes_episode_id_foreign',);
-        $this->forge->dropColumn('activitypub_notes', 'episode_id');
-    }
-}

app/Database/Migrations/2021-03-09-113000_add_created_by_to_notes.php

-<?php
-
-/**
- * Class AddCreatedByToNotes Adds created_by field to activitypub_notes table in database
- *
- * @copyright  2020 Podlibre
- * @license    https://www.gnu.org/licenses/agpl-3.0.en.html AGPL3
- * @link       https://castopod.org/
- */
-
-namespace App\Database\Migrations;
-
-use CodeIgniter\Database\Migration;
-
-class AddCreatedByToNotes extends Migration
-{
-    public function up(): void
-    {
-        $prefix = $this->db->getPrefix();
-
-        $createQuery = <<<CODE_SAMPLE
-            ALTER TABLE {$prefix}activitypub_notes
-            ADD COLUMN `created_by` INT UNSIGNED AFTER `episode_id`,
-            ADD FOREIGN KEY {$prefix}activitypub_notes_created_by_foreign(created_by) REFERENCES {$prefix}users(id) ON DELETE CASCADE;
-        CODE_SAMPLE;
-        $this->db->query($createQuery);
-    }
-
-    public function down(): void
-    {
-        $this->forge->dropForeignKey('activitypub_notes', 'activitypub_notes_created_by_foreign',);
-        $this->forge->dropColumn('activitypub_notes', 'created_by');
-    }
-}

app/Database/Migrations/2020-05-29-152000_add_categories.php → app/Database/Migrations/2021-05-29-152000_add_categories.php

 <?php
 
+declare(strict_types=1);
+
 /**
  * Class AddCategories Creates categories table in database
  *
- * @copyright  2020 Podlibre
+ * @copyright  2020 Ad Aures
  * @license    https://www.gnu.org/licenses/agpl-3.0.en.html AGPL3
  * @link       https://castopod.org/
  */
 
 namespace App\Database\Migrations;
 
-use CodeIgniter\Database\Migration;
+use Override;
 
-class AddCategories extends Migration
+class AddCategories extends BaseMigration
 {
+    #[Override]
     public function up(): void
     {
         $this->forge->addField([
             'id' => [
-                'type' => 'INT',
+                'type'     => 'INT',
                 'unsigned' => true,
             ],
             'parent_id' => [
-                'type' => 'INT',
+                'type'     => 'INT',
                 'unsigned' => true,
-                'null' => true,
+                'null'     => true,
             ],
             'code' => [
-                'type' => 'VARCHAR',
+                'type'       => 'VARCHAR',
                 'constraint' => 32,
             ],
             'apple_category' => [
-                'type' => 'VARCHAR',
+                'type'       => 'VARCHAR',
                 'constraint' => 32,
             ],
             'google_category' => [
-                'type' => 'VARCHAR',
+                'type'       => 'VARCHAR',
                 'constraint' => 32,
             ],
         ]);
@@ -45,6 +48,7 @@ class AddCategories extends Migration
         $this->forge->createTable('categories');
     }
 
+    #[Override]
     public function down(): void
     {
         $this->forge->dropTable('categories');

app/Database/Migrations/2020-05-30-101000_add_languages.php → app/Database/Migrations/2021-05-30-101000_add_languages.php

 <?php
 
+declare(strict_types=1);
+
 /**
  * Class AddLanguages Creates languages table in database
  *
- * @copyright  2020 Podlibre
+ * @copyright  2020 Ad Aures
  * @license    https://www.gnu.org/licenses/agpl-3.0.en.html AGPL3
  * @link       https://castopod.org/
  */
 
 namespace App\Database\Migrations;
 
-use CodeIgniter\Database\Migration;
+use Override;
 
-class AddLanguages extends Migration
+class AddLanguages extends BaseMigration
 {
+    #[Override]
     public function up(): void
     {
         $this->forge->addField([
             'code' => [
-                'type' => 'VARCHAR',
-                'comment' => 'ISO 639-1 language code',
+                'type'       => 'VARCHAR',
+                'comment'    => 'ISO 639-1 language code',
                 'constraint' => 2,
             ],
             'native_name' => [
-                'type' => 'VARCHAR',
+                'type'       => 'VARCHAR',
                 'constraint' => 128,
             ],
         ]);
@@ -31,6 +34,7 @@ class AddLanguages extends Migration
         $this->forge->createTable('languages');
     }
 
+    #[Override]
     public function down(): void
     {
         $this->forge->dropTable('languages');

app/Database/Migrations/2020-05-30-101500_add_podcasts.php → app/Database/Migrations/2021-05-30-101500_add_podcasts.php

 <?php
 
+declare(strict_types=1);
+
 /**
  * Class AddPodcasts Creates podcasts table in database
  *
- * @copyright  2020 Podlibre
+ * @copyright  2020 Ad Aures
  * @license    https://www.gnu.org/licenses/agpl-3.0.en.html AGPL3
  * @link       https://castopod.org/
  */
 
 namespace App\Database\Migrations;
 
-use CodeIgniter\Database\Migration;
+use Override;
 
-class AddPodcasts extends Migration
+class AddPodcasts extends BaseMigration
 {
+    #[Override]
     public function up(): void
     {
         $this->forge->addField([
             'id' => [
-                'type' => 'INT',
-                'unsigned' => true,
+                'type'           => 'INT',
+                'unsigned'       => true,
                 'auto_increment' => true,
             ],
+            'guid' => [
+                'type'       => 'CHAR',
+                'constraint' => 36,
+            ],
             'actor_id' => [
-                'type' => 'INT',
+                'type'     => 'INT',
                 'unsigned' => true,
             ],
-            'name' => [
-                'type' => 'VARCHAR',
+            'handle' => [
+                'type'       => 'VARCHAR',
                 'constraint' => 32,
             ],
             'title' => [
-                'type' => 'VARCHAR',
+                'type'       => 'VARCHAR',
                 'constraint' => 128,
             ],
             'description_markdown' => [
@@ -40,53 +47,51 @@ class AddPodcasts extends Migration
             'description_html' => [
                 'type' => 'TEXT',
             ],
-            'image_path' => [
-                'type' => 'VARCHAR',
-                'constraint' => 255,
+            'cover_id' => [
+                'type'     => 'INT',
+                'unsigned' => true,
             ],
-            // constraint is 13 because the longest safe mimetype for images is image/svg+xml,
-            // see https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types#image_types
-            'image_mimetype' => [
-                'type' => 'VARCHAR',
-                'constraint' => 13,
+            'banner_id' => [
+                'type'     => 'INT',
+                'unsigned' => true,
+                'null'     => true,
             ],
             'language_code' => [
-                'type' => 'VARCHAR',
+                'type'       => 'VARCHAR',
                 'constraint' => 2,
             ],
             'category_id' => [
-                'type' => 'INT',
+                'type'     => 'INT',
                 'unsigned' => true,
-                'default' => 0,
+                'default'  => 0,
             ],
             'parental_advisory' => [
-                'type' => 'ENUM',
+                'type'       => 'ENUM',
                 'constraint' => ['clean', 'explicit'],
-                'null' => true,
-                'default' => null,
+                'null'       => true,
             ],
             'owner_name' => [
-                'type' => 'VARCHAR',
+                'type'       => 'VARCHAR',
                 'constraint' => 128,
             ],
             'owner_email' => [
-                'type' => 'VARCHAR',
+                'type'       => 'VARCHAR',
                 'constraint' => 255,
             ],
             'publisher' => [
-                'type' => 'VARCHAR',
+                'type'       => 'VARCHAR',
                 'constraint' => 128,
-                'null' => true,
+                'null'       => true,
             ],
             'type' => [
-                'type' => 'ENUM',
+                'type'       => 'ENUM',
                 'constraint' => ['episodic', 'serial'],
-                'default' => 'episodic',
+                'default'    => 'episodic',
             ],
             'copyright' => [
-                'type' => 'VARCHAR',
+                'type'       => 'VARCHAR',
                 'constraint' => 128,
-                'null' => true,
+                'null'       => true,
             ],
             'episode_description_footer_markdown' => [
                 'type' => 'TEXT',
@@ -97,99 +102,105 @@ class AddPodcasts extends Migration
                 'null' => true,
             ],
             'is_blocked' => [
-                'type' => 'TINYINT',
+                'type'       => 'TINYINT',
                 'constraint' => 1,
-                'default' => 0,
+                'default'    => 0,
             ],
             'is_completed' => [
-                'type' => 'TINYINT',
+                'type'       => 'TINYINT',
                 'constraint' => 1,
-                'default' => 0,
+                'default'    => 0,
             ],
             'is_locked' => [
-                'type' => 'TINYINT',
+                'type'       => 'TINYINT',
                 'constraint' => 1,
-                'default' => 1,
+                'default'    => 1,
             ],
             'imported_feed_url' => [
-                'type' => 'VARCHAR',
+                'type'       => 'VARCHAR',
                 'constraint' => 512,
-                'comment' =>
-                    'The RSS feed URL if this podcast was imported, NULL otherwise.',
-                'null' => true,
+                'comment'    => 'The RSS feed URL if this podcast was imported, NULL otherwise.',
+                'null'       => true,
             ],
             'new_feed_url' => [
-                'type' => 'VARCHAR',
+                'type'       => 'VARCHAR',
                 'constraint' => 512,
-                'comment' =>
-                    'The RSS new feed URL if this podcast is moving out, NULL otherwise.',
-                'null' => true,
+                'comment'    => 'The RSS new feed URL if this podcast is moving out, NULL otherwise.',
+                'null'       => true,
             ],
             'payment_pointer' => [
-                'type' => 'VARCHAR',
+                'type'       => 'VARCHAR',
                 'constraint' => 128,
-                'comment' => 'Wallet address for Web Monetization payments',
-                'null' => true,
+                'comment'    => 'Wallet address for Web Monetization payments',
+                'null'       => true,
             ],
             'location_name' => [
-                'type' => 'VARCHAR',
+                'type'       => 'VARCHAR',
                 'constraint' => 128,
-                'null' => true,
+                'null'       => true,
             ],
             'location_geo' => [
-                'type' => 'VARCHAR',
+                'type'       => 'VARCHAR',
                 'constraint' => 32,
-                'null' => true,
+                'null'       => true,
             ],
             'location_osm' => [
-                'type' => 'VARCHAR',
+                'type'       => 'VARCHAR',
                 'constraint' => 12,
-                'null' => true,
+                'null'       => true,
             ],
             'custom_rss' => [
                 'type' => 'JSON',
                 'null' => true,
             ],
             'partner_id' => [
-                'type' => 'VARCHAR',
+                'type'       => 'VARCHAR',
                 'constraint' => 32,
-                'null' => true,
+                'null'       => true,
             ],
             'partner_link_url' => [
-                'type' => 'VARCHAR',
+                'type'       => 'VARCHAR',
                 'constraint' => 512,
-                'null' => true,
+                'null'       => true,
             ],
             'partner_image_url' => [
-                'type' => 'VARCHAR',
+                'type'       => 'VARCHAR',
                 'constraint' => 512,
-                'null' => true,
+                'null'       => true,
+            ],
+            'is_premium_by_default' => [
+                'type'       => 'TINYINT',
+                'constraint' => 1,
+                'default'    => 0,
             ],
             'created_by' => [
-                'type' => 'INT',
+                'type'     => 'INT',
                 'unsigned' => true,
             ],
             'updated_by' => [
-                'type' => 'INT',
+                'type'     => 'INT',
                 'unsigned' => true,
             ],
-            'created_at' => [
+            'published_at' => [
                 'type' => 'DATETIME',
+                'null' => true,
             ],
-            'updated_at' => [
+            'created_at' => [
                 'type' => 'DATETIME',
             ],
-            'deleted_at' => [
+            'updated_at' => [
                 'type' => 'DATETIME',
-                'null' => true,
             ],
         ]);
 
         $this->forge->addPrimaryKey('id');
         // TODO: remove name in favor of username from actor
-        $this->forge->addUniqueKey('name');
+        $this->forge->addUniqueKey('handle');
+        $this->forge->addUniqueKey('guid');
         $this->forge->addUniqueKey('actor_id');
-        $this->forge->addForeignKey('actor_id', 'activitypub_actors', 'id', '', 'CASCADE',);
+        $this->forge->addForeignKey('actor_id', 'fediverse_actors', 'id', '', 'CASCADE');
+        $this->forge->addForeignKey('cover_id', 'media', 'id');
+        $this->forge->addForeignKey('banner_id', 'media', 'id', '', 'SET NULL');
         $this->forge->addForeignKey('category_id', 'categories', 'id');
         $this->forge->addForeignKey('language_code', 'languages', 'code');
         $this->forge->addForeignKey('created_by', 'users', 'id');
@@ -197,6 +208,7 @@ class AddPodcasts extends Migration
         $this->forge->createTable('podcasts');
     }
 
+    #[Override]
     public function down(): void
     {
         $this->forge->dropTable('podcasts');

app/Database/Migrations/2020-06-05-170000_add_episodes.php → app/Database/Migrations/2021-06-05-170000_add_episodes.php

 <?php
 
+declare(strict_types=1);
+
 /**
  * Class AddEpisodes Creates episodes table in database
  *
- * @copyright  2020 Podlibre
+ * @copyright  2020 Ad Aures
  * @license    https://www.gnu.org/licenses/agpl-3.0.en.html AGPL3
  * @link       https://castopod.org/
  */
 
 namespace App\Database\Migrations;
 
-use CodeIgniter\Database\Migration;
+use Override;
 
-class AddEpisodes extends Migration
+class AddEpisodes extends BaseMigration
 {
+    #[Override]
     public function up(): void
     {
         $this->forge->addField([
             'id' => [
-                'type' => 'INT',
-                'unsigned' => true,
+                'type'           => 'INT',
+                'unsigned'       => true,
                 'auto_increment' => true,
             ],
             'podcast_id' => [
-                'type' => 'INT',
+                'type'     => 'INT',
                 'unsigned' => true,
             ],
             'guid' => [
-                'type' => 'VARCHAR',
+                'type'       => 'VARCHAR',
                 'constraint' => 255,
             ],
             'title' => [
-                'type' => 'VARCHAR',
+                'type'       => 'VARCHAR',
                 'constraint' => 128,
             ],
             'slug' => [
-                'type' => 'VARCHAR',
-                'constraint' => 191,
-            ],
-            'audio_file_path' => [
-                'type' => 'VARCHAR',
-                'constraint' => 255,
-            ],
-            'audio_file_duration' => [
-                // exact value for duration with max 99999,999 ~ 27.7 hours
-                'type' => 'DECIMAL(8,3)',
-                'unsigned' => true,
-                'comment' => 'Playtime in seconds',
-            ],
-            'audio_file_mimetype' => [
-                'type' => 'VARCHAR',
-                'constraint' => 255,
-            ],
-            'audio_file_size' => [
-                'type' => 'INT',
-                'unsigned' => true,
-                'comment' => 'File size in bytes',
+                'type'       => 'VARCHAR',
+                'constraint' => 128,
             ],
-            'audio_file_header_size' => [
-                'type' => 'INT',
+            'audio_id' => [
+                'type'     => 'INT',
                 'unsigned' => true,
-                'comment' => 'Header size in bytes',
             ],
             'description_markdown' => [
                 'type' => 'TEXT',
@@ -68,104 +51,96 @@ class AddEpisodes extends Migration
             'description_html' => [
                 'type' => 'TEXT',
             ],
-            'image_path' => [
-                'type' => 'VARCHAR',
-                'constraint' => 255,
-                'null' => true,
-            ],
-            // constraint is 13 because the longest safe mimetype for images is image/svg+xml,
-            // see https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types#image_types
-            'image_mimetype' => [
-                'type' => 'VARCHAR',
-                'constraint' => 13,
-                'null' => true,
+            'cover_id' => [
+                'type'     => 'INT',
+                'unsigned' => true,
+                'null'     => true,
             ],
-            'transcript_file_path' => [
-                'type' => 'VARCHAR',
-                'constraint' => 255,
-                'null' => true,
+            'transcript_id' => [
+                'type'     => 'INT',
+                'unsigned' => true,
+                'null'     => true,
             ],
-            'transcript_file_remote_url' => [
-                'type' => 'VARCHAR',
+            'transcript_remote_url' => [
+                'type'       => 'VARCHAR',
                 'constraint' => 512,
-                'null' => true,
+                'null'       => true,
             ],
-            'chapters_file_path' => [
-                'type' => 'VARCHAR',
-                'constraint' => 255,
-                'null' => true,
+            'chapters_id' => [
+                'type'     => 'INT',
+                'unsigned' => true,
+                'null'     => true,
             ],
-            'chapters_file_remote_url' => [
-                'type' => 'VARCHAR',
+            'chapters_remote_url' => [
+                'type'       => 'VARCHAR',
                 'constraint' => 512,
-                'null' => true,
+                'null'       => true,
             ],
             'parental_advisory' => [
-                'type' => 'ENUM',
+                'type'       => 'ENUM',
                 'constraint' => ['clean', 'explicit'],
-                'null' => true,
-                'default' => null,
+                'null'       => true,
             ],
             'number' => [
-                'type' => 'INT',
+                'type'     => 'INT',
                 'unsigned' => true,
-                'null' => true,
+                'null'     => true,
             ],
             'season_number' => [
-                'type' => 'INT',
+                'type'     => 'INT',
                 'unsigned' => true,
-                'null' => true,
+                'null'     => true,
             ],
             'type' => [
-                'type' => 'ENUM',
+                'type'       => 'ENUM',
                 'constraint' => ['trailer', 'full', 'bonus'],
-                'default' => 'full',
+                'default'    => 'full',
             ],
             'is_blocked' => [
-                'type' => 'TINYINT',
+                'type'       => 'TINYINT',
                 'constraint' => 1,
-                'default' => 0,
+                'default'    => 0,
             ],
             'location_name' => [
-                'type' => 'VARCHAR',
+                'type'       => 'VARCHAR',
                 'constraint' => 128,
-                'null' => true,
+                'null'       => true,
             ],
             'location_geo' => [
-                'type' => 'VARCHAR',
+                'type'       => 'VARCHAR',
                 'constraint' => 32,
-                'null' => true,
+                'null'       => true,
             ],
             'location_osm' => [
-                'type' => 'VARCHAR',
+                'type'       => 'VARCHAR',
                 'constraint' => 12,
-                'null' => true,
+                'null'       => true,
             ],
             'custom_rss' => [
                 'type' => 'JSON',
                 'null' => true,
             ],
-            'favourites_total' => [
-                'type' => 'INT',
+            'posts_count' => [
+                'type'     => 'INT',
                 'unsigned' => true,
-                'default' => 0,
+                'default'  => 0,
             ],
-            'reblogs_total' => [
-                'type' => 'INT',
+            'comments_count' => [
+                'type'     => 'INT',
                 'unsigned' => true,
-                'default' => 0,
+                'default'  => 0,
             ],
-            'notes_total' => [
-                'type' => 'INT',
-                'unsigned' => true,
-                'default' => 0,
+            'is_premium' => [
+                'type'       => 'TINYINT',
+                'constraint' => 1,
+                'default'    => 0,
             ],
             'created_by' => [
-                'type' => 'INT',
+                'type'     => 'INT',
                 'unsigned' => true,
             ],
             'updated_by' => [
-                'type' => 'INT',
+                'type'     => 'INT',
                 'unsigned' => true,
             ],
             'published_at' => [
@@ -178,19 +153,28 @@ class AddEpisodes extends Migration
             'updated_at' => [
                 'type' => 'DATETIME',
             ],
-            'deleted_at' => [
-                'type' => 'DATETIME',
-                'null' => true,
-            ],
         ]);
         $this->forge->addPrimaryKey('id');
         $this->forge->addUniqueKey(['podcast_id', 'slug']);
-        $this->forge->addForeignKey('podcast_id', 'podcasts', 'id', '', 'CASCADE',);
+        $this->forge->addForeignKey('podcast_id', 'podcasts', 'id', '', 'CASCADE');
+        $this->forge->addForeignKey('audio_id', 'media', 'id');
+        $this->forge->addForeignKey('cover_id', 'media', 'id', '', 'SET NULL');
+        $this->forge->addForeignKey('transcript_id', 'media', 'id', '', 'SET NULL');
+        $this->forge->addForeignKey('chapters_id', 'media', 'id', '', 'SET NULL');
         $this->forge->addForeignKey('created_by', 'users', 'id');
         $this->forge->addForeignKey('updated_by', 'users', 'id');
         $this->forge->createTable('episodes');
+
+        // Add Full-Text Search index on title and description_markdown
+        $prefix = $this->db->getPrefix();
+        $createQuery = <<<SQL
+            ALTER TABLE {$prefix}episodes
+            ADD FULLTEXT title (title, description_markdown);
+        SQL;
+        $this->db->query($createQuery);
     }
 
+    #[Override]
     public function down(): void
     {
         $this->forge->dropTable('episodes');

app/Database/Migrations/2020-06-05-190000_add_platforms.php → app/Database/Migrations/2021-06-05-190000_add_platforms.php

 <?php
 
+declare(strict_types=1);
+
 /**
  * Class AddPlatforms Creates platforms table in database
  *
- * @copyright  2020 Podlibre
+ * @copyright  2020 Ad Aures
  * @license    https://www.gnu.org/licenses/agpl-3.0.en.html AGPL3
  * @link       https://castopod.org/
  */
 
 namespace App\Database\Migrations;
 
-use CodeIgniter\Database\Migration;
+use Override;
 
-class AddPlatforms extends Migration
+class AddPlatforms extends BaseMigration
 {
+    #[Override]
     public function up(): void
     {
         $this->forge->addField([
             'slug' => [
-                'type' => 'VARCHAR',
+                'type'       => 'VARCHAR',
                 'constraint' => 32,
             ],
             'type' => [
-                'type' => 'ENUM',
+                'type'       => 'ENUM',
                 'constraint' => ['podcasting', 'social', 'funding'],
             ],
             'label' => [
-                'type' => 'VARCHAR',
+                'type'       => 'VARCHAR',
                 'constraint' => 32,
             ],
             'home_url' => [
-                'type' => 'VARCHAR',
+                'type'       => 'VARCHAR',
                 'constraint' => 255,
             ],
             'submit_url' => [
-                'type' => 'VARCHAR',
+                'type'       => 'VARCHAR',
                 'constraint' => 512,
-                'null' => true,
-                'default' => null,
+                'null'       => true,
             ],
         ]);
-        $this->forge->addField('`created_at` timestamp NOT NULL DEFAULT NOW()');
-        $this->forge->addField('`updated_at` timestamp NOT NULL DEFAULT NOW() ON UPDATE NOW()',);
+        $this->forge->addField('`created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP()');
+        $this->forge->addField(
+            '`updated_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP() ON UPDATE CURRENT_TIMESTAMP()',
+        );
         $this->forge->addPrimaryKey('slug');
         $this->forge->createTable('platforms');
     }
 
+    #[Override]
     public function down(): void
     {
         $this->forge->dropTable('platforms');

app/Database/Migrations/2017-12-01-160000_add_podcasts_platforms.php → app/Database/Migrations/2021-06-05-200000_add_podcasts_platforms.php

 <?php
 
+declare(strict_types=1);
+
 /**
  * Class AddAddPodcastsPlatforms Creates podcasts_platforms table in database
  *
- * @copyright  2020 Podlibre
+ * @copyright  2020 Ad Aures
  * @license    https://www.gnu.org/licenses/agpl-3.0.en.html AGPL3
  * @link       https://castopod.org/
  */
 
-namespace Analytics\Database\Migrations;
+namespace App\Database\Migrations;
 
-use CodeIgniter\Database\Migration;
+use Override;
 
-class AddPodcastsPlatforms extends Migration
+class AddPodcastsPlatforms extends BaseMigration
 {
+    #[Override]
     public function up(): void
     {
         $this->forge->addField([
             'podcast_id' => [
-                'type' => 'INT',
+                'type'     => 'INT',
                 'unsigned' => true,
             ],
             'platform_slug' => [
-                'type' => 'VARCHAR',
+                'type'       => 'VARCHAR',
                 'constraint' => 32,
             ],
             'link_url' => [
-                'type' => 'VARCHAR',
+                'type'       => 'VARCHAR',
                 'constraint' => 512,
             ],
-            'link_content' => [
-                'type' => 'VARCHAR',
+            'account_id' => [
+                'type'       => 'VARCHAR',
                 'constraint' => 128,
-                'null' => true,
+                'null'       => true,
             ],
             'is_visible' => [
-                'type' => 'TINYINT',
+                'type'       => 'TINYINT',
                 'constraint' => 1,
-                'default' => 0,
+                'default'    => 0,
             ],
-            'is_on_embeddable_player' => [
-                'type' => 'TINYINT',
+            'is_on_embed' => [
+                'type'       => 'TINYINT',
                 'constraint' => 1,
-                'default' => 0,
+                'default'    => 0,
             ],
         ]);
 
         $this->forge->addPrimaryKey(['podcast_id', 'platform_slug']);
+        $this->forge->addForeignKey('podcast_id', 'podcasts', 'id', '', 'CASCADE');
+        $this->forge->addForeignKey('platform_slug', 'platforms', 'slug', 'CASCADE');
         $this->forge->createTable('podcasts_platforms');
     }
 
+    #[Override]
     public function down(): void
     {
         $this->forge->dropTable('podcasts_platforms');

app/Database/Migrations/2021-08-12-150000_add_episode_comments.php

+<?php
+
+declare(strict_types=1);
+
+/**
+ * Class AddEpisodeComments creates episode_comments table in database
+ *
+ * @copyright  2021 Ad Aures
+ * @license    https://www.gnu.org/licenses/agpl-3.0.en.html AGPL3
+ * @link       https://castopod.org/
+ */
+
+namespace App\Database\Migrations;
+
+use Override;
+
+class AddEpisodeComments extends BaseMigration
+{
+    #[Override]
+    public function up(): void
+    {
+        $this->forge->addField([
+            'id' => [
+                'type'       => 'BINARY',
+                'constraint' => 16,
+            ],
+            'uri' => [
+                'type'       => 'VARCHAR',
+                'constraint' => 255,
+            ],
+            'episode_id' => [
+                'type'     => 'INT',
+                'unsigned' => true,
+            ],
+            'actor_id' => [
+                'type'     => 'INT',
+                'unsigned' => true,
+            ],
+            'in_reply_to_id' => [
+                'type'       => 'BINARY',
+                'constraint' => 16,
+                'null'       => true,
+            ],
+            'message' => [
+                'type'       => 'VARCHAR',
+                'constraint' => 5000,
+            ],
+            'message_html' => [
+                'type'       => 'VARCHAR',
+                'constraint' => 6000,
+            ],
+            'likes_count' => [
+                'type'     => 'INT',
+                'unsigned' => true,
+            ],
+            'replies_count' => [
+                'type'     => 'INT',
+                'unsigned' => true,
+            ],
+            'created_at' => [
+                'type' => 'DATETIME',
+            ],
+            'created_by' => [
+                'type'     => 'INT',
+                'unsigned' => true,
+                'null'     => true,
+            ],
+        ]);
+
+        $this->forge->addPrimaryKey('id');
+        $this->forge->addForeignKey('episode_id', 'episodes', 'id', '', 'CASCADE');
+        $this->forge->addForeignKey('actor_id', 'fediverse_actors', 'id', '', 'CASCADE');
+        $this->forge->addForeignKey('created_by', 'users', 'id');
+        $this->forge->createTable('episode_comments');
+    }
+
+    #[Override]
+    public function down(): void
+    {
+        $this->forge->dropTable('episode_comments');
+    }
+}