Feat: Reworked ENTIRE Project for Readability

src/core/algorithms/filter.ts

@@ -0,0 +1,50 @@
+import type { Manga, Source } from "@types";
+import type { Settings }      from "@types";
+import { shouldHideSource }   from "@core/util";
+
+// ── Source deduplication ──────────────────────────────────────────────────────
+
+/**
+ * Deduplicates sources by name, preferring `preferredLang` when multiple
+ * sources share a name. The local source (id "0") is always excluded.
+ *
+ * When `applyHide` is true, sources that fail the NSFW/block check are
+ * also removed — used in fan-out and cache-build paths where only
+ * user-visible sources should be queried.
+ */
+export function dedupeSourcesByLang(
+  sources:      Source[],
+  preferredLang: string,
+  settings:     Pick<Settings, "showNsfw" | "nsfwAllowedSourceIds" | "nsfwBlockedSourceIds">,
+  applyHide     = false,
+): Source[] {
+  const map = new Map<string, Source>();
+  for (const s of sources) {
+    if (s.id === "0") continue;
+    if (applyHide && shouldHideSource(s, settings)) continue;
+    const existing = map.get(s.name);
+    if (!existing) { map.set(s.name, s); continue; }
+    const existingPref = existing.lang === preferredLang;
+    const newPref      = s.lang === preferredLang;
+    if (newPref && !existingPref) map.set(s.name, s);
+    else if (!existingPref && !newPref && s.lang < existing.lang) map.set(s.name, s);
+  }
+  return Array.from(map.values());
+}
+
+// ── Manga predicate filters ───────────────────────────────────────────────────
+
+/**
+ * Generic predicate pipeline — composes multiple boolean predicates into one.
+ * All predicates must return true for an item to pass.
+ *
+ * Usage:
+ *   const keep = buildFilter<Manga>(
+ *     m => !shouldHideNsfw(m, settings),
+ *     m => m.inLibrary,
+ *   );
+ *   const filtered = items.filter(keep);
+ */
+export function buildFilter<T>(...predicates: ((item: T) => boolean)[]): (item: T) => boolean {
+  return (item) => predicates.every((p) => p(item));
+}

src/core/algorithms/index.ts

@@ -0,0 +1,5 @@
+export * from './sort';
+export * from './filter';
+export * from './paginate';
+export * from './search';
+export * from './queue';

src/core/algorithms/paginate.ts

@@ -0,0 +1,29 @@
+export interface PaginationState {
+  visible: number;
+}
+
+export interface PaginationResult<T> {
+  items: T[];
+  hasMore: boolean;
+  remaining: number;
+}
+
+export function createPaginator<T>(pageSize: number) {
+  return {
+    slice(all: T[], visible: number): PaginationResult<T> {
+      return {
+        items:     all.slice(0, visible),
+        hasMore:   all.length > visible,
+        remaining: Math.max(0, all.length - visible),
+      };
+    },
+
+    nextVisible(current: number): number {
+      return current + pageSize;
+    },
+
+    reset(): number {
+      return pageSize;
+    },
+  };
+}

src/core/algorithms/queue.ts

@@ -0,0 +1,29 @@
+export interface AsyncQueue<T> {
+  enqueue(item: T): void;
+  drain(): void;
+  clear(): void;
+  size(): number;
+}
+
+export function createAsyncQueue<T>(
+  worker: (item: T) => Promise<void>,
+  concurrency = 1,
+): AsyncQueue<T> {
+  const queue: T[] = [];
+  let active = 0;
+
+  function next() {
+    while (active < concurrency && queue.length > 0) {
+      const item = queue.shift()!;
+      active++;
+      worker(item).finally(() => { active--; next(); });
+    }
+  }
+
+  return {
+    enqueue(item) { queue.push(item); next(); },
+    drain()       { next(); },
+    clear()       { queue.length = 0; },
+    size()        { return queue.length; },
+  };
+}

src/core/algorithms/search.ts

@@ -0,0 +1,33 @@
+export interface SearchResult<T> {
+  item:  T;
+  score: number;
+}
+
+export function searchItems<T>(
+  items: T[],
+  query: string,
+  getField: (item: T) => string,
+): T[] {
+  const q = query.trim().toLowerCase();
+  if (!q) return items;
+  return items.filter(item => getField(item).toLowerCase().includes(q));
+}
+
+export function searchWithScore<T>(
+  items: T[],
+  query: string,
+  getField: (item: T) => string,
+): SearchResult<T>[] {
+  const q = query.trim().toLowerCase();
+  if (!q) return items.map(item => ({ item, score: 0 }));
+
+  return items
+    .map(item => {
+      const field = getField(item).toLowerCase();
+      if (!field.includes(q)) return null;
+      const score = field === q ? 2 : field.startsWith(q) ? 1 : 0;
+      return { item, score };
+    })
+    .filter((r): r is SearchResult<T> => r !== null)
+    .sort((a, b) => b.score - a.score);
+}

src/core/algorithms/sort.ts

