From a2cfa8f1e945252e300f96e3f432d3ad06d3ec99 Mon Sep 17 00:00:00 2001
From: "Aliaksei Yaletski (Tiendil)" <a.eletsky@gmail.com>
Date: Mon, 31 Aug 2026 17:27:39 +0200
Subject: [PATCH 1/8] base refactoring

---
 ffun/ffun/api/spa/entities.py                 | 13 ++-
 ffun/ffun/api/spa/tests/test_entities.py      | 21 ++++
 ffun/ffun/library/entities.py                 |  6 +-
 ffun/ffun/library/tests/test_entities.py      | 12 +--
 site/src/components/EntriesList.vue           | 18 +++-
 site/src/components/EntryForList.vue          | 95 ++++++++-----------
 .../body_list/ReverseTimeColumn.vue           |  5 +-
 .../notifications/LoadedOldNews.vue           |  2 +-
 site/src/logic/enums.ts                       |  9 +-
 site/src/logic/tests/types.test.ts            | 12 ++-
 site/src/logic/types.ts                       | 24 +++--
 site/src/values/Icon.vue                      |  4 -
 site/src/views/NewsView.vue                   |  1 -
 site/src/views/PublicCollectionView.vue       |  1 -
 14 files changed, 128 insertions(+), 95 deletions(-)

diff --git a/ffun/ffun/api/spa/entities.py b/ffun/ffun/api/spa/entities.py
index d4f1946f1..04aeec8a3 100644
--- a/ffun/ffun/api/spa/entities.py
+++ b/ffun/ffun/api/spa/entities.py
@@ -155,7 +155,9 @@ class Entry(BaseEntity):
     markers: list[Marker] = []
     score: int
     scoreContributions: dict[TagId, int]
-    publishedAt: datetime.datetime
+    effectivePublishedAt: datetime.datetime
+    firstSeenAt: datetime.datetime
+    sourcePublishedAt: datetime.datetime
     body: str | None = None
     references: list[Reference] | None = None
 
@@ -177,12 +179,9 @@ def from_internal(  # noqa: CFQ002
             markers=list(markers),
             score=score,
             scoreContributions=score_contributions,
-            # THIS IS AN INTENDED BEHAVIOR
-            # we set publishedAt for the frontend as global entry creation time
-            # because it is the only reliable time with "published" meaning
-            # actual published_at is absolutely unreliable because comes from the third-party sources
-            # and can be broken in numerous ways.
-            publishedAt=entry.created_at,
+            effectivePublishedAt=entry.effective_published_at,
+            firstSeenAt=entry.created_at,
+            sourcePublishedAt=entry.published_at,
             # Some APIs return full entry info, some return shorter info to save traffic and speed up the response.
             body=entry.body if with_body else None,
             references=[Reference.from_internal(reference) for reference in entry.references] if with_body else None,
diff --git a/ffun/ffun/api/spa/tests/test_entities.py b/ffun/ffun/api/spa/tests/test_entities.py
index 0f019c688..2ea0d18d9 100644
--- a/ffun/ffun/api/spa/tests/test_entities.py
+++ b/ffun/ffun/api/spa/tests/test_entities.py
@@ -7,6 +7,7 @@
 
 from ffun.api.spa.entities import (
     EntitlementKind,
+    Entry,
     Feed,
     FeedInfo,
     Marker,
@@ -31,6 +32,7 @@
 from ffun.entitlements.tests.make import make_effective_entitlement_interval, make_source_entitlement
 from ffun.feeds.entities import Feed as InternalFeed
 from ffun.feeds.entities import FeedError
+from ffun.library.entities import CollectedEntry
 from ffun.parsers import entities as p_entities
 from ffun.product.entities import Credit, Resource
 from ffun.resources import entities as r_entities
@@ -87,6 +89,25 @@ def test_from_internal__with_last_error(self, loaded_feed: InternalFeed) -> None
         assert external_feed.lastError == error.name
 
 
+class TestEntry:
+    def test_from_internal__maps_entry_dates(self, new_entry: CollectedEntry) -> None:
+        first_seen_at = utils.now()
+        source_published_at = first_seen_at + datetime.timedelta(days=1)
+        internal_entry = new_entry.replace(published_at=source_published_at).fake_entry(first_seen_at)
+
+        external_entry = Entry.from_internal(
+            internal_entry,
+            tags=[],
+            markers=[],
+            score=0,
+            score_contributions={},
+        )
+
+        assert external_entry.effectivePublishedAt == first_seen_at
+        assert external_entry.firstSeenAt == first_seen_at
+        assert external_entry.sourcePublishedAt == source_published_at
+
+
 class TestFeedInfo:
     def test_from_internal__keeps_site_url(self) -> None:
         feed_url = str_to_feed_url("https://example.com/feed")
diff --git a/ffun/ffun/library/entities.py b/ffun/ffun/library/entities.py
index d437753ef..9b367ec08 100644
--- a/ffun/ffun/library/entities.py
+++ b/ffun/ffun/library/entities.py
@@ -102,8 +102,8 @@ class Entry(BaseEntry):
     created_at: datetime.datetime
 
     @property
-    def published_at_for_processing(self) -> datetime.datetime:
-        """Entry published_at that is used to determine whether the entry is too old for processing.
+    def effective_published_at(self) -> datetime.datetime:
+        """Best available published_at value for product behavior.
 
         We use the smart algorithm to determine the "real" published_at value
         because an actual third-party published_at is absolutely unreliable.
@@ -141,7 +141,7 @@ def published_at_for_processing(self) -> datetime.datetime:
 
     @property
     def age_for_processing(self) -> datetime.timedelta:
-        return utils.now() - self.published_at_for_processing
+        return utils.now() - self.effective_published_at
 
     def collected_entry(self) -> "CollectedEntry":
         return CollectedEntry(
diff --git a/ffun/ffun/library/tests/test_entities.py b/ffun/ffun/library/tests/test_entities.py
index 1846db968..b0512a8ea 100644
--- a/ffun/ffun/library/tests/test_entities.py
+++ b/ffun/ffun/library/tests/test_entities.py
@@ -40,7 +40,7 @@ class TestEntry:
             ),
         ],
     )
