@duyquangnvx/webnovel-downloader 0.3.0 → 0.4.0

package/dist/index.cjs

@@ -448,7 +448,8 @@ __export(index_exports, {
   builtinAdapters: () => builtinAdapters,
   createDownloader: () => createDownloader,
   createLogger: () => createLogger,
-  downloader: () => downloader
+  downloader: () => downloader,
+  parseNovelHeader: () => parseNovelHeader
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -881,6 +882,31 @@ function clamp(n, lo, hi) {
 // src/http/index.ts
 init_cookie_jar();
 
+// src/http/stack-builder.ts
+var HttpStack = class _HttpStack {
+  #client;
+  constructor(client) {
+    this.#client = client;
+  }
+  static from(leaf) {
+    return new _HttpStack(leaf);
+  }
+  rotateUserAgent(uas, defaultHeaders, cookieJar) {
+    return new _HttpStack(
+      new UserAgentRotatingHttpClient(this.#client, uas, defaultHeaders, cookieJar)
+    );
+  }
+  rateLimit(limiter, onEvent) {
+    return new _HttpStack(new RateLimitedHttpClient(this.#client, limiter, onEvent));
+  }
+  retry(opts, logger, limiter, onEvent) {
+    return new _HttpStack(new RetryingHttpClient(this.#client, opts, logger, limiter, onEvent));
+  }
+  build() {
+    return this.#client;
+  }
+};
+
 // src/http/tiered.ts
 init_cf_challenge();
 var FALLBACK_UA = DEFAULT_UA_POOL[0] ?? "Mozilla/5.0";
@@ -942,21 +968,8 @@ function buildHttpClient(opts = {}) {
   const logger = opts.logger ?? silentLogger;
   const cookieJar = opts.cookieJar ?? new CookieJar();
   const leaf = opts.undiciOverride ?? new UndiciHttpClient({ logger });
-  const ua = new UserAgentRotatingHttpClient(
-    leaf,
-    opts.userAgents ?? new UserAgents(),
-    opts.defaultHeaders,
-    cookieJar
-  );
   const limiter = opts.rateLimiter ?? new RateLimiter(opts.rateLimit ?? DEFAULT_RATE_LIMIT);
-  const limited = new RateLimitedHttpClient(ua, limiter, opts.onEvent);
-  const httpBranch = new RetryingHttpClient(
-    limited,
-    normalizeRetry(opts.retry),
-    logger,
-    limiter,
-    opts.onEvent
-  );
+  const httpBranch = HttpStack.from(leaf).rotateUserAgent(opts.userAgents ?? new UserAgents(), opts.defaultHeaders, cookieJar).rateLimit(limiter, opts.onEvent).retry(normalizeRetry(opts.retry), logger, limiter, opts.onEvent).build();
   const { mode } = normalizeTransport(opts.transport);
   if (mode === "http-only") {
     return httpBranch;
@@ -1411,7 +1424,6 @@ function toResponse(entry) {
 
 // src/core/download-run.ts
 var import_p_queue = __toESM(require("p-queue"), 1);
-var import_node_path6 = require("path");
 
 // src/core/debouncer.ts
 var Debouncer = class {
@@ -1474,30 +1486,47 @@ init_primitives();
 
 // src/pipeline/fetch-toc.ts
 init_errors();
+
+// src/pipeline/walk-toc.ts
+init_errors();
 var TOC_PROGRESS_EMIT_EVERY = 50;
-async function fetchTocStage(adapter, url, ctx, bus, onRef, range) {
+async function walkToc(source, opts) {
+  const from = opts.range?.from;
+  const to = opts.range?.to;
   let count = 0;
-  const from = range?.from;
-  const to = range?.to;
-  if (ctx.signal.aborted) throw new CancelledError({ cause: ctx.signal.reason });
-  for await (const raw of adapter.fetchChapterList(url, ctx)) {
-    if (ctx.signal.aborted) throw new CancelledError({ cause: ctx.signal.reason });
-    const parsed = ChapterRefSchema.safeParse(raw);
-    if (!parsed.success) {
-      throw new ParseError(`Invalid ChapterRef from adapter`, { cause: parsed.error, url });
-    }
-    const ref = parsed.data;
+  if (opts.signal.aborted) throw new CancelledError({ cause: opts.signal.reason });
+  for await (const ref of source) {
+    if (opts.signal.aborted) throw new CancelledError({ cause: opts.signal.reason });
     if (to !== void 0 && ref.index > to) break;
     if (from !== void 0 && ref.index < from) continue;
-    await onRef(ref);
+    await opts.onRef(ref);
     count++;
-    if (count % TOC_PROGRESS_EMIT_EVERY === 0) bus.emit({ type: "toc:progress", discovered: count });
+    if (count % TOC_PROGRESS_EMIT_EVERY === 0) opts.bus.emit({ type: "toc:progress", discovered: count });
   }
-  bus.emit({ type: "toc:progress", discovered: count });
-  bus.emit({ type: "toc:complete", total: count });
+  opts.bus.emit({ type: "toc:progress", discovered: count });
+  opts.bus.emit({ type: "toc:complete", total: count });
   return count;
 }
 
+// src/pipeline/fetch-toc.ts
+async function fetchTocStage(adapter, url, ctx, bus, onRef, range) {
+  async function* validated() {
+    for await (const raw of adapter.fetchChapterList(url, ctx)) {
+      const parsed = ChapterRefSchema.safeParse(raw);
+      if (!parsed.success) {
+        throw new ParseError(`Invalid ChapterRef from adapter`, { cause: parsed.error, url });
+      }
+      yield parsed.data;
+    }
+  }
+  return walkToc(validated(), {
+    ...range !== void 0 ? { range } : {},
+    bus,
+    signal: ctx.signal,
+    onRef
+  });
+}
+
 // src/pipeline/fetch-chapters.ts
 init_errors();
 async function fetchChapterTask(adapter, ref, ctx, bus) {
@@ -1525,130 +1554,15 @@ function assembleNovelData(metadata, results) {
 // src/core/download-run.ts
 init_errors();
 
-// src/storage/resume-store.ts
-var import_promises3 = require("fs/promises");
+// src/storage/resume-token.ts
 var import_node_path3 = require("path");
-init_errors();
-
-// src/storage/resume-state.ts
 var import_zod4 = require("zod");
-init_primitives();
-var ResumeFailureRecordSchema = import_zod4.z.object({
-  index: ChapterIndexSchema,
-  lastError: import_zod4.z.object({ code: import_zod4.z.string(), message: import_zod4.z.string() }).readonly()
-}).readonly();
-var ResumeStateSchema = import_zod4.z.object({
-  schemaVersion: import_zod4.z.literal(1),
-  url: UrlSchema,
-  adapterId: AdapterIdSchema,
-  metadata: NovelMetadataSchema.nullable(),
-  toc: import_zod4.z.array(ChapterRefSchema).readonly().nullable(),
-  completed: import_zod4.z.array(ChapterIndexSchema).readonly(),
-  failed: import_zod4.z.array(ResumeFailureRecordSchema).readonly(),
-  startedAt: IsoDateSchema,
-  updatedAt: IsoDateSchema
-}).readonly();
-
-// src/storage/resume-store.ts
-var FilesystemResumeStore = class {
-  async load(path) {
-    let text;
-    try {
-      text = await (0, import_promises3.readFile)(path, "utf8");
-    } catch (err) {
-      if (isEnoent(err)) return null;
-      throw err;
-    }
-    let raw;
-    try {
-      raw = JSON.parse(text);
-    } catch (cause) {
-      throw new ParseError("Resume state file is corrupt; delete it to start over", { cause, path });
-    }
-    const parsed = ResumeStateSchema.safeParse(raw);
-    if (!parsed.success) {
-      throw new ParseError("Resume state file is corrupt; delete it to start over", {
-        cause: parsed.error,
-        path
-      });
-    }
-    return parsed.data;
-  }
-  async save(path, state) {
-    await atomicWriteJson(path, state);
-  }
-  async delete(path) {
-    try {
-      await (0, import_promises3.unlink)(path);
-    } catch (err) {
-      if (!isEnoent(err)) throw err;
-    }
-  }
-};
-
-// src/storage/chapter-store.ts
-var import_promises4 = require("fs/promises");
-var import_node_path4 = require("path");
-var FilesystemChapterStore = class {
-  #logger;
-  #dir;
-  constructor(dir, opts = {}) {
-    this.#dir = (0, import_node_path4.resolve)(dir);
-    this.#logger = opts.logger ?? silentLogger;
-  }
-  async save(chapter) {
-    await atomicWriteJson((0, import_node_path4.join)(this.#dir, `${Number(chapter.index)}.json`), chapter);
-  }
-  async loadAll() {
-    let entries;
-    try {
-      entries = await (0, import_promises4.readdir)(this.#dir);
-    } catch (err) {
-      if (isEnoent(err)) return [];
-      throw err;
-    }
-    const chapters = [];
-    for (const name of entries) {
-      if (!/^\d+\.json$/.test(name)) continue;
-      const path = (0, import_node_path4.join)(this.#dir, name);
-      let text;
-      try {
-        text = await (0, import_promises4.readFile)(path, "utf8");
-      } catch (err) {
-        this.#logger.warn({ path, err }, "chapter-store: failed to read file, skipping");
-        continue;
-      }
-      let raw;
-      try {
-        raw = JSON.parse(text);
-      } catch (err) {
-        this.#logger.warn({ path, err }, "chapter-store: invalid JSON, skipping");
-        continue;
-      }
-      const parsed = ChapterSchema.safeParse(raw);
-      if (!parsed.success) {
-        this.#logger.warn(
-          { path, issues: parsed.error.issues },
-          "chapter-store: schema mismatch, skipping"
-        );
-        continue;
-      }
-      chapters.push(parsed.data);
-    }
-    chapters.sort((a, b) => Number(a.index) - Number(b.index));
-    return chapters;
-  }
-};
-
-// src/storage/resume-token.ts
-var import_node_path5 = require("path");
-var import_zod5 = require("zod");
 init_errors();
 init_primitives();
-var TokenPayloadSchema = import_zod5.z.object({
-  v: import_zod5.z.literal(1),
-  stateFile: import_zod5.z.string().min(1),
-  urlHash: import_zod5.z.string().min(1)
+var TokenPayloadSchema = import_zod4.z.object({
+  v: import_zod4.z.literal(1),
+  stateFile: import_zod4.z.string().min(1),
+  urlHash: import_zod4.z.string().min(1)
 });
 function encodeResumeToken(stateFile, url) {
   const payload = { v: 1, stateFile, urlHash: sha1(url) };
@@ -1669,9 +1583,9 @@ function decodeResumeToken(token) {
   return { stateFile: parsed.data.stateFile, urlHash: parsed.data.urlHash };
 }
 function assertWithinCacheDir(stateFile) {
-  const root = (0, import_node_path5.resolve)((0, import_node_path5.join)(userCacheDir(), "webnovel-downloader"));
-  const rel = (0, import_node_path5.relative)(root, (0, import_node_path5.resolve)(stateFile));
-  if (rel === "" || rel.startsWith("..") || (0, import_node_path5.isAbsolute)(rel)) {
+  const root = (0, import_node_path3.resolve)((0, import_node_path3.join)(userCacheDir(), "webnovel-downloader"));
+  const rel = (0, import_node_path3.relative)(root, (0, import_node_path3.resolve)(stateFile));
+  if (rel === "" || rel.startsWith("..") || (0, import_node_path3.isAbsolute)(rel)) {
     throw new ParseError("Resume token state path escapes the cache directory");
   }
 }
@@ -1687,25 +1601,6 @@ function verifyResumeToken(token, url) {
 // src/core/download-run.ts
 var QUEUE_BACKPRESSURE_RATIO = 4;
 var STATE_PERSIST_DEBOUNCE_MS = 500;
-var TOC_PROGRESS_EMIT_EVERY2 = 50;
-function resolveResumeConfig(opt, url, logger) {
-  if (opt === void 0) return null;
-  const make = (stateFile) => ({
-    stateFile,
-    store: new FilesystemResumeStore(),
-    chapterStore: new FilesystemChapterStore(`${stateFile}.chapters`, { logger })
-  });
-  if (opt === true) {
-    const stateFile = (0, import_node_path6.join)(userCacheDir(), "webnovel-downloader", "state", `${sha1(url)}.json`);
-    return make(stateFile);
-  }
-  if ("stateFile" in opt) return make(opt.stateFile);
-  if ("token" in opt) {
-    const { stateFile } = verifyResumeToken(opt.token, url);
-    return make(stateFile);
-  }
-  return null;
-}
 function freshState(url, adapterId) {
   const now = nowIso();
   return {
@@ -1727,14 +1622,13 @@ var DownloadRun = class {
   #adapter;
   #validated;
   #normalizedRange;
-  #resumeCfg;
+  #resumeStorage;
   #concurrency;
   #signal;
   #ctx;
   #bus;
   #logger;
   #state = null;
-  #metadata;
   #successes = [];
   #failures = [];
   #completedSet = /* @__PURE__ */ new Set();
@@ -1748,7 +1642,7 @@ var DownloadRun = class {
     this.#adapter = args.adapter;
     this.#validated = args.validated;
     this.#normalizedRange = args.normalizedRange;
-    this.#resumeCfg = args.resumeCfg;
+    this.#resumeStorage = args.resumeStorage;
     this.#concurrency = args.concurrency;
     this.#signal = args.signal;
     this.#ctx = args.ctx;
@@ -1764,9 +1658,10 @@ var DownloadRun = class {
   async execute() {
     const initErr = await this.#initResume();
     if (initErr) return initErr;
-    const metaErr = await this.#resolveMetadata();
-    if (metaErr) return metaErr;
-    const ctxWithMeta = this.#startQueue();
+    const resolved = await this.#resolveMetadata();
+    if ("error" in resolved) return resolved.error;
+    const meta = resolved.meta;
+    const ctxWithMeta = this.#startQueue(meta);
     const onAbort = () => {
       this.#aborted = true;
       this.#queue.clear();
@@ -1776,16 +1671,16 @@ var DownloadRun = class {
       const stage2Error = await this.#runTocStage(ctxWithMeta);
       await this.#drainQueueOrAbort();
       await this.#flushQuietly();
-      return this.#finalize(stage2Error);
+      return this.#finalize(meta, stage2Error);
     } finally {
       this.#signal.removeEventListener("abort", onAbort);
     }
   }
   async #initResume() {
-    const resumeCfg = this.#resumeCfg;
+    const resumeCfg = this.#resumeStorage;
     if (resumeCfg) {
       try {
-        let state = await resumeCfg.store.load(resumeCfg.stateFile);
+        let state = await resumeCfg.resume.load(resumeCfg.stateFile);
         if (state) {
           if (state.url !== this.#validated) {
             throw new ParseError("Stale resume state: URL mismatch");
@@ -1802,7 +1697,7 @@ var DownloadRun = class {
       }
     }
     if (resumeCfg && this.#state) {
-      const prior = await resumeCfg.chapterStore.loadAll();
+      const prior = await resumeCfg.chapters.loadAll();
       this.#successes.push(...prior);
       const merged = new Set(this.#state.completed);
       for (const c of prior) merged.add(c.index);
@@ -1814,32 +1709,30 @@ var DownloadRun = class {
     return null;
   }
   async #persistState() {
-    const resumeCfg = this.#resumeCfg;
+    const resumeCfg = this.#resumeStorage;
     if (!resumeCfg || !this.#state) return;
     const next = { ...this.#state, updatedAt: nowIso() };
     this.#state = next;
-    await resumeCfg.store.save(resumeCfg.stateFile, next);
+    await resumeCfg.resume.save(resumeCfg.stateFile, next);
   }
   async #resolveMetadata() {
     try {
+      let meta;
       if (this.#state?.metadata) {
-        this.#metadata = this.#state.metadata;
+        meta = this.#state.metadata;
       } else {
-        this.#metadata = await fetchMetadataStage(this.#adapter, this.#validated, this.#ctx, this.#bus);
+        meta = await fetchMetadataStage(this.#adapter, this.#validated, this.#ctx, this.#bus);
         if (this.#state) {
-          this.#state = { ...this.#state, metadata: this.#metadata, updatedAt: nowIso() };
+          this.#state = { ...this.#state, metadata: meta, updatedAt: nowIso() };
           await this.#persistState();
         }
       }
+      return { meta };
     } catch (err) {
-      return {
-        status: "error",
-        error: normalizeToEnvelopeError(err)
-      };
+      return { error: { status: "error", error: normalizeToEnvelopeError(err) } };
     }
-    return null;
   }
-  #startQueue() {
+  #startQueue(meta) {
     const state = this.#state;
     const completedSet = this.#completedSet;
     const completedList = this.#completedList;
@@ -1851,8 +1744,7 @@ var DownloadRun = class {
         if (!completedSet.has(f.index)) failedMap.set(f.index, f);
       }
     }
-    if (!this.#metadata) throw new Error("invariant: metadata must be set before #startQueue");
-    return { ...this.#ctx, novelMetadata: this.#metadata };
+    return { ...this.#ctx, novelMetadata: meta };
   }
   async #enqueueRef(ref, ctxWithMeta) {
     if (this.#aborted || this.#signal.aborted) return;
@@ -1872,7 +1764,7 @@ var DownloadRun = class {
     try {
       const chapter = await fetchChapterTask(this.#adapter, ref, ctxWithMeta, this.#bus);
       if (this.#aborted) return;
-      if (this.#resumeCfg) await this.#resumeCfg.chapterStore.save(chapter);
+      if (this.#resumeStorage) await this.#resumeStorage.chapters.save(chapter);
       this.#successes.push(chapter);
       this.#completedList.push(ref.index);
       this.#completedSet.add(ref.index);
@@ -1889,7 +1781,7 @@ var DownloadRun = class {
       this.#bus.emit({
         type: "progress",
         completed: this.#successes.length,
-        total: this.#metadata?.totalChapters ?? this.#enqueuedSet.size
+        total: ctxWithMeta.novelMetadata?.totalChapters ?? this.#enqueuedSet.size
       });
     } catch (cause) {
       if (cause instanceof CancelledError) return;
@@ -1910,20 +1802,16 @@ var DownloadRun = class {
     let stage2Error;
     try {
       if (this.#state?.toc) {
-        const from = this.#normalizedRange?.from;
-        const to = this.#normalizedRange?.to;
-        let discovered = 0;
-        for (const ref of this.#state.toc) {
-          if (to !== void 0 && ref.index > to) break;
-          if (from !== void 0 && ref.index < from) continue;
-          await this.#enqueueRef(ref, ctxWithMeta);
-          discovered++;
-          if (discovered % TOC_PROGRESS_EMIT_EVERY2 === 0) {
-            this.#bus.emit({ type: "toc:progress", discovered });
-          }
+        const toc = this.#state.toc;
+        async function* fromState() {
+          for (const ref of toc) yield ref;
         }
-        this.#bus.emit({ type: "toc:progress", discovered });
-        this.#bus.emit({ type: "toc:complete", total: discovered });
+        await walkToc(fromState(), {
+          ...this.#normalizedRange !== void 0 ? { range: this.#normalizedRange } : {},
+          bus: this.#bus,
+          signal: this.#signal,
+          onRef: (ref) => this.#enqueueRef(ref, ctxWithMeta)
+        });
       } else {
         const tocBuffer = [];
         await fetchTocStage(
@@ -1998,10 +1886,8 @@ var DownloadRun = class {
       this.#logger.warn({ err, url: this.#validated }, "resume state persist failed (non-fatal)");
     }
   }
-  #finalize(stage2Error) {
+  #finalize(metadata, stage2Error) {
     if (stage2Error) return { status: "error", error: stage2Error };
-    if (!this.#metadata) throw new Error("invariant: metadata must be set before #finalize");
-    const metadata = this.#metadata;
     let data;
     try {
       data = assembleNovelData(metadata, this.#successes);
@@ -2012,8 +1898,8 @@ var DownloadRun = class {
       };
     }
     if (this.#failures.length > 0) {
-      if (this.#resumeCfg) {
-        const token = encodeResumeToken(this.#resumeCfg.stateFile, this.#validated);
+      if (this.#resumeStorage) {
+        const token = encodeResumeToken(this.#resumeStorage.stateFile, this.#validated);
         return { status: "partial", resumable: true, data, failures: this.#failures, resumeToken: token };
       }
       return { status: "partial", resumable: false, data, failures: this.#failures };
@@ -2029,6 +1915,185 @@ function normalizeChapterRange(range) {
   return out;
 }
 
+// src/storage/resume-storage.ts
+var import_node_path6 = require("path");
+
+// src/storage/resume-store.ts
+var import_promises3 = require("fs/promises");
+var import_node_path4 = require("path");
+init_errors();
+
+// src/storage/resume-state.ts
+var import_zod5 = require("zod");
+init_primitives();
+var ResumeFailureRecordSchema = import_zod5.z.object({
+  index: ChapterIndexSchema,
+  lastError: import_zod5.z.object({ code: import_zod5.z.string(), message: import_zod5.z.string() }).readonly()
+}).readonly();
+var ResumeStateSchema = import_zod5.z.object({
+  schemaVersion: import_zod5.z.literal(1),
+  url: UrlSchema,
+  adapterId: AdapterIdSchema,
+  metadata: NovelMetadataSchema.nullable(),
+  toc: import_zod5.z.array(ChapterRefSchema).readonly().nullable(),
+  completed: import_zod5.z.array(ChapterIndexSchema).readonly(),
+  failed: import_zod5.z.array(ResumeFailureRecordSchema).readonly(),
+  startedAt: IsoDateSchema,
+  updatedAt: IsoDateSchema
+}).readonly();
+
+// src/storage/resume-store.ts
+var MemoryResumeStore = class {
+  #map = /* @__PURE__ */ new Map();
+  async load(path) {
+    return this.#map.get((0, import_node_path4.resolve)(path)) ?? null;
+  }
+  async save(path, state) {
+    this.#map.set((0, import_node_path4.resolve)(path), state);
+  }
+  async delete(path) {
+    this.#map.delete((0, import_node_path4.resolve)(path));
+  }
+};
+var FilesystemResumeStore = class {
+  async load(path) {
+    let text;
+    try {
+      text = await (0, import_promises3.readFile)(path, "utf8");
+    } catch (err) {
+      if (isEnoent(err)) return null;
+      throw err;
+    }
+    let raw;
+    try {
+      raw = JSON.parse(text);
+    } catch (cause) {
+      throw new ParseError("Resume state file is corrupt; delete it to start over", { cause, path });
+    }
+    const parsed = ResumeStateSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new ParseError("Resume state file is corrupt; delete it to start over", {
+        cause: parsed.error,
+        path
+      });
+    }
+    return parsed.data;
+  }
+  async save(path, state) {
+    await atomicWriteJson(path, state);
+  }
+  async delete(path) {
+    try {
+      await (0, import_promises3.unlink)(path);
+    } catch (err) {
+      if (!isEnoent(err)) throw err;
+    }
+  }
+};
+
+// src/storage/chapter-store.ts
+var import_promises4 = require("fs/promises");
+var import_node_path5 = require("path");
+var MemoryChapterStore = class {
+  #map = /* @__PURE__ */ new Map();
+  async save(chapter) {
+    this.#map.set(Number(chapter.index), chapter);
+  }
+  async loadAll() {
+    return [...this.#map.values()].sort((a, b) => Number(a.index) - Number(b.index));
+  }
+};
+var FilesystemChapterStore = class {
+  #logger;
+  #dir;
+  constructor(dir, opts = {}) {
+    this.#dir = (0, import_node_path5.resolve)(dir);
+    this.#logger = opts.logger ?? silentLogger;
+  }
+  async save(chapter) {
+    await atomicWriteJson((0, import_node_path5.join)(this.#dir, `${Number(chapter.index)}.json`), chapter);
+  }
+  async loadAll() {
+    let entries;
+    try {
+      entries = await (0, import_promises4.readdir)(this.#dir);
+    } catch (err) {
+      if (isEnoent(err)) return [];
+      throw err;
+    }
+    const chapters = [];
+    for (const name of entries) {
+      if (!/^\d+\.json$/.test(name)) continue;
+      const path = (0, import_node_path5.join)(this.#dir, name);
+      let text;
+      try {
+        text = await (0, import_promises4.readFile)(path, "utf8");
+      } catch (err) {
+        this.#logger.warn({ path, err }, "chapter-store: failed to read file, skipping");
+        continue;
+      }
+      let raw;
+      try {
+        raw = JSON.parse(text);
+      } catch (err) {
+        this.#logger.warn({ path, err }, "chapter-store: invalid JSON, skipping");
+        continue;
+      }
+      const parsed = ChapterSchema.safeParse(raw);
+      if (!parsed.success) {
+        this.#logger.warn(
+          { path, issues: parsed.error.issues },
+          "chapter-store: schema mismatch, skipping"
+        );
+        continue;
+      }
+      chapters.push(parsed.data);
+    }
+    chapters.sort((a, b) => Number(a.index) - Number(b.index));
+    return chapters;
+  }
+};
+
+// src/storage/resume-storage.ts
+var ResumeStorage = class _ResumeStorage {
+  resume;
+  chapters;
+  stateFile;
+  constructor(resume, chapters, stateFile) {
+    this.resume = resume;
+    this.chapters = chapters;
+    this.stateFile = stateFile;
+  }
+  static forDefault(url, logger) {
+    const stateFile = (0, import_node_path6.join)(userCacheDir(), "webnovel-downloader", "state", `${sha1(url)}.json`);
+    return _ResumeStorage.#filesystem(stateFile, logger);
+  }
+  static forStateFile(stateFile, logger) {
+    return _ResumeStorage.#filesystem(stateFile, logger);
+  }
+  static forToken(token, url, logger) {
+    const { stateFile } = verifyResumeToken(token, url);
+    return _ResumeStorage.#filesystem(stateFile, logger);
+  }
+  static memory(stateFile) {
+    return new _ResumeStorage(new MemoryResumeStore(), new MemoryChapterStore(), stateFile);
+  }
+  static #filesystem(stateFile, logger) {
+    return new _ResumeStorage(
+      new FilesystemResumeStore(),
+      new FilesystemChapterStore(`${stateFile}.chapters`, { logger }),
+      stateFile
+    );
+  }
+};
+function resolveResumeStorage(opt, url, logger) {
+  if (opt === void 0) return null;
+  if (opt === true) return ResumeStorage.forDefault(url, logger);
+  if ("stateFile" in opt) return ResumeStorage.forStateFile(opt.stateFile, logger);
+  if ("token" in opt) return ResumeStorage.forToken(opt.token, url, logger);
+  return null;
+}
+
 // src/core/downloader.ts
 var DEFAULT_CACHE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
 var DEFAULT_CONCURRENCY = 4;
@@ -2200,12 +2265,12 @@ var Downloader = class {
     };
     try {
       this.#transportListeners.add(transportListener);
-      const resumeCfg = resolveResumeConfig(options?.resume, validated, this.#logger);
+      const resumeStorage = resolveResumeStorage(options?.resume, validated, this.#logger);
       const run = new DownloadRun({
         adapter,
         validated,
         normalizedRange,
-        resumeCfg,
+        resumeStorage,
         concurrency,
         signal,
         ctx,
@@ -2307,13 +2372,6 @@ function normalizeText(html) {
   });
   return text.replace(new RegExp(LINE, "g"), " ").replace(new RegExp(PARA, "g"), "\n\n").split(/\n{2,}/).map((p) => p.replace(/\s+/g, " ").trim()).filter(Boolean).join("\n\n").trim();
 }
-function pickText($, selectors) {
-  for (const sel of selectors) {
-    const t = $(sel).first().text().trim();
-    if (t) return t;
-  }
-  return "";
-}
 function wordCount(text) {
   return text.split(/\s+/).filter(Boolean).length;
 }
@@ -2385,6 +2443,9 @@ function refsFromAnchors($, opts) {
   return refs;
 }
 
+// src/adapters/shared/header.ts
+init_errors();
+
 // src/adapters/shared/cover.ts
 function extractCoverUrl($, selector, baseUrl) {
   const el = $(selector).first();
@@ -2392,6 +2453,36 @@ function extractCoverUrl($, selector, baseUrl) {
   return raw ? resolveUrl(baseUrl, raw) : void 0;
 }
 
+// src/adapters/shared/header.ts
+function parseNovelHeader($, selectors, sourceUrl) {
+  const title = $(selectors.title).first().text().trim();
+  if (!title) throw new ParseError("Missing title on novel page", { url: sourceUrl });
+  const author = $(selectors.author).first().text().trim();
+  const descSelectors = typeof selectors.description === "string" ? [selectors.description] : selectors.description;
+  let description = "";
+  for (const sel of descSelectors) {
+    const t = $(sel).first().text().trim();
+    if (t) {
+      description = t;
+      break;
+    }
+  }
+  description = description.replace(/\s+/g, " ").trim();
+  const genres = [];
+  $(selectors.genres).each((_, el) => {
+    const t = $(el).text().trim();
+    if (t && !genres.includes(t)) genres.push(t);
+  });
+  const coverUrl = extractCoverUrl($, selectors.cover, sourceUrl);
+  return {
+    title,
+    author,
+    description,
+    genres,
+    ...coverUrl !== void 0 ? { coverUrl } : {}
+  };
+}
+
 // src/adapters/shared/content.ts
 init_errors();
 function stripLeadingTitle(content, title) {
@@ -2432,31 +2523,16 @@ var TRUYENFULL_SELECTORS = {
 
 // src/adapters/truyenfull/parser.ts
 function parseNovelPage($, sourceUrl) {
-  const title = $(TRUYENFULL_SELECTORS.metadata.title).first().text().trim();
-  if (!title) {
-    throw new ParseError("Missing title on novel page", { url: sourceUrl });
-  }
-  const author = $(TRUYENFULL_SELECTORS.metadata.author).first().text().trim();
-  const description = $(TRUYENFULL_SELECTORS.metadata.description).text().replace(/\s+/g, " ").trim();
-  const genres = [];
-  $(TRUYENFULL_SELECTORS.metadata.genres).each((_, el) => {
-    const t = $(el).text().trim();
-    if (t) genres.push(t);
-  });
-  const coverUrl = extractCoverUrl($, TRUYENFULL_SELECTORS.metadata.cover, sourceUrl);
+  const header = parseNovelHeader($, TRUYENFULL_SELECTORS.metadata, sourceUrl);
   let status = "unknown";
   if ($(TRUYENFULL_SELECTORS.metadata.statusFull).length > 0) status = "completed";
   else if ($(TRUYENFULL_SELECTORS.metadata.statusOngoing).length > 0) status = "ongoing";
   return {
+    ...header,
     sourceUrl,
     sourceSite: unsafeBrandAdapterId("truyenfull"),
-    title,
-    author,
-    description,
-    genres,
     status,
-    fetchedAt: /* @__PURE__ */ new Date(),
-    ...coverUrl !== void 0 ? { coverUrl } : {}
+    fetchedAt: /* @__PURE__ */ new Date()
   };
 }
 function parseTocPage($, startIndex, baseUrl) {
@@ -2622,32 +2698,17 @@ var METRUYENCHU_SELECTORS = {
 // src/adapters/metruyenchu/parser.ts
 var SOURCE_SITE = unsafeBrandAdapterId("metruyenchu-com-vn");
 function parseNovelPage2($, sourceUrl) {
-  const title = $(METRUYENCHU_SELECTORS.metadata.title).first().text().trim();
-  if (!title) {
-    throw new ParseError("Missing title on novel page", { url: sourceUrl });
-  }
-  const author = $(METRUYENCHU_SELECTORS.metadata.author).first().text().trim();
-  const description = pickText($, METRUYENCHU_SELECTORS.metadata.description).replace(/\s+/g, " ").trim();
-  const genres = [];
-  $(METRUYENCHU_SELECTORS.metadata.genres).each((_, el) => {
-    const t = $(el).text().trim();
-    if (t && !genres.includes(t)) genres.push(t);
-  });
-  const coverUrl = extractCoverUrl($, METRUYENCHU_SELECTORS.metadata.cover, sourceUrl);
+  const header = parseNovelHeader($, METRUYENCHU_SELECTORS.metadata, sourceUrl);
   let status = "unknown";
   if ($(METRUYENCHU_SELECTORS.metadata.statusFull).length > 0) status = "completed";
   else if (METRUYENCHU_SELECTORS.metadata.statusOngoing.some((sel) => $(sel).length > 0)) status = "ongoing";
   const totalChapters = extractTotalChapters($);
   return {
+    ...header,
     sourceUrl,
     sourceSite: SOURCE_SITE,
-    title,
-    author,
-    description,
-    genres,
     status,
     fetchedAt: /* @__PURE__ */ new Date(),
-    ...coverUrl ? { coverUrl } : {},
     ...totalChapters !== void 0 ? { totalChapters } : {}
   };
 }
@@ -3078,6 +3139,7 @@ var downloader = createDownloader();
   builtinAdapters,
   createDownloader,
   createLogger,
-  downloader
+  downloader,
+  parseNovelHeader
 });
 //# sourceMappingURL=index.cjs.map