@@ -0,0 +1,32 @@
+export type SortDir = "asc" | "desc";
+
+export interface SortField<T> {
+  key: string;
+  comparator: (a: T, b: T, context?: Record<string, unknown>) => number;
+}
+
+export interface SortConfig<T> {
+  fields: SortField<T>[];
+  defaultField: string;
+  defaultDir: SortDir;
+}
+
+export interface Sorter<T> {
+  sort(items: T[], field: string, dir: SortDir, context?: Record<string, unknown>): T[];
+}
+
+export function createSorter<T>(config: SortConfig<T>): Sorter<T> {
+  const fieldMap = new Map(config.fields.map(f => [f.key, f]));
+
+  return {
+    sort(items, field, dir, context) {
+      const f = fieldMap.get(field) ?? fieldMap.get(config.defaultField);
+      if (!f) return [...items];
+      const d = dir ?? config.defaultDir;
+      return [...items].sort((a, b) => {
+        const cmp = f.comparator(a, b, context);
+        return d === "asc" ? cmp : -cmp;
+      });
+    },
+  };
+}

src/core/async/batchRequests.ts

@@ -0,0 +1,61 @@
+/**
+ * Runs an async task over every item in `items`, with at most `concurrency`
+ * tasks in-flight at once. Respects the provided AbortSignal — each worker
+ * exits early if the signal fires. Errors thrown by individual tasks are
+ * swallowed so one failure does not cancel the whole batch.
+ */
+export async function runConcurrent<T>(
+  items:       T[],
+  fn:          (item: T) => Promise<void>,
+  signal:      AbortSignal,
+  concurrency  = 6,
+): Promise<void> {
+  let i = 0;
+  async function worker() {
+    while (i < items.length) {
+      if (signal.aborted) return;
+      const item = items[i++];
+      await fn(item).catch(() => {});
+    }
+  }
+  await Promise.all(
+    Array.from({ length: Math.min(concurrency, items.length) }, worker),
+  );
+}
+
+/**
+ * Deduplicates in-flight async calls by key.
+ *
+ * Two call signatures are supported:
+ *
+ * 1. Direct call — supply a key and a zero-arg factory each time:
+ *      dedupeRequest("my-key", () => fetchSomething())
+ *    If a request with that key is already pending, the existing Promise is
+ *    returned and the factory is not called again.
+ *
+ * 2. Curried wrapper — supply a key-based fetcher once, get back a
+ *    single-arg function you can call repeatedly:
+ *      const get = dedupeRequest((key) => fetchSomething(key))
+ *      get("my-key")
+ */
+const _inflight = new Map<string, Promise<unknown>>();
+
+export function dedupeRequest<T>(key: string, factory: () => Promise<T>): Promise<T>;
+export function dedupeRequest<T>(fn: (key: string) => Promise<T>): (key: string) => Promise<T>;
+export function dedupeRequest<T>(
+  keyOrFn: string | ((key: string) => Promise<T>),
+  factory?: () => Promise<T>,
+): Promise<T> | ((key: string) => Promise<T>) {
+  // Curried wrapper form
+  if (typeof keyOrFn === 'function') {
+    const fn = keyOrFn;
+    return (key: string) => dedupeRequest(key, () => fn(key));
+  }
+
+  // Direct call form
+  const key = keyOrFn;
+  if (_inflight.has(key)) return _inflight.get(key) as Promise<T>;
+  const p = factory!().finally(() => _inflight.delete(key));
+  _inflight.set(key, p);
+  return p;
+}

src/core/async/createPaginatedQuery.ts

@@ -0,0 +1,25 @@
+export interface PaginatedQuery<T> {
+  fetchPage(page: number): Promise<T[]>;
+  reset(): void;
+  hasMore(): boolean;
+}
+
+export interface PaginatedQueryConfig<T> {
+  fetcher: (page: number) => Promise<{ items: T[]; hasNextPage: boolean }>;
+}
+
+export function createPaginatedQuery<T>(
+  config: PaginatedQueryConfig<T>,
+): PaginatedQuery<T> {
+  let _hasMore = true;
+
+  return {
+    async fetchPage(page) {
+      const { items, hasNextPage } = await config.fetcher(page);
+      _hasMore = hasNextPage;
+      return items;
+    },
+    reset()    { _hasMore = true; },
+    hasMore()  { return _hasMore; },
+  };
+}

src/core/async/fetchWithRetry.ts

@@ -0,0 +1,31 @@
+export interface RetryOptions {
+  maxAttempts?: number;
+  baseDelayMs?: number;
+  maxDelayMs?:  number;
+  shouldRetry?: (err: unknown, attempt: number) => boolean;
+}
+
+export async function fetchWithRetry<T>(
+  fetcher: () => Promise<T>,
+  options: RetryOptions = {},
+): Promise<T> {
+  const {
+    maxAttempts = 3,
+    baseDelayMs = 500,
+    maxDelayMs  = 10_000,
+    shouldRetry = () => true,
+  } = options;
+
+  let lastErr: unknown;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fetcher();
+    } catch (err) {
+      lastErr = err;
+      if (attempt === maxAttempts || !shouldRetry(err, attempt)) throw err;
+      const delay = Math.min(baseDelayMs * 2 ** (attempt - 1), maxDelayMs);
+      await new Promise(r => setTimeout(r, delay));
+    }
+  }
+  throw lastErr;
+}

src/core/async/index.ts

@@ -0,0 +1,3 @@
+export * from './fetchWithRetry';
+export * from './batchRequests';
+export * from './createPaginatedQuery';

src/core/auth.ts