-    def test_published_at_for_processing(
+    def test_effective_published_at(
         self,
         new_entry: CollectedEntry,
         published_at: datetime.datetime,
@@ -49,20 +49,20 @@ def test_published_at_for_processing(
     ) -> None:
         entry = new_entry.replace(published_at=published_at).fake_entry(created_at)
 
-        assert entry.published_at_for_processing == expected_published_at
+        assert entry.effective_published_at == expected_published_at
 
-    def test_published_at_for_processing__asserts_timezone_in_published_at(self, new_entry: CollectedEntry) -> None:
+    def test_effective_published_at__asserts_timezone_in_published_at(self, new_entry: CollectedEntry) -> None:
         created_at = datetime.datetime(2026, 1, 2, 3, 4, 5, tzinfo=datetime.UTC)
         entry = new_entry.replace(published_at=datetime.datetime(2026, 1, 2, 3, 4, 4)).fake_entry(created_at)
 
         with pytest.raises(AssertionError):
-            _ = entry.published_at_for_processing
+            _ = entry.effective_published_at
 
-    def test_published_at_for_processing__asserts_timezone_in_created_at(self, new_entry: CollectedEntry) -> None:
+    def test_effective_published_at__asserts_timezone_in_created_at(self, new_entry: CollectedEntry) -> None:
         entry = new_entry.fake_entry(datetime.datetime(2026, 1, 2, 3, 4, 5))
 
         with pytest.raises(AssertionError):
-            _ = entry.published_at_for_processing
+            _ = entry.effective_published_at
 
     def test_age_for_processing(self, new_entry: CollectedEntry) -> None:
         created_at = datetime.datetime(2026, 1, 2, 3, 4, 5, tzinfo=datetime.UTC)
diff --git a/site/src/components/EntriesList.vue b/site/src/components/EntriesList.vue
index 6478630c3..094aabc8b 100644
--- a/site/src/components/EntriesList.vue
+++ b/site/src/components/EntriesList.vue
@@ -1,6 +1,22 @@
 <template>
   <div>
     <template v-if="entriesToShow.length > 0">
+      <div class="mb-1 flex border-b pb-1 text-xs text-gray-500">
+        <div class="mr-2 w-4 flex-shrink-0" />
+
+        <div
+          v-if="showScore"
+          class="w-8 flex-shrink-0 pr-1 text-center">
+          Score
+        </div>
+
+        <div class="w-8 flex-shrink-0 pr-1" />
+
+        <div class="flex-grow">News</div>
+
+        <div class="w-16 flex-shrink-0 text-right">Published</div>
+      </div>
+
       <ul>
         <li
           v-for="entryId in entriesToShow"
@@ -9,7 +25,6 @@
           <entry-for-list
             :show-score="showScore"
             :entryId="entryId"
-            :time-field="timeField"
             :tags-count="tagsCount" />
         </li>
       </ul>
@@ -38,7 +53,6 @@
   const properties = defineProps<{
     loading: boolean;
     entriesIds: Array<t.EntryId>;
-    timeField: string;
     showFromStart: number;
     showPerPage: number;
     showScore: boolean;
diff --git a/site/src/components/EntryForList.vue b/site/src/components/EntryForList.vue
index 52362e82e..0ea4b3c46 100644
--- a/site/src/components/EntryForList.vue
+++ b/site/src/components/EntryForList.vue
@@ -1,25 +1,22 @@
 <template>
   <div
     ref="entryTop"
-    :class="['flex', 'text-lg', {'ml-8': isRead}]">
-    <div class="ffun-body-list-icon-column">
-      <a
-        v-if="isRead"
-        href="#"
-        @click.prevent="markUnread()"
-        title="Mark as unread"
-        class="text-green-700">
-        <icon icon="chevrons-left" />
-      </a>
-
-      <a
-        v-else
-        href="#"
-        @click.prevent="markRead()"
-        title="Mark as read"
-        class="text-orange-700">
-        <icon icon="chevrons-right" />
-      </a>
+    class="flex text-lg">
+    <div class="ffun-body-list-icon-column w-4">
+      <app-tooltip :text="isRead ? 'Mark as unread' : 'Mark as read'">
+        <button
+          type="button"
+          :aria-label="isRead ? 'Mark as unread' : 'Mark as read'"
+          class="flex h-7 w-4 cursor-pointer items-center justify-center rounded focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-blue-400"
+          @click="toggleReadState">
+          <span
+            aria-hidden="true"
+            :class="[
+              'block h-3 w-3 rounded-full border-2',
+              isRead ? 'border-green-700' : 'border-orange-700 bg-orange-700'
+            ]" />
+        </button>
+      </app-tooltip>
     </div>
 
     <div
@@ -49,9 +46,15 @@
         :contributions="showScore ? entry.scoreContributions : {}" />
     </div>
 
-    <body-list-reverse-time-column
-      :title="timeForTooltip"
-      :time="timeFor" />
+    <app-tooltip placement="top-end">
+      <body-list-reverse-time-column :time="entry.effectivePublishedAt" />
+
+      <template #content>
+        <div><span class="font-medium">Considered published at:</span> {{ formatDate(entry.effectivePublishedAt) }}</div>
+        <div><span class="font-medium">First seen by Feeds Fun:</span> {{ formatDate(entry.firstSeenAt) }}</div>
+        <div><span class="font-medium">Published by the source:</span> {{ formatDate(entry.sourcePublishedAt) }}</div>
+      </template>
+    </app-tooltip>
   </div>
 
   <body-list-entry-body
@@ -66,7 +69,6 @@
 </template>
 
 <script lang="ts" setup>
-  import _ from "lodash";
   import {computed, ref, useTemplateRef, onMounted, inject} from "vue";
   import type * as t from "@/logic/types";
   import * as events from "@/logic/events";
@@ -87,7 +89,6 @@
 
   const properties = defineProps<{
     entryId: t.EntryId;
-    timeField: string;
     tagsCount: {[key: string]: number};
     showScore: boolean;
   }>();
@@ -108,25 +109,9 @@
     return entry.value.id == entriesStore.displayedEntryId;
   });
 
-  const timeFor = computed(() => {
-    if (entry.value === null) {
-      return null;
-    }
-
-    return _.get(entry.value, properties.timeField, null);
-  });
-
-  const timeForTooltip = computed(() => {
-    if (entry.value === null) {
-      return "";
-    }
-
-    if (properties.timeField === "publishedAt") {
-      return "How long ago the news was published";
-    }
-
-    return "";
-  });
+  function formatDate(date: Date): string {
+    return date.toLocaleString();
+  }
 
   const purifiedTitle = computed(() => {
     return utils.purifyTitle({raw: entry.value.title, default_: "No title"});
@@ -197,17 +182,17 @@
     entriesStore.requestFullEntry({entryId: properties.entryId});
   });
 
-  async function markUnread() {
-    await entriesStore.removeMarker({
-      entryId: properties.entryId,
-      marker: e.Marker.Read
-    });
-  }
-
-  async function markRead() {
-    await entriesStore.setMarker({
-      entryId: properties.entryId,
-      marker: e.Marker.Read
-    });
+  async function toggleReadState() {
+    if (isRead.value) {
+      await entriesStore.removeMarker({
+        entryId: properties.entryId,
+        marker: e.Marker.Read
+      });
+    } else {
+      await entriesStore.setMarker({
+        entryId: properties.entryId,
+        marker: e.Marker.Read
+      });
+    }
   }
 </script>
diff --git a/site/src/components/body_list/ReverseTimeColumn.vue b/site/src/components/body_list/ReverseTimeColumn.vue
index be3dce1fc..16ed73d6f 100644
--- a/site/src/components/body_list/ReverseTimeColumn.vue
+++ b/site/src/components/body_list/ReverseTimeColumn.vue
@@ -1,7 +1,7 @@
 <template>
   <div
-    class="flex-shrink-0 w-16 cursor-default text-right"
-    :title="title">
+    class="w-16 flex-shrink-0 cursor-help rounded-sm text-right focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-blue-500"
+    tabindex="0">
     <value-date-time
       class=""
       :value="time"
@@ -23,6 +23,5 @@
 
   const properties = defineProps<{
     time: Date | null;
-    title: string;
   }>();
 </script>
diff --git a/site/src/components/notifications/LoadedOldNews.vue b/site/src/components/notifications/LoadedOldNews.vue
index 057156233..85f7a361d 100644
--- a/site/src/components/notifications/LoadedOldNews.vue
+++ b/site/src/components/notifications/LoadedOldNews.vue
@@ -41,7 +41,7 @@
 
     return properties.entries.every((entryId) => {
       const entry = entriesStore.entries[entryId];
-      return entry.publishedAt.getTime() < Date.now() - properties.period.seconds * 1000;
+      return entry.effectivePublishedAt.getTime() < Date.now() - properties.period.seconds * 1000;
     });
   });
 </script>
diff --git a/site/src/logic/enums.ts b/site/src/logic/enums.ts
index dfcb465d4..8bf811eb8 100644
--- a/site/src/logic/enums.ts
+++ b/site/src/logic/enums.ts
@@ -105,16 +105,15 @@ export enum EntriesOrder {
 export type EntriesOrderProperty = {
   readonly text: string;
   readonly orderField: string;
-  readonly timeField: string;
   readonly direction: number;
   readonly default?: boolean;
 };
 
 export const EntriesOrderProperties = new Map<EntriesOrder, EntriesOrderProperty>([
-  [EntriesOrder.Score, {text: "score", orderField: "score", timeField: "publishedAt", direction: 1, default: true}],
-  [EntriesOrder.ScoreToZero, {text: "score ~ 0", orderField: "scoreToZero", timeField: "publishedAt", direction: 1}],
-  [EntriesOrder.ScoreBackward, {text: "score backward", orderField: "score", timeField: "publishedAt", direction: -1}],
-  [EntriesOrder.Published, {text: "published", orderField: "publishedAt", timeField: "publishedAt", direction: 1}]
+  [EntriesOrder.Score, {text: "score", orderField: "score", direction: 1, default: true}],
+  [EntriesOrder.ScoreToZero, {text: "score ~ 0", orderField: "scoreToZero", direction: 1}],
+  [EntriesOrder.ScoreBackward, {text: "score backward", orderField: "score", direction: -1}],
+  [EntriesOrder.Published, {text: "published", orderField: "effectivePublishedAt", direction: 1}]
 ]);
 
 /////////////////////
diff --git a/site/src/logic/tests/types.test.ts b/site/src/logic/tests/types.test.ts
index b2f0c1bbd..d208319f9 100644
--- a/site/src/logic/tests/types.test.ts
+++ b/site/src/logic/tests/types.test.ts
@@ -34,7 +34,9 @@ function rawEntry(markers: number[]): RawEntry {
     markers,
     score: 0,
     scoreContributions: {},
-    publishedAt: "2026-05-11T12:00:00Z"
+    effectivePublishedAt: "2026-05-11T12:00:00Z",
+    firstSeenAt: "2026-05-12T12:00:00Z",
+    sourcePublishedAt: "2026-05-10T12:00:00Z"
   };
 }
 
@@ -110,6 +112,14 @@ describe("entryFromJSON", () => {
     expect(entry.markers).toEqual([e.Marker.Read, e.Marker.CanSeeTags]);
   });
 
+  it("translates entry dates", () => {
+    const entry = entryFromJSON(rawEntry([]), {});
+
+    expect(entry.effectivePublishedAt).toEqual(new Date("2026-05-11T12:00:00Z"));
+    expect(entry.firstSeenAt).toEqual(new Date("2026-05-12T12:00:00Z"));
+    expect(entry.sourcePublishedAt).toEqual(new Date("2026-05-10T12:00:00Z"));
+  });
+
   it("rejects unknown integer markers", () => {
     expect(() => entryFromJSON(rawEntry([100]), {})).toThrow("Unknown marker: 100");
   });
