diff --git a/app/components/Package/TrendsChart.vue b/app/components/Package/TrendsChart.vue
index 98548cf94f..98aa85d024 100644
--- a/app/components/Package/TrendsChart.vue
+++ b/app/components/Package/TrendsChart.vue
@@ -402,7 +402,9 @@ const isEndDateOnPeriodEnd = computed(() => {
 })
 
 const supportsEstimation = computed(
-  () => displayedGranularity.value !== 'daily' && selectedMetric.value !== 'contributors',
+  () =>
+    !['daily', 'weekly'].includes(displayedGranularity.value) &&
+    selectedMetric.value !== 'contributors',
 )
 
 const hasDownloadAnomalies = computed(() =>
@@ -1081,7 +1083,10 @@ const normalisedDataset = computed(() => {
       {
         averageWindow: settings.value.chartFilter.averageWindow,
         smoothingTau: settings.value.chartFilter.smoothingTau,
-        predictionPoints: settings.value.chartFilter.predictionPoints ?? DEFAULT_PREDICTION_POINTS,
+        predictionPoints:
+          granularity === 'weekly'
+            ? 0 // weekly buckets are end-aligned → always complete, no prediction needed
+            : (settings.value.chartFilter.predictionPoints ?? DEFAULT_PREDICTION_POINTS),
       },
       { granularity, lastDateMs, referenceMs, isAbsoluteMetric },
     )
@@ -1763,15 +1768,14 @@ watch(selectedMetric, value => {
             </span>
             <label
               class="flex items-center gap-1.5 text-2xs font-mono text-fg-subtle cursor-pointer h-4"
-              :class="{ 'opacity-50 pointer-events-none': !hasAnomalies }"
+              :class="{ 'opacity-50': !hasAnomalies }"
             >
               <input
-                :checked="settings.chartFilter.anomaliesFixed && hasAnomalies"
+                :checked="settings.chartFilter.anomaliesFixed"
                 @change="
                   settings.chartFilter.anomaliesFixed = ($event.target as HTMLInputElement).checked
                 "
                 type="checkbox"
-                :disabled="!hasAnomalies"
                 class="accent-[var(--accent-color,var(--fg-subtle))]"
               />
               {{ $t('package.trends.apply_correction') }}
diff --git a/app/composables/useCharts.ts b/app/composables/useCharts.ts
index 339d760e2d..0fc07ab6a0 100644
--- a/app/composables/useCharts.ts
+++ b/app/composables/useCharts.ts
@@ -13,21 +13,18 @@ import { parseRepoUrl } from '#shared/utils/git-providers'
 import type { PackageMetaResponse } from '#shared/types'
 import { encodePackageName } from '#shared/utils/npm'
 import { fetchNpmDownloadsRange } from '~/utils/npm/api'
+import { parseIsoDate, toIsoDate, addDays } from '~/utils/date'
+import {
+  buildDailyEvolution,
+  buildWeeklyEvolution,
+  buildMonthlyEvolution,
+  buildYearlyEvolution,
+} from '~/utils/chart-data-buckets'
 
 export type PackumentLikeForTime = {
   time?: Record<string, string>
 }
 
-function toIsoDateString(date: Date): string {
-  return date.toISOString().slice(0, 10)
-}
-
-function addDays(date: Date, days: number): Date {
-  const updatedDate = new Date(date)
-  updatedDate.setUTCDate(updatedDate.getUTCDate() + days)
-  return updatedDate
-}
-
 function startOfUtcMonth(date: Date): Date {
   return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), 1))
 }
@@ -36,17 +33,9 @@ function startOfUtcYear(date: Date): Date {
   return new Date(Date.UTC(date.getUTCFullYear(), 0, 1))
 }
 
-function parseIsoDateOnly(value: string): Date {
-  return new Date(`${value}T00:00:00.000Z`)
-}
-
-function formatIsoDateOnly(date: Date): string {
-  return date.toISOString().slice(0, 10)
-}
-
 function differenceInUtcDaysInclusive(startIso: string, endIso: string): number {
-  const start = parseIsoDateOnly(startIso)
-  const end = parseIsoDateOnly(endIso)
+  const start = parseIsoDate(startIso)
+  const end = parseIsoDate(endIso)
   return Math.floor((end.getTime() - start.getTime()) / 86400000) + 1
 }
 
@@ -59,16 +48,16 @@ function splitIsoRangeIntoChunksInclusive(
   if (totalDays <= maximumDaysPerRequest) return [{ startIso, endIso }]
 
   const chunks: Array<{ startIso: string; endIso: string }> = []
-  let cursorStart = parseIsoDateOnly(startIso)
-  const finalEnd = parseIsoDateOnly(endIso)
+  let cursorStart = parseIsoDate(startIso)
+  const finalEnd = parseIsoDate(endIso)
 
   while (cursorStart.getTime() <= finalEnd.getTime()) {
     const cursorEnd = addDays(cursorStart, maximumDaysPerRequest - 1)
     const actualEnd = cursorEnd.getTime() < finalEnd.getTime() ? cursorEnd : finalEnd
 
     chunks.push({
-      startIso: formatIsoDateOnly(cursorStart),
-      endIso: formatIsoDateOnly(actualEnd),
+      startIso: toIsoDate(cursorStart),
+      endIso: toIsoDate(actualEnd),
     })
 
     cursorStart = addDays(actualEnd, 1)
@@ -89,101 +78,6 @@ function mergeDailyPoints(points: DailyRawPoint[]): DailyRawPoint[] {
     .map(([day, value]) => ({ day, value }))
 }
 
-export function buildDailyEvolutionFromDaily(daily: DailyRawPoint[]): DailyDataPoint[] {
-  return daily
-    .slice()
-    .sort((a, b) => a.day.localeCompare(b.day))
-    .map(item => {
-      const dayDate = parseIsoDateOnly(item.day)
-      const timestamp = dayDate.getTime()
-
-      return { day: item.day, value: item.value, timestamp }
-    })
-}
-
-export function buildRollingWeeklyEvolutionFromDaily(
-  daily: DailyRawPoint[],
-  rangeStartIso: string,
-  rangeEndIso: string,
-): WeeklyDataPoint[] {
-  const sorted = daily.slice().sort((a, b) => a.day.localeCompare(b.day))
-  const rangeStartDate = parseIsoDateOnly(rangeStartIso)
-  const rangeEndDate = parseIsoDateOnly(rangeEndIso)
-
-  const groupedByIndex = new Map<number, number>()
-
-  for (const item of sorted) {
-    const itemDate = parseIsoDateOnly(item.day)
-    const dayOffset = Math.floor((itemDate.getTime() - rangeStartDate.getTime()) / 86400000)
-    if (dayOffset < 0) continue
-
-    const weekIndex = Math.floor(dayOffset / 7)
-    groupedByIndex.set(weekIndex, (groupedByIndex.get(weekIndex) ?? 0) + item.value)
-  }
-
-  return Array.from(groupedByIndex.entries())
-    .sort(([a], [b]) => a - b)
-    .map(([weekIndex, value]) => {
-      const weekStartDate = addDays(rangeStartDate, weekIndex * 7)
-      const weekEndDate = addDays(weekStartDate, 6)
-
-      // Clamp weekEnd to the actual data range end date
-      const clampedWeekEndDate =
-        weekEndDate.getTime() > rangeEndDate.getTime() ? rangeEndDate : weekEndDate
-
-      const weekStartIso = toIsoDateString(weekStartDate)
-      const weekEndIso = toIsoDateString(clampedWeekEndDate)
-
-      const timestampStart = weekStartDate.getTime()
-      const timestampEnd = clampedWeekEndDate.getTime()
-
-      return {
-        value,
-        weekKey: `${weekStartIso}_${weekEndIso}`,
-        weekStart: weekStartIso,
-        weekEnd: weekEndIso,
-        timestampStart,
-        timestampEnd,
-      }
-    })
-}
-
-export function buildMonthlyEvolutionFromDaily(daily: DailyRawPoint[]): MonthlyDataPoint[] {
-  const sorted = daily.slice().sort((a, b) => a.day.localeCompare(b.day))
-  const valuesByMonth = new Map<string, number>()
-
-  for (const item of sorted) {
-    const month = item.day.slice(0, 7)
-    valuesByMonth.set(month, (valuesByMonth.get(month) ?? 0) + item.value)
-  }
-
-  return Array.from(valuesByMonth.entries())
-    .sort(([a], [b]) => a.localeCompare(b))
-    .map(([month, value]) => {
-      const monthStartDate = parseIsoDateOnly(`${month}-01`)
-      const timestamp = monthStartDate.getTime()
-      return { month, value, timestamp }
-    })
-}
-
-export function buildYearlyEvolutionFromDaily(daily: DailyRawPoint[]): YearlyDataPoint[] {
-  const sorted = daily.slice().sort((a, b) => a.day.localeCompare(b.day))
-  const valuesByYear = new Map<string, number>()
-
-  for (const item of sorted) {
-    const year = item.day.slice(0, 4)
-    valuesByYear.set(year, (valuesByYear.get(year) ?? 0) + item.value)
-  }
-
-  return Array.from(valuesByYear.entries())
-    .sort(([a], [b]) => a.localeCompare(b))
-    .map(([year, value]) => {
-      const yearStartDate = parseIsoDateOnly(`${year}-01-01`)
-      const timestamp = yearStartDate.getTime()
-      return { year, value, timestamp }
-    })
-}
-
 const npmDailyRangeCache = import.meta.client ? new Map<string, Promise<DailyRawPoint[]>>() : null
 const likesEvolutionCache = import.meta.client ? new Map<string, Promise<DailyRawPoint[]>>() : null
 const contributorsEvolutionCache = import.meta.client
@@ -238,8 +132,8 @@ function buildWeeklyEvolutionFromContributorCounts(
 
       const clampedWeekEndDate = weekEndDate.getTime() > rangeEnd.getTime() ? rangeEnd : weekEndDate
 
-      const weekStartIso = toIsoDateString(weekStartDate)
-      const weekEndIso = toIsoDateString(clampedWeekEndDate)
+      const weekStartIso = toIsoDate(weekStartDate)
+      const weekEndIso = toIsoDate(clampedWeekEndDate)
 
       return {
         value,
@@ -415,11 +309,11 @@ export function useCharts() {
     )
 
     const endDateOnly = toDateOnly(evolutionOptions.endDate)
-    const end = endDateOnly ? parseIsoDateOnly(endDateOnly) : yesterday
+    const end = endDateOnly ? parseIsoDate(endDateOnly) : yesterday
 
     const startDateOnly = toDateOnly(evolutionOptions.startDate)
     if (startDateOnly) {
-      const start = parseIsoDateOnly(startDateOnly)
+      const start = parseIsoDate(startDateOnly)
       return { start, end }
     }
 
@@ -465,16 +359,17 @@ export function useCharts() {
 
     const { start, end } = resolveDateRange(resolvedOptions, resolvedCreatedIso)
 
-    const startIso = toIsoDateString(start)
-    const endIso = toIsoDateString(end)
+    const startIso = toIsoDate(start)
+    const endIso = toIsoDate(end)
 
     const sortedDaily = await fetchDailyRangeChunked(resolvedPackageName, startIso, endIso)
 
-    if (resolvedOptions.granularity === 'day') return buildDailyEvolutionFromDaily(sortedDaily)
+    if (resolvedOptions.granularity === 'day') return buildDailyEvolution(sortedDaily)
     if (resolvedOptions.granularity === 'week')
-      return buildRollingWeeklyEvolutionFromDaily(sortedDaily, startIso, endIso)
-    if (resolvedOptions.granularity === 'month') return buildMonthlyEvolutionFromDaily(sortedDaily)
-    return buildYearlyEvolutionFromDaily(sortedDaily)
+      return buildWeeklyEvolution(sortedDaily, startIso, endIso)
+    if (resolvedOptions.granularity === 'month')
+      return buildMonthlyEvolution(sortedDaily, startIso, endIso)
+    return buildYearlyEvolution(sortedDaily, startIso, endIso)
   }
 
   async function fetchPackageLikesEvolution(
@@ -508,17 +403,17 @@ export function useCharts() {
     const sortedDaily = await dailyLikesPromise
 
     const { start, end } = resolveDateRange(resolvedOptions, null)
-    const startIso = toIsoDateString(start)
-    const endIso = toIsoDateString(end)
+    const startIso = toIsoDate(start)
+    const endIso = toIsoDate(end)
 
     const filteredDaily = sortedDaily.filter(d => d.day >= startIso && d.day <= endIso)
 
-    if (resolvedOptions.granularity === 'day') return buildDailyEvolutionFromDaily(filteredDaily)
+    if (resolvedOptions.granularity === 'day') return buildDailyEvolution(filteredDaily)
     if (resolvedOptions.granularity === 'week')
-      return buildRollingWeeklyEvolutionFromDaily(filteredDaily, startIso, endIso)
+      return buildWeeklyEvolution(filteredDaily, startIso, endIso)
     if (resolvedOptions.granularity === 'month')
-      return buildMonthlyEvolutionFromDaily(filteredDaily)
-    return buildYearlyEvolutionFromDaily(filteredDaily)
+      return buildMonthlyEvolution(filteredDaily, startIso, endIso)
+    return buildYearlyEvolution(filteredDaily, startIso, endIso)
   }
 
   async function fetchRepoContributorsEvolution(
diff --git a/app/utils/chart-data-buckets.ts b/app/utils/chart-data-buckets.ts
new file mode 100644
index 0000000000..1165c4541f
--- /dev/null
+++ b/app/utils/chart-data-buckets.ts
@@ -0,0 +1,144 @@
+import type {
+  DailyDataPoint,
+  DailyRawPoint,
+  MonthlyDataPoint,
+  WeeklyDataPoint,
+  YearlyDataPoint,
+} from '~/types/chart'
+import { DAY_MS, parseIsoDate, toIsoDate, addDays, daysInMonth, daysInYear } from '~/utils/date'
+
+/** Proportionally scale a partial bucket to estimate the full-period value. */
+export function fillPartialBucket(value: number, actualDays: number, totalDays: number): number {
+  if (actualDays <= 0 || actualDays >= totalDays) return value
+  return Math.round((value * totalDays) / actualDays)
+}
+
+function sortedDaily(daily: DailyRawPoint[]): DailyRawPoint[] {
+  return daily.slice().sort((a, b) => a.day.localeCompare(b.day))
+}
+
+export function buildDailyEvolution(daily: DailyRawPoint[]): DailyDataPoint[] {
+  return sortedDaily(daily).map(item => ({
+    day: item.day,
+    value: item.value,
+    timestamp: parseIsoDate(item.day).getTime(),
+  }))
+}
+
+export function buildWeeklyEvolution(
+  daily: DailyRawPoint[],
+  rangeStartIso: string,
+  rangeEndIso: string,
+): WeeklyDataPoint[] {
+  const sorted = sortedDaily(daily)
+  if (sorted.length === 0) return []
+
+  const rangeStartDate = parseIsoDate(rangeStartIso)
+
+  // Align from last day with actual data (npm has 1-2 day delay, today is incomplete)
+  const lastNonZero = sorted.findLast(d => d.value > 0)
+  const pickerEnd = parseIsoDate(rangeEndIso)
+  const effectiveEnd = lastNonZero ? parseIsoDate(lastNonZero.day) : pickerEnd
+  const rangeEndDate = effectiveEnd.getTime() < pickerEnd.getTime() ? effectiveEnd : pickerEnd
+
+  // Group into 7-day buckets from END backwards
+  const buckets = new Map<number, number>()
+  for (const item of sorted) {
+    const offset = Math.floor((rangeEndDate.getTime() - parseIsoDate(item.day).getTime()) / DAY_MS)
+    if (offset < 0) continue
+    const idx = Math.floor(offset / 7)
+    buckets.set(idx, (buckets.get(idx) ?? 0) + item.value)
+  }
+
+  return Array.from(buckets.entries())
+    .sort(([a], [b]) => b - a)
+    .map(([idx, value]) => {
+      const weekEndDate = addDays(rangeEndDate, -(idx * 7))
+      let weekStartDate = addDays(weekEndDate, -6)
+
+      // First bucket may be partial
+      if (weekStartDate.getTime() < rangeStartDate.getTime()) {
+        weekStartDate = rangeStartDate
+        const actualDays =
+          Math.floor((weekEndDate.getTime() - rangeStartDate.getTime()) / DAY_MS) + 1
+        value = fillPartialBucket(value, actualDays, 7)
+      }
+
+      const weekStartIso = toIsoDate(weekStartDate)
+      const weekEndIso = toIsoDate(weekEndDate)
+      return {
+        value,
+        weekKey: `${weekStartIso}_${weekEndIso}`,
+        weekStart: weekStartIso,
+        weekEnd: weekEndIso,
+        timestampStart: weekStartDate.getTime(),
+        timestampEnd: weekEndDate.getTime(),
+      }
+    })
+}
+
+export function buildMonthlyEvolution(
+  daily: DailyRawPoint[],
+  rangeStartIso?: string,
+  rangeEndIso?: string,
+): MonthlyDataPoint[] {
+  const sorted = sortedDaily(daily)
+  const byMonth = new Map<string, number>()
+  for (const item of sorted) {
+    const m = item.day.slice(0, 7)
+    byMonth.set(m, (byMonth.get(m) ?? 0) + item.value)
+  }
+
+  const entries = Array.from(byMonth.entries()).sort(([a], [b]) => a.localeCompare(b))
+
+  return entries.map(([month, value], i) => {
+    const [y, m] = month.split('-').map(Number) as [number, number]
+    const total = daysInMonth(y, m - 1)
+    const isFirst = i === 0
+    const isLast = i === entries.length - 1
+
+    const startDay = isFirst && rangeStartIso ? Number(rangeStartIso.split('-')[2]) : 1
+    const endDay = isLast && rangeEndIso ? Number(rangeEndIso.split('-')[2]) : total
+    const actualDays = endDay - startDay + 1
+
+    if (actualDays < total) value = fillPartialBucket(value, actualDays, total)
+
+    return { month, value, timestamp: parseIsoDate(`${month}-01`).getTime() }
+  })
+}
+
+export function buildYearlyEvolution(
+  daily: DailyRawPoint[],
+  rangeStartIso?: string,
+  rangeEndIso?: string,
+): YearlyDataPoint[] {
+  const sorted = sortedDaily(daily)
+  const byYear = new Map<string, number>()
+  for (const item of sorted) {
+    const y = item.day.slice(0, 4)
+    byYear.set(y, (byYear.get(y) ?? 0) + item.value)
+  }
+
+  const entries = Array.from(byYear.entries()).sort(([a], [b]) => a.localeCompare(b))
+
+  return entries.map(([year, value], i) => {
+    const total = daysInYear(Number(year))
+    const yearStart = parseIsoDate(`${year}-01-01`)
+    const isFirst = i === 0
+    const isLast = i === entries.length - 1
+
+    const startOffset =
+      isFirst && rangeStartIso
+        ? Math.floor((parseIsoDate(rangeStartIso).getTime() - yearStart.getTime()) / DAY_MS)
+        : 0
+    const endOffset =
+      isLast && rangeEndIso
+        ? Math.floor((parseIsoDate(rangeEndIso).getTime() - yearStart.getTime()) / DAY_MS) + 1
+        : total
+    const actualDays = endOffset - startOffset
+
+    if (actualDays < total) value = fillPartialBucket(value, actualDays, total)
+
+    return { year, value, timestamp: yearStart.getTime() }
+  })
+}
diff --git a/app/utils/date.ts b/app/utils/date.ts
new file mode 100644
index 0000000000..c3165feb2e
--- /dev/null
+++ b/app/utils/date.ts
@@ -0,0 +1,24 @@
+// TODO: when temporal?
+export const DAY_MS = 86_400_000
+
+export function parseIsoDate(value: string): Date {
+  return new Date(`${value}T00:00:00.000Z`)
+}
+
+export function toIsoDate(date: Date): string {
+  return date.toISOString().slice(0, 10)
+}
+
+export function addDays(date: Date, days: number): Date {
+  const d = new Date(date)
+  d.setUTCDate(d.getUTCDate() + days)
+  return d
+}
+
+export function daysInMonth(year: number, month: number): number {
+  return new Date(Date.UTC(year, month + 1, 0)).getUTCDate()
+}
+
+export function daysInYear(year: number): number {
+  return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0) ? 366 : 365
+}
diff --git a/test/unit/app/composables/use-charts.spec.ts b/test/unit/app/composables/use-charts.spec.ts
index 1a66f85224..53021ad76a 100644
--- a/test/unit/app/composables/use-charts.spec.ts
+++ b/test/unit/app/composables/use-charts.spec.ts
@@ -4,126 +4,7 @@ vi.mock('~/utils/npm/api', () => ({
   fetchNpmDownloadsRange: vi.fn(),
 }))
 
-import {
-  buildDailyEvolutionFromDaily,
-  buildRollingWeeklyEvolutionFromDaily,
-  buildMonthlyEvolutionFromDaily,
-  buildYearlyEvolutionFromDaily,
-  getNpmPackageCreationDate,
-} from '../../../../app/composables/useCharts'
-
-describe('buildDailyEvolutionFromDaily', () => {
-  it('adds timestamps and preserves values', () => {
-    const result = buildDailyEvolutionFromDaily([
-      { day: '2025-03-01', value: 10 },
-      { day: '2025-03-02', value: 20 },
-    ])
-
-    expect(result).toEqual([
-      { day: '2025-03-01', value: 10, timestamp: Date.UTC(2025, 2, 1) },
-      { day: '2025-03-02', value: 20, timestamp: Date.UTC(2025, 2, 2) },
-    ])
-  })
-
-  it('sorts by day', () => {
-    const result = buildDailyEvolutionFromDaily([
-      { day: '2025-03-03', value: 3 },
-      { day: '2025-03-01', value: 1 },
-      { day: '2025-03-02', value: 2 },
-    ])
-
-    expect(result.map(r => r.day)).toEqual(['2025-03-01', '2025-03-02', '2025-03-03'])
-  })
-
-  it('returns empty array for empty input', () => {
-    expect(buildDailyEvolutionFromDaily([])).toEqual([])
-  })
-})
-
-describe('buildRollingWeeklyEvolutionFromDaily', () => {
-  it('groups daily data into rolling 7-day buckets', () => {
-    const daily = Array.from({ length: 14 }, (_, i) => ({
-      day: `2025-03-${String(i + 1).padStart(2, '0')}`,
-      value: 10,
-    }))
-
-    const result = buildRollingWeeklyEvolutionFromDaily(daily, '2025-03-01', '2025-03-14')
-
-    expect(result).toHaveLength(2)
-    expect(result[0]!.value).toBe(70)
-    expect(result[0]!.weekStart).toBe('2025-03-01')
-    expect(result[0]!.weekEnd).toBe('2025-03-07')
-    expect(result[1]!.value).toBe(70)
-    expect(result[1]!.weekStart).toBe('2025-03-08')
-    expect(result[1]!.weekEnd).toBe('2025-03-14')
-  })
-
-  it('clamps last week to range end date', () => {
-    const daily = [
-      { day: '2025-03-01', value: 5 },
-      { day: '2025-03-02', value: 5 },
-      { day: '2025-03-08', value: 10 },
-    ]
-
-    const result = buildRollingWeeklyEvolutionFromDaily(daily, '2025-03-01', '2025-03-09')
-
-    // Last week bucket should be clamped to end date
-    const lastWeek = result[result.length - 1]!
-    expect(lastWeek.weekEnd).toBe('2025-03-09')
-  })
-
-  it('returns empty array for empty input', () => {
-    expect(buildRollingWeeklyEvolutionFromDaily([], '2025-03-01', '2025-03-14')).toEqual([])
-  })
-})
-
-describe('buildMonthlyEvolutionFromDaily', () => {
-  it('aggregates daily data by month', () => {
-    const result = buildMonthlyEvolutionFromDaily([
-      { day: '2025-01-15', value: 10 },
-      { day: '2025-01-20', value: 5 },
-      { day: '2025-02-10', value: 20 },
-    ])
-
-    expect(result).toEqual([
-      { month: '2025-01', value: 15, timestamp: Date.UTC(2025, 0, 1) },
-      { month: '2025-02', value: 20, timestamp: Date.UTC(2025, 1, 1) },
-    ])
-  })
-
-  it('sorts by month', () => {
-    const result = buildMonthlyEvolutionFromDaily([
-      { day: '2025-03-01', value: 1 },
-      { day: '2025-01-01', value: 1 },
-      { day: '2025-02-01', value: 1 },
-    ])
-
-    expect(result.map(r => r.month)).toEqual(['2025-01', '2025-02', '2025-03'])
-  })
-
-  it('returns empty array for empty input', () => {
-    expect(buildMonthlyEvolutionFromDaily([])).toEqual([])
-  })
-})
-
-describe('buildYearlyEvolutionFromDaily', () => {
-  it('aggregates daily data by year', () => {
-    const result = buildYearlyEvolutionFromDaily([
-      { day: '2024-06-15', value: 100 },
-      { day: '2024-12-01', value: 50 },
-      { day: '2025-03-01', value: 200 },
-    ])
-
-    expect(result).toEqual([
-      { year: '2024', value: 150, timestamp: Date.UTC(2024, 0, 1) },
-      { year: '2025', value: 200, timestamp: Date.UTC(2025, 0, 1) },
-    ])
-  })
-
-  it('returns empty array for empty input', () => {
-    expect(buildYearlyEvolutionFromDaily([])).toEqual([])
-  })
-})
+import { getNpmPackageCreationDate } from '../../../../app/composables/useCharts'
 
 describe('getNpmPackageCreationDate', () => {
   it('returns created date from packument time', () => {
diff --git a/test/unit/app/utils/chart-data-buckets.spec.ts b/test/unit/app/utils/chart-data-buckets.spec.ts
new file mode 100644
index 0000000000..8538f18138
--- /dev/null
+++ b/test/unit/app/utils/chart-data-buckets.spec.ts
@@ -0,0 +1,230 @@
+import { describe, expect, it } from 'vitest'
+import {
+  fillPartialBucket,
+  buildDailyEvolution,
+  buildWeeklyEvolution,
+  buildMonthlyEvolution,
+  buildYearlyEvolution,
+} from '../../../../app/utils/chart-data-buckets'
+
+describe('fillPartialBucket', () => {
+  it('scales proportionally', () => {
+    expect(fillPartialBucket(100, 3, 7)).toBe(Math.round((100 * 7) / 3))
+  })
+
+  it('returns raw value when bucket is full', () => {
+    expect(fillPartialBucket(100, 7, 7)).toBe(100)
+  })
+
+  it('returns raw value when actualDays is 0', () => {
+    expect(fillPartialBucket(0, 0, 7)).toBe(0)
+  })
+})
+
+describe('buildDailyEvolution', () => {
+  it('adds timestamps and preserves values', () => {
+    const result = buildDailyEvolution([
+      { day: '2025-03-01', value: 10 },
+      { day: '2025-03-02', value: 20 },
+    ])
+
+    expect(result).toEqual([
+      { day: '2025-03-01', value: 10, timestamp: Date.UTC(2025, 2, 1) },
+      { day: '2025-03-02', value: 20, timestamp: Date.UTC(2025, 2, 2) },
+    ])
+  })
+
+  it('sorts by day', () => {
+    const result = buildDailyEvolution([
+      { day: '2025-03-03', value: 3 },
+      { day: '2025-03-01', value: 1 },
+      { day: '2025-03-02', value: 2 },
+    ])
+
+    expect(result.map(r => r.day)).toEqual(['2025-03-01', '2025-03-02', '2025-03-03'])
+  })
+
+  it('returns empty array for empty input', () => {
+    expect(buildDailyEvolution([])).toEqual([])
+  })
+})
+
+describe('buildWeeklyEvolution', () => {
+  it('groups daily data into 7-day buckets aligned from end', () => {
+    const daily = Array.from({ length: 14 }, (_, i) => ({
+      day: `2025-03-${String(i + 1).padStart(2, '0')}`,
+      value: 10,
+    }))
+
+    const result = buildWeeklyEvolution(daily, '2025-03-01', '2025-03-14')
+
+    expect(result).toHaveLength(2)
+    expect(result[0]!.value).toBe(70)
+    expect(result[0]!.weekStart).toBe('2025-03-01')
+    expect(result[0]!.weekEnd).toBe('2025-03-07')
+    expect(result[1]!.value).toBe(70)
+    expect(result[1]!.weekStart).toBe('2025-03-08')
+    expect(result[1]!.weekEnd).toBe('2025-03-14')
+  })
+
+  it('scales up partial first bucket proportionally', () => {
+    const daily = Array.from({ length: 10 }, (_, i) => ({
+      day: `2025-03-${String(i + 1).padStart(2, '0')}`,
+      value: 10,
+    }))
+
+    const result = buildWeeklyEvolution(daily, '2025-03-01', '2025-03-10')
+
+    expect(result).toHaveLength(2)
+    expect(result[0]!.value).toBe(Math.round((30 * 7) / 3))
+    expect(result[0]!.weekStart).toBe('2025-03-01')
+    expect(result[0]!.weekEnd).toBe('2025-03-03')
+    expect(result[1]!.value).toBe(70)
+    expect(result[1]!.weekStart).toBe('2025-03-04')
+    expect(result[1]!.weekEnd).toBe('2025-03-10')
+  })
+
+  it('aligns from last non-zero data day, ignoring trailing zeros', () => {
+    const daily = [
+      { day: '2025-03-01', value: 10 },
+      { day: '2025-03-02', value: 10 },
+      { day: '2025-03-03', value: 10 },
+      { day: '2025-03-04', value: 10 },
+      { day: '2025-03-05', value: 10 },
+      { day: '2025-03-06', value: 10 },
+      { day: '2025-03-07', value: 10 },
+      { day: '2025-03-08', value: 0 },
+      { day: '2025-03-09', value: 0 },
+    ]
+
+    const result = buildWeeklyEvolution(daily, '2025-03-01', '2025-03-09')
+
+    expect(result).toHaveLength(1)
+    expect(result[0]!.value).toBe(70)
+    expect(result[0]!.weekStart).toBe('2025-03-01')
+    expect(result[0]!.weekEnd).toBe('2025-03-07')
+  })
+
+  it('returns empty array for empty input', () => {
+    expect(buildWeeklyEvolution([], '2025-03-01', '2025-03-14')).toEqual([])
+  })
+})
+
+describe('buildMonthlyEvolution', () => {
+  it('aggregates daily data by month', () => {
+    const result = buildMonthlyEvolution([
+      { day: '2025-01-15', value: 10 },
+      { day: '2025-01-20', value: 5 },
+      { day: '2025-02-10', value: 20 },
+    ])
+
+    expect(result).toEqual([
+      { month: '2025-01', value: 15, timestamp: Date.UTC(2025, 0, 1) },
+      { month: '2025-02', value: 20, timestamp: Date.UTC(2025, 1, 1) },
+    ])
+  })
+
+  it('sorts by month', () => {
+    const result = buildMonthlyEvolution([
+      { day: '2025-03-01', value: 1 },
+      { day: '2025-01-01', value: 1 },
+      { day: '2025-02-01', value: 1 },
+    ])
+
+    expect(result.map(r => r.month)).toEqual(['2025-01', '2025-02', '2025-03'])
+  })
+
+  it('returns empty array for empty input', () => {
+    expect(buildMonthlyEvolution([])).toEqual([])
+  })
+
+  it('scales single month partial on both ends without double-scaling', () => {
+    // 2025-01-10 to 2025-01-20 = 11 days out of 31
+    const daily = Array.from({ length: 11 }, (_, i) => ({
+      day: `2025-01-${String(i + 10).padStart(2, '0')}`,
+      value: 10,
+    }))
+
+    const result = buildMonthlyEvolution(daily, '2025-01-10', '2025-01-20')
+
+    expect(result).toHaveLength(1)
+    expect(result[0]!.value).toBe(Math.round((110 * 31) / 11))
+  })
+
+  it('scales up partial first month', () => {
+    const daily = Array.from({ length: 14 }, (_, i) => ({
+      day: `2025-03-${String(i + 18).padStart(2, '0')}`,
+      value: 10,
+    }))
+
+    const result = buildMonthlyEvolution(daily, '2025-03-18', '2025-03-31')
+
+    expect(result).toHaveLength(1)
+    expect(result[0]!.value).toBe(Math.round((140 * 31) / 14))
+  })
+
+  it('scales up partial last month', () => {
+    const daily = [
+      ...Array.from({ length: 31 }, (_, i) => ({
+        day: `2025-01-${String(i + 1).padStart(2, '0')}`,
+        value: 10,
+      })),
+      ...Array.from({ length: 9 }, (_, i) => ({
+        day: `2025-02-${String(i + 1).padStart(2, '0')}`,
+        value: 10,
+      })),
+    ]
+
+    const result = buildMonthlyEvolution(daily, '2025-01-01', '2025-02-09')
+
+    expect(result).toHaveLength(2)
+    expect(result[0]!.value).toBe(310)
+    expect(result[1]!.value).toBe(Math.round((90 * 28) / 9))
+  })
+})
+
+describe('buildYearlyEvolution', () => {
+  it('aggregates daily data by year', () => {
+    const result = buildYearlyEvolution([
+      { day: '2024-06-15', value: 100 },
+      { day: '2024-12-01', value: 50 },
+      { day: '2025-03-01', value: 200 },
+    ])
+
+    expect(result).toEqual([
+      { year: '2024', value: 150, timestamp: Date.UTC(2024, 0, 1) },
+      { year: '2025', value: 200, timestamp: Date.UTC(2025, 0, 1) },
+    ])
+  })
+
+  it('returns empty array for empty input', () => {
+    expect(buildYearlyEvolution([])).toEqual([])
+  })
+
+  it('scales single year partial on both ends without double-scaling', () => {
+    // 2025-04-01 to 2025-06-30 = 91 days out of 365
+    const daily = Array.from({ length: 91 }, (_, i) => {
+      const d = new Date(Date.UTC(2025, 3, 1))
+      d.setUTCDate(d.getUTCDate() + i)
+      return { day: d.toISOString().slice(0, 10), value: 10 }
+    })
+
+    const result = buildYearlyEvolution(daily, '2025-04-01', '2025-06-30')
+
+    expect(result).toHaveLength(1)
+    expect(result[0]!.value).toBe(Math.round((910 * 365) / 91))
+  })
+
+  it('scales up partial first year', () => {
+    const daily = Array.from({ length: 184 }, (_, i) => {
+      const d = new Date(Date.UTC(2025, 6, 1))
+      d.setUTCDate(d.getUTCDate() + i)
+      return { day: d.toISOString().slice(0, 10), value: 10 }
+    })
+
+    const result = buildYearlyEvolution(daily, '2025-07-01', '2025-12-31')
+
+    expect(result).toHaveLength(1)
+    expect(result[0]!.value).toBe(Math.round((1840 * 365) / 184))
+  })
+})
diff --git a/test/unit/app/utils/date.spec.ts b/test/unit/app/utils/date.spec.ts
new file mode 100644
index 0000000000..0e3d24e06c
--- /dev/null
+++ b/test/unit/app/utils/date.spec.ts
@@ -0,0 +1,98 @@
+import { describe, expect, it } from 'vitest'
+import {
+  addDays,
+  DAY_MS,
+  daysInMonth,
+  daysInYear,
+  parseIsoDate,
+  toIsoDate,
+} from '../../../../app/utils/date'
+
+describe('DAY_MS', () => {
+  it('equals 86 400 000', () => {
+    expect(DAY_MS).toBe(86_400_000)
+  })
+})
+
+describe('parseIsoDate', () => {
+  it('returns a UTC midnight date', () => {
+    const d = parseIsoDate('2024-03-15')
+    expect(d.toISOString()).toBe('2024-03-15T00:00:00.000Z')
+  })
+
+  it('does not shift across timezones', () => {
+    const d = parseIsoDate('2024-01-01')
+    expect(d.getUTCHours()).toBe(0)
+    expect(d.getUTCFullYear()).toBe(2024)
+  })
+})
+
+describe('toIsoDate', () => {
+  it('formats a date as YYYY-MM-DD', () => {
+    expect(toIsoDate(new Date('2024-03-15T00:00:00.000Z'))).toBe('2024-03-15')
+  })
+
+  it('roundtrips with parseIsoDate', () => {
+    const iso = '2024-12-31'
+    expect(toIsoDate(parseIsoDate(iso))).toBe(iso)
+  })
+})
+
+describe('addDays', () => {
+  it('adds positive days', () => {
+    const d = parseIsoDate('2024-03-01')
+    expect(toIsoDate(addDays(d, 5))).toBe('2024-03-06')
+  })
+
+  it('subtracts with negative days', () => {
+    const d = parseIsoDate('2024-03-10')
+    expect(toIsoDate(addDays(d, -3))).toBe('2024-03-07')
+  })
+
+  it('crosses month boundary', () => {
+    const d = parseIsoDate('2024-01-30')
+    expect(toIsoDate(addDays(d, 3))).toBe('2024-02-02')
+  })
+
+  it('does not mutate the original date', () => {
+    const d = parseIsoDate('2024-06-15')
+    addDays(d, 10)
+    expect(toIsoDate(d)).toBe('2024-06-15')
+  })
+})
+
+describe('daysInMonth', () => {
+  it('returns 31 for January', () => {
+    expect(daysInMonth(2024, 0)).toBe(31)
+  })
+
+  it('returns 29 for Feb in a leap year', () => {
+    expect(daysInMonth(2024, 1)).toBe(29)
+  })
+
+  it('returns 28 for Feb in a non-leap year', () => {
+    expect(daysInMonth(2023, 1)).toBe(28)
+  })
+
+  it('returns 30 for April', () => {
+    expect(daysInMonth(2024, 3)).toBe(30)
+  })
+})
+
+describe('daysInYear', () => {
+  it('returns 366 for a leap year', () => {
+    expect(daysInYear(2024)).toBe(366)
+  })
+
+  it('returns 365 for a non-leap year', () => {
+    expect(daysInYear(2023)).toBe(365)
+  })
+
+  it('returns 365 for century non-leap year', () => {
+    expect(daysInYear(1900)).toBe(365)
+  })
+
+  it('returns 366 for year 2000 (divisible by 400)', () => {
+    expect(daysInYear(2000)).toBe(366)
+  })
+})
diff --git a/vitest.config.ts b/vitest.config.ts
index ba3986903b..794f176d83 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -11,6 +11,7 @@ export default defineConfig({
       {
         resolve: {
           alias: {
+            '~': `${rootDir}/app`,
             '#shared': `${rootDir}/shared`,
             '#server': `${rootDir}/server`,
           },