@@ -0,0 +1,79 @@
+import { store, updateSettings } from "@store/state.svelte";
+
+export type AuthMode = "NONE" | "BASIC_AUTH" | "SIMPLE_LOGIN" | "UI_LOGIN";
+
+export const authSession = {
+  clearTokens() {},
+  hasSession(): boolean { return true; },
+};
+
+function getServerBase(): string {
+  const url = store.settings.serverUrl;
+  return typeof url === "string" && url.trim() ? url.replace(/\/$/, "") : "http://127.0.0.1:4567";
+}
+
+function basicHeader(user: string, pass: string): Record<string, string> {
+  return { Authorization: `Basic ${btoa(`${user}:${pass}`)}` };
+}
+
+export function fetchAuthenticated(url: string, init: RequestInit, signal?: AbortSignal): Promise<Response> {
+  const mode = store.settings.serverAuthMode ?? "NONE";
+  if (mode === "BASIC_AUTH") {
+    const user = store.settings.serverAuthUser?.trim() ?? "";
+    const pass = store.settings.serverAuthPass?.trim() ?? "";
+    return fetch(url, {
+      ...init, signal, credentials: "omit",
+      headers: { ...(init.headers as Record<string, string> ?? {}), ...(user && pass ? basicHeader(user, pass) : {}) },
+    });
+  }
+  return fetch(url, { ...init, signal, credentials: "omit" });
+}
+
+export async function loginBasic(user: string, pass: string): Promise<void> {
+  const res = await fetch(`${getServerBase()}/api/graphql`, {
+    method: "POST", credentials: "omit",
+    headers: { "Content-Type": "application/json", ...basicHeader(user, pass) },
+    body: JSON.stringify({ query: "{ __typename }" }),
+    signal: AbortSignal.timeout(5000),
+  });
+  if (!res.ok) throw new Error(`Authentication failed (${res.status})`);
+  updateSettings({ serverAuthMode: "BASIC_AUTH", serverAuthUser: user, serverAuthPass: pass });
+}
+
+export async function logout(): Promise<void> {
+  updateSettings({ serverAuthPass: "" });
+}
+
+export async function probeServer(): Promise<"ok" | "auth_required" | "unsupported_mode" | "unreachable"> {
+  const base = getServerBase();
+  const mode = store.settings.serverAuthMode ?? "NONE";
+  const s    = store.settings;
+  try {
+    const headers: Record<string, string> = { "Content-Type": "application/json" };
+    if (mode === "BASIC_AUTH") {
+      const user = s.serverAuthUser?.trim() ?? "";
+      const pass = s.serverAuthPass?.trim() ?? "";
+      if (user && pass) Object.assign(headers, basicHeader(user, pass));
+    }
+    const res = await fetch(`${base}/api/graphql`, {
+      method: "POST", credentials: "omit", headers,
+      body: JSON.stringify({ query: "{ __typename }" }),
+      signal: AbortSignal.timeout(2000),
+    });
+    if (res.ok) return "ok";
+    if (res.status === 401) {
+      const wwwAuth = res.headers.get("WWW-Authenticate") ?? "";
+      if (/basic/i.test(wwwAuth)) {
+        if (mode !== "BASIC_AUTH") updateSettings({ serverAuthMode: "BASIC_AUTH" });
+        return "auth_required";
+      }
+      if (/bearer/i.test(wwwAuth)) {
+        if (mode !== "UI_LOGIN") updateSettings({ serverAuthMode: "UI_LOGIN" });
+      } else if (mode === "NONE") {
+        updateSettings({ serverAuthMode: "SIMPLE_LOGIN" });
+      }
+      return "unsupported_mode";
+    }
+    return "unreachable";
+  } catch { return "unreachable"; }
+}

src/core/cache/imageCache.ts

@@ -0,0 +1,104 @@
+import { fetch as tauriFetch } from "@tauri-apps/plugin-http";
+import { store } from "@store/state.svelte";
+
+const cache    = new Map<string, string>();
+const inflight = new Map<string, Promise<string>>();
+const MAX_CONCURRENT = 6;
+let   active = 0;
+let   drainScheduled = false;
+
+interface QueueEntry {
+  url:      string;
+  priority: number;
+  resolve:  (v: string) => void;
+  reject:   (e: unknown) => void;
+}
+
+const queue: QueueEntry[] = [];
+
+function getAuthHeaders(): Record<string, string> {
+  const user = store.settings.serverAuthUser?.trim() ?? "";
+  const pass = store.settings.serverAuthPass?.trim() ?? "";
+  return user && pass ? { Authorization: `Basic ${btoa(`${user}:${pass}`)}` } : {};
+}
+
+async function doFetch(url: string): Promise<string> {
+  const res = await tauriFetch(url, { method: "GET", headers: getAuthHeaders() });
+  if (!res.ok) throw new Error(`${res.status}`);
+  const blobUrl = URL.createObjectURL(await res.blob());
+  cache.set(url, blobUrl);
+  return blobUrl;
+}
+
+function insertSorted(entry: QueueEntry) {
+  let lo = 0, hi = queue.length;
+  while (lo < hi) {
+    const mid = (lo + hi) >>> 1;
+    if (queue[mid].priority > entry.priority) lo = mid + 1;
+    else hi = mid;
+  }
+  queue.splice(lo, 0, entry);
+}
+
+function drain() {
+  drainScheduled = false;
+  while (active < MAX_CONCURRENT && queue.length > 0) {
+    const entry = queue.shift()!;
+    active++;
+    doFetch(entry.url)
+      .then(entry.resolve, entry.reject)
+      .finally(() => { inflight.delete(entry.url); active--; drain(); });
+  }
+}
+
+function scheduleDrain() {
+  if (drainScheduled) return;
+  drainScheduled = true;
+  requestAnimationFrame(drain);
+}
+
+function enqueue(url: string, priority: number): Promise<string> {
+  const promise = new Promise<string>((resolve, reject) => { insertSorted({ url, priority, resolve, reject }); });
+  inflight.set(url, promise);
+  scheduleDrain();
+  return promise;
+}
+
+export function getBlobUrl(url: string, priority = 0): Promise<string> {
+  if (!url) return Promise.resolve("");
+  const cached = cache.get(url);
+  if (cached) return Promise.resolve(cached);
+  const existing = inflight.get(url);
+  if (existing) {
+    const idx = queue.findIndex(e => e.url === url);
+    if (idx !== -1 && priority > queue[idx].priority) {
+      const [entry] = queue.splice(idx, 1);
+      entry.priority = priority;
+      insertSorted(entry);
+    }
+    return existing;
+  }
+  return enqueue(url, priority);
+}
+
+export function preloadBlobUrls(urls: string[], basePriority = 0): void {
+  urls.forEach((url, i) => {
+    if (!url || cache.has(url) || inflight.has(url)) return;
+    enqueue(url, basePriority - i);
+  });
+}
+
+export function revokeBlobUrl(url: string): void {
+  const blob = cache.get(url);
+  if (blob) { URL.revokeObjectURL(blob); cache.delete(url); }
+}
+
+export function deprioritizeQueue(): void {
+  for (const entry of queue) entry.priority = 0;
+  queue.sort((a, b) => b.priority - a.priority);
+}
+
+export function clearBlobCache(): void {
+  cache.forEach(blob => URL.revokeObjectURL(blob));
+  cache.clear();
+}

