[BW-DL-05] Treat unavailable removable storage separately from corrupt downloads #20

Open
opened 2026-09-18 08:46:13 +02:00 by alexander · 1 comment
Owner

Migrated from GitHub issue #110. Forgejo issue: #20. GitHub source content synchronized on 2026-09-19. Migrated issue references below use Forgejo numbers where an equivalent issue exists; historical references without a Forgejo counterpart remain explicit GitHub links.

Classification

Active follow-up from #15 / GitHub PR #106.

Problem / opportunity

Current removable-volume support uses app-specific directories from getExternalFilesDirs. Existing manifests hold absolute file:// URIs. When an SD/removable volume is removed, startup verification sees those paths as missing and marks previously complete files/books Failed. Reinserting the intact card does not automatically restore the manifest's Complete state.

Separately, if the currently selected volume is absent, new downloads silently fall back to internal storage while the stored selection still names the missing UUID.

User value

Removing an SD card should read as storage unavailable, not download corrupt. Re-inserting an intact card should make existing books usable again without unnecessary re-download. New-download fallback should be visible rather than surprising.

Scope

  • Define a storage-availability model that distinguishes absent/unmounted removable storage from genuinely missing/corrupt files.
  • Identify/retain the physical copy's owning volume robustly enough to make that distinction after restart.
  • Change manifest verification so an unavailable owning volume does not downgrade intact-on-card files to Failed/Corrupt.
  • Re-verify when the volume becomes available again and restore usable availability when the files remain intact.
  • Expose that the selected future-download volume is unavailable and that new downloads will temporarily use internal storage, unless the user deliberately chooses another available volume.
  • Preserve the user's selected removable-volume preference rather than silently rewriting it merely because the card is temporarily absent.

Explicitly out of scope

  • No arbitrary SAF/user-chosen-directory implementation.
  • No moving already-downloaded files between volumes.
  • No automatic deletion/re-download because a card disappeared.
  • No device-wide delete semantics; BW-DL-06 owns that.

Dependencies

  • Parent audit #15 / GitHub PR #106.
  • BW-DL-02 / #17 is recommended first so Unavailable has a clean presentation boundary, but the storage correctness can be designed independently.

Architecture seams affected

  • StorageVolumes / DownloadRoots.
  • Download manifest / DownloadedBookEntity if durable owning-volume identity is required.
  • DownloadVerifier.
  • local availability projection / Downloads UI state.

Server / API assumptions

No server changes. This is local storage truth. Re-download remains available through existing Audiobookshelf media URLs when the active profile is authorized.

Storage / migration implications

Likely Medium.

The current global selected volume UUID is only the destination for future downloads; it is not enough to identify where an older physical copy belongs after volume changes. A robust solution may require storing an owning volume UUID (or an equivalent stable storage locator) per physical downloaded copy.

If a schema field is added:

  • ship an explicit Room migration and schema export;
  • existing rows must migrate to an Unknown/conservative identity unless ownership can be proven from existing URIs/platform data;
  • never mark/delete a legacy copy merely because its volume cannot be classified.

Privacy / security

Storage volume identity is device-local implementation metadata. Do not expose filesystem paths or volume identifiers in ordinary UI/logs; user-facing copy should use platform volume labels where safe.

Automated-test level

  • Pure mapping tests for Available / Unavailable / Missing-or-corrupt / Unknown.
  • DownloadVerifier tests proving absent volume does not mark files Failed.
  • Tests for volume return -> re-verification -> Complete/usability restoration.
  • Migration/schema tests if per-copy volume identity is added.
  • StorageVolumes tests for selected missing volume and internal fallback without rewriting preference.

Device / platform acceptance

Real removable-storage testing is required. JVM/Robolectric evidence is not enough.

Test:

  1. download complete book to removable storage;
  2. confirm offline playback;
  3. remove card while app stopped and relaunch;
  4. book reports storage unavailable, not corrupt; no bytes/manifest are destroyed;
  5. enqueue a new download and verify the UI says it will use internal fallback;
  6. reinsert card;
  7. old book is reverified and playable without redownload;
  8. future downloads use the selected card again when appropriate.

Estimated effort

Medium to Large.

Implementation risk

High. Incorrect classification can make valid offline media unavailable or trigger needless re-download/storage churn.

After BW-DL-02/03/04 unless this becomes a blocking device defect sooner.

