Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@booklore-ui/src/app/features/book/service/book-file.service.ts`:
- Around line 34-36: The cache path in BookFileService (when
localSettingsService.get().cacheStorageEnabled is true) must handle rejections
and falsy responses from cacheStorageService.getCache(url) and fall back to
this.http.get; update the logic around cacheStorageService.getCache(url) (the
Promise wrapped with from(...)) to catch Promise rejections and check for a
falsy response/blob, and on error or missing data return the HTTP Observable
(this.http.get<Blob>(url, { responseType: 'blob' as 'json' })); implement this
using RxJS operators (e.g., from(...).pipe(catchError(...)) or
switchMap/mergeMap to choose the HTTP fallback) so cache failures do not
propagate to callers.

In `@booklore-ui/src/app/features/readers/pdf-reader/pdf-reader.component.ts`:
- Around line 209-211: The constructed URI in pdf-reader.component.ts uses
direct concatenation of fileType into the query string (const uri = ... ?
`${API_CONFIG.BASE_URL}/api/v1/books/${bookId}/content?bookType=${fileType}` :
...), which can break for reserved characters; fix it by encoding the bookType
value with encodeURIComponent(fileType) when building the query parameter (keep
bookId and base URL unchanged) so the resulting uri is safe for HTTP requests.
- Around line 205-217: getBookData currently creates blob URLs via
URL.createObjectURL(blob) and assigns them to this.bookData without revoking
previous ones, and ngOnDestroy doesn't revoke the active blob URL; to fix,
introduce a property (e.g., currentBlobUrl) to track the active object URL,
ensure before assigning a new URL in getBookData you revoke the existing one via
URL.revokeObjectURL(currentBlobUrl) (and set currentBlobUrl to the new URL after
assignment), and revoke currentBlobUrl inside ngOnDestroy to release memory;
update any places that read/write this.bookData to use the tracked URL
accordingly (functions: getBookData, ngOnDestroy, and where this.bookData is
set/used).

In
`@booklore-ui/src/app/features/settings/local-settings/local-settings.component.html`:
- Around line 4-57: The template in local-settings.component.html is using
*transloco="let t; prefix: 'settingsNaming'" but still contains hardcoded
strings; replace each literal (header title/description, section
title/description, labels/descriptions for "Enable Cache Storage", "Cache
Storage Usage (MB)", "Clear Cache", and button labels "Refresh"/"Clear Cache")
with the appropriate transloco lookup using the t function (e.g. {{
t('localSettings.title') }}, {{ t('localSettings.description') }}, {{
t('cacheStorage.title') }}, etc.) while keeping bindings and event handlers
intact (settings.cacheStorageEnabled, cacheStorageUsageMb,
isLoadingCacheStorageUsage, isClearingCacheStorage, loadCacheStorageUsage(),
clearCacheStorage()); ensure keys use the existing prefix 'settingsNaming' so
strings localize consistently with other settings components.

In
`@booklore-ui/src/app/features/settings/local-settings/local-settings.component.scss`:
- Around line 9-45: Stylelint is flagging declaration-empty-line-before
violations in the SCSS blocks; open the .scss and for each selector shown in the
diff (.settings-title, .settings-description, .settings-card, .section-header,
.section-title, .section-description, .settings-content, .setting-item) adjust
blank lines so they follow the project's declaration-empty-line-before rule
(remove unexpected empty lines before declaration lists or add the single
required blank line where configured), ensure there are no extra blank lines
between declarations inside each block, and re-run stylelint (or apply stylelint
--fix) to verify the violations are resolved.

In
`@booklore-ui/src/app/features/settings/local-settings/local-settings.component.ts`:
- Around line 59-69: Wrap the body of the accept async handler in a
try/catch/finally: call await this.cacheStorageService.clear() and await
this.loadCacheStorageUsage() inside try, catch errors to call
this.messageService.add with a severity "error" and useful detail, and ensure
this.isClearingCacheStorage is always reset to false in finally; keep the
existing success message in the try path and reference the accept method,
isClearingCacheStorage flag, cacheStorageService.clear, loadCacheStorageUsage,
and messageService.add when making the changes.

In `@booklore-ui/src/app/features/settings/settings.component.html`:
- Around line 13-15: The "Local" tab label is hardcoded; update the p-tab
content that uses SettingsTab.LocalSettings to use the translation helper (e.g.,
{{ t('settings.tabs.local') }}) instead of the literal "Local", and add the
corresponding "settings.tabs.local" key with value "Local" to the translation
files (e.g., en.json) so the tab is internationalized; ensure you reference the
same key pattern used by other tabs like {{ t('reader') }}.

In `@booklore-ui/src/app/shared/service/cache-storage.service.ts`:
- Around line 97-101: The clear() method currently maps cache.keys() to an array
of this.delete(...) promises but doesn't wait for them, so fix clear() to await
all deletions before resolving: after obtaining keys from cache() and mapping to
this.delete(key.url), return or await Promise.all(...) of those delete promises
(or convert clear() to async and await the deletions). Ensure you still resolve
to void after all this.delete(...) calls complete, keeping references to the
cache() and delete(...) methods.
- Line 70: The catch clause in CacheStorageService uses an invalid union
annotation `catch (error: HttpErrorResponse | any)` which violates TS catch
typing rules; change the catch parameter to `catch (error: unknown)` in the
method where this appears (look for the catch in cache-storage.service.ts, e.g.,
inside methods of class CacheStorageService), then inside the catch block narrow
the error with runtime checks (for example use `if (error instanceof
HttpErrorResponse)` or type guard helpers) before accessing
HttpErrorResponse-specific properties, otherwise treat it as a generic error.

---

Nitpick comments:
In `@booklore-api/src/main/java/org/booklore/service/book/BookService.java`:
- Line 31: Replace the wildcard import "import org.springframework.http.*;" in
BookService.java with explicit imports for the symbols used so imports are clear
and avoid collisions; specifically add explicit imports for CacheControl,
MediaType, MediaTypeFactory, and ResponseEntity (remove the wildcard and
organize/import only the classes referenced by methods in BookService).

In `@booklore-ui/src/app/shared/service/cache-storage.service.ts`:
- Line 43: The call this.put(uri, res.clone()) is currently fire-and-forget and
can produce unobserved promise rejections if caches.open()/cache.put() fails;
update the caller (or put method) to await the promise or attach a .catch
handler to it and log or handle errors to prevent unhandled async errors.
Specifically, locate the invocation this.put(uri, res.clone()) in
CacheStorageService and change it to either await this.put(uri, res.clone())
inside an async function or append .catch(err => {/* log via your logger or
console.error with context */}) so failures from put() (and internals like
caches.open()/cache.put()) are observed and handled.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@booklore-ui/src/app/shared/service/cache-storage.service.ts`:
- Around line 100-106: There is an extra closing brace that prematurely ends the
CacheStorageService class (after the clear() method) causing
getCacheSizeInBytes() and cache() to be parsed as top-level statements; remove
the spurious '}' so the class remains open and those methods
(getCacheSizeInBytes, cache, clear, etc.) are defined as members of
CacheStorageService.
- Around line 38-45: The call to this.put(uri, res.clone()) is not awaited so
getCache() can return before the entry is persisted and write failures are
ignored; update the code to await the cache write (await this.put(uri,
res.clone())) and wrap it in a try/catch so write errors are logged/handled (or
rethrown) rather than silently dropped; ensure put(uri, Response) returns a
Promise if it doesn't already and that callers of getCache()/put() can properly
observe failures.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@booklore-ui/src/app/shared/service/cache-storage.service.ts`:
- Around line 70-76: In the catch block inside CacheStorageService
(cache-storage.service.ts) remove the duplicated check for HttpErrorResponse
with status === 304 so the branch appears only once; locate the catch handling
(the function where the try/catch checks "error instanceof HttpErrorResponse &&
error.status === 304") and delete the redundant repeated if statement so the
not-modified return true path is present a single time.

---

Duplicate comments:
In `@booklore-ui/src/app/features/readers/pdf-reader/pdf-reader.component.ts`:
- Around line 101-117: Before overwriting this.bookData with a new blob URL in
the next handler, revoke the previous blob URL to avoid leaking object URLs: if
this.bookData is a non-empty string that starts with "blob:" call
URL.revokeObjectURL(this.bookData) (guarding for null/undefined), then assign
the new bookData; apply the same revoke-before-assign pattern wherever
this.bookData is set (including the component's ngOnDestroy cleanup and any
other assignments) so previous blob URLs are always released.

Verify each finding against the current code and only fix it if needed.

Nitpick comments:
In `@booklore-ui/src/app/shared/service/cache-storage.service.ts`:
- Around line 104-111: getCacheSizeInBytes currently sums Content-Length headers
which can be missing; update it to fall back to the actual response body size by
calling response.blob() and using blob.size when headers lack content-length
(and handle null/undefined responses and non-OK responses). In the promise chain
starting from cache() -> cache.keys() -> this.match(key.url) (and inside the
responses array), for each response check
response?.headers.get("content-length") first, parse it if present, otherwise
await response.blob() and use blob.size (treat missing response as size 0), then
sum those sizes and return the total; keep Promise.all for the blob async calls
so behavior remains asynchronous.
- Around line 26-28: Remove the broad `@ts-ignore` and narrow the type explicitly:
instead of suppressing TypeScript, check that entry is not null/undefined (e.g.
if (!stale && entry !== undefined) return entry;) or use a non-null assertion
only on the return (return entry!) if you are certain entry exists; update the
code around the stale and entry variables so TypeScript can infer the defined
type without `@ts-ignore`.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@booklore-api/src/main/java/org/booklore/service/book/BookService.java`:
- Around line 349-350: The response currently sets CacheControl via
CacheControl.noCache().cachePrivate() in BookService (the
builder.cacheControl(...) call) which allows HTTP caching alongside the new
Cache Storage layer; update the backend to make Cache Storage the only persisted
cache by replacing the CacheControl invocation to use
CacheControl.noStore().cachePrivate() (i.e., change CacheControl.noCache() →
CacheControl.noStore() in the builder.cacheControl(...) call), so the server
sends no-store and avoids creating an unmanaged HTTP cache copy.