src/core/cache/index.ts

@@ -0,0 +1,3 @@
+export * from './memoryCache';
+export * from './imageCache';
+export * from './queryCache';

src/core/cache/queryCache.ts

@@ -0,0 +1,161 @@
+interface Entry<T> {
+  promise:   Promise<T>;
+  fetchedAt: number;
+}
+
+const store  = new Map<string, Entry<unknown>>();
+const subs   = new Map<string, Set<() => void>>();
+const groups = new Map<string, Set<string>>();
+
+export const DEFAULT_TTL_MS = 5 * 60 * 1_000;
+
+function notify(key: string) { subs.get(key)?.forEach(cb => cb()); }
+
+function registerGroups(key: string, group?: string | string[]) {
+  if (!group) return;
+  for (const tag of Array.isArray(group) ? group : [group]) {
+    if (!groups.has(tag)) groups.set(tag, new Set());
+    groups.get(tag)!.add(key);
+  }
+}
+
+export const cache = {
+  get<T>(key: string, fetcher: () => Promise<T>, ttl = DEFAULT_TTL_MS, group?: string | string[]): Promise<T> {
+    const existing = store.get(key) as Entry<T> | undefined;
+    if (existing && Date.now() - existing.fetchedAt < ttl) return existing.promise;
+    const promise = fetcher().catch(err => {
+      if (err?.name !== "AbortError") store.delete(key);
+      return Promise.reject(err);
+    }) as Promise<T>;
+    store.set(key, { promise, fetchedAt: Date.now() });
+    registerGroups(key, group);
+    promise.then(() => notify(key)).catch(() => {});
+    return promise;
+  },
+
+  set<T>(key: string, value: T, group?: string | string[]) {
+    store.set(key, { promise: Promise.resolve(value), fetchedAt: Date.now() });
+    registerGroups(key, group);
+    notify(key);
+  },
+
+  update<T>(key: string, fn: (prev: T) => T) {
+    const existing = store.get(key) as Entry<T> | undefined;
+    if (!existing) return;
+    const next = existing.promise.then(fn);
+    store.set(key, { promise: next, fetchedAt: Date.now() });
+    next.then(() => notify(key)).catch(() => {});
+  },
+
+  has(key: string): boolean { return store.has(key); },
+
+  ageOf(key: string): number | undefined {
+    const e = store.get(key);
+    return e ? Date.now() - e.fetchedAt : undefined;
+  },
+
+  clear(key: string) { store.delete(key); notify(key); },
+
+  clearGroup(tag: string) {
+    const keys = groups.get(tag);
+    if (!keys) return;
+    for (const key of keys) { store.delete(key); notify(key); }
+    groups.delete(tag);
+  },
+
+  clearAll() {
+    const allKeys = [...store.keys()];
+    store.clear(); groups.clear();
+    allKeys.forEach(notify);
+  },
+
+  subscribe(key: string, cb: () => void): () => void {
+    if (!subs.has(key)) subs.set(key, new Set());
+    subs.get(key)!.add(cb);
+    return () => subs.get(key)?.delete(cb);
+  },
+};
+
+export const CACHE_GROUPS = {
+  LIBRARY: "g:library",
+  SOURCES: "g:sources",
+} as const;
+
+export const CACHE_KEYS = {
+  LIBRARY:    "library",
+  ALL_MANGA:  "all_manga_unfiltered",
+  CATEGORIES: "categories",
+  SEARCH:     "search_all_manga",
+  SOURCES:    "sources",
+  POPULAR:    "popular",
+  GENRE:    (genre: string) => `genre:${genre}`,
+  MANGA:    (id: number)    => `manga:${id}`,
+  CHAPTERS: (id: number)    => `chapters:${id}`,
+
+  sourceMangaPages(sourceId: string, type: "POPULAR" | "LATEST" | "SEARCH", query?: string | string[]): string {
+    const q = Array.isArray(query) ? [...query].sort().join("+") : (query ?? "");
+    return `pages:${sourceId}:${type}:${q}`;
+  },
+
+  sourceMangaPage(sourceId: string, type: "POPULAR" | "LATEST" | "SEARCH", page: number, query?: string | string[]): string {
+    const q = Array.isArray(query) ? [...query].sort().join("+") : (query ?? "");
+    return `page:${sourceId}:${type}:${page}:${q}`;
+  },
+} as const;
+
+const inflight = new Map<string, Promise<unknown>>();
+
+export function deduped<T>(key: string, fetcher: () => Promise<T>): Promise<T> {
+  if (inflight.has(key)) return inflight.get(key) as Promise<T>;
+  const p = fetcher().finally(() => inflight.delete(key));
+  inflight.set(key, p);
+  return p;
+}
+
+const _pageSets = new Map<string, Set<number>>();
+
+export interface PageSet {
+  add(page: number): void;
+  pages(): Set<number>;
+  next(): number;
+  clear(): void;
+}
+
+export function getPageSet(sourceId: string, type: "POPULAR" | "LATEST" | "SEARCH", query?: string | string[]): PageSet {
+  const key = CACHE_KEYS.sourceMangaPages(sourceId, type, query);
+  return {
+    add(page)  { if (!_pageSets.has(key)) _pageSets.set(key, new Set()); _pageSets.get(key)!.add(page); },
+    pages()    { return new Set(_pageSets.get(key) ?? []); },
+    next()     { const s = _pageSets.get(key); return s?.size ? Math.max(...s) + 1 : 1; },
+    clear()    { _pageSets.delete(key); },
+  };
+}
+
+const FRECENCY_KEY         = "moku-source-frecency";
+const MAX_FRECENCY_SOURCES = 4;
+type FrecencyMap = Record<string, number>;
+
+function loadFrecency(): FrecencyMap {
+  try { const r = localStorage.getItem(FRECENCY_KEY); return r ? JSON.parse(r) : {}; }
+  catch { return {}; }
+}
+
+function saveFrecency(map: FrecencyMap) {
+  try { localStorage.setItem(FRECENCY_KEY, JSON.stringify(map)); } catch {}
+}
+
+export function recordSourceAccess(sourceId: string) {
+  if (!sourceId || sourceId === "0") return;
+  const map = loadFrecency();
+  map[sourceId] = (map[sourceId] ?? 0) + 1;
+  saveFrecency(map);
+}
+
+export function getTopSources<T extends { id: string }>(sources: T[]): T[] {
+  const map = loadFrecency();
+  const withScore = sources.map(s => ({ s, score: map[s.id] ?? 0 }));
+  if (withScore.some(x => x.score > 0)) {
+    return withScore.sort((a, b) => b.score - a.score).slice(0, MAX_FRECENCY_SOURCES).map(x => x.s);
+  }
+  return sources.slice(0, MAX_FRECENCY_SOURCES);
+}