diff --git a/site/src/logic/types.ts b/site/src/logic/types.ts
index 7e3756a86..8b4dfa66f 100644
--- a/site/src/logic/types.ts
+++ b/site/src/logic/types.ts
@@ -247,7 +247,9 @@ export class Entry {
   readonly score: number;
   readonly scoreContributions: {[key: string]: number};
   readonly scoreToZero: number;
-  readonly publishedAt: Date;
+  readonly effectivePublishedAt: Date;
+  readonly firstSeenAt: Date;
+  readonly sourcePublishedAt: Date;
   body: string | null;
   references: Reference[] | null;
 
@@ -260,7 +262,9 @@ export class Entry {
     markers,
     score,
     scoreContributions,
-    publishedAt,
+    effectivePublishedAt,
+    firstSeenAt,
+    sourcePublishedAt,
     body,
     references
   }: {
@@ -272,7 +276,9 @@ export class Entry {
     markers: e.Marker[];
     score: number;
     scoreContributions: {[key: string]: number};
-    publishedAt: Date;
+    effectivePublishedAt: Date;
+    firstSeenAt: Date;
+    sourcePublishedAt: Date;
     body: string | null;
     references: Reference[] | null;
   }) {
@@ -284,7 +290,9 @@ export class Entry {
     this.markers = markers;
     this.score = score;
     this.scoreContributions = scoreContributions;
-    this.publishedAt = publishedAt;
+    this.effectivePublishedAt = effectivePublishedAt;
+    this.firstSeenAt = firstSeenAt;
+    this.sourcePublishedAt = sourcePublishedAt;
     this.body = body;
     this.references = references;
 
@@ -321,7 +329,9 @@ export type RawEntry = {
   markers: number[];
   score: number;
   scoreContributions: {[key: number]: number};
-  publishedAt: string;
+  effectivePublishedAt: string;
+  firstSeenAt: string;
+  sourcePublishedAt: string;
   body?: string | null;
   references?: RawReference[] | null;
 };
@@ -349,7 +359,9 @@ export function entryFromJSON(rawEntry: RawEntry, tagsMapping: {[key: number]: s
     score: rawEntry.score,
     // map keys from int to string
     scoreContributions: contributions,
-    publishedAt: new Date(rawEntry.publishedAt),
+    effectivePublishedAt: new Date(rawEntry.effectivePublishedAt),
+    firstSeenAt: new Date(rawEntry.firstSeenAt),
+    sourcePublishedAt: new Date(rawEntry.sourcePublishedAt),
     body: rawEntry.body !== undefined ? rawEntry.body : null,
     references:
       rawEntry.references !== undefined && rawEntry.references !== null
diff --git a/site/src/values/Icon.vue b/site/src/values/Icon.vue
index 0bdc8003a..faa4d16be 100644
--- a/site/src/values/Icon.vue
+++ b/site/src/values/Icon.vue
@@ -16,8 +16,6 @@
     IconBrandDiscord,
     IconBrandGithub,
     IconExternalLink,
-    IconChevronsLeft,
-    IconChevronsRight,
     IconLayoutSidebarLeftCollapse,
     IconLayoutSidebarLeftExpand,
     IconUser,
@@ -43,8 +41,6 @@
     plus: IconPlus,
     dots: IconDots,
     "external-link": IconExternalLink,
-    "chevrons-right": IconChevronsRight,
-    "chevrons-left": IconChevronsLeft,
     "sidebar-left-collapse": IconLayoutSidebarLeftCollapse,
     "sidebar-left-expand": IconLayoutSidebarLeftExpand,
     user: IconUser,
diff --git a/site/src/views/NewsView.vue b/site/src/views/NewsView.vue
index 4b12662cc..2d7bed230 100644
--- a/site/src/views/NewsView.vue
+++ b/site/src/views/NewsView.vue
@@ -73,7 +73,6 @@
     <entries-list
       :loading="entriesStore.loading"
       :entriesIds="entriesReport"
-      :time-field="entriesStore.activeOrderProperties.timeField"
       :tags-count="tagsCount"
       :show-score="true"
       :showFromStart="25"
diff --git a/site/src/views/PublicCollectionView.vue b/site/src/views/PublicCollectionView.vue
index 665039887..c323a32ba 100644
--- a/site/src/views/PublicCollectionView.vue
+++ b/site/src/views/PublicCollectionView.vue
@@ -95,7 +95,6 @@
     <entries-list
       :loading="entriesStore.loading"
       :entriesIds="entriesReport"
-      :time-field="entriesStore.activeOrderProperties.timeField"
       :tags-count="tagsCount"
       :show-score="false"
       :showFromStart="25"

From e3fd0dce4ec44740b0d22dde17389ae091c4ec15 Mon Sep 17 00:00:00 2001
From: "Aliaksei Yaletski (Tiendil)" <a.eletsky@gmail.com>
Date: Mon, 31 Aug 2026 18:04:17 +0200
Subject: [PATCH 2/8] publishing date in the entry references

---
 site/src/components/EntryDate.vue             | 43 +++++++++++++++++++
 site/src/components/EntryForList.vue          | 28 ++++++------
 site/src/components/body_list/EntryBody.vue   |  6 ++-
 site/src/components/body_list/References.vue  |  2 +
 .../body_list/ReverseTimeColumn.vue           | 27 ------------
 site/src/logic/tests/utils.test.ts            | 23 +++++++++-
 site/src/logic/utils.ts                       | 40 ++++++++++++++---
 site/src/main.ts                              |  4 +-
 8 files changed, 120 insertions(+), 53 deletions(-)
 create mode 100644 site/src/components/EntryDate.vue
 delete mode 100644 site/src/components/body_list/ReverseTimeColumn.vue

diff --git a/site/src/components/EntryDate.vue b/site/src/components/EntryDate.vue
new file mode 100644
index 000000000..82491d58b
--- /dev/null
+++ b/site/src/components/EntryDate.vue
@@ -0,0 +1,43 @@
+<template>
+  <app-tooltip placement="top-end">
+    <span
+      :class="[
+        'block cursor-help focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-blue-500',
+        variant === 'column'
+          ? 'w-16 flex-shrink-0 rounded-sm text-right'
+          : 'rounded border bg-white px-1 py-1 text-sm font-medium leading-tight text-gray-900'
+      ]"
+      tabindex="0">
+      {{ displayedTime }}
+    </span>
+
+    <template #content>
+      <div><span class="font-medium">Considered published at:</span> {{ formatDate(effectivePublishedAt) }}</div>
+      <div><span class="font-medium">First seen by Feeds Fun:</span> {{ formatDate(firstSeenAt) }}</div>
+      <div><span class="font-medium">Published by the source:</span> {{ formatDate(sourcePublishedAt) }}</div>
+    </template>
+  </app-tooltip>
+</template>
+
+<script lang="ts" setup>
+  import {computed} from "vue";
+  import * as utils from "@/logic/utils";
+
+  type EntryDateVariant = "column" | "metadata";
+
+  const properties = defineProps<{
+    effectivePublishedAt: Date;
+    firstSeenAt: Date;
+    sourcePublishedAt: Date;
+    variant: EntryDateVariant;
+  }>();
+
+  const displayedTime = computed(() => {
+    const style = properties.variant === "column" ? "short" : "long";
+    return utils.timeSince(properties.effectivePublishedAt, style);
+  });
+
+  function formatDate(date: Date): string {
+    return date.toLocaleString();
+  }
+</script>
diff --git a/site/src/components/EntryForList.vue b/site/src/components/EntryForList.vue
index 0ea4b3c46..988a3b8f6 100644
--- a/site/src/components/EntryForList.vue
+++ b/site/src/components/EntryForList.vue
@@ -46,15 +46,11 @@
         :contributions="showScore ? entry.scoreContributions : {}" />
     </div>
 
-    <app-tooltip placement="top-end">
-      <body-list-reverse-time-column :time="entry.effectivePublishedAt" />
-
-      <template #content>
-        <div><span class="font-medium">Considered published at:</span> {{ formatDate(entry.effectivePublishedAt) }}</div>
-        <div><span class="font-medium">First seen by Feeds Fun:</span> {{ formatDate(entry.firstSeenAt) }}</div>
-        <div><span class="font-medium">Published by the source:</span> {{ formatDate(entry.sourcePublishedAt) }}</div>
-      </template>
-    </app-tooltip>
+    <entry-date
+      :effective-published-at="entry.effectivePublishedAt"
+      :first-seen-at="entry.firstSeenAt"
+      :source-published-at="entry.sourcePublishedAt"
+      variant="column" />
   </div>
 
   <body-list-entry-body
@@ -65,7 +61,15 @@
     :loading="entry.body === null"
     :text="purifiedBody"
     :references="references"
-    @body-title-clicked="newsLinkOpenedEvent" />
+    @body-title-clicked="newsLinkOpenedEvent">
+    <template #metadata>
+      <entry-date
+        :effective-published-at="entry.effectivePublishedAt"
+        :first-seen-at="entry.firstSeenAt"
+        :source-published-at="entry.sourcePublishedAt"
+        variant="metadata" />
+    </template>
+  </body-list-entry-body>
 </template>
 
 <script lang="ts" setup>
@@ -109,10 +113,6 @@
     return entry.value.id == entriesStore.displayedEntryId;
   });
 
-  function formatDate(date: Date): string {
-    return date.toLocaleString();
-  }
-
   const purifiedTitle = computed(() => {
     return utils.purifyTitle({raw: entry.value.title, default_: "No title"});
   });
diff --git a/site/src/components/body_list/EntryBody.vue b/site/src/components/body_list/EntryBody.vue
index 750132403..d2a547624 100644
--- a/site/src/components/body_list/EntryBody.vue
+++ b/site/src/components/body_list/EntryBody.vue
@@ -14,8 +14,10 @@
       </h2>
 
       <body-list-references
-        v-if="references.length > 0"
-        :references="references" />
+        v-if="references.length > 0 || $slots.metadata"
+        :references="references">
+        <slot name="metadata" />
+      </body-list-references>
 
       <slot name="body-prefix" />
 
diff --git a/site/src/components/body_list/References.vue b/site/src/components/body_list/References.vue
index e5d227979..105656073 100644
--- a/site/src/components/body_list/References.vue
+++ b/site/src/components/body_list/References.vue
@@ -4,6 +4,8 @@
       v-for="reference in references"
       :key="reference.url"
       :reference="reference" />
+
+    <slot />
   </div>
 </template>
 
diff --git a/site/src/components/body_list/ReverseTimeColumn.vue b/site/src/components/body_list/ReverseTimeColumn.vue
deleted file mode 100644
index 16ed73d6f..000000000
--- a/site/src/components/body_list/ReverseTimeColumn.vue
+++ /dev/null
@@ -1,27 +0,0 @@
-<template>
-  <div
-    class="w-16 flex-shrink-0 cursor-help rounded-sm text-right focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-blue-500"
-    tabindex="0">
-    <value-date-time
-      class=""
-      :value="time"
-      :reversed="true" />
-  </div>
-</template>
-
-<script lang="ts" setup>
-  import _ from "lodash";
-  import {computed, ref, useTemplateRef, onMounted} from "vue";
-  import type * as t from "@/logic/types";
-  import * as events from "@/logic/events";
-  import * as e from "@/logic/enums";
-  import {computedAsync} from "@vueuse/core";
-  import DOMPurify from "dompurify";
-  import {useEntriesStore} from "@/stores/entries";
-
-  const entriesStore = useEntriesStore();
-
-  const properties = defineProps<{
-    time: Date | null;
-  }>();
-</script>
diff --git a/site/src/logic/tests/utils.test.ts b/site/src/logic/tests/utils.test.ts
index fe5f41883..14e4091bf 100644
--- a/site/src/logic/tests/utils.test.ts
+++ b/site/src/logic/tests/utils.test.ts
@@ -1,9 +1,30 @@
 import {afterEach, describe, expect, it, vi} from "vitest";
 import DOMPurify from "dompurify";
-import {purifyBody, purifyTitle} from "@/logic/utils";
+import {purifyBody, purifyTitle, timeSince} from "@/logic/utils";
 
 afterEach(() => {
   vi.restoreAllMocks();
+  vi.useRealTimers();
+});
+
+describe("timeSince", () => {
+  it.each([
+    {secondsPast: 30, short: "<min", long: "just now"},
+    {secondsPast: 5 * 60, short: "5min", long: "5 minutes ago"},
+    {secondsPast: 3 * 60 * 60, short: "3h", long: "3 hours ago"},
+    {secondsPast: 24 * 60 * 60, short: "1d", long: "1 day ago"},
+    {secondsPast: 60 * 24 * 60 * 60, short: "2m", long: "2 months ago"},
+    {secondsPast: 720 * 24 * 60 * 60, short: "2y", long: "2 years ago"}
+  ])("formats $long in short and long styles", ({secondsPast, short, long}) => {
+    const now = new Date("2026-08-31T12:00:00Z");
+    vi.useFakeTimers();
+    vi.setSystemTime(now);
+
+    const date = new Date(now.getTime() - secondsPast * 1000);
+
+    expect(timeSince(date)).toBe(short);
+    expect(timeSince(date, "long")).toBe(long);
+  });
 });
 
 describe("purifyBody", () => {
diff --git a/site/src/logic/utils.ts b/site/src/logic/utils.ts
index fd8654ca4..e51226d8f 100644
--- a/site/src/logic/utils.ts
+++ b/site/src/logic/utils.ts
@@ -49,42 +49,68 @@ function hardenLinksSecurityAttributes(html: string) {
   return parsed.body.innerHTML;
 }
 
-export function timeSince(date: Date) {
+type TimeSinceStyle = "short" | "long";
+
+const relativeTimeFormatter = new Intl.RelativeTimeFormat("en", {numeric: "always"});
+
+function formatTimeSince({
+  value,
+  shortUnit,
+  longUnit,
+  style
+}: {
+  value: number;
+  shortUnit: string;
+  longUnit: Intl.RelativeTimeFormatUnit;
+  style: TimeSinceStyle;
+}) {
+  if (style === "short") {
+    return `${value}${shortUnit}`;
+  }
+
+  return relativeTimeFormatter.format(-value, longUnit);
+}
+
+export function timeSince(date: Date, style: TimeSinceStyle = "short") {
   const now = new Date();
 
   const secondsPast = Math.floor((now.getTime() - date.getTime()) / 1000);
 
   if (secondsPast < 60) {
-    return "<min";
+    if (style === "short") {
+      return "<min";
+    }
+
+    return "just now";
   }
 
   const minutesPast = Math.floor(secondsPast / 60);
 
   if (minutesPast < 60) {
-    return `${minutesPast}min`;
+    return formatTimeSince({value: minutesPast, shortUnit: "min", longUnit: "minute", style});
   }
 
   const hoursPast = Math.floor(minutesPast / 60);
 
   if (hoursPast < 24) {
-    return `${hoursPast}h`;
+    return formatTimeSince({value: hoursPast, shortUnit: "h", longUnit: "hour", style});
   }
 
   const daysPast = Math.floor(hoursPast / 24);
 
   if (daysPast < 30) {
-    return `${daysPast}d`;
+    return formatTimeSince({value: daysPast, shortUnit: "d", longUnit: "day", style});
   }
 
   const monthsPast = Math.floor(daysPast / 30);
 
   if (monthsPast < 12) {
-    return `${monthsPast}m`;
+    return formatTimeSince({value: monthsPast, shortUnit: "m", longUnit: "month", style});
   }
 
   const yearsPast = Math.floor(monthsPast / 12);
 
-  return `${yearsPast}y`;
+  return formatTimeSince({value: yearsPast, shortUnit: "y", longUnit: "year", style});
 }
 
 export function compareLexicographically(a: string[], b: string[]) {
diff --git a/site/src/main.ts b/site/src/main.ts
index cdcd99f35..2637dacc9 100644
--- a/site/src/main.ts
+++ b/site/src/main.ts
@@ -28,6 +28,7 @@ import TokenUsageStatistics from "./components/TokenUsageStatistics.vue";
 import ProductTokens from "./components/ProductTokens.vue";
 import NewsToolbar from "./components/NewsToolbar.vue";
 import AppTooltip from "./components/AppTooltip.vue";
+import EntryDate from "./components/EntryDate.vue";
 import FaviconElement from "./components/FaviconElement.vue";
 import RuleForList from "./components/RuleForList.vue";
 import UserSettingForNotification from "./components/UserSettingForNotification.vue";
@@ -81,7 +82,6 @@ import ValueScore from "./values/Score.vue";
 import Icon from "./values/Icon.vue";
 import SocialLink from "./values/SocialLink.vue";
 
-import BodyListReverseTimeColumn from "./components/body_list/ReverseTimeColumn.vue";
 import BodyListFaviconColumn from "./components/body_list/FaviconColumn.vue";
 import BodyListEntryBody from "./components/body_list/EntryBody.vue";
 import BodyListEntryCover from "./components/body_list/EntryCover.vue";
@@ -126,6 +126,7 @@ app.component("TokenUsageStatistics", TokenUsageStatistics);
 app.component("ProductTokens", ProductTokens);
 app.component("NewsToolbar", NewsToolbar);
 app.component("AppTooltip", AppTooltip);
+app.component("EntryDate", EntryDate);
 app.component("FaviconElement", FaviconElement);
 app.component("RuleForList", RuleForList);
 app.component("UserSettingForNotification", UserSettingForNotification);
@@ -179,7 +180,6 @@ app.component("ValueScore", ValueScore);
 app.component("Icon", Icon);
 app.component("SocialLink", SocialLink);
 
-app.component("BodyListReverseTimeColumn", BodyListReverseTimeColumn);
 app.component("BodyListFaviconColumn", BodyListFaviconColumn);
 app.component("BodyListEntryBody", BodyListEntryBody);
 app.component("BodyListEntryCover", BodyListEntryCover);

From 310dff517646e99621b46433ab27814652df37f8 Mon Sep 17 00:00:00 2001
From: "Aliaksei Yaletski (Tiendil)" <a.eletsky@gmail.com>
Date: Mon, 31 Aug 2026 18:54:11 +0200
Subject: [PATCH 3/8] better notification

---
 ffun/ffun/api/spa/entities.py                 |  2 ++
 ffun/ffun/api/spa/http_handlers.py            | 10 +++---
 ffun/ffun/cli/commands/profile.py             |  2 +-
 ffun/ffun/library/domain.py                   |  6 ++--
 ffun/ffun/library/tests/test_domain.py        | 18 +++++++----
 .../notifications/LoadedOldNews.vue           | 23 +++----------
 site/src/logic/api.ts                         | 32 +++++++------------
 site/src/logic/tests/types.test.ts            | 18 +++++++++++
 site/src/logic/types.ts                       | 22 +++++++++++++
 site/src/stores/entries.ts                    | 31 +++++++++++-------
 site/src/views/NewsView.vue                   |  5 +--
 site/src/views/PublicCollectionView.vue       |  3 +-
 12 files changed, 105 insertions(+), 67 deletions(-)

diff --git a/ffun/ffun/api/spa/entities.py b/ffun/ffun/api/spa/entities.py
index 04aeec8a3..f0f7dbcc0 100644
--- a/ffun/ffun/api/spa/entities.py
+++ b/ffun/ffun/api/spa/entities.py
@@ -570,6 +570,7 @@ def validate_period(cls, v: None | datetime.timedelta) -> None | datetime.timede
 
 class GetLastEntriesResponse(api.APISuccess):
     entries: list[Entry]
+    fallbackUsed: bool
     tagsMapping: dict[TagId, TagUid]
 
 
@@ -587,6 +588,7 @@ def validate_period(cls, v: None | datetime.timedelta) -> None | datetime.timede
 
 class GetLastCollectionEntriesResponse(api.APISuccess):
     entries: list[Entry]
+    fallbackUsed: bool
     tagsMapping: dict[TagId, TagUid]
 
 
diff --git a/ffun/ffun/api/spa/http_handlers.py b/ffun/ffun/api/spa/http_handlers.py
index 950102127..6dc5b2fd8 100644
--- a/ffun/ffun/api/spa/http_handlers.py
+++ b/ffun/ffun/api/spa/http_handlers.py
@@ -222,7 +222,7 @@ async def api_get_last_collection_entries(
 
     feed_ids = [feed_info.feed_id for feed_info in collection.feeds if feed_info.feed_id is not None]
 
-    entries = await l_domain.get_entries_by_filter_with_fallback(
+    entries, fallback_used = await l_domain.get_entries_by_filter_with_fallback(
         feeds_ids=feed_ids,
         period=request.period,
         limit=settings.max_returned_entries,
@@ -233,7 +233,9 @@ async def api_get_last_collection_entries(
         entries, with_body=False, user_id=None, min_tag_count=request.minTagCount
     )
 
-    return entities.GetLastCollectionEntriesResponse(entries=external_entries, tagsMapping=tags_mapping)
+    return entities.GetLastCollectionEntriesResponse(
+        entries=external_entries, fallbackUsed=fallback_used, tagsMapping=tags_mapping
+    )
 
 
 @api_public.post("/get-entries-by-ids")  # type: ignore
@@ -444,7 +446,7 @@ async def api_get_last_entries(request: entities.GetLastEntriesRequest, user: Us
 
     linked_feeds_ids = [link.feed_id for link in linked_feeds]
 
-    entries = await l_domain.get_entries_by_filter_with_fallback(
+    entries, fallback_used = await l_domain.get_entries_by_filter_with_fallback(
         feeds_ids=linked_feeds_ids,
         period=request.period,
         limit=settings.max_returned_entries,
@@ -455,7 +457,7 @@ async def api_get_last_entries(request: entities.GetLastEntriesRequest, user: Us
         entries, with_body=False, user_id=user.id, min_tag_count=request.minTagCount
     )
 
-    return entities.GetLastEntriesResponse(entries=external_entries, tagsMapping=tags_mapping)
+    return entities.GetLastEntriesResponse(entries=external_entries, fallbackUsed=fallback_used, tagsMapping=tags_mapping)
 
 
 @api_private.post("/create-or-update-rule")  # type: ignore
diff --git a/ffun/ffun/cli/commands/profile.py b/ffun/ffun/cli/commands/profile.py
index 6e48cc019..a5cee2e2a 100644
--- a/ffun/ffun/cli/commands/profile.py
+++ b/ffun/ffun/cli/commands/profile.py
@@ -43,7 +43,7 @@ async def _profile_get_last_entries() -> GetLastEntriesResponse:
 
     logger.info("almost_finishied", entries_number=len(external_entries), tags_number=len(tags_mapping))
 
-    return GetLastEntriesResponse(entries=external_entries, tagsMapping=tags_mapping)
+    return GetLastEntriesResponse(entries=external_entries, fallbackUsed=False, tagsMapping=tags_mapping)
 
 
 async def run_profile() -> None:
diff --git a/ffun/ffun/library/domain.py b/ffun/ffun/library/domain.py
index 17019662e..a6b19dace 100644
--- a/ffun/ffun/library/domain.py
+++ b/ffun/ffun/library/domain.py
@@ -94,17 +94,17 @@ async def normalize_entry(entry: Entry, apply: bool = False) -> list[EntryChange
 
 async def get_entries_by_filter_with_fallback(
     feeds_ids: list[FeedId], period: datetime.timedelta | None, limit: int, fallback_limit: int
-) -> list[Entry]:
+) -> tuple[list[Entry], bool]:
 
     entries = await get_entries_by_filter(feeds_ids=feeds_ids, period=period, limit=limit)
 
     if entries:
-        return entries
+        return entries, False
 
     # if there is no news in requested interval try to get some older news
     entries = await get_entries_by_filter(feeds_ids=feeds_ids, period=_fallback_period, limit=fallback_limit)
 
-    return entries
+    return entries, True
 
 
 @run_in_transaction
diff --git a/ffun/ffun/library/tests/test_domain.py b/ffun/ffun/library/tests/test_domain.py
index 4f88e1776..f94cd23b4 100644
--- a/ffun/ffun/library/tests/test_domain.py
+++ b/ffun/ffun/library/tests/test_domain.py
@@ -145,11 +145,12 @@ async def prepared_entries(self, loaded_feed: Feed, time_border: datetime.dateti
 
     @pytest.mark.asyncio
     async def test_no_entries_at_all(self, time_delta: datetime.timedelta) -> None:
-        entries = await get_entries_by_filter_with_fallback(
+        entries, fallback_used = await get_entries_by_filter_with_fallback(
             feeds_ids=[], period=time_delta, limit=10, fallback_limit=10
         )
 
         assert entries == []
+        assert fallback_used
 
     @pytest.mark.asyncio
     async def test_has_new_entries(
@@ -159,11 +160,12 @@ async def test_has_new_entries(
 
         await helpers.update_entry_created_time([entries[-1].id], time_border - datetime.timedelta(seconds=10))
 
-        loaded_entries = await get_entries_by_filter_with_fallback(
+        loaded_entries, fallback_used = await get_entries_by_filter_with_fallback(
             feeds_ids=[loaded_feed.id], period=time_delta, limit=10, fallback_limit=10
         )
 
         assert {entry.id for entry in loaded_entries} == {entry.id for entry in entries if entry.id != entries[-1].id}
+        assert not fallback_used
 
     @pytest.mark.asyncio
     async def test_has_new_entries__limit(
@@ -173,12 +175,13 @@ async def test_has_new_entries__limit(
 
         await helpers.update_entry_created_time([entries[-1].id], time_border - datetime.timedelta(seconds=10))
 
-        loaded_entries = await get_entries_by_filter_with_fallback(
+        loaded_entries, fallback_used = await get_entries_by_filter_with_fallback(
             feeds_ids=[loaded_feed.id], period=time_delta, limit=1, fallback_limit=10
         )
 
         assert len(loaded_entries) == 1
         assert loaded_entries[0].id in {entry.id for entry in entries if entry.id != entries[-1].id}
+        assert not fallback_used
 
     @pytest.mark.asyncio
     async def test_no_new_entries(
@@ -190,11 +193,12 @@ async def test_no_new_entries(
             [entry.id for entry in entries], time_border - datetime.timedelta(seconds=10)
         )
 
-        loaded_entries = await get_entries_by_filter_with_fallback(
+        loaded_entries, fallback_used = await get_entries_by_filter_with_fallback(
             feeds_ids=[loaded_feed.id], period=time_delta, limit=1, fallback_limit=10
         )
 
         assert {entry.id for entry in loaded_entries} == {entry.id for entry in entries}
+        assert fallback_used
 
     @pytest.mark.asyncio
     async def test_fallback_returns_entries_older_than_max_entry_age(
@@ -207,11 +211,12 @@ async def test_fallback_returns_entries_older_than_max_entry_age(
             utils.now() - settings.max_entry_age - datetime.timedelta(days=1),
         )
 
-        loaded_entries = await get_entries_by_filter_with_fallback(
+        loaded_entries, fallback_used = await get_entries_by_filter_with_fallback(
             feeds_ids=[loaded_feed.id], period=time_delta, limit=1, fallback_limit=10
         )
 
         assert {entry.id for entry in loaded_entries} == {entry.id for entry in entries}
+        assert fallback_used
 
     @pytest.mark.asyncio
     async def test_no_new_entries__limit(
@@ -223,12 +228,13 @@ async def test_no_new_entries__limit(
             [entry.id for entry in entries], time_border - datetime.timedelta(seconds=10)
         )
 
-        loaded_entries = await get_entries_by_filter_with_fallback(
+        loaded_entries, fallback_used = await get_entries_by_filter_with_fallback(
             feeds_ids=[loaded_feed.id], period=time_delta, limit=1, fallback_limit=1
         )
 
         assert len(loaded_entries) == 1
         assert loaded_entries[0].id in {entry.id for entry in entries}
+        assert fallback_used
 
 
 class TestShrinkFeed:
diff --git a/site/src/components/notifications/LoadedOldNews.vue b/site/src/components/notifications/LoadedOldNews.vue
index 85f7a361d..d8edaef26 100644
--- a/site/src/components/notifications/LoadedOldNews.vue
+++ b/site/src/components/notifications/LoadedOldNews.vue
@@ -4,44 +4,31 @@
   <!-- until the backend returns a new response -->
   <!-- It confuses users because the period size is changing in the text at the beginning of the request. -->
   <ui-notice
-    v-if="allEntriesAreOlderThanPeriod"
+    v-if="showNotification"
     tone="info">
     <p> We have not found any news that is newer than {{ period.text }}, so we loaded some older ones. </p>
   </ui-notice>
 </template>
 
 <script lang="ts" setup>
-  import {computed, ref, onUnmounted, watch, provide} from "vue";
-  import {useRoute, useRouter} from "vue-router";
-  import {computedAsync} from "@vueuse/core";
-  import * as api from "@/logic/api";
-  import * as tagsFilterState from "@/logic/tagsFilterState";
+  import {computed} from "vue";
   import * as e from "@/logic/enums";
-  import * as utils from "@/logic/utils";
   import type * as t from "@/logic/types";
-  import {useGlobalSettingsStore} from "@/stores/globalSettings";
   import {useEntriesStore} from "@/stores/entries";
-  import _ from "lodash";
 
   const entriesStore = useEntriesStore();
 
   const properties = defineProps<{
     entries: t.EntryId[];
+    fallbackUsed: boolean;
     period: e.LastEntriesPeriodProperty;
   }>();
 
-  const allEntriesAreOlderThanPeriod = computed(() => {
+  const showNotification = computed(() => {
     if (entriesStore.loading) {
       return false;
     }
 
-    if (properties.entries.length == 0) {
-      return false;
-    }
-
-    return properties.entries.every((entryId) => {
-      const entry = entriesStore.entries[entryId];
-      return entry.effectivePublishedAt.getTime() < Date.now() - properties.period.seconds * 1000;
-    });
+    return properties.fallbackUsed && properties.entries.length > 0;
   });
 </script>
diff --git a/site/src/logic/api.ts b/site/src/logic/api.ts
index 14ec56b4e..fca6c762d 100644
--- a/site/src/logic/api.ts
+++ b/site/src/logic/api.ts
@@ -157,20 +157,13 @@ export async function getLastCollectionEntries({
   period: number;
   collectionSlug: t.CollectionSlug | null;
   minTagCount: number;
-}) {
-  const response = await postPublic({
+}): Promise<t.EntriesLoadResult> {
+  const response: t.RawEntriesLoadResponse = await postPublic({
     url: "/get-last-collection-entries",
     data: {period: period, collectionSlug: collectionSlug, minTagCount: minTagCount}
   });
 
-  const entries = [];
-
-  for (let rawEntry of response.entries) {
-    const entry = t.entryFromJSON(rawEntry, response.tagsMapping);
-    entries.push(entry);
-  }
-
-  return entries;
+  return t.entriesLoadResultFromJSON(response);
 }
 
 export async function getEntriesByIds({ids}: {ids: t.EntryId[]}) {
@@ -350,8 +343,14 @@ export async function getFeedsByIds({ids}: {ids: t.FeedId[]}) {
   return feeds;
 }
 
-export async function getLastEntries({period, minTagCount}: {period: number; minTagCount: number}) {
-  const response = await postPrivate({
+export async function getLastEntries({
+  period,
+  minTagCount
+}: {
+  period: number;
+  minTagCount: number;
+}): Promise<t.EntriesLoadResult> {
+  const response: t.RawEntriesLoadResponse = await postPrivate({
     url: "/get-last-entries",
     data: {
       period: period,
@@ -359,14 +358,7 @@ export async function getLastEntries({period, minTagCount}: {period: number; min
     }
   });
 
-  const entries = [];
-
-  for (let rawEntry of response.entries) {
-    const entry = t.entryFromJSON(rawEntry, response.tagsMapping);
-    entries.push(entry);
-  }
-
-  return entries;
+  return t.entriesLoadResultFromJSON(response);
 }
 
 export async function createOrUpdateRule({
diff --git a/site/src/logic/tests/types.test.ts b/site/src/logic/tests/types.test.ts
index d208319f9..7797507dc 100644
--- a/site/src/logic/tests/types.test.ts
+++ b/site/src/logic/tests/types.test.ts
@@ -2,6 +2,7 @@ import {describe, expect, it} from "vitest";
 
 import * as e from "@/logic/enums";
 import {
+  entriesLoadResultFromJSON,
   entryFromJSON,
   feedFromJSON,
   productStateFromJSON,
@@ -125,6 +126,23 @@ describe("entryFromJSON", () => {
   });
 });
 
+describe("entriesLoadResultFromJSON", () => {
+  it("translates the complete entries response", () => {
+    const entry = rawEntry([]);
+    entry.tags = [1];
+
+    const result = entriesLoadResultFromJSON({
+      entries: [entry],
+      tagsMapping: {1: "technology"},
+      fallbackUsed: true
+    });
+
+    expect(result.entries).toHaveLength(1);
+    expect(result.entries[0].tags).toEqual(["technology"]);
+    expect(result.fallbackUsed).toBe(true);
+  });
+});
+
 describe("resourceStatisticsFromJSON", () => {
   it("translates an empty statistics record", () => {
     expect(
diff --git a/site/src/logic/types.ts b/site/src/logic/types.ts
index 8b4dfa66f..459a0e723 100644
--- a/site/src/logic/types.ts
+++ b/site/src/logic/types.ts
@@ -336,6 +336,17 @@ export type RawEntry = {
   references?: RawReference[] | null;
 };
 
+export type RawEntriesLoadResponse = {
+  entries: RawEntry[];
+  tagsMapping: {[key: number]: string};
+  fallbackUsed: boolean;
+};
+
+export type EntriesLoadResult = {
+  entries: Entry[];
+  fallbackUsed: boolean;
+};
+
 export function entryFromJSON(rawEntry: RawEntry, tagsMapping: {[key: number]: string}): Entry {
   const contributions: {[key: string]: number} = {};
 
@@ -370,6 +381,17 @@ export function entryFromJSON(rawEntry: RawEntry, tagsMapping: {[key: number]: s
   });
 }
 
+export function entriesLoadResultFromJSON({
+  entries,
+  tagsMapping,
+  fallbackUsed
+}: RawEntriesLoadResponse): EntriesLoadResult {
+  return {
+    entries: entries.map((entry) => entryFromJSON(entry, tagsMapping)),
+    fallbackUsed
+  };
+}
+
 export type Rule = {
   readonly id: RuleId;
   readonly requiredTags: string[];
diff --git a/site/src/stores/entries.ts b/site/src/stores/entries.ts
index 441855810..274f2c8dc 100644
--- a/site/src/stores/entries.ts
+++ b/site/src/stores/entries.ts
@@ -17,6 +17,11 @@ enum Mode {
   PublicCollection = "public-collection"
 }
 
+type LoadedEntriesReport = {
+  entryIds: t.EntryId[];
+  fallbackUsed: boolean;
+};
+
 export const useEntriesStore = defineStore("entriesStore", () => {
   const globalSettings = useGlobalSettingsStore();
   const globalState = useGlobalState();
@@ -115,7 +120,7 @@ export const useEntriesStore = defineStore("entriesStore", () => {
     entries.value = {...entries.value, ...delta};
   }
 
-  async function loadEntriesAccordingToMode() {
+  async function loadEntriesAccordingToMode(): Promise<t.EntriesLoadResult> {
     const periodProperties = e.LastEntriesPeriodProperties.get(globalSettings.lastEntriesPeriod as any);
 
     if (periodProperties === undefined) {
@@ -148,7 +153,7 @@ export const useEntriesStore = defineStore("entriesStore", () => {
     throw new Error(`Unknown mode ${mode.value}`);
   }
 
-  const loadedEntriesReport = computedAsync(async () => {
+  const loadedEntriesReport = computedAsync<LoadedEntriesReport | null>(async () => {
     // force refresh
     globalSettings.dataVersion;
 
@@ -158,20 +163,17 @@ export const useEntriesStore = defineStore("entriesStore", () => {
 
     entriesLoadRevision.value += 1;
 
-    const loadedEntries = await loadEntriesAccordingToMode();
-
-    const report = [];
+    const loadResult = await loadEntriesAccordingToMode();
 
     registerEntries({
-      newEntries: loadedEntries,
+      newEntries: loadResult.entries,
       updateTags: true
     });
 
-    for (const entry of loadedEntries) {
-      report.push(entry.id);
-    }
-
-    return report;
+    return {
+      entryIds: loadResult.entries.map((entry) => entry.id),
+      fallbackUsed: loadResult.fallbackUsed
+    };
   }, null);
 
   const _sortedEntries = computed(() => {
@@ -186,7 +188,12 @@ export const useEntriesStore = defineStore("entriesStore", () => {
     const field = activeOrderProperties.value.orderField;
     const direction = activeOrderProperties.value.direction;
 
-    const report = utils.sortIdsList({ids: loadedEntriesReport.value, storage: entries.value, field, direction});
+    const report = utils.sortIdsList({
+      ids: loadedEntriesReport.value.entryIds,
+      storage: entries.value,
+      field,
+      direction
+    });
 
     return report;
   });
diff --git a/site/src/views/NewsView.vue b/site/src/views/NewsView.vue
index 2d7bed230..8cf74c413 100644
--- a/site/src/views/NewsView.vue
+++ b/site/src/views/NewsView.vue
@@ -67,7 +67,8 @@
       :collections-warning_="false" />
 
     <notifications-loaded-old-news
-      :entries="entriesStore.loadedEntriesReport || []"
+      :entries="entriesStore.loadedEntriesReport?.entryIds || []"
+      :fallback-used="entriesStore.loadedEntriesReport?.fallbackUsed || false"
       :period="e.LastEntriesPeriodProperties.get(globalSettings.lastEntriesPeriod as any)" />
 
     <entries-list
@@ -153,7 +154,7 @@
 
     // TODO: it is a heuristic (score could be 0 even with rules)
     //       must be refactored to something more stable
-    for (const entryId of entriesStore.loadedEntriesReport) {
+    for (const entryId of entriesStore.loadedEntriesReport.entryIds) {
       if (entriesStore.entries[entryId].score != 0) {
         return true;
       }
diff --git a/site/src/views/PublicCollectionView.vue b/site/src/views/PublicCollectionView.vue
index c323a32ba..68847126d 100644
--- a/site/src/views/PublicCollectionView.vue
+++ b/site/src/views/PublicCollectionView.vue
@@ -89,7 +89,8 @@
     </ui-advisory>
 
     <notifications-loaded-old-news
-      :entries="entriesStore.loadedEntriesReport || []"
+      :entries="entriesStore.loadedEntriesReport?.entryIds || []"
+      :fallback-used="entriesStore.loadedEntriesReport?.fallbackUsed || false"
       :period="e.LastEntriesPeriodProperties.get(globalSettings.lastEntriesPeriod as any)" />
 
     <entries-list

From fdc88860b429d71f971c3b9e95712d108d8b309c Mon Sep 17 00:00:00 2001
From: "Aliaksei Yaletski (Tiendil)" <a.eletsky@gmail.com>
Date: Mon, 31 Aug 2026 19:01:12 +0200
Subject: [PATCH 4/8] polishing

---
 ffun/ffun/api/spa/http_handlers.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/ffun/ffun/api/spa/http_handlers.py b/ffun/ffun/api/spa/http_handlers.py
index 6dc5b2fd8..4ff5ef659 100644
--- a/ffun/ffun/api/spa/http_handlers.py
+++ b/ffun/ffun/api/spa/http_handlers.py
@@ -457,7 +457,9 @@ async def api_get_last_entries(request: entities.GetLastEntriesRequest, user: Us
         entries, with_body=False, user_id=user.id, min_tag_count=request.minTagCount
     )
 
-    return entities.GetLastEntriesResponse(entries=external_entries, fallbackUsed=fallback_used, tagsMapping=tags_mapping)
+    return entities.GetLastEntriesResponse(
+        entries=external_entries, fallbackUsed=fallback_used, tagsMapping=tags_mapping
+    )
 
 
 @api_private.post("/create-or-update-rule")  # type: ignore

From 4d079035a16bee903ca94bf3cb4fa06ee25088be Mon Sep 17 00:00:00 2001
From: "Aliaksei Yaletski (Tiendil)" <a.eletsky@gmail.com>
Date: Mon, 31 Aug 2026 19:23:57 +0200
Subject: [PATCH 5/8] polishing

---
 ffun/ffun/api/spa/http_handlers.py     | 12 ++++----
 ffun/ffun/library/domain.py            |  8 +++---
 ffun/ffun/library/entities.py          |  5 ++++
 ffun/ffun/library/tests/test_domain.py | 40 +++++++++++++-------------
 site/src/logic/tests/types.test.ts     | 11 +++++++
 site/src/logic/tests/utils.test.ts     |  4 +++
 6 files changed, 50 insertions(+), 30 deletions(-)

diff --git a/ffun/ffun/api/spa/http_handlers.py b/ffun/ffun/api/spa/http_handlers.py
index 4ff5ef659..c554dc64e 100644
--- a/ffun/ffun/api/spa/http_handlers.py
+++ b/ffun/ffun/api/spa/http_handlers.py
@@ -222,7 +222,7 @@ async def api_get_last_collection_entries(
 
     feed_ids = [feed_info.feed_id for feed_info in collection.feeds if feed_info.feed_id is not None]
 
-    entries, fallback_used = await l_domain.get_entries_by_filter_with_fallback(
+    load_result = await l_domain.get_entries_by_filter_with_fallback(
         feeds_ids=feed_ids,
         period=request.period,
         limit=settings.max_returned_entries,
@@ -230,11 +230,11 @@ async def api_get_last_collection_entries(
     )
 
     external_entries, tags_mapping = await _external_entries(
-        entries, with_body=False, user_id=None, min_tag_count=request.minTagCount
+        load_result.entries, with_body=False, user_id=None, min_tag_count=request.minTagCount
     )
 
     return entities.GetLastCollectionEntriesResponse(
-        entries=external_entries, fallbackUsed=fallback_used, tagsMapping=tags_mapping
+        entries=external_entries, fallbackUsed=load_result.fallback_used, tagsMapping=tags_mapping
     )
 
 
@@ -446,7 +446,7 @@ async def api_get_last_entries(request: entities.GetLastEntriesRequest, user: Us
 
     linked_feeds_ids = [link.feed_id for link in linked_feeds]
 
-    entries, fallback_used = await l_domain.get_entries_by_filter_with_fallback(
+    load_result = await l_domain.get_entries_by_filter_with_fallback(
         feeds_ids=linked_feeds_ids,
         period=request.period,
         limit=settings.max_returned_entries,
@@ -454,11 +454,11 @@ async def api_get_last_entries(request: entities.GetLastEntriesRequest, user: Us
     )
 
     external_entries, tags_mapping = await _external_entries(
-        entries, with_body=False, user_id=user.id, min_tag_count=request.minTagCount
+        load_result.entries, with_body=False, user_id=user.id, min_tag_count=request.minTagCount
     )
 
     return entities.GetLastEntriesResponse(
-        entries=external_entries, fallbackUsed=fallback_used, tagsMapping=tags_mapping
+        entries=external_entries, fallbackUsed=load_result.fallback_used, tagsMapping=tags_mapping
     )
 
 
diff --git a/ffun/ffun/library/domain.py b/ffun/ffun/library/domain.py
index a6b19dace..ade11ac17 100644
--- a/ffun/ffun/library/domain.py
+++ b/ffun/ffun/library/domain.py
@@ -7,7 +7,7 @@
 from ffun.domain.entities import EntryId, FeedId, UnknownUrl
 from ffun.feeds import domain as f_domain
 from ffun.library import operations
-from ffun.library.entities import Entry, EntryChange, FeedEntryLink
+from ffun.library.entities import EntriesLoadResult, Entry, EntryChange, FeedEntryLink
 
 logger = logging.get_module_logger()
 
@@ -94,17 +94,17 @@ async def normalize_entry(entry: Entry, apply: bool = False) -> list[EntryChange
 
 async def get_entries_by_filter_with_fallback(
     feeds_ids: list[FeedId], period: datetime.timedelta | None, limit: int, fallback_limit: int
-) -> tuple[list[Entry], bool]:
+) -> EntriesLoadResult:
 
     entries = await get_entries_by_filter(feeds_ids=feeds_ids, period=period, limit=limit)
 
     if entries:
-        return entries, False
+        return EntriesLoadResult(entries=entries, fallback_used=False)
 
     # if there is no news in requested interval try to get some older news
     entries = await get_entries_by_filter(feeds_ids=feeds_ids, period=_fallback_period, limit=fallback_limit)
 
-    return entries, True
+    return EntriesLoadResult(entries=entries, fallback_used=True)
 
 
 @run_in_transaction
diff --git a/ffun/ffun/library/entities.py b/ffun/ffun/library/entities.py
index 9b367ec08..bbc60360b 100644
--- a/ffun/ffun/library/entities.py
+++ b/ffun/ffun/library/entities.py
@@ -157,6 +157,11 @@ def collected_entry(self) -> "CollectedEntry":
         )
 
 
+class EntriesLoadResult(BaseEntity):
+    entries: list[Entry]
+    fallback_used: bool
+
+
 class CollectedEntry(BaseEntry):
     def fake_entry(self, created_at: datetime.datetime) -> Entry:
         return Entry(
diff --git a/ffun/ffun/library/tests/test_domain.py b/ffun/ffun/library/tests/test_domain.py
index f94cd23b4..48f7d7046 100644
--- a/ffun/ffun/library/tests/test_domain.py
+++ b/ffun/ffun/library/tests/test_domain.py
@@ -145,12 +145,12 @@ async def prepared_entries(self, loaded_feed: Feed, time_border: datetime.dateti
 
     @pytest.mark.asyncio
     async def test_no_entries_at_all(self, time_delta: datetime.timedelta) -> None:
-        entries, fallback_used = await get_entries_by_filter_with_fallback(
+        result = await get_entries_by_filter_with_fallback(
             feeds_ids=[], period=time_delta, limit=10, fallback_limit=10
         )
 
-        assert entries == []
-        assert fallback_used
+        assert result.entries == []
+        assert result.fallback_used
 
     @pytest.mark.asyncio
     async def test_has_new_entries(
@@ -160,12 +160,12 @@ async def test_has_new_entries(
 
         await helpers.update_entry_created_time([entries[-1].id], time_border - datetime.timedelta(seconds=10))
 
-        loaded_entries, fallback_used = await get_entries_by_filter_with_fallback(
+        result = await get_entries_by_filter_with_fallback(
             feeds_ids=[loaded_feed.id], period=time_delta, limit=10, fallback_limit=10
         )
 
-        assert {entry.id for entry in loaded_entries} == {entry.id for entry in entries if entry.id != entries[-1].id}
-        assert not fallback_used
+        assert {entry.id for entry in result.entries} == {entry.id for entry in entries if entry.id != entries[-1].id}
+        assert not result.fallback_used
 
     @pytest.mark.asyncio
     async def test_has_new_entries__limit(
@@ -175,13 +175,13 @@ async def test_has_new_entries__limit(
 
         await helpers.update_entry_created_time([entries[-1].id], time_border - datetime.timedelta(seconds=10))
 
-        loaded_entries, fallback_used = await get_entries_by_filter_with_fallback(
+        result = await get_entries_by_filter_with_fallback(
             feeds_ids=[loaded_feed.id], period=time_delta, limit=1, fallback_limit=10
         )
 
-        assert len(loaded_entries) == 1
-        assert loaded_entries[0].id in {entry.id for entry in entries if entry.id != entries[-1].id}
-        assert not fallback_used
+        assert len(result.entries) == 1
+        assert result.entries[0].id in {entry.id for entry in entries if entry.id != entries[-1].id}
+        assert not result.fallback_used
 
     @pytest.mark.asyncio
     async def test_no_new_entries(
@@ -193,12 +193,12 @@ async def test_no_new_entries(
             [entry.id for entry in entries], time_border - datetime.timedelta(seconds=10)
         )
 
-        loaded_entries, fallback_used = await get_entries_by_filter_with_fallback(
+        result = await get_entries_by_filter_with_fallback(
             feeds_ids=[loaded_feed.id], period=time_delta, limit=1, fallback_limit=10
         )
 
-        assert {entry.id for entry in loaded_entries} == {entry.id for entry in entries}
-        assert fallback_used
+        assert {entry.id for entry in result.entries} == {entry.id for entry in entries}
+        assert result.fallback_used
 
     @pytest.mark.asyncio
     async def test_fallback_returns_entries_older_than_max_entry_age(
@@ -211,12 +211,12 @@ async def test_fallback_returns_entries_older_than_max_entry_age(
             utils.now() - settings.max_entry_age - datetime.timedelta(days=1),
         )
 
-        loaded_entries, fallback_used = await get_entries_by_filter_with_fallback(
+        result = await get_entries_by_filter_with_fallback(
             feeds_ids=[loaded_feed.id], period=time_delta, limit=1, fallback_limit=10
         )
 
-        assert {entry.id for entry in loaded_entries} == {entry.id for entry in entries}
-        assert fallback_used
+        assert {entry.id for entry in result.entries} == {entry.id for entry in entries}
+        assert result.fallback_used
 
     @pytest.mark.asyncio
     async def test_no_new_entries__limit(
@@ -228,13 +228,13 @@ async def test_no_new_entries__limit(
             [entry.id for entry in entries], time_border - datetime.timedelta(seconds=10)
         )
 
-        loaded_entries, fallback_used = await get_entries_by_filter_with_fallback(
+        result = await get_entries_by_filter_with_fallback(
             feeds_ids=[loaded_feed.id], period=time_delta, limit=1, fallback_limit=1
         )
 
-        assert len(loaded_entries) == 1
-        assert loaded_entries[0].id in {entry.id for entry in entries}
-        assert fallback_used
+        assert len(result.entries) == 1
+        assert result.entries[0].id in {entry.id for entry in entries}
+        assert result.fallback_used
 
 
 class TestShrinkFeed:
diff --git a/site/src/logic/tests/types.test.ts b/site/src/logic/tests/types.test.ts
index 7797507dc..d53904c1c 100644
--- a/site/src/logic/tests/types.test.ts
+++ b/site/src/logic/tests/types.test.ts
@@ -141,6 +141,17 @@ describe("entriesLoadResultFromJSON", () => {
     expect(result.entries[0].tags).toEqual(["technology"]);
     expect(result.fallbackUsed).toBe(true);
   });
+
+  it("translates an empty entries response", () => {
+    const result = entriesLoadResultFromJSON({
+      entries: [],
+      tagsMapping: {},
+      fallbackUsed: false
+    });
+
+    expect(result.entries).toEqual([]);
+    expect(result.fallbackUsed).toBe(false);
+  });
 });
 
 describe("resourceStatisticsFromJSON", () => {
diff --git a/site/src/logic/tests/utils.test.ts b/site/src/logic/tests/utils.test.ts
index 14e4091bf..ac7bfa9e5 100644
--- a/site/src/logic/tests/utils.test.ts
+++ b/site/src/logic/tests/utils.test.ts
@@ -10,10 +10,14 @@ afterEach(() => {
 describe("timeSince", () => {
   it.each([
     {secondsPast: 30, short: "<min", long: "just now"},
+    {secondsPast: 60, short: "1min", long: "1 minute ago"},
     {secondsPast: 5 * 60, short: "5min", long: "5 minutes ago"},
+    {secondsPast: 60 * 60, short: "1h", long: "1 hour ago"},
     {secondsPast: 3 * 60 * 60, short: "3h", long: "3 hours ago"},
     {secondsPast: 24 * 60 * 60, short: "1d", long: "1 day ago"},
+    {secondsPast: 30 * 24 * 60 * 60, short: "1m", long: "1 month ago"},
     {secondsPast: 60 * 24 * 60 * 60, short: "2m", long: "2 months ago"},
+    {secondsPast: 360 * 24 * 60 * 60, short: "1y", long: "1 year ago"},
     {secondsPast: 720 * 24 * 60 * 60, short: "2y", long: "2 years ago"}
   ])("formats $long in short and long styles", ({secondsPast, short, long}) => {
     const now = new Date("2026-08-31T12:00:00Z");

From d0771977f41822556b7594ebd1c2b1d68a96f21b Mon Sep 17 00:00:00 2001
From: "Aliaksei Yaletski (Tiendil)" <a.eletsky@gmail.com>
Date: Mon, 31 Aug 2026 19:25:32 +0200
Subject: [PATCH 6/8] changelog

---
 changes/unreleased.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/changes/unreleased.md b/changes/unreleased.md
index 373eb997b..e8076aeed 100644
--- a/changes/unreleased.md
+++ b/changes/unreleased.md
@@ -1,2 +1,2 @@
 
-No changes.
+- ff-707 (gh-480) — unified display of entry published dates.

From d44c7a0fe01f40a62f850896a1be9fd7d7764cd3 Mon Sep 17 00:00:00 2001
From: "Aliaksei Yaletski (Tiendil)" <a.eletsky@gmail.com>
Date: Mon, 31 Aug 2026 19:33:20 +0200
Subject: [PATCH 7/8] changes approved

---
 changes/{unreleased.md => next_release.md} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename changes/{unreleased.md => next_release.md} (100%)

diff --git a/changes/unreleased.md b/changes/next_release.md
similarity index 100%
rename from changes/unreleased.md
rename to changes/next_release.md

From a6b886e7ef494d57b5391b0b42de18f68396caaa Mon Sep 17 00:00:00 2001
From: "Aliaksei Yaletski (Tiendil)" <a.eletsky@gmail.com>
Date: Mon, 31 Aug 2026 19:37:40 +0200
Subject: [PATCH 8/8] removed unused import

---
 site/src/components/EntriesList.vue | 1 -
 1 file changed, 1 deletion(-)

diff --git a/site/src/components/EntriesList.vue b/site/src/components/EntriesList.vue
index 094aabc8b..6ab8e64f1 100644
--- a/site/src/components/EntriesList.vue
+++ b/site/src/components/EntriesList.vue
@@ -48,7 +48,6 @@
 <script lang="ts" setup>
   import {computed, ref} from "vue";
   import type * as t from "@/logic/types";
-  import {computedAsync} from "@vueuse/core";
 
   const properties = defineProps<{
     loading: boolean;