In
`@booklore-ui/src/app/features/settings/local-settings/local-settings.component.html`:
- Around line 28-33: The label for the "Enable Cache Storage" control is not
associated with the p-checkbox, so clicking the label won't toggle the checkbox
and screen readers lose the relationship; update the label element to include
for="cache-storage-enabled" and set the p-checkbox prop
inputId="cache-storage-enabled" (the p-checkbox bound to
settings.cacheStorageEnabled and using (onChange)="onSettingChange()") so the
visible label is correctly tied to the checkbox input for accessibility.

In `@booklore-ui/src/app/shared/service/local-settings.service.ts`:
- Around line 15-17: The default LocalSettings currently enables persistent
cache by setting defaultSettings.cacheStorageEnabled to true; change this
default to false so cacheStorageEnabled is opt-in via the Local Settings UI
(update the defaultSettings: LocalSettings object and any code that relies on
its initial value such as consumers of LocalSettings to handle false as
default). Ensure references to defaultSettings and the cacheStorageEnabled
property are updated so the app treats persistence as disabled until the user
explicitly enables it.

---

Duplicate comments:
In `@booklore-ui/src/app/features/readers/pdf-reader/pdf-reader.component.ts`:
- Around line 101-118: When assigning a new blob URL to this.bookData (the code
path that calls URL.createObjectURL around lines where createObjectURL is used),
revoke any previously-created URL first to avoid leaking pinned blobs; e.g., if
this.bookData?.blobUrl (or whatever property holds the URL) exists call
URL.revokeObjectURL(prevUrl) before overwriting this.bookData, and ensure
ngOnDestroy still revokes the final URL (the existing revoke logic in
ngOnDestroy should remain but confirm it uses the same property). Update the
assignment sites (the createObjectURL block and wherever this.bookData is
replaced) to perform the revoke and then set the new blob URL.

---

Nitpick comments:
In `@booklore-api/src/main/java/org/booklore/util/FileUtils.java`:
- Around line 86-91: The getFileLastModified(Path) method currently logs all
IOExceptions as errors; change it to mirror getFileSizeInKb(Path) by detecting a
missing-file condition (e.g., NoSuchFileException or Files.notExists(filePath))
and logging that case at WARN level while returning null, and only log other
IOExceptions as errors; update the log call in getFileLastModified to use
log.warn(...) for missing-paths and keep log.error(...) for unexpected
IOExceptions so transient cache misses aren't treated as server faults.