src/core/keybinds/defaultBinds.ts

@@ -0,0 +1,47 @@
+export interface Keybinds {
+  turnPageRight:          string;
+  turnPageLeft:           string;
+  firstPage:              string;
+  lastPage:               string;
+  turnChapterRight:       string;
+  turnChapterLeft:        string;
+  exitReader:             string;
+  toggleReadingDirection: string;
+  togglePageStyle:        string;
+  toggleFullscreen:       string;
+  openSettings:           string;
+  toggleBookmark:         string;
+  toggleMarker:           string;
+}
+
+export const DEFAULT_KEYBINDS: Keybinds = {
+  turnPageRight:          "ArrowRight",
+  turnPageLeft:           "ArrowLeft",
+  firstPage:              "ctrl+ArrowLeft",
+  lastPage:               "ctrl+ArrowRight",
+  turnChapterRight:       "]",
+  turnChapterLeft:        "[",
+  exitReader:             "Backspace",
+  toggleReadingDirection: "d",
+  togglePageStyle:        "q",
+  toggleFullscreen:       "f",
+  openSettings:           "o",
+  toggleBookmark:         "m",
+  toggleMarker:           "n",
+};
+
+export const KEYBIND_LABELS: Record<keyof Keybinds, string> = {
+  turnPageRight:          "Turn page right (→)",
+  turnPageLeft:           "Turn page left (←)",
+  firstPage:              "Jump to first page",
+  lastPage:               "Jump to last page",
+  turnChapterRight:       "Turn chapter right (→)",
+  turnChapterLeft:        "Turn chapter left (←)",
+  exitReader:             "Exit reader",
+  toggleReadingDirection: "Toggle reading direction",
+  togglePageStyle:        "Toggle page style",
+  toggleFullscreen:       "Toggle fullscreen",
+  openSettings:           "Open settings",
+  toggleBookmark:         "Toggle bookmark",
+  toggleMarker:           "Toggle marker",
+};

src/core/keybinds/index.ts

@@ -0,0 +1,3 @@
+export { eventToKeybind, matchesKeybind, toggleFullscreen } from "./keybindEngine";
+export { DEFAULT_KEYBINDS, KEYBIND_LABELS } from "./defaultBinds";
+export type { Keybinds } from "./defaultBinds";

src/core/keybinds/keybindEngine.ts

