[release] Bump to version 51.1

- Fix scrobbling comic books
[books] Fix bug in scrobbling comic books
2026-06-11 19:07:00 -04:00 · 2026-06-11 19:06:37 -04:00 · 2026-06-11 18:39:31 -04:00 · 2026-06-11 18:38:51 -04:00 · 2026-06-11 11:00:04 -04:00 · 2026-06-11 10:48:38 -04:00
32 changed files with 1230 additions and 305 deletions
--- a/PROJECT.org
+++ b/PROJECT.org
@ -451,32 +451,6 @@ https://app.todoist.com/app/task/add-a-csv-endpoint-for-users-book-reads-that-li
 :PROPERTIES:
 :ID:       79f867c3-1288-4143-b6bf-2a452983ee9f
 :END:
-** TODO [#B] Fix koreader scrobble imports to use DST properly :bug:books:imports:
-:PROPERTIES:
-:ID:       79758cba-a440-48b6-a637-efb88827acf2
-:END:
-
- Note taken on [2025-09-25 Thu 10:37] \\
-
-  This may already be fixed ... need to check.
-
- Note taken on [2025-02-25 12:34] \\
-
-  The page data has the canonical date something was read in it, but it seems
-  to be an hour off. I traced this back to being off during DST, so we just need
-  the importer to be aware of whether a user is using DST or not and roll back
-  an hour for part of the year. Also, we'd need to adjust any old scrobbles that
-  took place with DST off to roll them back by an hour.
-      
-  
-*** Description
-
-This is a long-standing problem when daylight saving time takes effect. Time is
-manually set on a KoReader device (or at least, always saved in local time). So
-whatever time KoReader reports, we need to know, given the date and the user
-profile's historic timezone, how many hours to adjust the KoReader time to get
-to GMT to save it in the database.
-
 ** TODO [#B] Make IMAP and WebDAV configurable :webdav:feature:imap:importers:
 :PROPERTIES:
 :ID:       b1426d92-2feb-4d15-9738-d5b7b0594f96
@ -534,7 +508,268 @@ async with the POST data stored in the log["raw_data"] and used by the celery en
 to go try to enrich the media instance.  Should this enrichment fail, tag the scrobble as "enrichment-failed"
 log a warning and move on.

+** TODO [#B] Allow browing a user's favorited media :favorites:feature:
+:PROPERTIES:
+:ID:       5c2cf004-d01f-4576-9bbb-974235e7408a
+:END:
+
+*** Description
+
+We should have a global view `/favorites/` that shows the logged in users's
+favorited media objects.
+
+* Version 51.1 [1/1]
+** DONE [#A] Fix scrobbling comic books :books:scrobbles:bug:
+:PROPERTIES:
+:ID:       8dfbff19-3fa4-f3b8-21c7-7a416498000c
+:END:
+
+*** Description
+
+At some point logdata and log got confused, and now when you try
+to scrobble a comic book, it just throws errors. We should look
+into where the confusion happened and fix it.
+
+
+* Version 51.0 [3/3]
+** DONE [#B] Fix koreader scrobble imports to use DST properly :bug:books:imports:
+:PROPERTIES:
+:ID:       79758cba-a440-48b6-a637-efb88827acf2
+:END:
+
+- Note taken on [2025-09-25 Thu 10:37] \\
+
+  This may already be fixed ... need to check.
+
+- Note taken on [2025-02-25 12:34] \\
+
+  The page data has the canonical date something was read in it, but it seems
+  to be an hour off. I traced this back to being off during DST, so we just need
+  the importer to be aware of whether a user is using DST or not and roll back
+  an hour for part of the year. Also, we'd need to adjust any old scrobbles that
+  took place with DST off to roll them back by an hour.
+      
+  
+*** Description
+
+This is a long-standing problem when daylight saving time takes effect. Time is
+manually set on a KoReader device (or at least, always saved in local time). So
+whatever time KoReader reports, we need to know, given the date and the user
+profile's historic timezone, how many hours to adjust the KoReader time to get
+to GMT to save it in the database.
+
+** DONE [#A] Fix book scrobbles where page_data is a list :bug:books:scrobbles:
+:PROPERTIES:
+:ID:       35b323fa-ccc0-4009-b227-8a0f12bbd469
+:END:
+
+*** Description
+
+Comic scrobbling is currently kind of janky. Most of the problems boil down to them
+storing saved page data in a list of dicts rather than a dict keyed off of the page number that
+was read.
+
+We need to adjust comic scrobbling to use a dict of pages keyed off the page number, and also
+write a migration script that runs as a data migration to update any book scrobbles that may
+have page_data as a list.
+
+*** Example data
+#+begin_src python
+{"notes": null, "page_end": 27, "page_data": [{"notes": null, "end_ts": 1771815895, "duration": 14, "start_ts": 1771815881, "description": null, "page_number": "1"}, {"notes": null, "end_ts": 1771815908, "duration": 13, "start_ts": 1771815895, "description": null, "page_number": "1"}, {"notes": null, "end_ts": 1771815913, "duration": 5, "start_ts": 1771815908, "description": null, "page_number": "2"}, {"notes": null, "end_ts": 1771815933, "duration": 20, "start_ts": 1771815913, "description": null, "page_number": "3"}, {"notes": null, "end_ts": 1771815945, "duration": 12, "start_ts": 1771815933, "description": null, "page_number": "4"}, {"notes": null, "end_ts": 1771815983, "duration": 38, "start_ts": 1771815945, "description": null, "page_number": "5"}, {"notes": null, "end_ts": 1771816007, "duration": 24, "start_ts": 1771815983, "description": null, "page_number": "6"}, {"notes": null, "end_ts": 1771816011, "duration": 4, "start_ts": 1771816007, "description": null, "page_number": "7"}, {"notes": null, "end_ts": 1771816013, "duration": 2, "start_ts": 1771816011, "description": null, "page_number": "8"}, {"notes": null, "end_ts": 1771816052, "duration": 39, "start_ts": 1771816013, "description": null, "page_number": "7"}, {"notes": null, "end_ts": 1771816127, "duration": 75, "start_ts": 1771816052, "description": null, "page_number": "8"}, {"notes": null, "end_ts": 1771816134, "duration": 7, "start_ts": 1771816127, "description": null, "page_number": "9"}, {"notes": null, "end_ts": 1771816196, "duration": 62, "start_ts": 1771816134, "description": null, "page_number": "10"}, {"notes": null, "end_ts": 1771816262, "duration": 66, "start_ts": 1771816196, "description": null, "page_number": "11"}, {"notes": null, "end_ts": 1771816293, "duration": 31, "start_ts": 1771816262, "description": null, "page_number": "12"}, {"notes": null, "end_ts": 1771816322, "duration": 29, "start_ts": 1771816293, "description": null, "page_number": "13"}, {"notes": null, "end_ts": 1771816330, "duration": 8, "start_ts": 1771816322, "description": null, "page_number": "14"}, {"notes": null, "end_ts": 1771816368, "duration": 38, "start_ts": 1771816330, "description": null, "page_number": "15"}, {"notes": null, "end_ts": 1771816388, "duration": 20, "start_ts": 1771816368, "description": null, "page_number": "16"}, {"notes": null, "end_ts": 1771816482, "duration": 94, "start_ts": 1771816388, "description": null, "page_number": "17"}, {"notes": null, "end_ts": 1771816550, "duration": 68, "start_ts": 1771816482, "description": null, "page_number": "18"}, {"notes": null, "end_ts": 1771816567, "duration": 17, "start_ts": 1771816550, "description": null, "page_number": "19"}, {"notes": null, "end_ts": 1771816586, "duration": 19, "start_ts": 1771816567, "description": null, "page_number": "20"}, {"notes": null, "end_ts": 1771816597, "duration": 11, "start_ts": 1771816586, "description": null, "page_number": "21"}, {"notes": null, "end_ts": 1771816616, "duration": 19, "start_ts": 1771816597, "description": null, "page_number": "22"}, {"notes": null, "end_ts": 1771816640, "duration": 24, "start_ts": 1771816616, "description": null, "page_number": "23"}, {"notes": null, "end_ts": 1771816690, "duration": 50, "start_ts": 1771816640, "description": null, "page_number": "24"}, {"notes": null, "end_ts": 1771816702, "duration": 12, "start_ts": 1771816690, "description": null, "page_number": "25"}, {"notes": null, "end_ts": 1771816823, "duration": 121, "start_ts": 1771816702, "description": null, "page_number": "26"}, {"notes": null, "end_ts": null, "duration": null, "start_ts": 1771816823, "description": null, "page_number": "27"}], "page_start": 1, "pages_read": 27, "resume_url": null, "description": null, "koreader_hash": null, "long_play_complete": false}
+
+#+end_src
+** DONE [#A] Lichess imports do not set default visbility :boardgames:bug:importers:lichess:
+:PROPERTIES:
+:ID:       a78f7c72-a20a-8db2-cde0-d92a731d4fba
+:END:
+
+* Version 50.2 [2/2]
+** DONE [#B] Koreader imports only import single-page scrobbles the next day :bug:books:importers:
+:PROPERTIES:
+:ID:       b50141fd-cda6-4a3a-afd3-cd8499e7523e
+:END:
+
+*** Description
+
+When you read a single page in a book in Koreader and try to import it, the scrobble is only
+created the day after, not on the day of the reading.
+
+** DONE [#A] Fix bugs in celery tasks causing imports to fail :bug:celery:tasks:
+:PROPERTIES:
+:ID:       d1171cb0-6413-44b8-a68a-019a4d2fb285
+:END:
+
+*** Description
+
+Seems like all celery tasks are failing for different reasons except the chart
+updates.
+
+*** Errors
+****  scrobbles.tasks.send_notification_for_in_progress
+#+begin_src bash
+KeyError: 'track'
+
+During handling of the above exception, another exception occurred:
+
+Traceback (most recent call last):
+File "/usr/local/lib/python3.11/site-packages/django/db/backends/utils.py", line 89, in _execute
+return self.cursor.execute(sql, params)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+psycopg2.errors.UndefinedColumn: column music_track.artist_id does not exist
+LINE 1: ..."."title", "music_track"."base_run_time_seconds", "music_tra...
+^
+HINT: Perhaps you meant to reference the column "music_track.artist_fk_id".
+#+end_src
+
+**** scrobbles.tasks.import_from_webdav_all_users
+#+begin_src bash
+File "/usr/local/lib/python3.11/site-packages/vrobbler/apps/scrobbles/importers/webdav.py", line 166, in scan_webdav_for_koreader
+if last_import and last_import.webdav_etag and remote_etag:
+^^^^^^^^^^^^^^^^^^^^^^^
+AttributeError: 'KoReaderImport' object has no attribute 'webdav_etag'
+#+end_src
+
+**** scrobbles.tasks.process_bgstats_import
+#+begin_src bash
+
+Traceback (most recent call last):
+File "/usr/local/lib/python3.11/site-packages/django/db/backends/utils.py", line 89, in _execute
+return self.cursor.execute(sql, params)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+psycopg2.errors.NotNullViolation: null value in column "visibility" of relation "scrobbles_scrobble" violates not-null constraint
+DETAIL: Failing row contains (374463, 2026-06-11 13:27:06.528319+00, 2026-06-11 13:27:06.52834+00, 2026-06-11 13:17:34+00, 180, f, f, BG Stats, 1, null, t, {"players": [{"new": false, "win": false, "rank": 0, "role": "",..., null, null, null, 8e73ceec-b731-4623-9637-712bbf9f76ce, null, null, null, null, , null, BoardGame, 324, null, null, America/New_York, null, null, , null, null, , null, null, null, null, null, null, null, null, null, null, null).
+#+end_src
+
+* Version 50.1 [1/1]
+** DONE [#B] Fix bug in charts where only #1 is displayed :charts:templates:
+:PROPERTIES:
+:ID:       7136dffb-e6b7-184b-48ac-bb09bae0b0f0
+:END:
+
+* Version 50.0 [2/2]
+** DONE [#A] Allow updating all a user's scrobble visibility at once :scrobbles:sharing:feature:
+:PROPERTIES:
+:ID:       9ed2ec65-bf69-4300-965c-6a7d3ef7ea03
+:END:
+
+*** Description
+
+We now have the ability to share or unshare scrobbles and create private links.
+We should add a toggle in the user's settings that will bulk make all their
+scrobbles public or private, so that a user can either share everything, or lock
+their account down.
+
+This should not affect scrobbles that are  in the "Shared" visibility state.
+
+And users should be able to also control whether all scrobbles of a specific
+type are shared or not. Maybe this could be a JSONField in profile that contains
+a media_type key with a visibility type for a value, and if it's not present,
+sharing defaults to private?
+
+Additionally, users's should have links in their settings to see what scrobbles
+are either public, shared or private. Probably this could be done with a
+?visbility=<> filter on the /scrobbles/ page.
+
+*** Changes
+
+- Added `media_type_visibility` JSONField to UserProfile (migration 0038)
+- Created `BulkVisibilityView` at `/settings/visibility/` with:
+  - Radio toggle to make all non-shared scrobbles Public or Private
+  - Per-media-type dropdown for each of the 20 media types (inherit/public/shared/private)
+- Created `BulkVisibilityForm` with dynamic media_type fields
+- Created `profiles/visibility_settings.html` template with visibility stats + filter links
+- Added link from main settings page to visibility settings
+- Added `?visibility=` filter support to `ScrobbleListView` (public/shared/private)
+- Added filter indicator to `scrobble_all_list.html`
+- Updated `Scrobble.create()` to check `user.profile.media_type_visibility` for media-type-specific defaults before falling back to PRIVATE
+
+
         
+** DONE [#A] Replace columsn of Top Artists, Tracks and Series with Maloja widget :templates:charts:
+:PROPERTIES:
+:ID:       3946afb1-932c-46fe-a188-f4c9add1a491
+:END:
+
+
+*** Description
+
+The tables are fine, but Maloja widgets are better. We should drop the top track table, add top albums
+and replace top artists and top tv series with the Maloja style widgets.
+
+
+* Version 49.1 [1/1]
+** DONE [#A] Fix bug with missing default visbility for scrobbles :bug:scrobbles:sharing:
+:PROPERTIES:
+:ID:       20843992-6453-9a9a-cde6-2c2b6677db23
+:END:
+
+*** Description
+
+We can't scrobble anything now because visbility is not null, but has no default
+value.
+
+*** Notes
+- Note taken on [2026-06-09 Tue 13:14]
+  The full stack trace:
+  #+begin_src sh
+    File "/usr/local/lib/python3.11/site-packages/vrobbler/apps/scrobbles/models.py", line 1430, in create_or_update
+        elif "log" in scrobble_data.keys() and scrobble.log:
+        ^^^^^^^^^^^^^^^^^^^^^^^^^
+    File "/usr/local/lib/python3.11/site-packages/vrobbler/apps/scrobbles/models.py", line 1583, in create
+        )
+
+    File "/usr/local/lib/python3.11/site-packages/django/db/models/manager.py", line 87, in manager_method
+        return getattr(self.get_queryset(), name)(*args, **kwargs)
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    File "/usr/local/lib/python3.11/site-packages/django/db/models/query.py", line 658, in create
+        obj.save(force_insert=True, using=self.db)
+    File "/usr/local/lib/python3.11/site-packages/vrobbler/apps/scrobbles/models.py", line 870, in save
+        if self.media_obj:
+            ^^^^^^^^^^^^
+    File "/usr/local/lib/python3.11/site-packages/django_extensions/db/models.py", line 22, in save
+        super().save(**kwargs)
+    File "/usr/local/lib/python3.11/site-packages/django/db/models/base.py", line 814, in save
+        self.save_base(
+    File "/usr/local/lib/python3.11/site-packages/django/db/models/base.py", line 877, in save_base
+        updated = self._save_table(
+                ^^^^^^^^^^^^^^^^^
+    File "/usr/local/lib/python3.11/site-packages/django/db/models/base.py", line 1020, in _save_table
+        results = self._do_insert(
+                ^^^^^^^^^^^^^^^^
+    File "/usr/local/lib/python3.11/site-packages/django/db/models/base.py", line 1061, in _do_insert
+        return manager._insert(
+            ^^^^^^^^^^^^^^^^
+    File "/usr/local/lib/python3.11/site-packages/django/db/models/manager.py", line 87, in manager_method
+        return getattr(self.get_queryset(), name)(*args, **kwargs)
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    File "/usr/local/lib/python3.11/site-packages/django/db/models/query.py", line 1805, in _insert
+        return query.get_compiler(using=using).execute_sql(returning_fields)
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    File "/usr/local/lib/python3.11/site-packages/django/db/models/sql/compiler.py", line 1822, in execute_sql
+        cursor.execute(sql, params)
+    File "/usr/local/lib/python3.11/site-packages/django/db/backends/utils.py", line 67, in execute
+        return self._execute_with_wrappers(
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    File "/usr/local/lib/python3.11/site-packages/django/db/backends/utils.py", line 80, in _execute_with_wrappers
+        return executor(sql, params, many, context)
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    File "/usr/local/lib/python3.11/site-packages/django/db/backends/utils.py", line 84, in _execute
+        with self.db.wrap_database_errors:
+    File "/usr/local/lib/python3.11/site-packages/django/db/utils.py", line 91, in __exit__
+        raise dj_exc_value.with_traceback(traceback) from exc_value
+    File "/usr/local/lib/python3.11/site-packages/django/db/backends/utils.py", line 89, in _execute
+        return self.cursor.execute(sql, params)
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    django.db.utils.IntegrityError: null value in column "visibility" of relation "scrobbles_scrobble" violates not-null constraint
+    DETAIL:  Failing row contains (373813, 2026-06-09 17:13:38.11355+00, 2026-06-09 17:13:38.113566+00, 2026-06-09 17:13:36+00, 0, f, f, Todoist, 1, null, t, {"title": "Animal chores", "labels": ["chore", "farm"], "todoist..., null, null, null, 68680dbf-f9a9-476c-b1c7-adbd231bbab6, null, null, null, null, , null, Task, null, null, null, America/New_York, null, null, , null, null, , 72, null, null, null, null, null, null, null, null, null, null).
+    #+end_src        
+
+* Version 49.0 [1/1]
+** DONE [#A] Fix broken tests with new sharing and add tests :scrobbles:sharing:tests:
+:PROPERTIES:
+:ID:       10ecd169-eaee-8554-d4ee-f1d34bfad99f
+:END:
+
 * Version 48.3 [1/1]
 ** DONE [#A] Fix bug in missing sqids dep :dependencies:project:
 :PROPERTIES:
--- a/pyproject.toml
+++ b/pyproject.toml
@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vrobbler"
-version = "48.3"
+version = "51.1"
 description = ""
 authors = ["Colin Powell <colin@unbl.ink>"]

--- a/tests/scrobbles_tests/test_views.py
+++ b/tests/scrobbles_tests/test_views.py
@ -8,7 +8,8 @@ from django.urls import reverse
 from django.utils import timezone
 from music.models import Album, Artist, Track
 from podcasts.models import PodcastEpisode
-from scrobbles.models import Scrobble
+from scrobbles.models import Scrobble, ShareViewLog
+from scrobbles.sqids import encode_scrobble_share
 from tasks.models import Task


@ -512,6 +513,7 @@ def test_scrobble_detail_view_with_notes_as_flat_list(client):
        task=task,
        media_type="Task",
        user=user,
+        visibility="public",
        log={
            "notes": ["First note", "Second note"],
            "description": "Test description",
@ -534,6 +536,7 @@ def test_scrobble_detail_view_with_notes_as_dict_timestamps(client):
        task=task,
        media_type="Task",
        user=user,
+        visibility="public",
        log={
            "notes": [
                {"2024-01-01 10:00:00": "Note at first timestamp"},
@ -562,6 +565,7 @@ def test_scrobble_detail_view_with_notes_and_labels(client):
        task=task,
        media_type="Task",
        user=user,
+        visibility="public",
        log={
            "notes": [
                {"2024-01-01 10:00:00": "Note with label"},
@ -739,3 +743,293 @@ def test_gps_webhook_creates_location(client, valid_auth_token):
    )
    assert response.status_code == 200
    assert "scrobble_id" in response.data
+
+
+@pytest.mark.django_db
+def test_share_view_shared_visibility(client):
+    user = get_user_model().objects.create_user(
+        username="shareuser", password="testpass"
+    )
+    task = Task.objects.create(title="Test Task")
+    scrobble = Scrobble.objects.create(
+        task=task, media_type="Task", user=user, visibility="shared",
+        timestamp=timezone.now(),
+    )
+    url = reverse(
+        "scrobbles:shared-detail",
+        kwargs={"sqid": encode_scrobble_share(scrobble.id, scrobble.share_token_version)},
+    )
+    response = client.get(url)
+    assert response.status_code == 200
+
+
+@pytest.mark.django_db
+def test_share_view_public_visibility(client):
+    user = get_user_model().objects.create_user(
+        username="shareuser2", password="testpass"
+    )
+    task = Task.objects.create(title="Test Task")
+    scrobble = Scrobble.objects.create(
+        task=task, media_type="Task", user=user, visibility="public",
+        timestamp=timezone.now(),
+    )
+    url = reverse(
+        "scrobbles:shared-detail",
+        kwargs={"sqid": encode_scrobble_share(scrobble.id, scrobble.share_token_version)},
+    )
+    response = client.get(url)
+    assert response.status_code == 200
+
+
+@pytest.mark.django_db
+def test_share_view_private_visibility_returns_404(client):
+    user = get_user_model().objects.create_user(
+        username="shareuser3", password="testpass"
+    )
+    task = Task.objects.create(title="Test Task")
+    scrobble = Scrobble.objects.create(
+        task=task, media_type="Task", user=user, visibility="private",
+        timestamp=timezone.now(),
+    )
+    url = reverse(
+        "scrobbles:shared-detail",
+        kwargs={"sqid": encode_scrobble_share(scrobble.id, scrobble.share_token_version)},
+    )
+    response = client.get(url)
+    assert response.status_code == 404
+
+
+@pytest.mark.django_db
+def test_share_view_invalid_sqid_returns_404(client):
+    url = reverse("scrobbles:shared-detail", kwargs={"sqid": "InvalidSqid123"})
+    response = client.get(url)
+    assert response.status_code == 404
+
+
+@pytest.mark.django_db
+def test_share_view_expired_token_returns_404(client):
+    user = get_user_model().objects.create_user(
+        username="shareuser4", password="testpass"
+    )
+    task = Task.objects.create(title="Test Task")
+    scrobble = Scrobble.objects.create(
+        task=task, media_type="Task", user=user, visibility="shared",
+        timestamp=timezone.now(),
+    )
+    old_sqid = encode_scrobble_share(scrobble.id, scrobble.share_token_version)
+    scrobble.regenerate_share_token()
+    url = reverse("scrobbles:shared-detail", kwargs={"sqid": old_sqid})
+    response = client.get(url)
+    assert response.status_code == 404
+
+
+@pytest.mark.django_db
+def test_share_view_increments_count_and_logs_view(client):
+    user = get_user_model().objects.create_user(
+        username="shareuser5", password="testpass"
+    )
+    task = Task.objects.create(title="Test Task")
+    scrobble = Scrobble.objects.create(
+        task=task, media_type="Task", user=user, visibility="shared",
+        timestamp=timezone.now(),
+    )
+    assert scrobble.share_view_count == 0
+
+    url = reverse(
+        "scrobbles:shared-detail",
+        kwargs={"sqid": encode_scrobble_share(scrobble.id, scrobble.share_token_version)},
+    )
+    response = client.get(url)
+    assert response.status_code == 200
+
+    scrobble.refresh_from_db()
+    assert scrobble.share_view_count == 1
+    assert ShareViewLog.objects.filter(scrobble=scrobble).count() == 1
+
+    log_entry = ShareViewLog.objects.filter(scrobble=scrobble).first()
+    assert log_entry.ip_address == "127.0.0.1"
+    assert log_entry.user_agent == ""
+    assert log_entry.referrer == ""
+
+
+@pytest.mark.django_db
+def test_explore_view_shows_only_public_scrobbles(client):
+    user = get_user_model().objects.create_user(
+        username="exploreuser", password="testpass"
+    )
+    public_task = Task.objects.create(title="Public Task Title")
+    shared_task = Task.objects.create(title="Shared Task Title")
+    private_task = Task.objects.create(title="Private Task Title")
+    ts = timezone.now()
+    public_scrobble = Scrobble.objects.create(
+        task=public_task, media_type="Task", user=user, visibility="public",
+        timestamp=ts,
+    )
+    Scrobble.objects.create(
+        task=shared_task, media_type="Task", user=user, visibility="shared",
+        timestamp=ts,
+    )
+    Scrobble.objects.create(
+        task=private_task, media_type="Task", user=user, visibility="private",
+        timestamp=ts,
+    )
+
+    url = reverse("scrobbles:explore")
+    response = client.get(url)
+    assert response.status_code == 200
+
+    content = response.content.decode()
+    assert "Public Task Title" in content
+    assert "Shared Task Title" not in content
+    assert "Private Task Title" not in content
+
+
+@pytest.mark.django_db
+def test_change_visibility_owner_can_change(client):
+    user = get_user_model().objects.create_user(
+        username="visuser", password="testpass"
+    )
+    task = Task.objects.create(title="Test Task")
+    scrobble = Scrobble.objects.create(
+        task=task, media_type="Task", user=user, visibility="private",
+        timestamp=timezone.now(),
+    )
+
+    client.force_login(user)
+    url = reverse("scrobbles:change-visibility", kwargs={"uuid": scrobble.uuid})
+    response = client.post(url, {"visibility": "shared"})
+    assert response.status_code == 302
+
+    scrobble.refresh_from_db()
+    assert scrobble.visibility == "shared"
+
+
+@pytest.mark.django_db
+def test_change_visibility_non_owner_gets_404(client):
+    owner = get_user_model().objects.create_user(
+        username="owner", password="testpass"
+    )
+    other = get_user_model().objects.create_user(
+        username="other", password="testpass"
+    )
+    task = Task.objects.create(title="Test Task")
+    scrobble = Scrobble.objects.create(
+        task=task, media_type="Task", user=owner, visibility="private",
+        timestamp=timezone.now(),
+    )
+
+    client.force_login(other)
+    url = reverse("scrobbles:change-visibility", kwargs={"uuid": scrobble.uuid})
+    response = client.post(url, {"visibility": "shared"})
+    assert response.status_code == 404
+
+    scrobble.refresh_from_db()
+    assert scrobble.visibility == "private"
+
+
+@pytest.mark.django_db
+def test_change_visibility_anonymous_redirects_to_login(client):
+    user = get_user_model().objects.create_user(
+        username="anontest", password="testpass"
+    )
+    task = Task.objects.create(title="Test Task")
+    scrobble = Scrobble.objects.create(
+        task=task, media_type="Task", user=user, visibility="private",
+        timestamp=timezone.now(),
+    )
+    url = reverse("scrobbles:change-visibility", kwargs={"uuid": scrobble.uuid})
+    response = client.post(url, {"visibility": "shared"})
+    assert response.status_code == 302
+    assert "/login/" in response.url
+
+
+@pytest.mark.django_db
+def test_regenerate_share_token_invalidates_old_sqid(client):
+    user = get_user_model().objects.create_user(
+        username="regentest", password="testpass"
+    )
+    task = Task.objects.create(title="Test Task")
+    scrobble = Scrobble.objects.create(
+        task=task, media_type="Task", user=user, visibility="shared",
+        timestamp=timezone.now(),
+    )
+    old_sqid = encode_scrobble_share(scrobble.id, scrobble.share_token_version)
+
+    client.force_login(user)
+    url = reverse("scrobbles:regenerate-share-token", kwargs={"uuid": scrobble.uuid})
+    response = client.post(url)
+    assert response.status_code == 302
+
+    scrobble.refresh_from_db()
+    assert scrobble.share_token_version == 1
+
+    old_url = reverse("scrobbles:shared-detail", kwargs={"sqid": old_sqid})
+    old_response = client.get(old_url)
+    assert old_response.status_code == 404
+
+    new_sqid = encode_scrobble_share(scrobble.id, scrobble.share_token_version)
+    new_url = reverse("scrobbles:shared-detail", kwargs={"sqid": new_sqid})
+    new_response = client.get(new_url)
+    assert new_response.status_code == 200
+
+
+@pytest.mark.django_db
+def test_share_analytics_owner_can_view(client):
+    user = get_user_model().objects.create_user(
+        username="analyticsuser", password="testpass"
+    )
+    task = Task.objects.create(title="Test Task")
+    scrobble = Scrobble.objects.create(
+        task=task, media_type="Task", user=user, visibility="shared",
+        timestamp=timezone.now(),
+    )
+
+    client.force_login(user)
+    url = reverse("scrobbles:share-analytics", kwargs={"uuid": scrobble.uuid})
+    response = client.get(url)
+    assert response.status_code == 200
+
+
+@pytest.mark.django_db
+def test_share_analytics_non_owner_gets_404(client):
+    owner = get_user_model().objects.create_user(
+        username="analyticsowner", password="testpass"
+    )
+    other = get_user_model().objects.create_user(
+        username="analyticsother", password="testpass"
+    )
+    task = Task.objects.create(title="Test Task")
+    scrobble = Scrobble.objects.create(
+        task=task, media_type="Task", user=owner, visibility="shared",
+        timestamp=timezone.now(),
+    )
+
+    client.force_login(other)
+    url = reverse("scrobbles:share-analytics", kwargs={"uuid": scrobble.uuid})
+    response = client.get(url)
+    assert response.status_code == 404
+
+
+@pytest.mark.django_db
+def test_share_analytics_shows_view_logs(client):
+    user = get_user_model().objects.create_user(
+        username="analyticsviews", password="testpass"
+    )
+    task = Task.objects.create(title="Test Task")
+    scrobble = Scrobble.objects.create(
+        task=task, media_type="Task", user=user, visibility="shared",
+        timestamp=timezone.now(),
+    )
+
+    sqid = encode_scrobble_share(scrobble.id, scrobble.share_token_version)
+    share_url = reverse("scrobbles:shared-detail", kwargs={"sqid": sqid})
+    client.get(share_url)
+    client.get(share_url)
+
+    client.force_login(user)
+    url = reverse("scrobbles:share-analytics", kwargs={"uuid": scrobble.uuid})
+    response = client.get(url)
+    assert response.status_code == 200
+    content = response.content.decode()
+    assert "127.0.0.1" in content
+    assert ShareViewLog.objects.filter(scrobble=scrobble).count() == 2
--- a/vrobbler/apps/boardgames/sources/lichess.py
+++ b/vrobbler/apps/boardgames/sources/lichess.py
@ -103,6 +103,7 @@ def import_chess_games_for_user_id(user_id: int, commit: bool = False) -> dict:
            "source": "Lichess",
            "timezone": user.profile.timezone,
            "log": log_data,
+            "visibility": "private",
        }
        if commit:
            Scrobble.objects.create(**scrobble_dict)
--- a/vrobbler/apps/books/koreader.py
+++ b/vrobbler/apps/books/koreader.py
@ -1,9 +1,8 @@
 import logging
 import re
 import sqlite3
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from enum import Enum
-from zoneinfo import ZoneInfo

 import requests
 from books.constants import BOOKS_TITLES_TO_IGNORE
@ -174,7 +173,7 @@ def build_book_map(rows) -> dict:
    return book_id_map


-def build_page_data(page_rows: list, book_map: dict, user_tz=None) -> dict:
+def build_page_data(page_rows: list, book_map: dict) -> dict:
    """Given rows of page data from KoReader, parse each row and build
    scrobbles for our user, loading the page data into the page_data
    field on the scrobble instance.
@ -187,18 +186,20 @@ def build_page_data(page_rows: list, book_map: dict, user_tz=None) -> dict:
            book_ids_not_found.append(koreader_book_id)
            continue

-        if "pages" not in book_map[koreader_book_id].keys():
-            book_map[koreader_book_id]["pages"] = {}
+        book_map[koreader_book_id].setdefault("pages", [])

        page_number = page_row[KoReaderPageStatColumn.PAGE.value]
        duration = page_row[KoReaderPageStatColumn.DURATION.value]
        start_ts = page_row[KoReaderPageStatColumn.START_TIME.value]

-        book_map[koreader_book_id]["pages"][page_number] = {
-            "duration": duration,
-            "start_ts": start_ts,
-            "end_ts": start_ts + duration,
-        }
+        book_map[koreader_book_id]["pages"].append(
+            {
+                "page_number": page_number,
+                "duration": duration,
+                "start_ts": start_ts,
+                "end_ts": start_ts + duration,
+            }
+        )
    if book_ids_not_found:
        logger.info(f"Found pages for books not in file: {set(book_ids_not_found)}")
    return book_map
@ -225,11 +226,12 @@ def build_scrobbles_from_book_map(book_map: dict, user: "User") -> list["Scrobbl
        pages_processed = 0
        total_pages_read = len(book_map[koreader_book_id]["pages"])
        ordered_pages = sorted(
-            book_map[koreader_book_id]["pages"].items(),
-            key=lambda x: x[1]["start_ts"],
+            book_map[koreader_book_id]["pages"],
+            key=lambda x: x["start_ts"],
        )

-        for cur_page_number, stats in ordered_pages:
+        for stats in ordered_pages:
+            page_number = stats["page_number"]
            pages_processed += 1

            seconds_from_last_page = 0
@ -243,12 +245,14 @@ def build_scrobbles_from_book_map(book_map: dict, user: "User") -> list["Scrobbl
            )

            end_of_reading = pages_processed == total_pages_read
-            big_jump_to_this_page = (cur_page_number - last_page_number) > 10
+            big_jump_to_this_page = (page_number - last_page_number) > 10
            is_session_gap = seconds_from_last_page > SESSION_GAP_SECONDS
            if (is_session_gap and not big_jump_to_this_page) or end_of_reading:
                should_create_scrobble = True

            if should_create_scrobble:
+                if not scrobble_page_data:
+                    scrobble_page_data[page_number] = stats
                scrobble_page_data = dict(
                    sorted(
                        scrobble_page_data.items(),
@ -270,19 +274,16 @@ def build_scrobbles_from_book_map(book_map: dict, user: "User") -> list["Scrobbl
                    continue

                timestamp = user.profile.get_timestamp_with_tz(
-                    datetime.fromtimestamp(int(first_page.get("start_ts")))
+                    datetime.fromtimestamp(
+                        int(first_page.get("start_ts"))
+                    )
                )
                stop_timestamp = user.profile.get_timestamp_with_tz(
-                    datetime.fromtimestamp(int(last_page.get("end_ts")))
+                    datetime.fromtimestamp(
+                        int(last_page.get("end_ts"))
+                    )
                )

-                # Adjust for Daylight Saving Time
-                # if timestamp.dst() == timedelta(
-                #    0
-                # ) or stop_timestamp.dst() == timedelta(0):
-                #    timestamp = timestamp - timedelta(hours=1)
-                #    stop_timestamp = stop_timestamp - timedelta(hours=1)
-
                scrobble = Scrobble.objects.filter(
                    timestamp=timestamp,
                    book_id=book_id,
@ -291,7 +292,7 @@ def build_scrobbles_from_book_map(book_map: dict, user: "User") -> list["Scrobbl

                if not scrobble:
                    logger.info(
-                        f"Queueing scrobble for {book_id}, page {cur_page_number}"
+                        f"Queueing scrobble for {book_id}, page {page_number}"
                    )
                    log_data = {
                        "koreader_hash": book_dict.get("hash"),
@ -324,10 +325,84 @@ def build_scrobbles_from_book_map(book_map: dict, user: "User") -> list["Scrobbl
                scrobble_page_data = {}

            # We accumulate pages for the scrobble until we should create a new one
-            scrobble_page_data[cur_page_number] = stats
+            scrobble_page_data[page_number] = stats

-            last_page_number = cur_page_number
+            last_page_number = page_number
            prev_page_stats = stats
+
+        # Handle leftover pages that never triggered a session gap
+        if scrobble_page_data:
+            scrobble_page_data = dict(
+                sorted(
+                    scrobble_page_data.items(),
+                    key=lambda x: x[1]["start_ts"],
+                )
+            )
+            try:
+                first_page = scrobble_page_data.get(
+                    list(scrobble_page_data.keys())[0]
+                )
+                last_page = scrobble_page_data.get(
+                    list(scrobble_page_data.keys())[-1]
+                )
+            except IndexError:
+                logger.error(
+                    "Could not process book, no page data found",
+                    extra={"scrobble_page_data": scrobble_page_data},
+                )
+                continue
+
+            playback_position_seconds = sum(
+                p["duration"] for p in scrobble_page_data.values()
+            )
+
+            timestamp = user.profile.get_timestamp_with_tz(
+                datetime.fromtimestamp(
+                    int(first_page.get("start_ts"))
+                )
+            )
+            stop_timestamp = user.profile.get_timestamp_with_tz(
+                datetime.fromtimestamp(
+                    int(last_page.get("end_ts"))
+                )
+            )
+
+            scrobble = Scrobble.objects.filter(
+                timestamp=timestamp,
+                book_id=book_id,
+                user_id=user.id,
+            ).first()
+
+            if not scrobble:
+                logger.info(
+                    f"Queueing scrobble for {book_id}, page {list(scrobble_page_data.keys())[0]}"
+                )
+                log_data = {
+                    "koreader_hash": book_dict.get("hash"),
+                    "page_data": scrobble_page_data,
+                    "pages_read": len(scrobble_page_data.keys()),
+                }
+                if hasattr(timestamp.tzinfo, "tzname"):
+                    tz = timestamp.tzinfo.tzname
+                if hasattr(timestamp.tzinfo, "name"):
+                    tz = timestamp.tzinfo.name
+                scrobbles_to_create.append(
+                    Scrobble(
+                        book_id=book_id,
+                        user_id=user.id,
+                        source="KOReader",
+                        media_type=Scrobble.MediaType.BOOK,
+                        timestamp=timestamp,
+                        log=log_data,
+                        stop_timestamp=stop_timestamp,
+                        playback_position_seconds=playback_position_seconds,
+                        in_progress=False,
+                        played_to_completion=True,
+                        long_play_complete=False,
+                        timezone=tz,
+                    )
+                )
+
    if pages_not_found:
        logger.info(f"Pages not found for books: {set(pages_not_found)}")
    return scrobbles_to_create
@ -357,9 +432,6 @@ def process_koreader_sqlite_file(file_path, user_id) -> list:

    new_scrobbles = []
    user = User.objects.filter(id=user_id).first()
-    tz = ZoneInfo("UTC")
-    if user:
-        tz = user.profile.tzinfo

    is_os_file = "https://" not in file_path
    if is_os_file:
@ -375,7 +447,6 @@ def process_koreader_sqlite_file(file_path, user_id) -> list:
        book_map = build_page_data(
            cur.execute("SELECT * from page_stat_data ORDER BY id_book, start_time"),
            book_map,
-            tz,
        )
        new_scrobbles = build_scrobbles_from_book_map(book_map, user)
    else:
@ -392,7 +463,7 @@ def process_koreader_sqlite_file(file_path, user_id) -> list:
            _sqlite_bytes(file_path), max_buffer_size=1_048_576
        ):
            if table_name == "page_stat_data":
-                book_map = build_page_data(rows, book_map, tz)
+                book_map = build_page_data(rows, book_map)
                new_scrobbles = build_scrobbles_from_book_map(book_map, user)

    logger.info(f"Creating {len(new_scrobbles)} new scrobbles")
--- a/vrobbler/apps/books/models.py
+++ b/vrobbler/apps/books/models.py
@ -4,6 +4,7 @@ from dataclasses import dataclass
 from datetime import datetime
 from typing import Optional
 from uuid import uuid4
+from zoneinfo import ZoneInfo

 import requests
 from books.constants import MediaSourceTag, READCOMICSONLINE_URL
@ -71,7 +72,7 @@ class BookLogData(BaseLogData, LongPlayLogData):
    _excluded_fields = {"koreader_hash", "page_data"}

    def avg_seconds_per_page(self):
-        if self.page_data:
+        if self.page_data and isinstance(self.page_data, dict):
            total_duration = 0
            for page_num, stats in self.page_data.items():
                total_duration += stats.get("duration", 0)
@ -173,6 +174,9 @@ class Book(LongPlayScrobblableMixin):
    genre = TaggableManager(through=ObjectWithGenres, blank=True, verbose_name="Genre")

    def __str__(self) -> str:
+        if not self.subtitle:
+            return self.title
+
        return f"{self.title} - {self.subtitle}"

    def save(self, *args, **kwargs):
@ -184,12 +188,18 @@ class Book(LongPlayScrobblableMixin):

    @property
    def subtitle(self):
-        subtitle = self.author
+        subtitle_parts = []
+        if self.author:
+            subtitle_parts.append(self.author.name)
        if self.issue_number and "Issue" not in str(self.title):
-            subtitle += " - Issue {self.issue_number}"
+            subtitle_parts.append(f"Issue {self.issue_number}")
        if self.volume_number and "Volume" not in str(self.title):
-            subtitle += " - Volume {self.volume_number}"
-        return subtitle
+            subtitle_parts.append(f"Volume {self.volume_number}")
+        if len(subtitle_parts) > 1:
+            return " / ".join(subtitle_parts)
+        if len(subtitle_parts) == 1:
+            return subtitle_parts[0]
+        return ""

    @property
    def strings(self) -> ScrobblableConstants:
@ -463,8 +473,11 @@ class Book(LongPlayScrobblableMixin):
            if scrobble.logdata.page_data:
                for page, data in scrobble.logdata.page_data.items():
                    if convert_timestamps:
-                        data["start_ts"] = datetime.fromtimestamp(data["start_ts"])
-                        data["end_ts"] = datetime.fromtimestamp(data["end_ts"])
+                        tz = None
+                        if scrobble.timezone:
+                            tz = ZoneInfo(scrobble.timezone)
+                        data["start_ts"] = datetime.fromtimestamp(data["start_ts"], tz=tz)
+                        data["end_ts"] = datetime.fromtimestamp(data["end_ts"], tz=tz)
                    pages[page] = data
        sorted_pages = OrderedDict(
            sorted(pages.items(), key=lambda x: x[1]["start_ts"])
--- a/vrobbler/apps/books/tests/conftest.py
+++ b/vrobbler/apps/books/tests/conftest.py
@ -32,8 +32,6 @@ class KoReaderBookRows:
    DEFAULT_STR = "N/A"
    DEFAULT_INT = 0
    DEFAULT_TIME = 1703800469
-    BOOK_ROWS = []
-    PAGE_STATS_ROWS = []

    def _gen_random_row(self, i):
        wiggle = random.randrange(15)
@ -110,6 +108,8 @@ class KoReaderBookRows:
                    end_session = True

    def __init__(self, book_count=0, **kwargs):
+        self.BOOK_ROWS = []
+        self.PAGE_STATS_ROWS = []
        self._generate_random_book_rows(book_count)
        self._generate_custom_book_row(**kwargs)
        self._generate_random_page_stats_rows()
--- a/vrobbler/apps/books/tests/test_koreader.py
+++ b/vrobbler/apps/books/tests/test_koreader.py
@ -44,8 +44,12 @@ def test_build_scrobbles_from_pages(get_mock, koreader_rows, demo_user, valid_re
    book_map = build_page_data(koreader_rows.PAGE_STATS_ROWS, book_map)

    scrobbles = build_scrobbles_from_book_map(book_map, demo_user)
-    # Corresponds to number of sessions per book ( 20 pages per session, 120 +/- 15 pages read )
-    expected_scrobbles = 6 * len(book_map.keys())
+    # The test data generator adds the session-gap 3600s AFTER the trigger page
+    # (not before), so the first session includes 21 pages (1-21), and each
+    # subsequent session has 20 until the last. The last trigger page (120) was
+    # previously orphaned by the loop structure; the post-loop fix now creates a
+    # scrobble for it.
+    expected_scrobbles = 7 * len(book_map.keys())
    assert len(scrobbles) == expected_scrobbles
    assert len(scrobbles[0].logdata.page_data.keys()) == 21
    assert len(scrobbles[1].logdata.page_data.keys()) == 20
@ -53,6 +57,7 @@ def test_build_scrobbles_from_pages(get_mock, koreader_rows, demo_user, valid_re
    assert len(scrobbles[3].logdata.page_data.keys()) == 20
    assert len(scrobbles[4].logdata.page_data.keys()) == 20
    assert len(scrobbles[5].logdata.page_data.keys()) == 18
+    assert len(scrobbles[6].logdata.page_data.keys()) == 1


 def test_get_author_str_from_row():
--- a/vrobbler/apps/charts/templatetags/chart_tags.py
+++ b/vrobbler/apps/charts/templatetags/chart_tags.py
@ -7,7 +7,10 @@ register = template.Library()
 def get_item(dictionary, key):
    if isinstance(dictionary, dict):
        return dictionary.get(key)
-    return None
+    try:
+        return dictionary[int(key)]
+    except (IndexError, KeyError, TypeError, ValueError):
+        return None


@register.filter
--- a/vrobbler/apps/charts/views.py
+++ b/vrobbler/apps/charts/views.py
@ -114,108 +114,106 @@ class ChartRecordView(TemplateView):
        context["current_week"] = current_week
        context["current_day"] = current_day

-        if chart_type == "maloja":
-            context["chart_keys"] = {
-                "today": "Today",
-                "week": "This Week",
-                "month": "This Month",
-                "year": "This Year",
-                "all": "All Time",
-            }
+        context["chart_keys"] = {
+            "today": "Today",
+            "week": "This Week",
+            "month": "This Month",
+            "year": "This Year",
+            "all": "All Time",
+        }

-            context["maloja_charts"] = {
-                "artist": {
-                    "today": list(
-                        self.get_charts_for_period(
-                            user,
-                            "artist",
-                            year=current_year,
-                            month=current_month,
-                            day=current_day,
-                        )
-                    ),
-                    "week": list(
-                        self.get_charts_for_period(
-                            user,
-                            "artist",
-                            year=current_year,
-                            week=current_week,
-                        )
-                    ),
-                    "month": list(
-                        self.get_charts_for_period(
-                            user,
-                            "artist",
-                            year=current_year,
-                            month=current_month,
-                        )
-                    ),
-                    "year": list(
-                        self.get_charts_for_period(user, "artist", year=current_year)
-                    ),
-                    "all": list(self.get_charts_for_period(user, "artist")),
-                },
-                "track": {
-                    "today": list(
-                        self.get_charts_for_period(
-                            user,
-                            "track",
-                            year=current_year,
-                            month=current_month,
-                            day=current_day,
-                        )
-                    ),
-                    "week": list(
-                        self.get_charts_for_period(
-                            user, "track", year=current_year, week=current_week
-                        )
-                    ),
-                    "month": list(
-                        self.get_charts_for_period(
-                            user,
-                            "track",
-                            year=current_year,
-                            month=current_month,
-                        )
-                    ),
-                    "year": list(
-                        self.get_charts_for_period(user, "track", year=current_year)
-                    ),
-                    "all": list(self.get_charts_for_period(user, "track")),
-                },
-                "tv_series": {
-                    "today": list(
-                        self.get_charts_for_period(
-                            user,
-                            "tv_series",
-                            year=current_year,
-                            month=current_month,
-                            day=current_day,
-                        )
-                    ),
-                    "week": list(
-                        self.get_charts_for_period(
-                            user,
-                            "tv_series",
-                            year=current_year,
-                            week=current_week,
-                        )
-                    ),
-                    "month": list(
-                        self.get_charts_for_period(
-                            user,
-                            "tv_series",
-                            year=current_year,
-                            month=current_month,
-                        )
-                    ),
-                    "year": list(
-                        self.get_charts_for_period(user, "tv_series", year=current_year)
-                    ),
-                    "all": list(self.get_charts_for_period(user, "tv_series")),
-                },
-            }
-            return context
+        context["maloja_charts"] = {
+            "artist": {
+                "today": list(
+                    self.get_charts_for_period(
+                        user,
+                        "artist",
+                        year=current_year,
+                        month=current_month,
+                        day=current_day,
+                    )
+                ),
+                "week": list(
+                    self.get_charts_for_period(
+                        user,
+                        "artist",
+                        year=current_year,
+                        week=current_week,
+                    )
+                ),
+                "month": list(
+                    self.get_charts_for_period(
+                        user,
+                        "artist",
+                        year=current_year,
+                        month=current_month,
+                    )
+                ),
+                "year": list(
+                    self.get_charts_for_period(user, "artist", year=current_year)
+                ),
+                "all": list(self.get_charts_for_period(user, "artist")),
+            },
+            "album": {
+                "today": list(
+                    self.get_charts_for_period(
+                        user,
+                        "album",
+                        year=current_year,
+                        month=current_month,
+                        day=current_day,
+                    )
+                ),
+                "week": list(
+                    self.get_charts_for_period(
+                        user, "album", year=current_year, week=current_week
+                    )
+                ),
+                "month": list(
+                    self.get_charts_for_period(
+                        user,
+                        "album",
+                        year=current_year,
+                        month=current_month,
+                    )
+                ),
+                "year": list(
+                    self.get_charts_for_period(user, "album", year=current_year)
+                ),
+                "all": list(self.get_charts_for_period(user, "album")),
+            },
+            "tv_series": {
+                "today": list(
+                    self.get_charts_for_period(
+                        user,
+                        "tv_series",
+                        year=current_year,
+                        month=current_month,
+                        day=current_day,
+                    )
+                ),
+                "week": list(
+                    self.get_charts_for_period(
+                        user,
+                        "tv_series",
+                        year=current_year,
+                        week=current_week,
+                    )
+                ),
+                "month": list(
+                    self.get_charts_for_period(
+                        user,
+                        "tv_series",
+                        year=current_year,
+                        month=current_month,
+                    )
+                ),
+                "year": list(
+                    self.get_charts_for_period(user, "tv_series", year=current_year)
+                ),
+                "all": list(self.get_charts_for_period(user, "tv_series")),
+            },
+        }

        if not date_param:
            context["period"] = "current"
--- a/vrobbler/apps/profiles/forms.py
+++ b/vrobbler/apps/profiles/forms.py
@ -1,6 +1,8 @@
 from django import forms

 from profiles.models import UserProfile
+from scrobbles.constants import Visibility
+from scrobbles.models import Scrobble


 class UserProfileForm(forms.ModelForm):
@ -45,3 +47,51 @@ class UserProfileForm(forms.ModelForm):
            "archivebox_password": forms.PasswordInput(render_value=True),
            "webdav_pass": forms.PasswordInput(render_value=True),
        }
+
+
+MEDIA_TYPE_LABELS = {
+    mt.value: mt.label for mt in Scrobble.MediaType
+}
+
+INHERIT = ""
+
+
+class BulkVisibilityForm(forms.Form):
+    bulk_action = forms.ChoiceField(
+        choices=[
+            (Visibility.PUBLIC, "Public"),
+            (Visibility.PRIVATE, "Private"),
+        ],
+        widget=forms.RadioSelect,
+        required=False,
+        label="Set all non-shared scrobbles to",
+    )
+
+    def __init__(self, *args, **kwargs):
+        self.profile = kwargs.pop("profile")
+        super().__init__(*args, **kwargs)
+        media_types = Scrobble.MediaType.values
+        choices = [
+            (Visibility.PUBLIC, "Public"),
+            (Visibility.SHARED, "Shared"),
+            (Visibility.PRIVATE, "Private"),
+        ]
+        existing_overrides = self.profile.media_type_visibility or {}
+        for mt in sorted(media_types):
+            label = MEDIA_TYPE_LABELS.get(mt, mt)
+            self.fields[f"media_type_{mt}"] = forms.ChoiceField(
+                choices=choices,
+                required=False,
+                label=label,
+                initial=existing_overrides.get(mt, Visibility.PRIVATE),
+            )
+
+    def clean(self):
+        cleaned = super().clean()
+        overrides = {}
+        for mt in Scrobble.MediaType.values:
+            val = cleaned.get(f"media_type_{mt}")
+            if val:
+                overrides[mt] = val
+        cleaned["media_type_visibility"] = overrides
+        return cleaned
--- a/vrobbler/apps/profiles/migrations/0038_userprofile_media_type_visibility.py
+++ b/vrobbler/apps/profiles/migrations/0038_userprofile_media_type_visibility.py
@ -0,0 +1,20 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("profiles", "0037_alter_userprofile_default_scrobble_visibility"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="userprofile",
+            name="media_type_visibility",
+            field=models.JSONField(
+                blank=True,
+                default=dict,
+                help_text='Per-media-type visibility overrides, e.g. {"Video": "public", "Track": "private"}',
+            ),
+        ),
+    ]
--- a/vrobbler/apps/profiles/models.py
+++ b/vrobbler/apps/profiles/models.py
@ -90,6 +90,12 @@ class UserProfile(TimeStampedModel):
        default="private",
    )

+    media_type_visibility = models.JSONField(
+        default=dict,
+        blank=True,
+        help_text="Per-media-type visibility overrides, e.g. {\"Video\": \"public\", \"Track\": \"private\"}",
+    )
+
    home_scrobble_limit = models.IntegerField(default=20)

    weigh_in_units = models.CharField(
@ -134,6 +140,11 @@ class UserProfile(TimeStampedModel):
        return history

    def get_timestamp_with_tz(self, timestamp):
+        from django.conf import settings
+
+        server_tz = ZoneInfo(settings.TIME_ZONE)
+        ref_dt = timestamp if timestamp.tzinfo is not None else timestamp.replace(tzinfo=server_tz)
+
        timezone = self.tzinfo
        if self.timezone_change_log:
            change_list = self.historic_timezone_changes
@ -144,13 +155,13 @@ class UserProfile(TimeStampedModel):
                    end = None

                if end:
-                    if start <= timestamp.replace(tzinfo=end.timezone) <= end:
+                    if start <= ref_dt <= end:
                        timezone = start.timezone
                else:
-                    if start <= timestamp.replace(tzinfo=start.timezone):
+                    if start <= ref_dt:
                        timezone = start.timezone

-        return timestamp.replace(tzinfo=timezone)
+        return ref_dt.astimezone(timezone)

    def adjust_timezone_of_scrobbles(self, commit=False):
        current_dt = None
--- a/vrobbler/apps/profiles/urls.py
+++ b/vrobbler/apps/profiles/urls.py
@ -6,4 +6,9 @@ app_name = "profiles"

 urlpatterns = [
    path("settings/", views.ProfileFormView.as_view(), name="profile_settings"),
+    path(
+        "settings/visibility/",
+        views.BulkVisibilityView.as_view(),
+        name="bulk_visibility",
+    ),
 ]
--- a/vrobbler/apps/profiles/views.py
+++ b/vrobbler/apps/profiles/views.py
@ -1,8 +1,12 @@
+from django.contrib import messages
 from django.contrib.auth.mixins import LoginRequiredMixin
+from django.db.models import Count, Q
 from django.http.response import HttpResponseBadRequest
 from django.urls import reverse_lazy
 from django.views.generic import FormView
-from profiles.forms import UserProfileForm
+from profiles.forms import BulkVisibilityForm, UserProfileForm
+from scrobbles.constants import Visibility
+from scrobbles.models import Scrobble
 from tasks.todoist import generate_todoist_oauth_url


@ -30,3 +34,46 @@ class ProfileFormView(LoginRequiredMixin, FormView):
        context["profile"] = self.request.user.profile
        context["todoist_oauth_url"] = generate_todoist_oauth_url(self.request.user.id)
        return context
+
+
+class BulkVisibilityView(LoginRequiredMixin, FormView):
+    template_name = "profiles/visibility_settings.html"
+    form_class = BulkVisibilityForm
+    success_url = reverse_lazy("profiles:bulk_visibility")
+
+    def get_form_kwargs(self):
+        kwargs = super().get_form_kwargs()
+        kwargs["profile"] = self.request.user.profile
+        return kwargs
+
+    def form_valid(self, form):
+        request = self.request
+        profile = request.user.profile
+
+        bulk_action = form.cleaned_data.get("bulk_action")
+        if bulk_action:
+            qs = Scrobble.objects.filter(
+                user=request.user,
+            ).exclude(visibility=Visibility.SHARED)
+            total = qs.count()
+            qs.update(visibility=bulk_action)
+            messages.success(
+                request,
+                f"Updated {total} scrobble(s) to {bulk_action}.",
+            )
+
+        profile.media_type_visibility = form.cleaned_data["media_type_visibility"]
+        profile.save(update_fields=["media_type_visibility"])
+        messages.success(request, "Per-media-type visibility overrides saved.")
+        return super().form_valid(form)
+
+    def get_context_data(self, **kwargs):
+        ctx = super().get_context_data(**kwargs)
+        profile = self.request.user.profile
+        qs = Scrobble.objects.filter(user=self.request.user)
+        ctx["scrobble_count"] = qs.count()
+        ctx["visibility_counts"] = qs.values("visibility").annotate(
+            count=Count("id")
+        )
+        ctx["profile"] = profile
+        return ctx
--- a/vrobbler/apps/scrobbles/importers/lastfm.py
+++ b/vrobbler/apps/scrobbles/importers/lastfm.py
@ -76,6 +76,7 @@ class LastFM:
                in_progress=False,
                media_type=Scrobble.MediaType.TRACK,
                timezone=tz_timestamp.tzinfo.name,
+                visibility="private",
            )
            # Vrobbler scrobbles on finish, LastFM scrobbles on start
            seconds_eariler = timestamp - timedelta(seconds=20)
--- a/vrobbler/apps/scrobbles/importers/scale.py
+++ b/vrobbler/apps/scrobbles/importers/scale.py
@ -111,6 +111,7 @@ def import_scale_csv(file_path, user_id):
                played_to_completion=True,
                in_progress=False,
                media_type=Scrobble.MediaType.TASK,
+                visibility="private",
            )
            new_scrobbles.append(new_scrobble)

--- a/vrobbler/apps/scrobbles/importers/trail_gpx.py
+++ b/vrobbler/apps/scrobbles/importers/trail_gpx.py
@ -305,6 +305,7 @@ def import_trail_gpx(file_path, user_id, original_filename=None):
        played_to_completion=True,
        in_progress=False,
        media_type=Scrobble.MediaType.TRAIL,
+        visibility="private",
    )

    _, ext = os.path.splitext(file_path)
--- a/vrobbler/apps/scrobbles/importers/tsv.py
+++ b/vrobbler/apps/scrobbles/importers/tsv.py
@ -80,6 +80,7 @@ def import_audioscrobbler_tsv_file(file_path, user_id):
            in_progress=False,
            media_type=Scrobble.MediaType.TRACK,
            timezone=timestamp.tzinfo.name,
+            visibility="private",
        )
        existing = Scrobble.objects.filter(
            timestamp=timestamp, track=track, user=user
--- a/vrobbler/apps/scrobbles/importers/webdav.py
+++ b/vrobbler/apps/scrobbles/importers/webdav.py
@ -153,7 +153,7 @@ def scan_webdav_for_koreader(
    )

    if update_etag_only:
-        if last_import and remote_etag:
+        if last_import and remote_etag and hasattr(last_import, "webdav_etag"):
            last_import.webdav_etag = remote_etag
            last_import.save(update_fields=["webdav_etag"])
            logger.info(
@ -163,7 +163,7 @@ def scan_webdav_for_koreader(
            )
        return 0

-    if last_import and last_import.webdav_etag and remote_etag:
+    if last_import and getattr(last_import, "webdav_etag", None) and remote_etag:
        if last_import.webdav_etag == remote_etag:
            logger.info(
                "koreader stats file unchanged (ETag match)",
--- a/vrobbler/apps/scrobbles/migrations/0095_backfill_null_visibility.py
+++ b/vrobbler/apps/scrobbles/migrations/0095_backfill_null_visibility.py
@ -0,0 +1,20 @@
+from django.db import migrations
+
+
+def backfill_null_visibility(apps, schema_editor):
+    Scrobble = apps.get_model("scrobbles", "Scrobble")
+    Scrobble.objects.filter(visibility__isnull=True).update(visibility="private")
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("scrobbles", "0094_scrobble_share_view_count_alter_scrobble_visibility_and_more"),
+    ]
+
+    operations = [
+        migrations.RunPython(
+            backfill_null_visibility,
+            reverse_code=migrations.RunPython.noop,
+        ),
+    ]
--- a/vrobbler/apps/scrobbles/migrations/0096_convert_book_page_data_to_dict.py
+++ b/vrobbler/apps/scrobbles/migrations/0096_convert_book_page_data_to_dict.py
@ -0,0 +1,35 @@
+from django.db import migrations
+
+
+def convert_page_data_to_dict(apps, schema_editor):
+    Scrobble = apps.get_model("scrobbles", "Scrobble")
+    for scrobble in Scrobble.objects.filter(media_type="Book").exclude(
+        log__page_data=None
+    ):
+        page_data = scrobble.log.get("page_data")
+        if isinstance(page_data, list):
+            new_page_data = {}
+            for entry in page_data:
+                page_num = entry.get("page_number")
+                if page_num is not None:
+                    try:
+                        page_num = int(page_num)
+                    except (ValueError, TypeError):
+                        continue
+                    new_page_data[page_num] = entry
+            scrobble.log["page_data"] = new_page_data
+            scrobble.save(update_fields=["log"])
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("scrobbles", "0095_backfill_null_visibility"),
+    ]
+
+    operations = [
+        migrations.RunPython(
+            convert_page_data_to_dict,
+            reverse_code=migrations.RunPython.noop,
+        ),
+    ]
--- a/vrobbler/apps/scrobbles/models.py
+++ b/vrobbler/apps/scrobbles/models.py
@ -225,7 +225,9 @@ class KoReaderImport(BaseFileImportMixin):

        self.mark_started()
        try:
-            scrobbles = process_koreader_sqlite_file(self.upload_file_path, self.user.id)
+            scrobbles = process_koreader_sqlite_file(
+                self.upload_file_path, self.user.id
+            )
            self.record_log(scrobbles)
        except Exception as e:
            self.record_error(f"Import failed: {e}")
@ -272,7 +274,9 @@ class AudioScrobblerTSVImport(BaseFileImportMixin):

        self.mark_started()
        try:
-            scrobbles = import_audioscrobbler_tsv_file(self.upload_file_path, self.user.id)
+            scrobbles = import_audioscrobbler_tsv_file(
+                self.upload_file_path, self.user.id
+            )
            self.record_log(scrobbles)
        except Exception as e:
            self.record_error(f"Import failed: {e}")
@ -936,6 +940,8 @@ class Scrobble(TimeStampedModel):
            logdata_cls = logdata.BaseLogData

        log_dict = self.log
+        if isinstance(log_dict, logdata.BaseLogData):
+            log_dict = log_dict.asdict
        if isinstance(self.log, str):
            # There's nothing stopping django from saving a string in a JSONField :(
            logger.warning(
@ -1412,20 +1418,18 @@ class Scrobble(TimeStampedModel):
                or scrobble_data["playback_status"] == "stopped"
            ):
                if read_log_page:
-                    page_list = scrobble.log.get("page_data", [])
-                    if page_list:
-                        for page in page_list:
+                    page_data = scrobble.log.get("page_data", {})
+                    if page_data:
+                        for page_num, page in page_data.items():
                            if not page.get("end_ts", None):
                                page["end_ts"] = int(timezone.now().timestamp())
                                page["duration"] = page["end_ts"] - page.get("start_ts")

-                    page_list.append(
-                        BookPageLogData(
-                            page_number=read_log_page,
-                            start_ts=int(timezone.now().timestamp()),
-                        )
+                    page_data[read_log_page] = BookPageLogData(
+                        page_number=read_log_page,
+                        start_ts=int(timezone.now().timestamp()),
                    )
-                    scrobble.log["page_data"] = page_list
+                    scrobble.log["page_data"] = page_data
                    scrobble.save(update_fields=["log"])
                elif "log" in scrobble_data.keys() and scrobble.log:
                    scrobble_data["log"] = scrobble.log | scrobble_data["log"]
@ -1436,13 +1440,13 @@ class Scrobble(TimeStampedModel):

        if read_log_page:
            scrobble_data["log"] = BookLogData(
-                page_data=[
-                    BookPageLogData(
+                page_data={
+                    read_log_page: BookPageLogData(
                        page_number=read_log_page,
                        start_ts=int(timezone.now().timestamp()),
                    )
-                ]
-            )
+                }
+            ).asdict

        logger.info(
            f"[scrobbling] creating new scrobble",
@ -1457,7 +1461,7 @@ class Scrobble(TimeStampedModel):
            "calories", None
        ):
            if media.calories:
-                scrobble_data["log"] = FoodLogData(calories=media.calories)
+                scrobble_data["log"] = FoodLogData(calories=media.calories).asdict

        scrobble = cls.create(scrobble_data)
        return scrobble
@ -1612,6 +1616,18 @@ class Scrobble(TimeStampedModel):
        cls,
        scrobble_data: dict,
    ) -> "Scrobble":
+        if "visibility" not in scrobble_data:
+            user = scrobble_data.get("user")
+            media_type = scrobble_data.get("media_type")
+            override = None
+            if user and media_type:
+                try:
+                    profile = user.profile
+                    overrides = profile.media_type_visibility or {}
+                    override = overrides.get(media_type)
+                except user.__class__.profile.RelatedObjectDoesNotExist:
+                    pass
+            scrobble_data["visibility"] = override or Visibility.PRIVATE
        scrobble = cls.objects.create(**scrobble_data)
        if not (
            scrobble.media_type == cls.MediaType.GEO_LOCATION
@ -1768,33 +1784,27 @@ class Scrobble(TimeStampedModel):
        return False

    def calculate_reading_stats(self, commit=True):
-        page_data = self.log.get("page_data")
+        page_data = self.logdata.page_data

        if page_data:
-            # --- Sort safely by numeric page_number ---
-            def safe_page_number(entry):
-                try:
-                    return int(getattr("page_number", entry), 0)
-                except (ValueError, TypeError):
-                    return float("inf")
-
            if isinstance(page_data, dict):
-                logger.warning("Page data is dict, migrate koreader data")
-                return
+                valid_pages = sorted(int(k) for k in page_data.keys())
+                if valid_pages:
+                    self.log["page_start"] = min(valid_pages)
+                    self.log["page_end"] = max(valid_pages)
+                    self.log["pages_read"] = len(set(valid_pages))
+            elif isinstance(page_data, list):
+                valid_pages = []
+                for page in page_data:
+                    try:
+                        valid_pages.append(int(page["page_number"]))
+                    except (ValueError, TypeError):
+                        continue

-            page_data.sort(key=safe_page_number)
-
-            valid_pages = []
-            for page in page_data:
-                try:
-                    valid_pages.append(int(page["page_number"]))
-                except (ValueError, TypeError):
-                    continue
-
-            if valid_pages:
-                self.log["page_start"] = min(valid_pages)
-                self.log["page_end"] = max(valid_pages)
-                self.log["pages_read"] = len(set(valid_pages))
+                if valid_pages:
+                    self.log["page_start"] = min(valid_pages)
+                    self.log["page_end"] = max(valid_pages)
+                    self.log["pages_read"] = len(set(valid_pages))
        else:
            page_start = self.log.get("page_start")
            page_end = self.log.get("page_end")
@ -1834,9 +1844,7 @@ class FavoriteMedia(TimeStampedModel):
    birding_location = models.ForeignKey(
        BirdingLocation, on_delete=models.CASCADE, **BNULL
    )
-    media_type = models.CharField(
-        max_length=20, choices=Scrobble.MediaType.choices
-    )
+    media_type = models.CharField(max_length=20, choices=Scrobble.MediaType.choices)
    sent_to_mopidy = models.BooleanField(default=False)

    class Meta:
--- a/vrobbler/apps/scrobbles/scrobblers.py
+++ b/vrobbler/apps/scrobbles/scrobblers.py
@ -540,6 +540,7 @@ def email_scrobble_board_game(
            "playback_position_seconds": duration_seconds,
            "source": "BG Stats",
            "log": log_data,
+            "visibility": "private",
        }

        scrobble = None
@ -1152,7 +1153,7 @@ def web_scrobbler_scrobble_video_or_song(
    artist_name = data_dict.get("artist")
    track_name = data_dict.get("track")
    tracks = Track.objects.filter(
-        artist__name=data_dict.get("artist"), title=data_dict.get("track")
+        artist_fk__name=data_dict.get("artist"), title=data_dict.get("track")
    )
    if tracks.count() > 1:
        logger.warning(
--- a/vrobbler/apps/scrobbles/views.py
+++ b/vrobbler/apps/scrobbles/views.py
@ -371,6 +371,9 @@ class ScrobbleListView(LoginRequiredMixin, ListView):
                qs = qs.filter(id__in=matching_ids).distinct()
        else:
            tag_list = []
+        visibility_param = self.request.GET.get("visibility", "")
+        if visibility_param in ("public", "shared", "private"):
+            qs = qs.filter(visibility=visibility_param)
        self.tag_list = tag_list
        self._full_queryset = qs
        return qs
--- a/vrobbler/settings.py
+++ b/vrobbler/settings.py
@ -145,7 +145,7 @@ CELERY_BEAT_SCHEDULE = {
    },
    "import-from-webdav": {
        "task": "scrobbles.tasks.import_from_webdav_all_users",
-        "schedule": crontab(minute="*/3"),
+        "schedule": crontab(minute="*/2"),
    },
    # Deprecated: BG Stats files now picked up from WebDAV var/bgstats/
    # "import-from-imap": {
--- a/vrobbler/templates/base_list.html
+++ b/vrobbler/templates/base_list.html
@ -15,6 +15,7 @@
              <a href="{% url 'charts:charts-home' %}" class="btn btn-sm btn-outline-secondary">Charts</a>
            </div>
            {% endif %}
+            {% block grid_view_button %}
            <div class="btn-group me-2">
                {% if view == 'grid' %}
                <button type="button" class="btn btn-sm btn-outline-secondary"><a href="?{% urlreplace view='list' %}">List View</a>
@ -22,6 +23,7 @@
                <button type="button" class="btn btn-sm btn-outline-secondary"><a href="?{% urlreplace view='grid' %}">Grid View</a>
                {% endif %}
            </div>
+            {% endblock %}
            {% block charts_button %}{% endblock %}
        </div>
    </div>
--- a/vrobbler/templates/charts/chart_index.html
+++ b/vrobbler/templates/charts/chart_index.html
@ -1,4 +1,5 @@
 {% extends "base_list.html" %}
+{% load static %}

 {% block title %}Charts{% if period_str %} - {{ period_str }}{% endif %}{% endblock %}

@ -12,11 +13,46 @@
    .nav-tabs {
        cursor: pointer;
    }
+    .image-wrapper {
+        contain: content;
+    }
+    .image-wrapper :hover {
+        background: rgba(0,0,0,0.3);
+    }
+    .caption {
+        position: fixed;
+        top: 5px;
+        left: 5px;
+        padding: 3px;
+        font-size: 90%;
+        color: white;
+        background: rgba(0,0,0,0.4);
+    }
+    .caption-medium {
+        position: fixed;
+        top: 5px;
+        left: 5px;
+        padding: 3px;
+        font-size: 75%;
+        color: white;
+        background: rgba(0,0,0,0.4);
+    }
+    .caption-small {
+        position: fixed;
+        top: 5px;
+        left: 5px;
+        padding: 3px;
+        font-size: 60%;
+        color: white;
+        background: rgba(0,0,0,0.4);
+    }
 </style>
 {% endblock %}

 {% block lists %}

+{% block grid_view_button %}{% endblock %}
+
 <div class="row mb-3">
    <div class="col-12">
        <a href="{% url 'charts:spotify-tracks' %}" class="btn btn-sm btn-outline-secondary">🎵 Spotify Tracks</a>
@ -24,10 +60,6 @@
    </div>
 </div>

-{% if chart_type == "maloja" %}
-{% include "scrobbles/_top_charts.html" %}
-{% else %}
-
 <div class="row">
    <div class="col-12">
        <div class="btn-group mb-3" role="group">
@ -88,43 +120,9 @@
 </div>
 {% endif %}

+{% include "scrobbles/_top_charts.html" %}
+
 <div class="row">
-    {% if charts.artist %}
-    <div class="col-md-6 col-lg-4 chart-section">
-        <h3>🎤 Top Artists</h3>
-        <ul class="list-group">
-            {% for chart in charts.artist|slice:":20" %}
-            <li class="list-group-item d-flex justify-content-between align-items-center">
-                <span class="me-2"><strong>#{{chart.rank}}</strong></span>
-                <a href="{{chart.artist.get_absolute_url}}">{{chart.artist.name}}</a>
-                <span class="badge bg-primary rounded-pill">{{chart.count}}</span>
-            </li>
-            {% endfor %}
-            <li class="list-group-item">
-                <a href="{% url 'charts:chart-detail' 'artist' %}">View all &raquo;</a>
-            </li>
-        </ul>
-    </div>
-    {% endif %}
-
-    {% if charts.album %}
-    <div class="col-md-6 col-lg-4 chart-section">
-        <h3>💿 Top Albums</h3>
-        <ul class="list-group">
-            {% for chart in charts.album|slice:":20" %}
-            <li class="list-group-item d-flex justify-content-between align-items-center">
-                <span class="me-2"><strong>#{{chart.rank}}</strong></span>
-                <a href="{{chart.album.get_absolute_url}}">{{chart.album.name}}</a>
-                <span class="badge bg-primary rounded-pill">{{chart.count}}</span>
-            </li>
-            {% endfor %}
-            <li class="list-group-item">
-                <a href="{% url 'charts:chart-detail' 'album' %}">View all &raquo;</a>
-            </li>
-        </ul>
-    </div>
-    {% endif %}
-
    {% if charts.track %}
    <div class="col-md-6 col-lg-4 chart-section">
        <h3>🎵 Top Tracks</h3>
@ -143,24 +141,6 @@
    </div>
    {% endif %}

-    {% if charts.tv_series %}
-    <div class="col-md-6 col-lg-4 chart-section">
-        <h3>📺 Top TV Series</h3>
-        <ul class="list-group">
-            {% for chart in charts.tv_series|slice:":20" %}
-            <li class="list-group-item d-flex justify-content-between align-items-center">
-                <span class="me-2"><strong>#{{chart.rank}}</strong></span>
-                <a href="{{chart.tv_series.get_absolute_url}}">{{chart.tv_series.name}}</a>
-                <span class="badge bg-primary rounded-pill">{{chart.count}}</span>
-            </li>
-            {% endfor %}
-            <li class="list-group-item">
-                <a href="{% url 'charts:chart-detail' 'tv_series' %}">View all &raquo;</a>
-            </li>
-        </ul>
-    </div>
-    {% endif %}
-
    {% if charts.video %}
    <div class="col-md-6 col-lg-4 chart-section">
        <h3>🎬 Top Videos</h3>
@ -314,6 +294,4 @@
 </div>
 {% endif %}

-{% endif %}
-
 {% endblock %}
--- a/vrobbler/templates/profiles/settings_form.html
+++ b/vrobbler/templates/profiles/settings_form.html
@ -106,6 +106,7 @@
 {% block title %}Settings{% endblock %}
 {% block details %}
 <p class="settings-link"><a href="{% url 'people:person_form' %}">Manage People</a></p>
+<p class="settings-link"><a href="{% url 'profiles:bulk_visibility' %}">Scrobble Visibility Settings</a></p>
 <form method="post" class="settings-form">{% csrf_token %}
    {% for field in form %}
        {% if field.name == "enable_public_widgets" %}
--- a/vrobbler/templates/profiles/visibility_settings.html
+++ b/vrobbler/templates/profiles/visibility_settings.html
@ -0,0 +1,117 @@
+{% extends "base_detail.html" %}
+
+{% block title %}Scrobble Visibility Settings{% endblock %}
+
+{% block head_extra %}
+<style>
+.vis-form {
+    max-width: 700px;
+}
+.vis-form h3 {
+    margin-top: 24px;
+    margin-bottom: 12px;
+}
+.vis-form h4 {
+    margin-top: 20px;
+    margin-bottom: 8px;
+    font-size: 1.1rem;
+}
+.vis-form label {
+    font-weight: 600;
+    margin-right: 12px;
+}
+.vis-form .bulk-radio-group {
+    margin: 8px 0 16px 0;
+}
+.vis-form .bulk-radio-group label {
+    font-weight: normal;
+    display: block;
+    margin: 4px 0;
+}
+.vis-form .media-type-row {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    margin: 6px 0;
+    padding: 4px 8px;
+    border-radius: 4px;
+}
+.vis-form .media-type-row:nth-child(even) {
+    background: #f8f9fa;
+}
+.vis-form .media-type-row label {
+    font-weight: normal;
+    min-width: 130px;
+}
+.vis-form select {
+    padding: 4px 8px;
+    border: 1px solid #ccc;
+    border-radius: 4px;
+}
+.vis-form input[type="submit"] {
+    margin-top: 20px;
+    padding: 10px 24px;
+    background: #007bff;
+    color: white;
+    border: none;
+    border-radius: 4px;
+    cursor: pointer;
+    font-size: 14px;
+}
+.vis-form input[type="submit"]:hover {
+    background: #0056b3;
+}
+.vis-stats {
+    margin: 16px 0;
+    padding: 12px;
+    background: #f8f9fa;
+    border-radius: 4px;
+}
+.vis-stats strong {
+    display: block;
+    margin-bottom: 6px;
+}
+.vis-stats ul {
+    margin: 0;
+    padding-left: 18px;
+}
+</style>
+{% endblock %}
+
+{% block details %}
+<p><a href="{% url 'profiles:profile_settings' %}">&laquo; Back to settings</a></p>
+
+<div class="vis-stats">
+    <strong>Current scrobble visibility ({{ scrobble_count }} total)</strong>
+    <ul>
+        {% for item in visibility_counts %}
+        <li><a href="{% url 'scrobbles:scrobble-list' %}?visibility={{ item.visibility }}">{{ item.visibility|title }}</a>: {{ item.count }}</li>
+        {% endfor %}
+    </ul>
+</div>
+
+<form method="post" class="vis-form">{% csrf_token %}
+    <h3>Bulk Update</h3>
+    <p>Choose a visibility to apply to all scrobbles that are <strong>not</strong> currently "Shared".</p>
+    <div class="bulk-radio-group">
+        {% for radio in form.bulk_action %}
+        <label>{{ radio.tag }} {{ radio.choice_label }}</label>
+        {% endfor %}
+    </div>
+
+    <details>
+        <summary><h3 style="display:inline">Per-Media-Type Defaults</h3></summary>
+        <p>Override default visibility for new scrobbles of specific types.</p>
+        {% for field in form %}
+            {% if field.name != "bulk_action" %}
+            <div class="media-type-row">
+                <label for="{{ field.id_for_label }}">{{ field.label }}</label>
+                {{ field }}
+            </div>
+            {% endif %}
+        {% endfor %}
+    </details>
+
+    <input type="submit" value="Save Visibility Settings">
+</form>
+{% endblock %}
--- a/vrobbler/templates/scrobbles/_top_charts.html
+++ b/vrobbler/templates/scrobbles/_top_charts.html
@ -76,44 +76,44 @@
 </div>

 <div class="row">
-    <h2>🎵 Top Tracks</h2>
-    <ul class="nav nav-tabs" id="trackTab" role="tablist">
+    <h2>💿 Top Albums</h2>
+    <ul class="nav nav-tabs" id="albumTab" role="tablist">
        {% for key, name in chart_keys.items %}
        <li class="nav-item" role="presentation">
            <button class="nav-link {% if forloop.counter == 2 %}active{% endif %}"
-                    id="track-{{key}}-tab" data-bs-toggle="tab" data-bs-target="#track-{{key}}"
+                    id="album-{{key}}-tab" data-bs-toggle="tab" data-bs-target="#album-{{key}}"
                    type="button" role="tab">{{name}}</button>
        </li>
        {% endfor %}
    </ul>

-    <div class="tab-content" id="trackTabContent" class="maloja-chart">
+    <div class="tab-content" id="albumTabContent" class="maloja-chart">
        {% for key, name in chart_keys.items %}
-        {% with maloja_charts.track|get_item:key as tracks %}
-        <div class="tab-pane fade {% if forloop.counter == 2 %}show active{% endif %}" id="track-{{key}}" role="tabpanel">
-            {% if tracks.0 %}
+        {% with maloja_charts.album|get_item:key as albums %}
+        <div class="tab-pane fade {% if forloop.counter == 2 %}show active{% endif %}" id="album-{{key}}" role="tabpanel">
+            {% if albums.0 %}
            <div style="display:block">
                <div style="float:left;">
                    <div class="image-wrapper" style="display:flex; flex-wrap: wrap; margin:0">
-                        <div class="caption">#1 {{tracks.0.track.title}}</div>
-                        {% if tracks.0.track.album.cover_image %}
-                        <a href="{{tracks.0.track.get_absolute_url}}"><img src="{{tracks.0.track.album.cover_image_medium.url}}" width="300px"></a>
+                        <div class="caption">#1 {{albums.0.album.title}}</div>
+                        {% if albums.0.album.cover_image %}
+                        <a href="{{albums.0.album.get_absolute_url}}"><img src="{{albums.0.album.cover_image_medium.url}}" width="300px"></a>
                        {% else %}
-                        <a href="{{tracks.0.track.get_absolute_url}}"><img src="{% static 'images/not-found.jpg' %}" width="300px"></a>
+                        <a href="{{albums.0.album.get_absolute_url}}"><img src="{% static 'images/not-found.jpg' %}" width="300px"></a>
                        {% endif %}
                    </div>
                </div>
                <div style="float:left; width:300px;">
                    <div style="display:flex; flex-wrap: wrap;">
                        {% for i in "2345" %}
-                        {% with tracks|get_item:forloop.counter as track %}
-                        {% if track %}
+                        {% with albums|get_item:forloop.counter as album %}
+                        {% if album %}
                        <div class="image-wrapper" style="width:50%">
-                            <div class="caption-medium">#{{forloop.counter|add:1}} {{track.track.title}}</div>
-                            {% if track.track.album.cover_image %}
-                            <a href="{{track.track.get_absolute_url}}"><img src="{{track.track.album.cover_image_medium.url}}" width="150px"></a>
+                            <div class="caption-medium">#{{forloop.counter|add:1}} {{album.album.title}}</div>
+                            {% if album.album.cover_image %}
+                            <a href="{{album.album.get_absolute_url}}"><img src="{{album.album.cover_image_medium.url}}" width="150px"></a>
                            {% else %}
-                            <a href="{{track.track.get_absolute_url}}"><img src="{% static 'images/not-found.jpg' %}" width="150px"></a>
+                            <a href="{{album.album.get_absolute_url}}"><img src="{% static 'images/not-found.jpg' %}" width="150px"></a>
                            {% endif %}
                        </div>
                        {% endif %}
@ -124,14 +124,14 @@
                <div style="float:left; width:300px;">
                    <div style="display:flex; flex-wrap: wrap;">
                        {% for i in "67891011121314" %}
-                        {% with tracks|get_item:forloop.counter|add:5 as track %}
-                        {% if track %}
+                        {% with albums|get_item:forloop.counter|add:5 as album %}
+                        {% if album %}
                        <div class="image-wrapper" style="width:33%">
-                            <div class="caption-small">#{{forloop.counter|add:6}} {{track.track.title}}</div>
-                            {% if track.track.album.cover_image %}
-                            <a href="{{track.track.get_absolute_url}}"><img src="{{track.track.album.cover_image_medium.url}}" width="100px"></a>
+                            <div class="caption-small">#{{forloop.counter|add:6}} {{album.album.title}}</div>
+                            {% if album.album.cover_image %}
+                            <a href="{{album.album.get_absolute_url}}"><img src="{{album.album.cover_image_medium.url}}" width="100px"></a>
                            {% else %}
-                            <a href="{{track.track.get_absolute_url}}"><img src="{% static 'images/not-found.jpg' %}" width="100px"></a>
+                            <a href="{{album.album.get_absolute_url}}"><img src="{% static 'images/not-found.jpg' %}" width="100px"></a>
                            {% endif %}
                        </div>
                        {% endif %}
--- a/vrobbler/templates/scrobbles/scrobble_all_list.html
+++ b/vrobbler/templates/scrobbles/scrobble_all_list.html
@ -13,6 +13,9 @@
            <p class="text-muted small mb-0">Total time: {{ total_time_seconds|natural_duration }}</p>
            {% endif %}
            {% endif %}
+            {% if request.GET.visibility %}
+            <h6 class="text-muted">Filter: {{ request.GET.visibility|title }} scrobbles only</h6>
+            {% endif %}
        </div>
    </div>
Author	SHA1	Message	Date
Colin Powell	25776eb495	[release] Bump to version 51.1 All checks were successful build / test (push) Successful in 2m55s Details deploy / test (push) Successful in 2m38s Details deploy / build-and-deploy (push) Successful in 44s Details - Fix scrobbling comic books	2026-06-11 19:07:00 -04:00
Colin Powell	5ac4625af9	[books] Fix bug in scrobbling comic books Some checks failed build / test (push) Has been cancelled Details	2026-06-11 19:06:37 -04:00
Colin Powell	a731427f6e	[release] Bump to version 51.0 All checks were successful build / test (push) Successful in 2m52s Details deploy / test (push) Successful in 2m25s Details deploy / build-and-deploy (push) Successful in 49s Details - Fix koreader scrobble imports to use DST properly - Fix book scrobbles where page_data is a list - Lichess imports do not set default visbility	2026-06-11 18:39:31 -04:00
Colin Powell	410da163fe	[books] Fix koreader imports, maybe forever	2026-06-11 18:38:51 -04:00
Colin Powell	a171192a6f	[books] Fix list page_data for old book scrobbles All checks were successful build / test (push) Successful in 2m2s Details	2026-06-11 11:00:04 -04:00
Colin Powell	c16b61db40	[importers] Fix strange bug where celery version mismatches All checks were successful build / test (push) Successful in 2m9s Details	2026-06-11 10:48:38 -04:00
Colin Powell	29cb6a4991	[books] Really fix the subtitle bug	2026-06-11 10:48:21 -04:00
Colin Powell	25c28e8335	[books] Fix bug in subtitle gen All checks were successful build / test (push) Successful in 2m5s Details	2026-06-11 10:34:20 -04:00
Colin Powell	25626be3b6	[boardgames] Add visibility to lichess imports	2026-06-11 10:02:37 -04:00
Colin Powell	0a880a2f2f	[release] Bump to version 50.2 All checks were successful build / test (push) Successful in 2m6s Details deploy / test (push) Successful in 2m7s Details deploy / build-and-deploy (push) Successful in 35s Details - Koreader imports only import single-page scrobbles the next day - Fix bugs in celery tasks causing imports to fail	2026-06-11 09:58:56 -04:00
Colin Powell	248d3f2d3e	[settings] Check webdav every two minuts All checks were successful build / test (push) Successful in 2m13s Details	2026-06-11 09:41:50 -04:00
Colin Powell	e243fec679	[books] Try fixing the one-off import issue	2026-06-11 09:41:19 -04:00
Colin Powell	de9b4ee9c1	[release] Bump to version 50.1 All checks were successful build / test (push) Successful in 2m2s Details deploy / test (push) Successful in 1m57s Details deploy / build-and-deploy (push) Successful in 32s Details - Fix bug in charts where only #1 is displayed	2026-06-09 22:08:48 -04:00
Colin Powell	bf9a6a9679	[charts] Fix only seeing first top media instance	2026-06-09 22:08:15 -04:00
Colin Powell	709fed5cfe	[release] Bump to version 50.0 All checks were successful build / test (push) Successful in 2m7s Details deploy / test (push) Successful in 2m6s Details deploy / build-and-deploy (push) Successful in 31s Details - Allow updating all a user's scrobble visibility at once - Replace columsn of Top Artists, Tracks and Series with Maloja widget	2026-06-09 17:19:10 -04:00
Colin Powell	b7df6299d0	[sharing] Add bulk scrobble share management	2026-06-09 17:18:51 -04:00
Colin Powell	be16d513ef	[charts] Add better chart views per Maloja All checks were successful build / test (push) Successful in 2m3s Details	2026-06-09 17:04:59 -04:00
Colin Powell	15d27f6d94	[release] Bump to version 49.1 All checks were successful build / test (push) Successful in 2m7s Details deploy / test (push) Successful in 2m3s Details deploy / build-and-deploy (push) Successful in 33s Details - Fix bug with missing default visbility for scrobbles	2026-06-09 13:16:53 -04:00
Colin Powell	c8292d1c06	[scrobbles] Back fill visibility field Some checks failed build / test (push) Has been cancelled Details	2026-06-09 13:15:57 -04:00
Colin Powell	68f821fce1	[release] Bump to version 49.0 Some checks failed build / test (push) Successful in 1m59s Details deploy / test (push) Successful in 2m9s Details deploy / build-and-deploy (push) Failing after 2m20s Details - Fix broken tests with new sharing and add tests	2026-06-09 12:48:22 -04:00
Colin Powell	ed2ed59f65	[scrobbles] Fix tests around visbility	2026-06-09 12:48:01 -04:00