Acceptance criteria

  • Temporarily absent removable media is never labelled corrupt solely because it is absent.
  • No automatic destructive action occurs on volume loss.
  • Reinserted intact media becomes usable again through verification, without mandatory redownload.
  • Missing selected volume fallback is disclosed to the user.
  • Any schema migration preserves legacy bytes conservatively.
  • SAF remains explicitly out of scope.
> Migrated from [GitHub issue #110](https://github.com/AlexanderWilhelmsenBerg/Audiobookshelf-Manager-Claude/issues/110). Forgejo issue: #20. GitHub source content synchronized on 2026-09-19. Migrated issue references below use Forgejo numbers where an equivalent issue exists; historical references without a Forgejo counterpart remain explicit GitHub links. ## Classification Active follow-up from #15 / [GitHub PR #106](https://github.com/AlexanderWilhelmsenBerg/Audiobookshelf-Manager-Claude/pull/106). ## Problem / opportunity Current removable-volume support uses app-specific directories from `getExternalFilesDirs`. Existing manifests hold absolute `file://` URIs. When an SD/removable volume is removed, startup verification sees those paths as missing and marks previously complete files/books Failed. Reinserting the intact card does not automatically restore the manifest's Complete state. Separately, if the currently selected volume is absent, new downloads silently fall back to internal storage while the stored selection still names the missing UUID. ## User value Removing an SD card should read as **storage unavailable**, not **download corrupt**. Re-inserting an intact card should make existing books usable again without unnecessary re-download. New-download fallback should be visible rather than surprising. ## Scope - Define a storage-availability model that distinguishes absent/unmounted removable storage from genuinely missing/corrupt files. - Identify/retain the physical copy's owning volume robustly enough to make that distinction after restart. - Change manifest verification so an unavailable owning volume does not downgrade intact-on-card files to Failed/Corrupt. - Re-verify when the volume becomes available again and restore usable availability when the files remain intact. - Expose that the selected future-download volume is unavailable and that new downloads will temporarily use internal storage, unless the user deliberately chooses another available volume. - Preserve the user's selected removable-volume preference rather than silently rewriting it merely because the card is temporarily absent. ## Explicitly out of scope - No arbitrary SAF/user-chosen-directory implementation. - No moving already-downloaded files between volumes. - No automatic deletion/re-download because a card disappeared. - No device-wide delete semantics; BW-DL-06 owns that. ## Dependencies - Parent audit #15 / [GitHub PR #106](https://github.com/AlexanderWilhelmsenBerg/Audiobookshelf-Manager-Claude/pull/106). - BW-DL-02 / #17 is recommended first so `Unavailable` has a clean presentation boundary, but the storage correctness can be designed independently. ## Architecture seams affected - `StorageVolumes` / `DownloadRoots`. - Download manifest / `DownloadedBookEntity` if durable owning-volume identity is required. - `DownloadVerifier`. - local availability projection / Downloads UI state. ## Server / API assumptions No server changes. This is local storage truth. Re-download remains available through existing Audiobookshelf media URLs when the active profile is authorized. ## Storage / migration implications Likely Medium. The current global selected volume UUID is only the destination for **future** downloads; it is not enough to identify where an older physical copy belongs after volume changes. A robust solution may require storing an owning volume UUID (or an equivalent stable storage locator) per physical downloaded copy. If a schema field is added: - ship an explicit Room migration and schema export; - existing rows must migrate to an `Unknown`/conservative identity unless ownership can be proven from existing URIs/platform data; - never mark/delete a legacy copy merely because its volume cannot be classified. ## Privacy / security Storage volume identity is device-local implementation metadata. Do not expose filesystem paths or volume identifiers in ordinary UI/logs; user-facing copy should use platform volume labels where safe. ## Automated-test level - Pure mapping tests for Available / Unavailable / Missing-or-corrupt / Unknown. - `DownloadVerifier` tests proving absent volume does not mark files Failed. - Tests for volume return -> re-verification -> Complete/usability restoration. - Migration/schema tests if per-copy volume identity is added. - `StorageVolumes` tests for selected missing volume and internal fallback without rewriting preference. ## Device / platform acceptance **Real removable-storage testing is required.** JVM/Robolectric evidence is not enough. Test: 1. download complete book to removable storage; 2. confirm offline playback; 3. remove card while app stopped and relaunch; 4. book reports storage unavailable, not corrupt; no bytes/manifest are destroyed; 5. enqueue a new download and verify the UI says it will use internal fallback; 6. reinsert card; 7. old book is reverified and playable without redownload; 8. future downloads use the selected card again when appropriate. ## Estimated effort Medium to Large. ## Implementation risk High. Incorrect classification can make valid offline media unavailable or trigger needless re-download/storage churn. ## Recommended sequence After BW-DL-02/03/04 unless this becomes a blocking device defect sooner. ## Acceptance criteria - Temporarily absent removable media is never labelled corrupt solely because it is absent. - No automatic destructive action occurs on volume loss. - Reinserted intact media becomes usable again through verification, without mandatory redownload. - Missing selected volume fallback is disclosed to the user. - Any schema migration preserves legacy bytes conservatively. - SAF remains explicitly out of scope. ## Links - Parent audit: #15 - Audit PR: [GitHub #106](https://github.com/AlexanderWilhelmsenBerg/Audiobookshelf-Manager-Claude/issues/106) - Recommended predecessor: #17
Author
Owner

Canonical implementation-readiness update — unified Downloads branch

Shared branch: mcp/downloads-coherent-experience
Refreshed implementation HEAD before #20 mutation: 0f55bc3d6078de070b05ae5d3b0ca191909cdef8
Current main at investigation start: f9f7feba8e7bb499c6001bf0cc19a38357b7494a

This supersedes provisional #20 assumptions for the unified #19/#20/#21/#22/#29 program.

Current failure, confirmed from source

Current removable support stores only:

  • the global UUID selected for future downloads; and
  • absolute file:// URIs on each downloaded file.

It does not persist which volume owns a physical book copy.

StorageVolumes.roots() silently falls back to internal storage when the selected removable UUID is absent. DownloadVerifier then treats an absent file path exactly like a genuinely missing file and downgrades the manifest to Failed. This is the defect described by #20.

There is a second correctness problem: because retries resolve the current selected root again, a physical (server,item) copy can theoretically drift/split across volumes after the storage preference changes. Owning-volume identity therefore has to be a durable physical-copy fact, not inferred later from path text.

Playback also needs this distinction. OfflineSessionBuilder and DefaultPlaybackRepository currently accept a complete manifest and substitute its committed file:// URIs without asking whether the owning volume is mounted. Preserving Complete in Room without a storage-availability playback gate would merely move the failure from verification to the player.

Required state dimensions

#20 will add a transient storage-availability dimension independent of durable download state:

  • Available — owning volume is known and presently mounted/reachable.
  • Unavailable — owning removable volume is known and presently absent.
  • Unknown — legacy copy has no provable durable owner.
  • Missing — owner is available, but a committed file is absent/wrong length.
  • Corrupt — owner is available and file exists at expected length, but full verification cannot open it as media.

Unavailable is not Failed/Corrupt. Unknown is not permission to guess an owner.

A valid combination is therefore:

durable Complete + removable owner + storage Unavailable

and it remains logically preserved until the volume returns.

Durable owning-volume identity

Add nullable storageVolumeUuid to the physical downloaded-book row/model:

  • null = Unknown legacy owner.
  • "" = internal storage (same semantic UUID already used by StorageVolumeOption.INTERNAL_UUID).
  • non-empty = known Android removable-volume UUID.

This belongs on DownloadedBookEntity / OfflineBook, not profile claims and not individual WorkManager state. One physical copy has one owner.

Database version: 20 -> 21.

Migration:
ALTER TABLE downloaded_books ADD COLUMN storageVolumeUuid TEXT DEFAULT NULL

The migration deliberately leaves every existing row Unknown. It must not infer UUIDs by parsing absolute paths, because that would manufacture ownership that cannot be proven while a card is absent. No file is touched by migration.

Update exported schema and the migration test. A version-20 downloaded row must survive with storageVolumeUuid IS NULL, all files/claims intact.

New-copy and retry ownership

For a brand-new physical copy:

  • determine the actual root selected for the transfer;
  • persist that root's UUID on the book before bytes are committed;
  • every later file/retry for that physical copy resolves the stored owner, not whatever storage preference is current then.

If the listener selected removable storage but that UUID is absent when a new copy is created:

  • keep the stored preference unchanged;
  • use internal storage as the actual fallback destination;
  • persist internal UUID as that new physical copy's owner;
  • expose in Downloads UI that the selected removable destination is unavailable and new downloads temporarily use internal storage.

When the selected card returns, future new copies automatically resolve to it again because the preference was never rewritten.

This also prevents one physical book from being split across roots by a preference change.

Storage capability seam

Extend the existing storage boundary without creating a second database:

  • StorageVolumes remains authority for selected UUID and currently mounted volumes.
  • expose an aggregate flow/snapshot of available volume UUIDs (internal is always available);
  • expose resolution of a specific known owner UUID to its current app-specific root;
  • keep arbitrary SAF/document-tree support out of scope.

Mount/unmount observation must be aggregate/process-level (media mount/eject/removal), not one listener per download row.

Verification rules

DownloadVerifier must classify the owner before classifying missing/corrupt files:

  1. Known owner + volume Unavailable:

    • do not mark any file/book Failed;
    • do not delete anything;
    • report/preserve storage Unavailable.
  2. Known owner + Available:

    • missing/wrong-length committed file => Missing;
    • full verification unreadable media => Corrupt;
    • ordinary intact file => Available.
  3. Unknown legacy owner:

    • if the existing URI is reachable, verification may verify the bytes normally;
    • if it is not reachable, remain Unknown rather than downgrading to corruption solely because ownership cannot be classified;
    • do not backfill a precise owner unless runtime evidence proves it unambiguously.

When a previously absent known volume becomes available, trigger manifest re-verification. An intact Complete copy becomes usable again with no redownload.

Playback/localisation rules

Storage availability must also guard local playback:

  • a Complete + Available copy can build an offline session and can replace server track URLs with local URIs;
  • a Complete + Unavailable copy remains preserved but must not substitute dead local URIs and must not claim an offline session is playable;
  • a Complete + Unknown legacy copy may use local files only when they are actually reachable;
  • server playback remains available when online, without destructive manifest mutation.

This prevents an absent card from being described as corrupt while also preventing a dead file:// URL from being handed to Media3.

Downloads UI

Each stored row receives a storage-availability presentation independent of download recovery/execution state.

Known unavailable removable copy:

  • stays in On device / stored copies management, because the physical copy is still owned by this device;
  • shows generic Storage unavailable state;
  • does not expose UUID/path;
  • offers no automatic redownload/destructive repair merely because the card is absent.

Unknown legacy:

  • generic Storage location unknown / conservative equivalent where needed;
  • no fabricated removable label.

Selected missing destination:

  • preserve the radio selection;
  • show that the selected removable storage is unavailable;
  • clearly state that new downloads use internal storage temporarily.

Privacy

Never surface/log:

  • volume UUID;
  • raw filesystem path;
  • server/item/profile ID;
  • hidden title/author;
  • another profile name.

Generic facts such as Storage unavailable / Internal fallback are allowed.

Exact implementation surface

Expected changes:

  • core/model/.../OfflineDownload.kt: owning-volume field + storage-availability model as appropriate.
  • core/database/.../Entities.kt: nullable storageVolumeUuid.
  • ShelfPlayerDatabase.kt / core/database/build.gradle.kts: version 21.
  • Migrations.kt: explicit 20->21 additive nullable migration.
  • exported Room schema 21 + migration tests.
  • DownloadMappers.kt: map owning UUID both directions where applicable.
  • DownloadRepository / DefaultDownloadRepository: assign/read stable physical owner and avoid changing it for additional profile claims.
  • DownloadRoots / StorageVolumes / DownloadStorage: resolve the known physical owner separately from the selected future destination; aggregate availability observation.
  • BookDownloader / FileDownloader: every file/retry uses the physical copy's stored owner.
  • DownloadVerifier: Unavailable/Unknown cannot be collapsed into Missing/Corrupt.
  • OfflineSessionBuilder / playback localisation: do not use local URIs whose storage is unavailable.
  • DownloadsViewModel / UI: storage state + selected-volume fallback disclosure.
  • deterministic storage/verifier/playback/migration tests.

Required deterministic proof

At minimum:

  • Available / Unavailable / Unknown / Missing / Corrupt remain distinguishable;
  • absent known removable owner never mutates Complete -> Failed;
  • reinsertion + verification restores usable local playback without redownload;
  • unknown migrated row is not guessed or destroyed;
  • version-20 -> 21 migration preserves manifest, files and claims;
  • preference remains selected while absent;
  • new copy during selected-card absence owns internal fallback;
  • card return makes later new copies use selected removable again;
  • changing preference after a partial does not move/split that physical copy;
  • online session does not substitute dead local URI while volume is absent;
  • offline fallback refuses unavailable local media cleanly;
  • no raw volume/path/identity leaks in UI/log semantics.

Physical acceptance still mandatory

Real removable-storage acceptance remains exactly required by #20:

  1. complete download to removable storage;
  2. confirm offline playback;
  3. stop app;
  4. remove card;
  5. launch;
  6. show storage unavailable, not corruption;
  7. no destruction;
  8. new transfer discloses internal fallback;
  9. reinsert card;
  10. old copy is reverified;
  11. it plays without redownload;
  12. selected removable destination remains selected for future downloads.

SAF remains out of scope.

#20 IMPLEMENTATION READY

## Canonical implementation-readiness update — unified Downloads branch Shared branch: `mcp/downloads-coherent-experience` Refreshed implementation HEAD before #20 mutation: `0f55bc3d6078de070b05ae5d3b0ca191909cdef8` Current main at investigation start: `f9f7feba8e7bb499c6001bf0cc19a38357b7494a` This supersedes provisional #20 assumptions for the unified #19/#20/#21/#22/#29 program. ### Current failure, confirmed from source Current removable support stores only: - the global UUID selected for **future** downloads; and - absolute `file://` URIs on each downloaded file. It does **not** persist which volume owns a physical book copy. `StorageVolumes.roots()` silently falls back to internal storage when the selected removable UUID is absent. `DownloadVerifier` then treats an absent file path exactly like a genuinely missing file and downgrades the manifest to Failed. This is the defect described by #20. There is a second correctness problem: because retries resolve the current selected root again, a physical `(server,item)` copy can theoretically drift/split across volumes after the storage preference changes. Owning-volume identity therefore has to be a durable **physical-copy** fact, not inferred later from path text. Playback also needs this distinction. `OfflineSessionBuilder` and `DefaultPlaybackRepository` currently accept a complete manifest and substitute its committed `file://` URIs without asking whether the owning volume is mounted. Preserving Complete in Room without a storage-availability playback gate would merely move the failure from verification to the player. ### Required state dimensions #20 will add a transient storage-availability dimension independent of durable download state: - **Available** — owning volume is known and presently mounted/reachable. - **Unavailable** — owning removable volume is known and presently absent. - **Unknown** — legacy copy has no provable durable owner. - **Missing** — owner is available, but a committed file is absent/wrong length. - **Corrupt** — owner is available and file exists at expected length, but full verification cannot open it as media. Unavailable is not Failed/Corrupt. Unknown is not permission to guess an owner. A valid combination is therefore: `durable Complete + removable owner + storage Unavailable` and it remains logically preserved until the volume returns. ### Durable owning-volume identity Add nullable `storageVolumeUuid` to the physical downloaded-book row/model: - `null` = **Unknown legacy owner**. - `""` = internal storage (same semantic UUID already used by `StorageVolumeOption.INTERNAL_UUID`). - non-empty = known Android removable-volume UUID. This belongs on `DownloadedBookEntity` / `OfflineBook`, not profile claims and not individual WorkManager state. One physical copy has one owner. Database version: 20 -> 21. Migration: `ALTER TABLE downloaded_books ADD COLUMN storageVolumeUuid TEXT DEFAULT NULL` The migration deliberately leaves every existing row Unknown. It must not infer UUIDs by parsing absolute paths, because that would manufacture ownership that cannot be proven while a card is absent. No file is touched by migration. Update exported schema and the migration test. A version-20 downloaded row must survive with `storageVolumeUuid IS NULL`, all files/claims intact. ### New-copy and retry ownership For a brand-new physical copy: - determine the actual root selected for the transfer; - persist that root's UUID on the book before bytes are committed; - every later file/retry for that physical copy resolves the **stored owner**, not whatever storage preference is current then. If the listener selected removable storage but that UUID is absent when a new copy is created: - keep the stored preference unchanged; - use internal storage as the actual fallback destination; - persist internal UUID as that **new physical copy's owner**; - expose in Downloads UI that the selected removable destination is unavailable and new downloads temporarily use internal storage. When the selected card returns, future new copies automatically resolve to it again because the preference was never rewritten. This also prevents one physical book from being split across roots by a preference change. ### Storage capability seam Extend the existing storage boundary without creating a second database: - `StorageVolumes` remains authority for selected UUID and currently mounted volumes. - expose an aggregate flow/snapshot of available volume UUIDs (internal is always available); - expose resolution of a specific known owner UUID to its current app-specific root; - keep arbitrary SAF/document-tree support out of scope. Mount/unmount observation must be aggregate/process-level (media mount/eject/removal), not one listener per download row. ### Verification rules `DownloadVerifier` must classify the owner **before** classifying missing/corrupt files: 1. Known owner + volume Unavailable: - do not mark any file/book Failed; - do not delete anything; - report/preserve storage Unavailable. 2. Known owner + Available: - missing/wrong-length committed file => Missing; - full verification unreadable media => Corrupt; - ordinary intact file => Available. 3. Unknown legacy owner: - if the existing URI is reachable, verification may verify the bytes normally; - if it is not reachable, remain Unknown rather than downgrading to corruption solely because ownership cannot be classified; - do not backfill a precise owner unless runtime evidence proves it unambiguously. When a previously absent known volume becomes available, trigger manifest re-verification. An intact Complete copy becomes usable again with no redownload. ### Playback/localisation rules Storage availability must also guard local playback: - a Complete + Available copy can build an offline session and can replace server track URLs with local URIs; - a Complete + Unavailable copy remains preserved but must **not** substitute dead local URIs and must not claim an offline session is playable; - a Complete + Unknown legacy copy may use local files only when they are actually reachable; - server playback remains available when online, without destructive manifest mutation. This prevents an absent card from being described as corrupt while also preventing a dead `file://` URL from being handed to Media3. ### Downloads UI Each stored row receives a storage-availability presentation independent of download recovery/execution state. Known unavailable removable copy: - stays in **On device / stored copies** management, because the physical copy is still owned by this device; - shows generic **Storage unavailable** state; - does not expose UUID/path; - offers no automatic redownload/destructive repair merely because the card is absent. Unknown legacy: - generic **Storage location unknown** / conservative equivalent where needed; - no fabricated removable label. Selected missing destination: - preserve the radio selection; - show that the selected removable storage is unavailable; - clearly state that **new downloads use internal storage temporarily**. ### Privacy Never surface/log: - volume UUID; - raw filesystem path; - server/item/profile ID; - hidden title/author; - another profile name. Generic facts such as Storage unavailable / Internal fallback are allowed. ### Exact implementation surface Expected changes: - `core/model/.../OfflineDownload.kt`: owning-volume field + storage-availability model as appropriate. - `core/database/.../Entities.kt`: nullable `storageVolumeUuid`. - `ShelfPlayerDatabase.kt` / `core/database/build.gradle.kts`: version 21. - `Migrations.kt`: explicit 20->21 additive nullable migration. - exported Room schema 21 + migration tests. - `DownloadMappers.kt`: map owning UUID both directions where applicable. - `DownloadRepository` / `DefaultDownloadRepository`: assign/read stable physical owner and avoid changing it for additional profile claims. - `DownloadRoots` / `StorageVolumes` / `DownloadStorage`: resolve the known physical owner separately from the selected future destination; aggregate availability observation. - `BookDownloader` / `FileDownloader`: every file/retry uses the physical copy's stored owner. - `DownloadVerifier`: Unavailable/Unknown cannot be collapsed into Missing/Corrupt. - `OfflineSessionBuilder` / playback localisation: do not use local URIs whose storage is unavailable. - `DownloadsViewModel` / UI: storage state + selected-volume fallback disclosure. - deterministic storage/verifier/playback/migration tests. ### Required deterministic proof At minimum: - Available / Unavailable / Unknown / Missing / Corrupt remain distinguishable; - absent known removable owner never mutates Complete -> Failed; - reinsertion + verification restores usable local playback without redownload; - unknown migrated row is not guessed or destroyed; - version-20 -> 21 migration preserves manifest, files and claims; - preference remains selected while absent; - new copy during selected-card absence owns internal fallback; - card return makes later new copies use selected removable again; - changing preference after a partial does not move/split that physical copy; - online session does not substitute dead local URI while volume is absent; - offline fallback refuses unavailable local media cleanly; - no raw volume/path/identity leaks in UI/log semantics. ### Physical acceptance still mandatory Real removable-storage acceptance remains exactly required by #20: 1. complete download to removable storage; 2. confirm offline playback; 3. stop app; 4. remove card; 5. launch; 6. show storage unavailable, not corruption; 7. no destruction; 8. new transfer discloses internal fallback; 9. reinsert card; 10. old copy is reverified; 11. it plays without redownload; 12. selected removable destination remains selected for future downloads. SAF remains out of scope. ## #20 IMPLEMENTATION READY
Sign in to join this conversation.
No labels
No milestone
No project
No assignees
1 participant
Notifications
Due date
The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set

Reference
alexander/Audiobookshelf-Manager-Claude#20
No description provided.