@@ -0,0 +1,25 @@
+import { getCurrentWindow } from "@tauri-apps/api/window";
+
+export function eventToKeybind(e: KeyboardEvent): string {
+  if (["Control", "Alt", "Shift", "Meta"].includes(e.key)) return "";
+  const parts: string[] = [];
+  if (e.ctrlKey)  parts.push("ctrl");
+  if (e.altKey)   parts.push("alt");
+  if (e.shiftKey) parts.push("shift");
+  if (e.metaKey)  parts.push("meta");
+  parts.push(e.key);
+  return parts.join("+");
+}
+
+export function matchesKeybind(e: KeyboardEvent, bind: string): boolean {
+  return eventToKeybind(e) === bind;
+}
+
+export async function toggleFullscreen(): Promise<void> {
+  try {
+    const win = getCurrentWindow();
+    await win.setFullscreen(!await win.isFullscreen());
+  } catch (e) {
+    console.warn("toggleFullscreen unavailable:", e);
+  }
+}

src/core/theme.ts

@@ -0,0 +1,36 @@
+import { store } from "@store/state.svelte";
+
+let themeStyleEl: HTMLStyleElement | null = null;
+
+export function applyTheme() {
+  const themeId  = store.settings.theme ?? "dark";
+  const isCustom = themeId.startsWith("custom:");
+
+  if (!isCustom) {
+    themeStyleEl?.remove();
+    themeStyleEl = null;
+    document.documentElement.setAttribute("data-theme", themeId);
+    return;
+  }
+
+  const custom = store.settings.customThemes?.find(t => t.id === themeId);
+  if (!custom) {
+    themeStyleEl?.remove();
+    themeStyleEl = null;
+    document.documentElement.setAttribute("data-theme", "dark");
+    return;
+  }
+
+  const vars = Object.entries(custom.tokens)
+    .map(([k, v]) => `  --${k}: ${v};`)
+    .join("\n");
+  const css = `[data-theme="custom"] {\n${vars}\n}`;
+
+  if (!themeStyleEl) {
+    themeStyleEl = document.createElement("style");
+    themeStyleEl.id = "moku-custom-theme";
+    document.head.appendChild(themeStyleEl);
+  }
+  themeStyleEl.textContent = css;
+  document.documentElement.setAttribute("data-theme", "custom");
+}

src/core/ui/idle.ts

@@ -0,0 +1,23 @@
+import { store } from "@store/state.svelte";
+
+const IDLE_EVENTS = ["mousemove", "mousedown", "keydown", "touchstart", "wheel"] as const;
+
+export function mountIdleDetection(onIdle: () => void, onActive: () => void): () => void {
+  let timer: ReturnType<typeof setTimeout> | null = null;
+
+  function reset() {
+    if (timer) clearTimeout(timer);
+    const ms = (store.settings.idleTimeoutMin ?? 5) * 60 * 1000;
+    if (ms === 0) return;
+    timer = setTimeout(onIdle, ms);
+    onActive();
+  }
+
+  IDLE_EVENTS.forEach(e => window.addEventListener(e, reset, { passive: true }));
+  reset();
+
+  return () => {
+    if (timer) clearTimeout(timer);
+    IDLE_EVENTS.forEach(e => window.removeEventListener(e, reset));
+  };
+}

src/core/ui/index.ts

@@ -0,0 +1,2 @@
+export * from './idle';
+export * from './zoom';

src/core/ui/zoom.ts

@@ -0,0 +1,40 @@
+import { store } from "@store/state.svelte";
+
+let _appliedZoom: number = -1;
+let _vhRafId: number | null = null;
+
+export function applyZoom() {
+  const uiZoom = store.settings.uiZoom ?? 1.0;
+  if (uiZoom === _appliedZoom) return;
+  _appliedZoom = uiZoom;
+
+  document.documentElement.style.setProperty("--ui-zoom", String(uiZoom));
+  document.documentElement.style.setProperty("--ui-scale", String(uiZoom));
+  document.documentElement.style.zoom = `${uiZoom * 100}%`;
+
+  if (_vhRafId !== null) cancelAnimationFrame(_vhRafId);
+  _vhRafId = requestAnimationFrame(() => {
+    _vhRafId = null;
+    document.documentElement.style.setProperty("--visual-vh", `${window.innerHeight / uiZoom}px`);
+  });
+}
+
+export function handleZoomKey(e: KeyboardEvent) {
+  if (!e.ctrlKey) return;
+  const current = store.settings.uiZoom ?? 1.0;
+  if (e.key === "=" || e.key === "+") {
+    e.preventDefault();
+    store.settings.uiZoom = Math.min(2.0, Math.round((current + 0.1) * 10) / 10);
+  } else if (e.key === "-") {
+    e.preventDefault();
+    store.settings.uiZoom = Math.max(0.5, Math.round((current - 0.1) * 10) / 10);
+  } else if (e.key === "0") {
+    e.preventDefault();
+    store.settings.uiZoom = 1.0;
+  }
+}
+
+export function mountZoomKey(): () => void {
+  window.addEventListener("keydown", handleZoomKey);
+  return () => window.removeEventListener("keydown", handleZoomKey);
+}

src/core/updater.ts

