data-ark 0.1.0 → 0.1.2

package/src/commands/upload.js

@@ -12,7 +12,8 @@ import {
   parseSize,
   planChunks,
 } from '../chunking.js'
-import { connect as realConnect, requireChat } from '../client.js'
+import { chunkCaption, manifestCaption } from '../caption.js'
+import { closeQuietly, connect as realConnect, describeChat, requireChat } from '../client.js'
 import { defaultConfigDir, loadConfig, saveConfig } from '../config.js'
 import {
   buildManifest,
@@ -22,27 +23,32 @@ import {
   serializeManifest,
 } from '../manifest.js'
 import { createProgress, formatBytes, formatDuration } from '../progress.js'
-import { clearState, loadState, markChunkDone, saveState, stateDir, stateKey } from '../state.js'
+import { clearState, loadState, markChunkDone, saveState, stateFile, stateKey } from '../state.js'
 import { uploadRange } from '../uploader.js'
 
-// Trên ngưỡng này thì phải nói rõ đang chờ bao lâu, theo spec §8.
+// Above this threshold the wait must be spelled out, per spec §8.
 const LONG_WAIT_MS = 60_000
 
-async function realSendChunk(client, peer, { inputFile, fileName, caption }) {
+// Chunks and manifests differ only in where the bytes come from. Everything Telegram is
+// told about them — document, not preview; this exact file name — is decided once.
+async function sendDocument(client, peer, { file, fileName, caption }) {
   return await client.sendFile(peer, {
-    file: inputFile,
+    file,
     caption,
     forceDocument: true,
     attributes: [new Api.DocumentAttributeFilename({ fileName })],
   })
 }
 
+async function realSendChunk(client, peer, { inputFile, fileName, caption }) {
+  return await sendDocument(client, peer, { file: inputFile, fileName, caption })
+}
+
 async function realSendManifest(client, peer, { bytes, fileName, caption }) {
-  return await client.sendFile(peer, {
+  return await sendDocument(client, peer, {
     file: new CustomFile(fileName, bytes.length, '', bytes),
+    fileName,
     caption,
-    forceDocument: true,
-    attributes: [new Api.DocumentAttributeFilename({ fileName })],
   })
 }
 
@@ -65,12 +71,12 @@ export async function runUpload(filePath, options = {}, deps = {}) {
   try {
     stat = await fs.stat(absPath)
   } catch (err) {
-    if (err.code === 'ENOENT') throw new Error(`File không tồn tại: ${absPath}`)
+    if (err.code === 'ENOENT') throw new Error(`File does not exist: ${absPath}`)
     throw err
   }
 
   if (!stat.isFile()) {
-    throw new Error(`${absPath} không phải là file.`)
+    throw new Error(`${absPath} is not a file.`)
   }
 
   const config = await loadConfig(configDir)
@@ -80,9 +86,9 @@ export async function runUpload(filePath, options = {}, deps = {}) {
 
   if (!Number.isInteger(concurrency) || concurrency < 1 || concurrency > MAX_CONCURRENCY) {
     throw new Error(
-      `--concurrency không hợp lệ: "${options.concurrency}". ` +
-        `Phải là số nguyên từ 1 đến ${MAX_CONCURRENCY} — mỗi luồng giữ một phần 512KB trong RAM ` +
-        'và Telegram sẽ bắt chờ FLOOD_WAIT nếu bắn quá nhiều request cùng lúc.',
+      `Invalid --concurrency: "${options.concurrency}". ` +
+        `Must be an integer from 1 to ${MAX_CONCURRENCY} — each slot holds a 512KB part in RAM ` +
+        'and Telegram answers with FLOOD_WAIT if too many requests go out at once.',
     )
   }
 
@@ -93,11 +99,11 @@ export async function runUpload(filePath, options = {}, deps = {}) {
   const resuming = Boolean(state) && state.chunkSize === chunkSize
 
   if (resuming && state.chat !== String(chat)) {
-    const stateFile = path.join(stateDir(configDir), `${key}.json`)
+    const file = stateFile(key, configDir)
     throw new Error(
-      `Backup dở dang này đang gửi vào ${state.chat}, nhưng lệnh hiện tại chỉ định đích ${chat} — ` +
-        `không thể tách một backup ra hai đích khác nhau. Chạy lại không kèm --to để tiếp tục gửi vào ` +
-        `${state.chat}, hoặc xoá ${stateFile} rồi chạy lại để bắt đầu backup mới vào ${chat}.`,
+      `This unfinished backup is going to ${state.chat}, but the current command targets ${chat} — ` +
+        `a single backup cannot be split across two destinations. Run again without --to to keep ` +
+        `sending to ${state.chat}, or delete ${file} and run again to start a new backup in ${chat}.`,
     )
   }
 
@@ -121,46 +127,45 @@ export async function runUpload(filePath, options = {}, deps = {}) {
   const log = silent ? () => {} : (line) => console.log(line)
   const warn = silent ? () => {} : writeErr
 
-  // Thử lại và FLOOD_WAIT phải nói ra: một FLOOD_WAIT_3600 mà im lặng thì người
-  // dùng chỉ thấy thanh tiến độ đứng hình cả tiếng và tưởng máy treo.
+  // Retries and FLOOD_WAIT must be announced: a silent FLOOD_WAIT_3600 leaves the user
+  // staring at a frozen progress bar for an hour, assuming the process has hung.
   function onRetry(err, attempt, delayMs) {
     if (delayMs > LONG_WAIT_MS) {
       warn(
-        `\nTelegram bắt chờ ${formatDuration(delayMs / 1000)} rồi mới cho gửi tiếp ` +
-          `(${err.message}). data-ark đang đợi và sẽ tự đi tiếp, đừng tắt.\n`,
+        `\nTelegram wants ${formatDuration(delayMs / 1000)} of waiting before the next send ` +
+          `(${err.message}). data-ark is waiting and will carry on by itself, leave it running.\n`,
       )
       return
     }
 
     warn(
-      `\nLỗi tạm thời (${err.message}), thử lại lần ${attempt} sau ` +
+      `\nTemporary error (${err.message}), retry ${attempt} in ` +
         `${formatDuration(delayMs / 1000)}.\n`,
     )
   }
 
   log(`Backup ${state.id}`)
-  log(`File   ${absPath} (${formatBytes(stat.size)}, ${chunks.length} chunk)`)
-  log(`Đích   ${chat}\n`)
+  log(`File   ${absPath} (${formatBytes(stat.size)}, ${chunks.length} chunks)`)
+  log(`To     ${describeChat(chat)}\n`)
 
-  const client = await connect(config)
+  const client = await connect(config, { verbose: options.verbose })
 
   try {
     for (const chunk of chunks) {
       if (state.done[String(chunk.i)]) {
-        log(`Chunk ${chunk.i + 1}/${chunks.length} đã có, bỏ qua.`)
+        log(`Chunk ${chunk.i + 1}/${chunks.length} already uploaded, skipping.`)
         continue
       }
 
       const fileName = chunkFileName(state.id, chunk.i)
       const handle = await fs.open(absPath, 'r')
 
-      const progress = silent
-        ? { advance: () => {}, finish: () => {} }
-        : createProgress({
-            total: chunk.length,
-            label: `Chunk ${chunk.i + 1}/${chunks.length}`,
-            write: writeErr,
-          })
+      // warn is already the no-op when silent, and createProgress draws through nothing else.
+      const progress = createProgress({
+        total: chunk.length,
+        label: `Chunk ${chunk.i + 1}/${chunks.length}`,
+        write: warn,
+      })
 
       try {
         const { inputFile, sha256 } = await uploadRange(client, handle.fd, {
@@ -178,7 +183,7 @@ export async function runUpload(filePath, options = {}, deps = {}) {
         const message = await sendChunk(client, chat, {
           inputFile,
           fileName,
-          caption: `#dataark ${state.id} ${chunk.i + 1}/${chunks.length}`,
+          caption: chunkCaption({ id: state.id, number: chunk.i + 1, total: chunks.length }),
         })
 
         state = await markChunkDone(
@@ -193,17 +198,17 @@ export async function runUpload(filePath, options = {}, deps = {}) {
       }
     }
 
-    // File có thể bị ghi đè trong lúc upload — với file 50GB thì cả tiếng đồng
-    // hồ trôi qua giữa chunk đầu và chunk cuối. Khi đó manifest mô tả một file
-    // lai chưa từng tồn tại: restore vẫn khớp sha256 nhưng dữ liệu là rác.
+    // The file can be overwritten mid-upload — with a 50GB file an hour passes between
+    // the first and last chunk. The manifest would then describe a hybrid file that never
+    // existed: restore still matches every sha256, but the data is garbage.
     const after = await fs.stat(absPath)
 
     if (after.size !== stat.size || after.mtimeMs !== stat.mtimeMs) {
       throw new Error(
-        `${absPath} đã thay đổi trong lúc upload ` +
-          `(kích thước ${stat.size} → ${after.size}, mtime ${stat.mtimeMs} → ${after.mtimeMs}). ` +
-          'Backup này trộn dữ liệu cũ với dữ liệu mới nên không đáng tin — data-ark không gửi manifest. ' +
-          'Chờ file ổn định rồi chạy lại để tạo một backup mới.',
+        `${absPath} changed during the upload ` +
+          `(size ${stat.size} → ${after.size}, mtime ${stat.mtimeMs} → ${after.mtimeMs}). ` +
+          'This backup mixes old and new data and cannot be trusted — data-ark is not sending the manifest. ' +
+          'Wait until the file settles, then run again to create a new backup.',
       )
     }
 
@@ -218,20 +223,23 @@ export async function runUpload(filePath, options = {}, deps = {}) {
     await sendManifest(client, chat, {
       bytes: serializeManifest(manifest),
       fileName: manifestFileName(state.id),
-      caption: `#dataark ${state.id} manifest`,
+      caption: manifestCaption({
+        id: manifest.id,
+        name: manifest.name,
+        size: manifest.size,
+        chunks: manifest.chunks.length,
+        createdAt: manifest.createdAt,
+      }),
     })
 
     await clearState(key, configDir)
 
-    log(`\nXong. Khôi phục bằng:\n  npx data-ark restore ${state.id}`)
+    log(`\nDone. Restore with:\n  npx data-ark restore ${state.id}`)
 
     return { id: state.id, chunks: chunks.length }
   } finally {
-    // Ngắt kết nối hỏng thì cũng không được nuốt mất lỗi thật đang bay lên.
-    try {
-      await disconnect(client)
-    } catch (err) {
-      warn(`\nCảnh báo: không đóng được kết nối Telegram: ${err.message}\n`)
-    }
+    await closeQuietly(client, disconnect, (err) =>
+      warn(`\nWarning: could not close the Telegram connection: ${err.message}\n`),
+    )
   }
 }

package/src/config.js

@@ -22,20 +22,25 @@ export async function loadConfig(dir = defaultConfigDir()) {
   try {
     return JSON.parse(raw)
   } catch {
-    throw new Error(`File cấu hình hỏng: ${file}. Xoá nó rồi chạy lại "data-ark login".`)
+    throw new Error(`Corrupt config file: ${file}. Delete it and run "data-ark login" again.`)
   }
 }
 
-export async function saveConfig(config, dir = defaultConfigDir()) {
-  await fs.mkdir(dir, { recursive: true, mode: 0o700 })
+// Config and state are both small JSON files holding something that must survive a crash
+// mid-write: write beside the target, then rename, which is atomic on the same filesystem.
+export async function writeJsonAtomic(file, value) {
+  await fs.mkdir(path.dirname(file), { recursive: true, mode: 0o700 })
 
-  const file = path.join(dir, FILE_NAME)
   const tmp = `${file}.tmp`
 
-  await fs.writeFile(tmp, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 })
+  await fs.writeFile(tmp, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 })
   await fs.rename(tmp, file)
 }
 
+export async function saveConfig(config, dir = defaultConfigDir()) {
+  await writeJsonAtomic(path.join(dir, FILE_NAME), config)
+}
+
 export async function clearSession(dir = defaultConfigDir()) {
   const config = await loadConfig(dir)
   delete config.session

package/src/downloader.js

@@ -19,17 +19,17 @@ export async function downloadToFile(client, message, fd, { offset, onProgress }
   const document = message?.media?.document
 
   if (!document) {
-    throw new Error(`Message ${message?.id} không chứa file đính kèm.`)
+    throw new Error(`Message ${message?.id} has no file attached.`)
   }
 
   if (!Number.isFinite(offset)) {
-    throw new Error(`offset phải là một số hữu hạn, nhận được: ${offset}`)
+    throw new Error(`offset must be a finite number, got: ${offset}`)
   }
 
   const hash = createHash('sha256')
   let written = 0
 
-  for await (const buffer of client.iterDownload({ file: document, requestSize: PART_SIZE })) {
+  for await (const buffer of client.iterDownload({ file: message.media, requestSize: PART_SIZE })) {
     await writeExactly(fd, buffer, offset + written)
     hash.update(buffer)
     written += buffer.length

package/src/manifest.js

@@ -1,5 +1,7 @@
 import { randomBytes } from 'node:crypto'
 
+import { countChunks } from './chunking.js'
+
 export const MANIFEST_VERSION = 1
 
 export function newBackupId(now = new Date(), randomHex = () => randomBytes(3).toString('hex')) {
@@ -42,48 +44,49 @@ export function parseManifest(input) {
   try {
     manifest = JSON.parse(text)
   } catch {
-    throw new Error('Không đọc được manifest: nội dung không phải JSON hợp lệ.')
+    throw new Error('Cannot read manifest: content is not valid JSON.')
   }
 
   if (manifest.v !== MANIFEST_VERSION) {
     throw new Error(
-      `Manifest dùng phiên bản ${manifest.v}, bản data-ark này chỉ hiểu phiên bản ${MANIFEST_VERSION}.`,
+      `Manifest uses version ${manifest.v}, this build of data-ark only understands version ${MANIFEST_VERSION}.`,
     )
   }
 
   if (!Array.isArray(manifest.chunks) || manifest.chunks.length === 0) {
-    throw new Error('Manifest thiếu danh sách chunk.')
+    throw new Error('Manifest has no chunk list.')
   }
 
   manifest.chunks.forEach((chunk, index) => {
     if (chunk.i !== index) {
-      throw new Error(`Manifest thiếu chunk số ${index}: danh sách chunk không liên tục.`)
+      throw new Error(`Manifest is missing chunk ${index}: the chunk list is not contiguous.`)
     }
   })
 
-  const expectedChunks = Math.ceil(manifest.size / manifest.chunkSize)
+  const expectedChunks = countChunks(manifest.size, manifest.chunkSize)
   if (manifest.chunks.length !== expectedChunks) {
-    throw new Error(`Manifest thiếu ${expectedChunks - manifest.chunks.length} chunk(s).`)
+    throw new Error(`Manifest is missing ${expectedChunks - manifest.chunks.length} chunk(s).`)
   }
 
   const total = manifest.chunks.reduce((sum, chunk) => sum + chunk.size, 0)
   if (total !== manifest.size) {
     throw new Error(
-      `Tổng kích thước các chunk (${total}) không khớp kích thước file trong manifest (${manifest.size}).`,
+      `Chunk sizes add up to ${total}, but the manifest records a file size of ${manifest.size}.`,
     )
   }
 
-  // Restore ghi chunk i vào đúng offset i * chunkSize, nên bố cục phải đều:
-  // mọi chunk đúng bằng chunkSize, riêng chunk cuối là phần dư. Tổng đúng mà
-  // từng chunk lệch thì file ghép ra sẽ thủng lỗ hoặc dài thêm mà sha256 từng
-  // chunk vẫn khớp — sai âm thầm, đúng thứ data-ark không được phép để xảy ra.
+  // Restore writes chunk i at exactly offset i * chunkSize, so the layout must be
+  // uniform: every chunk is chunkSize, except the last one which is the remainder.
+  // A correct total with individually wrong sizes yields a file with a hole or
+  // extra length while every per-chunk sha256 still matches — silently wrong data,
+  // precisely what data-ark must never produce.
   manifest.chunks.forEach((chunk, index) => {
     const expected = Math.min(manifest.chunkSize, manifest.size - index * manifest.chunkSize)
     if (chunk.size !== expected) {
       throw new Error(
-        `Chunk ${index + 1} trong manifest ghi ${chunk.size} byte, nhưng theo bố cục ` +
-          `${manifest.chunkSize} byte mỗi chunk thì phải là ${expected} byte. ` +
-          'Manifest này mô tả sai vị trí các chunk, khôi phục sẽ ra file hỏng.',
+        `Manifest records ${chunk.size} bytes for chunk ${index + 1}, but a layout of ` +
+          `${manifest.chunkSize} bytes per chunk requires ${expected} bytes. ` +
+          'This manifest describes the wrong chunk positions; restoring it would produce a corrupt file.',
       )
     }
   })

package/src/progress.js

@@ -33,13 +33,13 @@ export function renderProgress({ done, total, elapsedMs, label, width = 24 }) {
   const bar = `${'█'.repeat(filled)}${'░'.repeat(width - filled)}`
 
   const bytesPerSecond = elapsedMs > 0 ? done / (elapsedMs / 1000) : 0
-  // Kẹp về 0: done có thể vượt total (đếm dư một nhịp) và ETA âm thì vô nghĩa.
+  // Clamp to 0: done can overshoot total (one extra tick) and a negative ETA is meaningless.
   const remaining = bytesPerSecond > 0 ? Math.max(0, (total - done) / bytesPerSecond) : Infinity
 
   const percent = String(Math.floor(ratio * 100)).padStart(3)
   const speed = `${formatBytes(Math.round(bytesPerSecond))}/s`
 
-  return `${label} ${bar} ${percent}% ${formatBytes(done)}/${formatBytes(total)} ${speed} còn ${formatDuration(remaining)}`
+  return `${label} ${bar} ${percent}% ${formatBytes(done)}/${formatBytes(total)} ${speed} ETA ${formatDuration(remaining)}`
 }
 
 export function createProgress({
@@ -52,9 +52,15 @@ export function createProgress({
   const startedAt = now()
   let done = 0
   let lastDrawnAt = startedAt
+  let widestLine = 0
 
+  // \r only moves the cursor home, it does not erase. A redraw that is shorter than the one
+  // before it (a shrinking ETA, a speed that changes unit) would leave the previous tail on
+  // screen, so pad every line out to the widest one drawn so far.
   function draw(suffix) {
-    write(`\r${renderProgress({ done, total, elapsedMs: now() - startedAt, label })}${suffix}`)
+    const line = renderProgress({ done, total, elapsedMs: now() - startedAt, label })
+    widestLine = Math.max(widestLine, line.length)
+    write(`\r${line.padEnd(widestLine)}${suffix}`)
   }
 
   return {

package/src/state.js

@@ -2,7 +2,7 @@ import { createHash } from 'node:crypto'
 import { promises as fs } from 'node:fs'
 import path from 'node:path'
 
-import { defaultConfigDir } from './config.js'
+import { defaultConfigDir, writeJsonAtomic } from './config.js'
 
 export function stateDir(configDir = defaultConfigDir()) {
   return path.join(configDir, 'state')
@@ -12,7 +12,7 @@ export function stateKey(absPath, size, mtimeMs) {
   return createHash('sha1').update(`${absPath}:${size}:${mtimeMs}`).digest('hex')
 }
 
-function stateFile(key, configDir) {
+export function stateFile(key, configDir = defaultConfigDir()) {
   return path.join(stateDir(configDir), `${key}.json`)
 }
 
@@ -27,14 +27,7 @@ export async function loadState(key, configDir = defaultConfigDir()) {
 }
 
 export async function saveState(key, state, configDir = defaultConfigDir()) {
-  const dir = stateDir(configDir)
-  await fs.mkdir(dir, { recursive: true, mode: 0o700 })
-
-  const file = stateFile(key, configDir)
-  const tmp = `${file}.tmp`
-
-  await fs.writeFile(tmp, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 })
-  await fs.rename(tmp, file)
+  await writeJsonAtomic(stateFile(key, configDir), state)
 }
 
 export async function markChunkDone(key, state, i, entry, configDir = defaultConfigDir()) {
@@ -50,3 +43,27 @@ export async function clearState(key, configDir = defaultConfigDir()) {
     if (err.code !== 'ENOENT') throw err
   }
 }
+
+// status needs every unfinished backup at once. A state file that cannot be read is skipped
+// rather than fatal, for the same reason loadState returns null: one corrupt file must not
+// hide the other backups still waiting to be finished.
+export async function listStates(configDir = defaultConfigDir()) {
+  let names
+  try {
+    names = await fs.readdir(stateDir(configDir))
+  } catch (err) {
+    if (err.code === 'ENOENT') return []
+    throw err
+  }
+
+  const states = []
+
+  for (const name of names) {
+    if (!name.endsWith('.json')) continue
+
+    const state = await loadState(name.slice(0, -'.json'.length), configDir)
+    if (state) states.push(state)
+  }
+
+  return states
+}

package/src/uploader.js

@@ -10,19 +10,22 @@ import { withRetry } from './retry.js'
 
 const read = promisify(readCallback)
 
-// Telegram tách hai API upload theo kích thước file: trên 10MB mới được dùng
-// nhóm "big". GramJS chọn đúng ngưỡng này (LARGE_FILE_THRESHOLD trong
-// node_modules/telegram/client/uploads.js), data-ark bám theo.
+// Telegram splits its upload API by file size: only files above 10MB may use the
+// "big" family. GramJS picks the same threshold (LARGE_FILE_THRESHOLD in
+// node_modules/telegram/client/uploads.js), and data-ark follows it.
 export const LARGE_FILE_THRESHOLD = 10 * 1024 * 1024
 
 async function readExactly(fd, length, position) {
-  const buffer = Buffer.alloc(length)
+  // allocUnsafe skips zero-filling 512KB per part — about 0.4s of memset per 1800MB chunk,
+  // on the same thread that drives the in-flight requests. Safe only because the loop below
+  // either fills every byte or throws: no uninitialised byte can reach a request or the hash.
+  const buffer = Buffer.allocUnsafe(length)
   let filled = 0
 
   while (filled < length) {
     const { bytesRead } = await read(fd, buffer, filled, length - filled, position + filled)
     if (bytesRead === 0) {
-      throw new Error(`Đọc hụt: cần ${length} byte từ vị trí ${position} nhưng file đã hết.`)
+      throw new Error(`Short read: needed ${length} bytes at offset ${position} but the file ended.`)
     }
     filled += bytesRead
   }
@@ -45,7 +48,7 @@ export async function uploadRange(client, fd, options) {
 
   if (totalParts > MAX_PARTS) {
     throw new Error(
-      `Dải byte này cần ${totalParts} phần, trong khi Telegram chỉ nhận tối đa 4000 phần mỗi file.`,
+      `This byte range needs ${totalParts} parts, but Telegram accepts at most 4000 parts per file.`,
     )
   }
 
@@ -73,7 +76,7 @@ export async function uploadRange(client, fd, options) {
     let sendFailed = false
     let readError = null
 
-    // Đọc tuần tự để hash đúng thứ tự, gửi song song.
+    // Read sequentially so the hash sees parts in order, but send in parallel.
     try {
       for (let part = start; part < end; part += 1) {
         const partOffset = part * partSize
@@ -82,17 +85,18 @@ export async function uploadRange(client, fd, options) {
 
         hash.update(bytes)
 
-        // Gắn handler ngay lúc tạo promise, không đợi Promise.all ở cuối lô:
-        // nếu readExactly ném ở part sau, một promise đã push mà chưa ai bắt sẽ
-        // nổ thành unhandledRejection và che mất lỗi thật.
+        // Attach the handler when the promise is created rather than waiting for the
+        // Promise.all at the end of the batch: if readExactly throws on a later part,
+        // an already-pushed promise with no handler becomes an unhandledRejection and
+        // hides the real error.
         sending.push(
           withRetry(() => client.invoke(partRequest(part, bytes)), retryOptions).then(
             () => onProgress?.(partLength),
             (err) => {
-              // Không dùng `sendError ??= err`: nếu lý do reject là falsy
-              // (undefined/null), phép gán đó vẫn set sendError = err (falsy)
-              // rồi `if (sendError)` bên dưới coi như không có lỗi — nuốt mất
-              // một lần gửi thất bại và biến nó thành "thành công" giả.
+              // Not `sendError ??= err`: if the rejection reason is falsy
+              // (undefined/null), that assignment still sets sendError to a falsy
+              // value and the `if (sendError)` below reads as "no error" — swallowing
+              // a failed send and turning it into a fake success.
               if (!sendFailed) {
                 sendFailed = true
                 sendError = err
@@ -105,8 +109,8 @@ export async function uploadRange(client, fd, options) {
       readError = err
     }
 
-    // Mọi promise trong sending đều đã tự nuốt lỗi ở trên nên luôn resolve;
-    // await ở đây chỉ để chắc chắn không còn request nào đang bay khi ném lỗi.
+    // Every promise in `sending` already absorbed its own error above, so they all
+    // resolve; this await only guarantees no request is still in flight when we throw.
     await Promise.all(sending)
 
     if (readError) throw readError