@@ -0,0 +1,40 @@
+import { invoke } from "@tauri-apps/api/core";
+import { getVersion } from "@tauri-apps/api/app";
+import { addToast } from "@store/state.svelte";
+
+function parse(tag: string): number[] {
+  return tag.replace(/^v/, "").split(".").map(Number);
+}
+
+function compare(a: number[], b: number[]): number {
+  for (let i = 0; i < 3; i++) {
+    if ((a[i] ?? 0) !== (b[i] ?? 0)) return (b[i] ?? 0) - (a[i] ?? 0);
+  }
+  return 0;
+}
+
+export async function checkForUpdateSilently(): Promise<void> {
+  try {
+    const [currentVersion, releases] = await Promise.all([
+      getVersion(),
+      invoke<Array<{ tag_name: string; html_url: string }>>("list_releases"),
+    ]);
+
+    const valid = releases.filter(r => typeof r.tag_name === "string" && r.tag_name.trim());
+    if (!valid.length) return;
+
+    const latestTag = valid
+      .map(r => r.tag_name)
+      .sort((a, b) => compare(parse(a), parse(b)))[0]
+      .replace(/^v/, "");
+
+    if (compare(parse(latestTag), parse(currentVersion)) < 0) {
+      addToast({
+        kind:     "info",
+        title:    `Update available — v${latestTag}`,
+        body:     "Open Settings → About to install.",
+        duration: 8000,
+      });
+    }
+  } catch {}
+}

src/core/util.ts

@@ -0,0 +1,241 @@
+import type { Manga, Source } from "@types";
+import type { Settings } from "@types";
+
+// ── Class utility ─────────────────────────────────────────────────────────────
+
+export { clsx as cn } from "clsx";
+
+// ── Time / formatting ─────────────────────────────────────────────────────────
+
+export function timeAgo(ts: number): string {
+  const diff = Date.now() - ts, m = Math.floor(diff / 60000);
+  if (m < 1)  return "Just now";
+  if (m < 60) return `${m}m ago`;
+  const h = Math.floor(m / 60);
+  if (h < 24) return `${h}h ago`;
+  const d = Math.floor(h / 24);
+  if (d < 7)  return `${d}d ago`;
+  return new Date(ts).toLocaleDateString("en-US", { month: "short", day: "numeric" });
+}
+
+export function dayLabel(ts: number): string {
+  const d = new Date(ts), now = new Date();
+  if (d.toDateString() === now.toDateString()) return "Today";
+  const yest = new Date(now); yest.setDate(now.getDate() - 1);
+  if (d.toDateString() === yest.toDateString()) return "Yesterday";
+  return d.toLocaleDateString("en-US", { weekday: "long", month: "long", day: "numeric" });
+}
+
+export function formatReadTime(m: number): string {
+  if (m < 1)  return "< 1 min";
+  if (m < 60) return `${m} min`;
+  const h = Math.floor(m / 60), r = m % 60;
+  return r === 0 ? `${h}h` : `${h}h ${r}m`;
+}
+
+// ── NSFW filtering ────────────────────────────────────────────────────────────
+
+/**
+ * Default genre substrings used when no user-configured list is available.
+ * Stored as settings.nsfwFilteredTags; editable in Settings > Content.
+ */
+export const DEFAULT_NSFW_TAGS = [
+  "adult",
+  "mature",
+  "hentai",
+  "ecchi",
+  "erotic",       // catches "erotica", "erotic content", "erotic manga"
+  "pornograph",   // catches "pornographic", "pornography"
+  "18+",
+  "smut",
+  "lemon",
+  "explicit",
+  "sexual violence",
+];
+
+/**
+ * Returns true if the manga's genre list contains any of the given substrings.
+ * Falls back to DEFAULT_NSFW_TAGS if no tag list is provided.
+ */
+export function isNsfwManga(
+  manga: { genre?: string[] | null },
+  tags: string[] = DEFAULT_NSFW_TAGS,
+): boolean {
+  return (manga.genre ?? []).some(g =>
+    tags.some(sub => g.toLowerCase().trim().includes(sub))
+  );
+}
+
+/**
+ * Single authoritative NSFW gate used by all views.
+ * Returns true when the manga should be HIDDEN. Priority order:
+ *   1. Source in blockedSourceIds → always hidden, even when showNsfw is on.
+ *   2. showNsfw globally enabled → only blocked sources are hidden.
+ *   3. Source in allowedSourceIds → skip isNsfw flag, but genre tags still apply.
+ *   4. source.isNsfw flag → hidden.
+ *   5. Genre tag match → hidden.
+ *
+ * Usage: items.filter(m => !shouldHideNsfw(m, settings))
+ */
+export function shouldHideNsfw(
+  manga: Pick<Manga, "genre" | "source">,
+  settings: Pick<Settings, "showNsfw" | "nsfwFilteredTags" | "nsfwAllowedSourceIds" | "nsfwBlockedSourceIds">,
+): boolean {
+  const srcId = manga.source?.id;
+
+  if (srcId && settings.nsfwBlockedSourceIds.includes(srcId)) return true;
+  if (settings.showNsfw) return false;
+
+  const sourceAllowed = !!(srcId && settings.nsfwAllowedSourceIds.includes(srcId));
+  if (!sourceAllowed && manga.source?.isNsfw) return true;
+
+  return isNsfwManga(manga, settings.nsfwFilteredTags);
+}
+
+/**
+ * Gate for Source objects — parallel to shouldHideNsfw for manga.
+ * Usage: sources.filter(s => !shouldHideSource(s, settings))
+ */
+export function shouldHideSource(
+  source: Pick<Source, "id" | "isNsfw">,
+  settings: Pick<Settings, "showNsfw" | "nsfwAllowedSourceIds" | "nsfwBlockedSourceIds">,
+): boolean {
+  if (settings.nsfwBlockedSourceIds.includes(source.id)) return true;
+  if (settings.nsfwAllowedSourceIds.includes(source.id)) return false;
+  return !settings.showNsfw && source.isNsfw;
+}
+
+// ── Source deduplication ──────────────────────────────────────────────────────
+
+/**
+ * Deduplicates sources by name. When multiple sources share a name,
+ * the preferred language wins; otherwise falls back to alphabetical by lang.
+ * The local source (id "0") is always excluded.
+ */
+export function dedupeSources(sources: Source[], preferredLang: string): Source[] {
+  const byName = new Map<string, Source[]>();
+  for (const src of sources) {
+    if (src.id === "0") continue;
+    if (!byName.has(src.name)) byName.set(src.name, []);
+    byName.get(src.name)!.push(src);
+  }
+  const picked: Source[] = [];
+  for (const group of byName.values()) {
+    const preferred = group.find(s => s.lang === preferredLang);
+    picked.push(preferred ?? group.sort((a, b) => a.lang.localeCompare(b.lang))[0]);
+  }
+  return picked;
+}
+
+// ── Manga deduplication ───────────────────────────────────────────────────────
+
+/** Strips punctuation, articles, and source suffixes for fuzzy title matching. */
+export function normalizeTitle(title: string): string {
+  return title
+    .toLowerCase()
+    .replace(/\(official\)|\(web comic\)|\(webtoon\)|\(manhwa\)|\(manhua\)/gi, "")
+    .replace(/[^a-z0-9\s]/g, " ")
+    .replace(/^(the|a|an)\s+/, "")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+/** Strips all non-alphanumeric chars and collapses whitespace. */
+function norm(s: string): string {
+  return s.toLowerCase().replace(/[^a-z0-9]/g, " ").replace(/\s+/g, " ").trim();
+}
+
+/**
+ * First 200 normalized chars of a description — reliable cross-source fingerprint.
+ * Returns null if too short (< 60 chars) to be a trustworthy signal.
+ */
+function descFingerprint(desc: string | null | undefined): string | null {
+  if (!desc) return null;
+  const n = norm(desc);
+  return n.length >= 60 ? n.slice(0, 200) : null;
+}
+
+/**
+ * Normalized author + artist concatenation for tie-breaking.
+ * Returns null if no author info available.
+ */
+function authorFingerprint(author?: string | null, artist?: string | null): string | null {
+  const parts = [author, artist].filter(Boolean).map(s => norm(s!));
+  return parts.length ? parts.sort().join("|") : null;
+}
+
+/**
+ * Deduplicates manga across sources using title, description, and author signals,
+ * plus explicit user-defined links (settings.mangaLinks).
+ *
+ * When two entries match, the better one is kept:
+ *   - Library membership wins over non-library.
+ *   - Otherwise higher downloadCount wins.
+ *   - Otherwise first occurrence wins.
+ */
+export function dedupeMangaByTitle<T extends {
+  id:             number;
+  title:          string;
+  description?:   string | null;
+  author?:        string | null;
+  artist?:        string | null;
+  inLibrary?:     boolean;
+  downloadCount?: number;
+}>(items: T[], links: Record<number, number[]> = {}): T[] {
+  const byTitle      = new Map<string, number>();
+  const byDesc       = new Map<string, number>();
+  const byAuthorDesc = new Map<string, number>();
+  const byId         = new Map<number, number>();
+  const out: T[]     = [];
+
+  for (const m of items) {
+    const tk = normalizeTitle(m.title);
+    const dk = descFingerprint(m.description);
+    const ak = (dk && m.author) ? `${authorFingerprint(m.author, m.artist)}||${dk}` : null;
+
+    const linkedIds   = links[m.id] ?? [];
+    const linkedIdx   = linkedIds.map(lid => byId.get(lid)).find(i => i !== undefined);
+    const existingIdx =
+      linkedIdx ??
+      byTitle.get(tk) ??
+      (dk ? byDesc.get(dk)       : undefined) ??
+      (ak ? byAuthorDesc.get(ak) : undefined);
+
+    if (existingIdx !== undefined) {
+      const existing = out[existingIdx];
+      const mBetter  =
+        (m.inLibrary && !existing.inLibrary) ||
+        (!existing.inLibrary && (m.downloadCount ?? 0) > (existing.downloadCount ?? 0));
+
+      if (mBetter) {
+        out[existingIdx] = m;
+        byTitle.set(tk, existingIdx);
+        byId.set(m.id, existingIdx);
+        if (dk) byDesc.set(dk, existingIdx);
+        if (ak) byAuthorDesc.set(ak, existingIdx);
+      }
+      continue;
+    }
+
+    const idx = out.length;
+    out.push(m);
+    byTitle.set(tk, idx);
+    byId.set(m.id, idx);
+    if (dk) byDesc.set(dk, idx);
+    if (ak) byAuthorDesc.set(ak, idx);
+  }
+
+  return out;
+}
+
+/**
+ * Lossless deduplication by ID only. Preserves first occurrence.
+ */
+export function dedupeMangaById<T extends { id: number }>(items: T[]): T[] {
+  const seen = new Set<number>();
+  const out: T[] = [];
+  for (const m of items) {
+    if (!seen.has(m.id)) { seen.add(m.id); out.push(m); }
+  }
+  return out;
+}